ۥ-x@ -ԙ٢'+ݛݛݛݛݛ}}}} #L}oMX*******,,,+W77U4PUݛUU'@ SPRY TI-RPC tc "SPRY TI-RPC " Reference Guide  SPRY TI-RPC Guide, Copyright December, 1993 Introductiontc "Introduction" The SPRY TI-RPC (Transport Independent Remote Procedure Calls) for Windows Sockets provides a standard API for developing client and server applications that use remote procedure call technology. TI-RPC implements a standard RPC protocol, making it well-suited for distributed computing environments.tc "The SPRY TI-RPC (Transport Independent Remote Procedure Calls) for Windows Sockets provides a standard API for developing client and server applications that use remote procedure call technology. TI-RPC implements a standard RPC protocol, making it well-suited for distributed computing environments." The standard API and protocol supported by the TI-RPC for Windows Sockets is an implementation of the Sun Microsystems, Inc, Open Network Computing Transport Independent Remote Procedure Call (ONC+/TI-RPC) specification. ONC+/TI-RPC has received wide acceptance and is offered by a variety of vendors. Using SPRYs TI-RPC for Windows Sockets high-level API, you can develop applications that use TCP/UDP and invoke no transport functions directly. The lower levels of the API provide increasing degrees of control over transport-specific functions which you can program if required. TI-RPC for Windows Sockets will aid in the development of distributed applications. By using TI-RPC, a distributed application can take advantage of the following features: SYMBOL 183 \f "Symbol" \s 12 \h Machine independence SYMBOL 183 \f "Symbol" \s 12 \h Portable code SYMBOL 183 \f "Symbol" \s 12 \h Heterogeneous environment What's Includedtc "What's Included" The TI-RPC Guide includes: SYMBOL 183 \f "Symbol" \s 12 \h Documentation on TIRPC procedure calls SYMBOL 183 \f "Symbol" \s 12 \h The TIRPC.LIB file SYMBOL 183 \f "Symbol" \s 12 \h The TIRPC.DLL file SYMBOL 183 \f "Symbol" \s 12 \h Header files for constant definition and function prototypes Index to Routinestc "Index to Routines" This manual uses the traditional UNIX manual page format to document commands. The following table lists RPC routines and the sections in which they are described: RPC Routine Manual Reference Page auth_destroy rpc_clnt_auth authnone_create rpc_clnt_auth authsys_create rpc_clnt_auth authsys_create_default rpc_clnt_auth authunix_create rpc_soc authunix_create_default rpc_soc callrpc rpc_soc clnt_broadcast rpc_soc clnt_call rpc_clnt_calls clnt_control rpc_clnt_create clnt_create rpc_clnt_create clnt_destroy rpc_clnt_create clnt_dg_create rpc_clnt_create clnt_freeres rpc_clnt_calls clnt_geterr rpc_clnt_calls clnt_pcreateerror rpc_clnt_create clnt_perrno rpc_clnt_calls clnt_perror rpc_clnt_calls clnt_raw_create rpc_clnt_create clnt_spcreateerror rpc_clnt_create clnt_sperrno rpc_clnt_calls clnt_sperror rpc_clnt_calls clnt_tli_create rpc_clnt_create clnt_tp_create rpc_clnt_create clnt_udpcreate rpc_soc clnt_vc_create rpc_clnt_create clntraw_create rpc_soc clnttcp_create rpc_soc clntudp_bufcreate rpc_soc get_myaddress rpc_soc pmap_getmaps rpc_soc pmap_getport rpc_soc pmap_rmtcall rpc_soc pmap_set rpc_soc pmap_unset rpc_soc registerrpc rpc_soc rpc_broadcast rpc_clnt_calls rpc_broadcast_exp rpc_clnt_calls rpc_call rpc_clnt_calls rpc_reg rpc_svc_calls svc_create rpc_svc_create svc_destroy rpc_svc_create svc_dg_create rpc_svc_create svc_dg_enablecache rpc_svc_calls svc_fd_create rpc_svc_create svc_fds rpc_soc svc_freeargs rpc_svc_reg svc_getargs rpc_svc_reg svc_getcaller rpc_soc svc_getreq rpc_soc svc_getreqset rpc_svc_calls svc_getrpccaller rpc_svc_calls svc_raw_create rpc_svc_create svc_reg rpc_svc_calls svc_register rpc_soc svc_run rpc_svc_reg svc_sendreply rpc_svc_reg svc_tli_create rpc_svc_create svc_tp_create rpc_svc_create svc_unreg rpc_svc_calls svc_unregister rpc_soc svc_vc_create rpc_svc_create svcerr_auth rpc_svc_err svcerr_decode rpc_svc_err svcerr_noproc rpc_svc_err svcerr_noprog rpc_svc_err svcerr_progvers rpc_svc_err svcerr_systemerr rpc_svc_err svcerr_weakauth rpc_svc_err svcfd_create rpc_soc svcraw_create rpc_soc svctcp_create rpc_soc svcudp_bufcreate rpc_soc svcudp_create rpc_soc xdr_accepted_reply rpc_xdr xdr_authsys_parms rpc_xdr xdr_authunix_parms rpc_soc xdr_callhdr rpc_xdr xdr_callmsg rpc_xdr xdr_opaque_auth rpc_xdr xdr_rejected_reply rpc_xdr xdr_replymsg rpc_xdr xprt_register rpc_svc_calls xprt_unregister rpc_svc_calls RPC Synopsistc "RPC Synopsis" cl [ option ... ] filename ... -link [ linkoption ... ] #include The RPC routines allow C language programs to make procedure calls on other machines across a network. First, the client sends a request to the server. On receipt of the request, the server calls a dispatch routine to perform the requested service, and then sends back a reply. All RPC routines require the header . Using the Nettype Stringtc "Using the Nettype String" Some of the high-level RPC interface routines (for example, clnt_create(), svc_create(), rpc_reg(), rpc_call()) take a nettype string as one of the parameters . This string defines a class of transports which can be used for a particular application. nettype can be one of the following: netpath Choose from the transports which have been indicated by their token names in the environment variable. If is unset or NULL, it defaults to visible. netpath is the default nettype. visible Choose the transports which have the visible flag(v) set in the /etc/netconfig file. circuit_v This is same as visible except that it chooses only the connection oriented transports (semantics tpi_cots or tpi_cots_ord) from the entries in the /etc/netconfig file. datagram_v This is same as visible except that it chooses only the connectionless datagram transports (semantics tpi_clts) from the entries in the /etc/netconfig file. circuit_n This is same as netpath except that it chooses only the connection oriented datagram transports (semantics tpi_cots or tpi_cots_ord). datagram_n This is same as netpath except that it chooses only the connectionless datagram transports (semantics tpi_clts). udp This refers to Internet UDP. tcp This refers to Internet TCP. If nettype is NULL, it defaults to netpath. The transports are tried in left to right order in the variable or in top to down order in the /etc/netconfig file. RPC Data Structurestc "RPC Data Structures" Some of the data structures used by the RPC package are shown below. The AUTH Structuretc "The AUTH Structure" union des_block { struct { u_int32 high; u_int32 low; } key; char c[8]; }; typedef union des_block des_block; extern bool_t xdr_des_block(); /* * Authentication info. Opaque to client. */ struct opaque_auth { enum_t oa_flavor; /* flavor of auth */ caddr_t oa_base; /* address of more auth stuff */ u_int oa_length; /* not to exceed MAX_AUTH_BYTES */ }; /* * Auth handle, interface to client side authenticators. */ typedef struct { struct opaque_auth ah_cred; struct opaque_auth ah_verf; union des_block ah_key; struct auth_ops { void (*ah_nextverf)(); int (*ah_marshal)(); /* nextverf & serialize */ int (*ah_validate)(); /* validate verifier */ int (*ah_refresh)(); /* refresh credentials */ void (*ah_destroy)(); /* destroy this structure */ } *ah_ops; caddr_t ah_private; } AUTH; The CLIENT Structuretc "The CLIENT Structure" /*tc "/*" * Client rpc handle. * Created by individual implementations * Client is responsible for initializing auth. */ typedef struct { AUTH *cl_auth; /* authenticator*/ struct clnt_ops { enum clnt_stat (*cl_call)(); /* call remote procedure */ void (*cl_abort)(); /* abort a call */ void (*cl_geterr)(); /* get specific error code */ bool_t (*cl_freeres)(); /* frees results */ void (*cl_destroy)(); /* destroy this structure */ bool_t (*cl_control)(); /* the ioctl() of rpc */ } *cl_ops; caddr_t cl_private; /* private stuff */ char *cl_netid; /* net identifier */ char *cl_tp; /* device name */ } CLIENT; The SVCXPRT Structuretc "The SVCXPRT Structure" enum xprt_stat {tc "enum xprt_stat {" XPRT_DIED, XPRT_MOREREQS, XPRT_IDLE }; /* * Server side transport handle */ typedef struct { int xp_fd; /* file descriptor for the server handle */ u_short xp_port; /* obsolete */ struct xp_ops { bool_t (*xp_recv)(); /* receive incoming requests */ enum xprt_stat (*xp_stat)(); /* get transport status */ bool_t (*xp_getargs)(); /* get arguments */ bool_t (*xp_reply)(); /* send reply */ bool_t (*xp_freeargs)(); /* free mem alloc. for args */ void (*xp_destroy)(); /* destroy this struct */ } *xp_ops; int xp_addrlen; /* length of remote addr. Obsolete */ char *xp_tp; /* transport provider device name */ char *xp_netid; /* network identifier */ struct netbuf xp_ltaddr; /* local transport address */ struct netbuf xp_rtaddr; /* remote transport address */ char xp_raddr[16]; /* remote address. Obsolete */ struct opaque_auth xp_verf; /* raw response verifier */ caddr_t xp_type /* transport/yp */ caddr_t xp_p1; /* private: for use by svc ops */ caddr_t xp_p2; /* private: for use by svc ops */ caddr_t xp_p3; /* private: for use by svc lib */ } SVCXPRT; The svc_reg Structuretc "The svc_reg Structure" struct svc_req { u_long rq_prog; /* service program number */ u_long rq_vers; /* service protocol version */ u_long rq_proc; /* the desired procedure */ struct opaque_auth rq_cred; /* raw creds from the wire */ caddr_t rq_clntcred; /* read only cooked cred */ SVCXPRT *rq_xprt; /* associated transport */ }; The XDR Structuretc "The XDR Structure" /* * XDR operations. * XDR_ENCODE causes the type to be encoded into the stream. * XDR_DECODE causes the type to be extracted from the stream. * XDR_FREE can be used to release the space allocated by an XDR_DECODE request. */ enum xdr_op { XDR_ENCODE=0, XDR_DECODE=1, XDR_FREE=2 }; /* The no. of bytes per unit of external data */ #define BYTES_PER_XDR_UNIT (4) #define RNDUP(x) ((((x) + BYTES_PER_XDR_UNIT - 1) / BYTES_PER_XDR_UNIT) \ * BYTES_PER_XDR_UNIT) /* * A xdrproc_t exists for each data type which is to be encoded or decoded. * The second argument to the xdrproc_t is a pointer to an opaque pointer. * The opaque pointer generally points to a structure of the data type * to be decoded. If this points to 0, then the type routines should * allocate dynamic storage of the appropriate size and return it. * bool_t (*xdrproc_t)(XDR *, caddr_t *); */ typedef bool_t (*xdrproc_t)(); /* * The XDR handle. * Contains operation which is being applied to the stream, * an operations vector for the particular implementation */ typedef struct { enum xdr_op x_op; /* operation; fast additional param */ struct xdr_ops { bool_t (*x_getlong)(); /* get a long from underlying stream */ bool_t (*x_putlong)(); /* put a long to the underlying stream*/ bool_t (*x_getbytes)(); /* get some bytes from the underlying stream */ bool_t (*x_putbytes)(); /* put some bytes to the underlying stream */ u_int (*x_getpostn)(); /* returns bytes off from beginning */ bool_t (*x_setpostn)(); /* lets you reposition the stream */ long * (*x_inline)(); /* buf quick ptr to buffered data */ void (*x_destroy)(); /* free privates of this xdr_stream */ } *x_ops; caddr_t x_public; /* users data */ caddr_t x_private; /* pointer to private data */ caddr_t x_base; /* private used for position info */ int x_handy; /* extra private word */ } XDR; rpc_clnt_auth rpc_clnt_authtc "rpc_clnt_auth rpc_clnt_auth" NAMEtc "NAME" rpc_clnt_auth, auth_destroy, authnone_create, authsys_create, authsys_create_default - library routines for client side remote procedure call authentication DESCRIPTIONtc "DESCRIPTION" These routines are part of the RPC library that allows C language programs to make procedure calls on other machines across the network, with desired authentication. These routines are normally called after creating the handle. The cl_auth field of the structure should be initialized by the structure returned by some of the following routines. The clients authentication information is passed to the server when the RPC call is made. Routinestc "Routines" The following routines require that the header be included (see rpc for the definition of the data structure). #include void auth_destroy(AUTH *auth); A function macro that destroys the authentication information associated with auth. Destruction usually involves deallocation of private data structures. The use of auth is undefined after calling auth destroy(). AUTH *authnone_create(void); Create and return an RPC authentication handle that passes nonusable authentication information with each remote procedure call. This is the default authentication used by RPC. AUTH *authsys_create(const char *host, const uid t uid, const gid_t gid, const int len, const gid t *aup gids); Create and return an RPC authentication handle that contains authentication information. The parameter host is the name of the machine on which the information was created; uid is the users user ID; gid is the users current group ID; len and aup gids refer to a counted array of groups to which the user belongs. AUTH *authsys_create_default(void); Call authsys_create() with the appropriate parameters. SEE ALSOtc "SEE ALSO" rpc, rpc_clnt_calls, rpc_clnt_create, secure_rpc rpc_clnt_calls rpc_clnt_callstc "rpc_clnt_calls rpc_clnt_calls" NAMEtc "NAME" rpc_clnt_calls, clnt_call, clnt_freeres, clnt_geterr, clnt_perrno, clnt_perror, clnt_sperrno, clnt_sperror, rpc_broadcast, rpc_broadcast_exp, rpc_call - library routines for client side calls DESCRIPTIONtc "DESCRIPTION" RPC library routines allow C language programs to make procedure calls on other machines across the network. First, the client calls a procedure to send a request to the server. Upon receipt of the request, the server calls a dispatch routine to perform the requested service, and then sends back a reply. The clnt_call(), rpc_call(), and rpc_broadcast() routines handle the client side of the procedure call. The remaining routines deal with error handling in the case of errors. Some of the routines take a CLIENT handle as one of the parameters. A CLIENT handle can be created by an RPC creation routine such as clnt_create() (see rpc_clnt_create). Routinestc "Routines" See rpc for the definition of the data structure. #include enum clnt_stat clnt_call(CLIENT *clnt, const u long procnum, const xdrproc_t inproc, const caddr_t in, const xdrproc t outproc, caddr t out, const struct timeval tout); A function macro that calls the remote procedure proc num associated with the client handle, clnt, which is obtained with an RPC client creation routine such as clnt_create() (see rpc_clnt_create). The parameter inproc is the XDR function used to encode the procedures parameters, and outproc is the XDR function used to decode the procedures results; in is the address of the procedures argument(s), and out is the address of where to place the result(s). tout is the time allowed for results to be returned, which is over-ridden by a default time-out set by clnt_create() or by clnt_create_vers() or by a time-out set explicitly through clnt_control(), see rpc_clnt_create. If the remote call succeeds, the status returned is RPC_SUCCESS, otherwise an appropriate status is returned. bool_t clnt_freeres(CLIENT *clnt, const xdrproc t outproc, caddr_t out); A function macro that frees any data allocated by the RPC/XDR system when it decoded the results of an RPC call. The parameter out is the address of the results, and outproc is the XDR routine describing the results. This routine returns 1 if the results were successfully freed, and 0 otherwise. void clnt_geterr(const CLIENT *clnt, struct rpc err *errp); A function macro that copies the error structure out of the client handle to the structure at address errp. void clnt_perrno(const enum clnt_stat stat); Print a message to standard error corresponding to the condition indicated by stat. A newline is appended. Normally used after a procedure call fails for a routine for which a client handle is not needed, for instance rpc_call(). void clnt_perror(const CLIENT *clnt, const char *s); Print a message to the standard error indicating why an RPC call failed; clnt is the handle used to do the call. The message is prepended with string s and a colon. A newline is appended. Normally used after a remote procedure call fails for a routine which requires a client handle, for instance clnt_call(). char *clnt_sperrno(const enum clnt_stat stat); Take the same arguments as clnt_perrno(), but instead of sending a message to the standard error indicating why an RPC call failed, return a pointer to a string which contains the message. clnt_sperrno() is normally used instead of clnt_perrno() when the program does not have a standard error (as a program running as a server quite likely does not), or if the programmer does not want the message to be output with printf(), or if a message format different than that supported by clnt_perrno() is to be used. Note: unlike clnt_sperror() and clnt_spcreaterror() (see rpc_clnt_create), clnt_sperrno() does not return pointer to static data so the result will not get overwritten on each call. char *clnt_sperror(const CLIENT *clnt, const char *s); Like clnt_perror(), except that (like clnt_sperrno()) it returns a string instead of printing to standard error. However, clnt_sperror() does not append a newline at the end of the message. Warning: Returns pointer to static data that is overwritten on each call. enum clnt_stat rpc_broadcast(const u_long prognum, const u_long versnum, const u long procnum, const xdrproc_t inproc, const caddr t in, const xdrproc_t outproc, caddr t out, const resultproc_t eachresult, const char *nettype); Like rpc_call(), except the call message is broadcast to all the connectionless transports specified by net type. If nettype is NULL, it defaults to netpath . Each time it receives a response, this routine calls eachresult(), whose form is: bool_t eachresult(caddr_t out, const struct netbuf *addr, const struct netconfig *netconf); where out is the same as out passed to rpc broadcast(), except that the remote procedures output is decoded there; addr points to the address of the machine that sent the results, and netconf is the netconfig structure of the transport on which the remote server responded. If eachresult() returns 0, rpc_broadcast() waits for more replies; otherwise it returns with appropriate status. Warning: Broadcast file descriptors are limited in size to the maximum transfer size of that transport. For Ethernet, this value is 1500 bytes. rpc_broadcast() uses SB AUTH_SYS credentials by default (see rpc_clnt_auth). enum clnt_stat rpc_broadcast_exp(const u_long prognum, const u_long versnum, const u long procnum, const xdrproc_t xargs, caddr t argsp, const xdrproc_t xresults, caddr t resultsp, const int inittime, const int waittime, const resultproc_t eachresult, const char *nettype); ); Like rpc_broadcast(), except that the initial timeout, inittime and the maximum timeout, waittime are specified in milliseconds. inittime is the initial time that rpc broadcast exp() waits before resending the request. After the first resend, the re-transmission interval increases exponentially until it exceeds waittime. enum clnt_stat rpc_call(const char *host, const u long prognum, const u_long versnum, const u long procnum, const xdrproc_t inproc, const char *in, const xdrproc_t outproc, char *out, const char *nettype); Call the remote procedure associated with prognum, versnum, and procnum on the machine, host. The parameter inproc is used to encode the procedures parameters, and outproc is used to decode the procedures results; in is the address of the procedures argument(s), and out is the address of where to place the result(s). nettype can be any of the values listed on rpc. This routine returns RPC_SUCCESS if it succeeds, or an appropriate status is returned. Use the clnt_perrno() routine to translate failure status into error messages. Warning: rpc_call() uses the first available transport belonging to the class nettype, on which it can create a connection. You do not have control of timeouts or authentication using this routine. SEE ALSOtc "SEE ALSO" rpc, rpc_clnt_auth, rpc_clnt_create rpc_clnt_create rpc_clnt_createtc "rpc_clnt_create rpc_clnt_create" NAMEtc "NAME" rpc_clnt_create, clnt_control, clnt_create, clnt_create_vers, clnt_destroy, clnt_dg_create, clnt_pcreateerror, clnt_raw_create, clnt_spcreateerror, clnt_tli_create, clnt_tp_create, clnt_vc_create, rpc_createerr - library routines for dealing with creation and manipulation of CLIENT handles DESCRIPTIONtc "DESCRIPTION" RPC library routines allow C language programs to make procedure calls on other machines across the network. First a handle is created and then the client calls a procedure to send a request to the server. On receipt of the request, the server calls a dispatch routine to perform the requested service, and then sends a reply. Routinestc "Routines" See rpc for the definition of the data structure. #include bool_t clnt_control(CLIENT *clnt, const u int req, char *info); A function macro to change or retrieve various information about a client object. req indicates the type of operation, and info is a pointer to the information. For both connectionless and connection-oriented transports, the supported values of req and their argument types and what they do are: CLSET_TIMEOUT struct timeval *set total timeout CLGET_TIMEOUT struct timeval *get total timeout [Note] If you set the timeout using clnt_control(), the timeout argument passed by clnt_call() is ignored in all subsequent calls. [Note] If you set the timeout value to 0 clnt_control() immediately returns an error (RPC_TIMEDOUT). Set timeout to 0 for batching calls. CLGET_FD int * get the associated file descriptor CLGET_SVC_ADDR struct netbuf *get servers address CLSET_FD_CLOSE voidclose the file descriptor when destroying the client handle (see clnt_destroy()) CLSET_FD_NCLOSE voiddo not close the file descriptor when destroyingthe client handle CLGET_VERS unsigned long *get the RPC programs version number associated with the client handle CLSET_VERS unsigned long *set the RPC programs version number associated with the client handle. This assumes that the RPC server for this new version is still listening at the address of the previous version. CLGET_XID unsigned long *get the XID of the previous remote procedure call CLSET_XID unsigned long *set the XID of the next remote procedure call The following operations are valid for connectionless transports only: CLSET_RETRY_TIMEOUT struct timeval * set the retry timeout CLGET_RETRY_TIMEOUT struct timeval * get the retry timeout The retry timeout is the time that RPC waits for the server to reply before retransmitting the request. clnt_control() returns on success and on failure. CLIENT *clnt_create(const char *host, const u long prognum, const u_long versnum, const char *nettype); Generic client creation routine for program prognum and version versnum. host identifies the name of the remote host where the server is located. nettype indicates the class of transport protocol to use. The transports are tried in left to right order in variable or in top to bottom order in the netconfig database. clnt_create() tries all the transports of the nettype class available from the environment variable and the netconfig database, and chooses the first successful one. A default timeout is set and can be modified using clnt_control(). This routine returns if it fails. The clnt_pcreaterror() routine can be used to print the reason for failure. [Note] clnt_create() returns a valid client handle even if the particular version number supplied to clnt_create() is not registered with the rpcbind service. This mismatch will be discovered by a clnt_call later (see rpc_clnt_calls). CLIENT *clnt_create_vers(const char *host, const u long prognum, u_long *vers outp, const u long vers low, const u_long vers high, char *nettype); Generic client creation routine which is similar to clnt_create() but which also checks for the version availability. host identifies the name of the remote host where the server is located. nettype indicates the class transport protocols to be used. If the routine is successful it returns a client handle created for the highest version between vers low and vers high that is supported by the server. vers outp is set to this value. That is, after a successful return vers low <= *vers outp <= vers high. If no version between vers low and vers high is supported by the server then the routine fails and returns NULL. A default timeout is set and can be modified using clnt_control(). This routine returns if it fails. The clnt_pcreaterror() routine can be used to print the reason for failure. [Note] clnt_create() returns a valid client handle even if the particular version number supplied to clnt_create() is not registered with the rpcbind service. This mismatch will be discovered by a clnt_call later (see rpc_clnt_calls). However, clnt_create_vers() does this for you and returns a valid handle only if a version within the range supplied is supported by the server. void clnt_destroy(CLIENT *clnt); A function macro that destroys the clients RPC handle. Destruction usually involves deallocation of private data structures, including clnt itself. Use of clnt is undefined after calling clnt_destroy(). If the RPC library opened the associated file descriptor, or was set using clnt_control(), the file descriptor will be closed. The caller should call auth_destroy(clnt->cl auth) (before calling clnt_destroy()) to destroy the associated AUTH structure (see rpc_clnt_auth). CLIENT *clnt_dg_create(const int fildes, const struct netbuf *svcaddr, const u long prognum, const u_long versnum, const u int sendsz, const u_int recvsz); This routine creates an RPC client for the remote program prognum and version versnum; the client uses a connectionless transport. The remote program is located at address svcaddr. The parameter fildes is an open and bound file descriptor. This routine will resend the call message in intervals of 15 seconds until a response is received or until the call times out. The total time for the call to time out is specified by clnt_call() (see clnt_call() in rpc_clnt_calls). The retry time out and the total time out periods can be changed using clnt_control(). The user may set the size of the send and receive buffers with the parameters sendsz and recvsz; values of 0 choose suitable defaults. This routine returns if it fails. void clnt_pcreateerror(const char *s); Print a message to standard error indicating why a client RPC handle could not be created. The message is prepended with the string s and a colon, and appended with a newline. CLIENT *clnt_raw_create(const u_long prognum, const u_long versnum); This routine creates an RPC client handle for the remote program prognum and version versnum. The transport used to pass messages to the service is a buffer within the processs address space, so the corresponding RPC server should live in the same address space; (see svc_raw_create() in rpc_svc_create). This allows simulation of RPC and measurement of RPC overheads, such as round trip times, without any kernel or networking interference. This routine returns if it fails. clnt_raw_create() should be called after svc_raw_create(). char *clnt_spcreateerror(const char *s); Like clnt_pcreateerror(), except that it returns a string instead of printing to the standard error. A newline is not appended to the message in this case. Warning: Returns a pointer to static data that is overwritten on each call. CLIENT *clnt_tli_create(const int fildes, const struct netconfig *netconf, const struct netbuf *svcaddr, const long prognum, const u_long versnum, const u int sendsz, const u_int recvsz); This routine creates an RPC client handle for the remote program prognum and version versnum. The remote program is located at address svcaddr. If svcaddr is and it is connection-oriented, it is assumed that the file descriptor is connected. For connectionless transports, if svcaddr is NULL, error is set. fildes is a file descriptor which may be open, bound and connected. If it is RPC_ANYFD, it opens a file descriptor on the transport specified by netconf. If fildes is and netconf is NULL, a error is set. If fildes is unbound, then it will attempt to bind the descriptor. The user may specify the size of the buffers with the parameters sendsz and recvsz; values of 0 choose suitable defaults. Depending upon the type of the transport (connection-oriented or connectionless), clnt_tli_create() calls appropriate client creation routines. This routine returns if it fails. The clnt_pcreaterror() routine can be used to print the reason for failure. The remote rpcbind service is not consulted for the address of the remote service. CLIENT *clnt_tp_create(const char *host, const u long prognum, const u_long versnum, const struct netconfig *netconf); Like clnt_create() except clnt_tp_create() tries only one transport specified through netconf. clnt_tp_create() creates a client handle for the program prognum, the version versnum, and for the transport specified by netconf. Default options are set, which can be changed using clnt_control() calls. The remote rpcbind service on the host host is consulted for the address of the remote service. This routine returns if it fails. The clnt_pcreaterror() routine can be used to print the reason for failure. CLIENT *clnt_vc_create(const int fildes, const struct netbuf *svcaddr, const u long prognum, const u_long versnum, const u int sendsz, const u_int recvsz); This routine creates an RPC client for the remote program prognum and version versnum; the client uses a connection-oriented transport. The remote program is located at address svcaddr. The parameter fildes is an open and bound file descriptor. The user may specify the size of the send and receive buffers with the parameters sendsz and recvsz; values of 0 choose suitable defaults. This routine returns if it fails. The address svcaddr should not be and should point to the actual address of the remote program. clnt_vc_create() does not consult the remote rpcbind service for this information. struct rpc_createerr rpc_createerr; A global variable whose value is set by any RPC client handle creation routine that fails. It is used by the routine clnt_pcreateerror() to print the reason for the failure. SEE ALSOtc "SEE ALSO" rpc, rpc_clnt_auth, rpc_clnt_calls rpc_svc_calls rpc_svc_callstc "rpc_svc_calls rpc_svc_calls" NAMEtc "NAME" rpc_svc_calls, svc_dg_enablecache, svc_exit, svc_fdset, svc_freeargs, svc_getargs, svc_getreq_common, svc_getreq_poll, svc_getreqset, svc_getrpccaller, svc_pollset, svc_run, svc_sendreply - library routines for RPC servers DESCRIPTIONtc "DESCRIPTION" These routines are part of the RPC library which allows C language programs to make procedure calls on other machines across the network. These routines are associated with the server side of the RPC mechanism. Some of them are called by the server side dispatch function, while others (such as svc_run()) are called when the server is initiated. Routinestc "Routines" #include int svc_dg_enablecache(SVCXPRT *xprt, const unsigned long cache size); This function allocates a duplicate request cache for the service endpoint xprt, large enough to hold cache size entries. Once enabled, there is no way to disable caching. This routine returns 0 if space necessary for a cache of the given size was successfully allocated, and 1 otherwise. void svc_exit(void); This function when called by any of the RPC server procedure or otherwise, causes svc_run() to return. fd_set svc_fdset; A global variable reflecting the RPC servers read file descriptor bit mask; it is suitable as a parameter to the select(3C) system call. This is only of interest if service implementors do not call svc_run(), but rather do their own asynchronous event processing. This variable is read-only (do not pass its address to select(3C)!), yet it may change after calls to svc_getreqset() or any creation routines. bool_t svc_freeargs(const SVCXPRT *xprt, const xdrproc t inproc, caddr_t in); A function macro that frees any data allocated by the system when it decoded the arguments to a service procedure using svc_getargs(). This routine returns if the results were successfully freed, and otherwise. bool_t svc_getargs(const SVCXPRT *xprt, const xdrproc t inproc, caddr_t in); A function macro that decodes the arguments of an RPC request associated with the RPC service transport handle xprt. The parameter in is the address where the arguments will be placed; inproc is the XDR routine used to decode the arguments. This routine returns if decoding succeeds, and otherwise. void svc_getreq_common(const int fd); This routine is called to handle a request on the given file descriptor. void svc_getreq_poll(struct pollfd *pfdp, const int pollretval); This routine is only of interest if a service implementor does not call svc_run(), but instead implements custom asynchronous event processing. It is called when poll(2) has determined that an RPC request has arrived on some RPC file descriptors; pollretval is the return value from poll() and pfdp is the array of pollfd structures on which the poll() was done. It is assumed to be an array large enough to contain the maximal number of descriptors allowed. void svc_getreqset(fd_set *rdfds); This routine is only of interest if a service implementor does not call svc_run(), but instead implements custom asynchronous event processing. It is called when poll() has determined that an RPC request has arrived on some RPC file descriptors; rdfds is the resultant read file descriptor bit mask. The routine returns when all file descriptors associated with the value of rdfds have been serviced. struct netbuf *svc_getrpccaller(const SVCXPRT *xprt); The approved way of getting the network address of the caller of a procedure associated with the RPC service transport handle xprt. void svc_run(void); This routine never returns. It waits for RPC requests to arrive, and calls the appropriate service procedure using svc_getreq_poll() when one arrives. This procedure is usually waiting for the poll() library call to return. bool_t svc_sendreply(const SVCXPRT *xprt, const xdrproc_t outproc, const caddr t *out); Called by an RPC services dispatch routine to send the results of a remote procedure call. The parameter xprt is the requests associated transport handle; outproc is the XDR routine which is used to encode the results; and out is the address of the results. This routine returns if it succeeds, otherwise. SEE ALSOtc "SEE ALSO" rpc, rpc_svc_create, rpc_svc_err rpc_svc_create rpc_svc_createtc "rpc_svc_create rpc_svc_create" NAMEtc "NAME" rpc_svc_create, svc_create, svc_destroy, svc_dg_create, svc_fd_create, svc_raw_create, svc_tli_create, svc_tp_create, svc_vc_create - library routines for the creation of server handles DESCRIPTIONtc "DESCRIPTION" These routines are part of the RPC library which allows C language programs to make procedure calls on servers across the network. These routines deal with the creation of service handles. Once the handle is created, the server can be invoked by calling svc_run(). Routinestc "Routines" See rpc for the definition of the data structure. #include int svc_create(const void (*dispatch)(struct svc_req * rqstp , SVCXPRT * transp ), const u_long prognum, const u_long versnum, const char *nettype); svc_create() creates server handles for all the transports belonging to the class nettype. nettype defines a class of transports which can be used for a particular application. The transports are tried in left to right order in variable or in top to bottom order in the netconfig database. If nettype is NULL, it defaults to netpath. svc_create() registers itself with the rpcbind service. dispatch is called when there is a remote procedure call for the given prognum and vers num; this requires calling svc run() (see svc run() in rpc_svc_reg). If svc_create() succeeds, it returns the number of server handles it created, otherwise it returns 0 and an error message is logged. void svc_destroy(SVCXPRT *xprt); A function macro that destroys the RPC service handle xprt. Destruction usually involves deallocation of private data structures, including xprt itself. Use of xprt is undefined after calling this routine. SVCXPRT *svc_dg_create(const int fildes, const u int sendsz, const u_int recvsz); This routine creates a connectionless RPC service handle, and returns a pointer to it. This routine returns if it fails, and an error message is logged. sendsz and recvsz are parameters used to specify the size of the buffers. If they are 0, suitable defaults are chosen. The file descriptor fildes should be open and bound. The server is not registered with rpcbind. Warning: Since connectionless-based RPC messages can only hold limited amount of encoded data, this transport cannot be used for procedures that take large arguments or return huge results. SVCXPRT *svc_fd_create(const int fildes, const u int sendsz, const u_int recvsz); This routine creates a service on top of an open and bound file descriptor, and returns the handle to it. Typically, this descriptor is a connected file descriptor for a connection-oriented transport. sendsz and recvsz indicate sizes for the send and receive buffers. If they are 0, reasonable defaults are chosen. This routine returns if it fails, and an error message is logged. SVCXPRT *svc_raw_create(void); This routine creates an RPC service handle and returns a pointer to it. The transport is really a buffer within the processs address space, so the corresponding RPC client should live in the same address space; (see clnt_raw_create() in rpc_clnt_create). This routine allows simulation of RPC and acquisition of RPC overheads (such as round trip times), without any kernel and networking interference. This routine returns if it fails, and an error message is logged. [Note] svc_run() should not be called when the raw interface is being used. SVCXPRT *svc_tli_create(const int fildes, const struct netconfig *netconf, const struct t_bind *bindaddr, const u int sendsz, const u_int recvsz); This routine creates an RPC server handle, and returns a pointer to it. fildes is the file descriptor on which the service is listening. If fildes is RPC ANYFD, it opens a file descriptor on the transport specified by netconf. If the file descriptor is unbound and bindaddr is non-null fildes is bound to the address specified by bindaddr, otherwise fildes is bound to a default address chosen by the transport. In the case where the default address is chosen, the number of outstanding connect requests is set to 8 for connectionoriented transports. The user may specify the size of the send and receive buffers with the parameters sendsz and recvsz ; values of 0 choose suitable defaults. This routine returns if it fails, and an error message is logged. The server is not registered with the rpcbind service. SVCPRT *svc_tp_create(const void (*dispatch) (const struct svc_reg *, const SVCXPRT *), const u_long prognum, const u long versnum, const struct netconfig *netconf); svc_tp_create() creates a server handle for the network specified by netconf, and registers itself with the rpcbind service. dispatch is called when there is a remote procedure call for the given prognum and versnum; this requires calling svc run(). svc tp create() returns the service handle if it succeeds, otherwise a is returned and an error message is logged. SVCXPRT *svc_vc_create(const int fildes, const u int sendsz, const u_int recvsz); This routine creates a connection-oriented RPC service and returns a pointer to it. This routine returns if it fails, and an error message is logged. The users may specify the size of the send and receive buffers with the parameters sendsz and recvsz; values of 0 choose suitable defaults. The file descriptor fildes should be open and bound. The server is not registered with the rpcbind service. SEE ALSOtc "SEE ALSO" rpc, rpc_svc_calls, rpc_svc_err, rpc_svc_reg rpc_svc_err rpc_svc_errtc "rpc_svc_err rpc_svc_err" NAMEtc "NAME" rpc_svc_err, svcerr_auth, svcerr_decode, svcerr_noproc, svcerr_noprog, svcerr_progvers, svcerr_systemerr, svcerr_weakauth - library routines for server side remote procedure call errors DESCRIPTIONtc "DESCRIPTION" These routines are part of the RPC library which allows C language programs to make procedure calls on other machines across the network. These routines can be called by the server side dispatch function if there is any error in the transaction with the client. Routinestc "Routines" See rpc for the definition of the data structure. #include void svcerr_auth(const SVCXPRT *xprt, const enum auth stat why); Called by a service dispatch routine that refuses to perform a remote procedure call due to an authentication error. void svcerr_decode(const SVCXPRT *xprt); Called by a service dispatch routine that cannot successfully decode the remote parameters (see svc_getargs() in rpc_svc_reg). void svcerr_noproc(const SVCXPRT *xprt); Called by a service dispatch routine that does not implement the procedure number that the caller requests. void svcerr_noprog(const SVCXPRT *xprt); Called when the desired program is not registered with the RPC package. Service implementors usually do not need this routine. void svcerr_progvers(const SVCXPRT *xprt, u long low vers, u_long high vers); Called when the desired version of a program is not registered with the RPC package. low vers is the lowest version number, and high vers is the highest version number. Service implementors usually do not need this routine. void svcerr_systemerr(const SVCXPRT *xprt); Called by a service dispatch routine when it detects a system error not covered by any particular protocol. For example, if a service can no longer allocate storage, it may call this routine. void svcerr_weakauth(const SVCXPRT *xprt); Called by a service dispatch routine that refuses to perform a remote procedure call due to insufficient (but correct) authentication parameters. The routine calls svcerr_auth(xprt, AUTH_TOOWEAK). SEE ALSOtc "SEE ALSO" rpc, rpc_svc_calls, rpc_svc_create, rpc_svc_reg rpc_svc_reg rpc_svc_regtc "rpc_svc_reg rpc_svc_reg" NAMEtc "NAME" rpc_svc_reg, rpc_reg, svc_reg, svc_unreg, svc_auth_reg, xprt_register, xprt_unregister - library routines for registering servers DESCRIPTIONtc "DESCRIPTION" These routines are a part of the RPC library which allows the RPC servers to register themselves with rpcbind() and associate the given program and version number with the dispatch function. When the RPC server receives a RPC request, the library invokes the dispatch routine with the appropriate arguments. Routinestc "Routines" See rpc for the definition of the data structure. #include bool_t rpc_reg(const u_long prognum, const u long versnum, const u_long procnum, const char *(*procname), const xdrproc_t inproc, const xdrproc_t outproc, const char *nettype); Register program prognum, procedure procname, and version versnum with the RPC service package. If a request arrives for program prognum, version versnum, and procedure procnum, procname is called with a pointer to its parameter(s); procname should return a pointer to its static result(s); inproc is the XDR function used to decode the parameters while outproc is the XDR function used to encode the results. Procedures are registered on all available transports of the class nettype. See rpc. This routine returns 0 if the registration succeeded, -1 otherwise. int svc_reg(const SVCXPRT *xprt, const u long prognum, const u_long versnum, const void (*dispatch), const struct netconfig *netconf); Associates prognum and versnum with the service dispatch procedure, dispatch. If netconf is NULL, the service is not registered with the rpcbind service. If netconf is non-zero, then a mapping of the triple [prognum, versnum, netconf->nc netid] to xprt->xp ltaddr is established with the local rpcbind service. The svc_reg() routine returns 1 if it succeeds, and 0 otherwise. void svc_unreg(const u_long prognum, const u long versnum); Remove from the rpcbind service, all mappings of the triple [prognum, versnum, all-transports] to network address and all mappings within the RPC service package of the double [prognum, versnum] to dispatch routines. int svc_auth_reg(const int cred flavor, const enum auth stat (*handler)); Registers the service authentication routine handler with the dispatch mechanism so that it can be invoked to authenticate RPC requests received with authentication type cred flavor. This interface allows developers to add new authentication types to their RPC applications without needing to modify the libraries. Service implementors usually do not need this routine. Typical service application would call svc_auth_reg() after registering the service and prior to calling svc_run(). When needed to process an RPC credential of type cred flavor, the handler procedure will be called with two parameters (struct svc_req *rqst, struct rpc_msg *msg) and is expected to return a valid enum auth_stat value. There is no provision to change or delete an authentication handler once registered. The svc_auth_reg() routine returns 0 if the registration is successful, 1 if cred flavor already has an authentication handler registered for it, and -1 otherwise. void xprt_register(const SVCXPRT *xprt); After RPC service transport handle xprt is created, it is registered with the RPC service package. This routine modifies the global variable svc_fdset (see rpc_svc_calls). Service implementors usually do not need this routine. void xprt_unregister(const SVCXPRT *xprt); Before an RPC service transport handle xprt is destroyed, it unregisters itself with the RPC service package. This routine modifies the global variable svc_fdset (see rpc_svc_calls). Service implementors usually do not need this routine. SEE ALSOtc "SEE ALSO" rpc, rpc_svc_calls, rpc_svc_create, rpc_svc_err, rpcbind rpc_xdr rpc_xdrtc "rpc_xdr rpc_xdr" NAMEtc "NAME" rpc_xdr, xdr_accepted_reply, xdr_authsys_parms, xdr_callhdr, xdr_callmsg, xdr_opaque_auth, xdr_rejected_reply, xdr_replymsg - XDR library routines for remote procedure calls DESCRIPTIONtc "DESCRIPTION" These routines are used for describing the RPC messages in XDR language. They should normally be used by those who do not want to use the RPC package directly. These routines return TRUE if they succeed, FALSE otherwise. Routinestc "Routines" See rpc for the definition of the data structure. #include bool_t xdr_accepted_reply(XDR *xdrs, const struct accepted_reply *ar); Used to translate between RPC reply messages and their external representation. It includes the status of the RPC call in the XDR language format. In the case of success, it also includes the call results. bool_t xdr_authsys_parms(XDR *xdrs, struct authsys parms *aupp); Used for describing UNIX operating system credentials. It includes machine-name, uid, gid list, etc. void xdr_callhdr(XDR *xdrs, struct rpc msg *chdr); Used for describing RPC call header messages. It encodes the static part of the call message header in the XDR language format. It includes information such as transaction ID, RPC version number, program and version number. bool_t xdr_callmsg(XDR *xdrs, struct rpc msg *cmsg); Used for describing RPC call messages. This includes all the RPC call information such as transaction ID, RPC version number, program number, version number, authentication information, etc. This is normally used by servers to determine information about the client RPC call. bool_t xdr_opaque_auth(XDR *xdrs, struct opaque auth *ap); Used for describing RPC opaque authentication information messages. bool_t xdr_rejected_reply(XDR *xdrs, const struct rejected_reply *rr); Used for describing RPC reply messages. It encodes the rejected RPC message in the XDR language format. The message could be rejected either because of version number mis-match or because of authentication errors. bool_t xdr_replymsg(XDR *xdrs, const struct rpc msg *rmsg); Used for describing RPC reply messages. It translates between the RPC reply message and its external representation. This reply could be either an acceptance, rejection or NULL. SEE ALSOtc "SEE ALSO" rpc, xdr rpcbind rpcbindtc "rpcbind rpcbind" NAMEtc "NAME" rpcbind, rpcb_getmaps, rpcb_getaddr, rpcb_gettime, rpcb_rmtcall, rpcb_set, rpcb_unset - library routines for RPC bind service DESCRIPTIONtc "DESCRIPTION" These routines allow client C programs to make procedure calls to the RPC binder service. rpcbind maintains a list of mappings between programs and their universal addresses. Routinestc "Routines" #include tc "#include " struct rpcblist *rpcb_getmaps(const struct netconfig *netconf, const char *host); An interface to the rpcbind service, which returns a list of the current RPC program-to-address mappings on host. It uses the transport specified through netconf to contact the remote rpcbind service on host. This routine will return NULL, if the remote rpcbind could not be contacted. bool_t rpcb_getaddr(const u_long prognum, const u long versnum, const struct netconfig *netconf, struct netbuf *svcaddr, const char *host); An interface to the rpcbind service, which finds the address of the service on host that is registered with program number prognum, version versnum, and speaks the transport protocol associated with netconf. The address found is returned in svcaddr. svcaddr should be preallocated. This routine returns if it succeeds. A return value of means that the mapping does not exist or that the RPC system failed to contact the remote rpcbind service. In the latter case, the global variable rpc_createerr (see rpc_clnt_create) contains the RPC status. bool_t rpcb_gettime(const char *host, time t *timep); This routine returns the time on host in timep. If host is NULL, rpcb gettime() returns the time on its own machine. This routine returns if it succeeds, if it fails. rpcb_gettime() can be used to synchronize the time between the client and the remote server. This routine is particularly useful for secure RPC. enum clnt_stat rpcb_rmtcall(const struct netconfig *netconf, const char *host, const u long prognum, const u_long versnum, const u long procnum, const xdrproc_t inproc, const caddr t in, const xdrproc_t outproc, caddr t out, const struct timeval tout, struct netbuf *svcaddr); An interface to the rpcbind service, which instructs rpcbind on host to make an RPC call on your behalf to a procedure on that host. The netconfig structure should correspond to a connectionless transport. The parameter *svcaddr will be modified to the servers address if the procedure succeeds (see rpc_call() and clnt_call() in rpc_clnt_calls for the definitions of other parameters). This procedure should normally be used for a ping and nothing else. This routine allows programs to do lookup and call, all in one step. [Note] Even if the server is not running rpcbind does not return any error messages to the caller. In such a case, the caller times out. [Note] rpcb_rmtcall() is only available for connectionless transports. bool_t rpcb_set(const u_long prognum, const u long versnum, const struct netconfig *netconf, const struct netbuf *svcaddr); An interface to the rpcbind service, which establishes a mapping between the triple [prognum, versnum, netconf->nc netid] and svcaddr on the machines rpcbind service. The value of nc netid must correspond to a network identifier that is defined by the netconfig database. This routine returns if it succeeds, otherwise. (See also svc_reg() in rpc_svc_calls). If there already exists such an entry with rpcbind, rpcb_set() will fail. bool_t rpcb_unset(const u_long prognum, const u long versnum, const struct netconfig *netconf); An interface to the rpcbind service, which destroys the mapping between the triple [prognum, versnum, netconf->nc netid] and the address on the machines rpcbind service. If netconf is NULL, rpcb unset() destroys all mapping between the triple [prognum, versnum, all-transports] and the addresses on the machines rpcbind service. This routine returns if it succeeds, otherwise. Only the owner of the service or the super-user can destroy the mapping. (See also svc_unreg() in rpc_svc_calls). SEE ALSOtc "SEE ALSO" rpcbind(1M), rpcinfo(1M), rpc_clnt_calls, rpc_svc_calls xdr xdrtc "xdr xdr" NAMEtc "NAME" xdr - library routines for external data representation DESCRIPTIONtc "DESCRIPTION" XDR routines allow C programmers to describe arbitrary data structures in a machine-independent fashion. Data for remote procedure calls (RPC) are transmitted using these routines. Index to Routinestc "Index to Routines" The following table lists XDR routines and the sections in which they are described: XDR Routine Section xdr_array xdr_complex xdr_bool xdr_simple xdr_bytes xdr_complex xdr_char xdr_simple xdr_destroy xdr_create xdr_double xdr_simple xdr_enum xdr_simple xdr_float xdr_simple xdr_free xdr_simple xdr_getpos xdr_admin xdr_hyper xdr_simple xdr_inline xdr_admin xdr_int xdr_simple xdr_long xdr_simple xdr_longlong_t xdr_simple xdr_opaque xdr_complex xdr_pointer xdr_complex xdr_quadruple xdr_simple xdr_reference xdr_complex xdr_setpos xdr_admin xdr_short xdr_simple xdr_string xdr_complex xdr_u_char xdr_simple xdr_u_hyper xdr_simple xdr_u_int xdr_simple xdr_u_long xdr_simple xdr_u_longlong_t xdr_simple xdr_u_short xdr_simple xdr_union xdr_complex xdr_vector xdr_complex xdr_void xdr_simple xdr_wrapstring xdr_complex xdrmem_create xdr_create xdrrec_create xdr_create xdrrec_endofrecord xdr_admin xdrrec_eof xdr_admin xdrrec_skiprecord xdr_admin xdrstdio_create xdr_create SEE ALSOtc "SEE ALSO" rpc, xdr_admin, xdr_complex, xdr_create, xdr_simple xdr_admin xdr_admintc "xdr_admin xdr_admin" NAMEtc "NAME" xdr_admin, xdr_getpos, xdr_inline, xdrrec_endofrecord, xdrrec_eof, xdrrec_skiprecord, xdr_setpos, xdr_sizeof library routines for external data representation DESCRIPTIONtc "DESCRIPTION" XDR library routines allow C programmers to describe arbitrary data structures in a machine-independent fashion. Protocols such as remote procedure calls (RPC) use these routines to describe the format of the data. These routines deal specifically with the management of the XDR stream. Routinestc "Routines" See rpc for the definition of the data structure. Note that any buffers passed to the XDR routines must be properly aligned. It is suggested that malloc(3C) be used to allocate these buffers or that the programmer insure that the buffer address is divisible evenly by four. #include u_int xdr_getpos(const XDR *xdrs); A macro that invokes the get-position routine associated with the XDR stream, xdrs. The routine returns an unsigned integer, which indicates the position of the XDR byte stream. A desirable feature of XDR streams is that simple arithmetic works with this number, although the XDR stream instances need not guarantee this. Therefore, applications written for portability should not depend on this feature. long *xdr_inline(XDR *xdrs, const int len); A macro that invokes the in-line routine associated with the XDR stream, xdrs. The routine returns a pointer to a contiguous piece of the streams buffer; len is the byte length of the desired buffer. Note: pointer is cast to long *. Warning: xdr_inline() may return (0) if it cannot allocate a contiguous piece of a buffer. Therefore the behavior may vary among stream instances; it exists for the sake of efficiency, and applications written for portability should not depend on this feature. bool_t xdrrec_endofrecord(XDR *xdrs , int sendnow); This routine can be invoked only on streams created by xdrrec_create() (see xdr_create). The data in the output buffer is marked as a completed record, and the output buffer is optionally written out if sendnow is non-zero. This routine returns TRUE if it succeeds, FALSE otherwise. bool_t xdrrec_eof(XDR *xdrs); This routine can be invoked only on streams created by xdrrec_create(). After consuming the rest of the current record in the stream, this routine returns if the stream has no more input, otherwise. bool_t xdrrec_skiprecord(XDR *xdrs); This routine can be invoked only on streams created by xdrrec_create() (see xdr_create). It tells the XDR implementation that the rest of the current record in the streams input buffer should be discarded. This routine returns TRUE if it succeeds, FALSE otherwise. bool_t xdr_setpos(XDR *xdrs, const u int pos); A macro that invokes the set position routine associated with the XDR stream xdrs. The parameter pos is a position value obtained from xdr_getpos(). This routine returns if the XDR stream was repositioned, and otherwise. Warning: It is difficult to reposition some types of XDR streams, so this routine may fail with one type of stream and succeed with another. Therefore, applications written for portability should not depend on this feature. unsigned long xdr_sizeof(xdrproc_t func, void *data); This routine returns the number of bytes required to encode data using the XDR filter function func, excluding potential overhead such as RPC headers or record markers. O is returned on error. This information might be used to select between transport protocols, or to determine the buffer size for various lower levels of RPC client and server creation routines, or to allocate storage when XDR is used outside of the RPC subsystem. SEE ALSOtc "SEE ALSO" malloc(3C), rpc, xdr_complex, xdr_create, xdr_simple xdr_complex xdr_complextc "xdr_complex xdr_complex" NAMEtc "NAME" xdr_complex, xdr_array, xdr_bytes, xdr_opaque, xdr_pointer, xdr_reference, xdr_string, xdr_union, xdr_vector, xdr_wrapstring - library routines for external data representation DESCRIPTIONtc "DESCRIPTION" XDR library routines allow C programmers to describe complex data structures in a machine-independent fashion. Protocols such as remote procedure calls (RPC) use these routines to describe the format of the data. These routines are the XDR library routines for complex data structures. They require the creation of XDR stream (see xdr_create). Routinestc "Routines" See rpc for the definition of the data structure. Note that any buffers passed to the XDR routines must be properly aligned. It is suggested that malloc() be used to allocate these buffers or that the programmer insure that the buffer address is divisible evenly by four. #include bool_t xdr_array(XDR *xdrs, caddr t *arrp, u int *sizep, const u_int maxsize, const u int elsize, const xdrproc_t elproc); xdr_array() translates between variable-length arrays and their corresponding external representations. The parameter arrp is the address of the pointer to the array, while sizep is the address of the element count of the array; this element count cannot exceed maxsize. The parameter elsize is the size of each of the arrays elements, and elproc is an XDR routine that translates between the array elements C form and their external representation. If *aarp is null when decoding, xdr_array() allocates memory and *aarp points to it. This routine returns if it succeeds, otherwise. bool_t xdr_bytes(XDR *xdrs, char **sp, u int *sizep, const u_int maxsize); xdr_bytes() translates between counted byte strings and their external representations. The parameter sp is the address of the string pointer. The length of the string is located at address sizep; strings cannot be longer than maxsize. If *sp is null when decoding, xdr_bytes() allocates memory and *sp points to it. This routine returns if it succeeds, otherwise. bool_t xdr_opaque(XDR *xdrs, caddr t cp, const u int cnt); xdr_opaque() translates between fixed size opaque data and its external representation. The parameter cp is the address of the opaque object, and cnt is its size in bytes. This routine returns if it succeeds, otherwise. bool_t xdr_pointer(XDR *xdrs, char **objpp, u int objsize, const xdrproc_t xdrobj); Like xdr_reference() except that it serializes pointers, whereas xdr_reference() does not. Thus, xdr_pointer() can represent recursive data structures, such as binary trees or linked lists. If *objpp is null when decoding, xdr_pointer() allocates memory and *objpp points to it. bool_t xdr_reference(XDR *xdrs, caddr t *pp, u int size, const xdrproc_t proc); xdr_reference() provides pointer chasing within structures. The parameter pp is the address of the pointer; size is the sizeof the structure that *pp points to; and proc is an XDR procedure that translates the structure between its C form and its external representation. If *pp is null when decoding, xdr reference() allocates memory and *pp points to it. This routine returns 1 if it succeeds, 0 otherwise. Warning: This routine does not understand pointers. Use xdr_pointer() instead. bool_t xdr_string(XDR *xdrs, char **sp, const u int maxsize); xdr_string() translates between C strings and their corresponding external representations. Strings cannot be longer than maxsize. Note: sp is the address of the strings pointer. If *sp is null when decoding, xdr_string() allocates memory and *sp points to it. This routine returns Note: xdr_string() can be used to send an empty string (), but not a NULL string. if it succeeds, otherwise. bool_t xdr_union(XDR *xdrs, enum t *dscmp, char *unp, const struct xdr_discrim *choices, const xdrproc_t (*defaultarm); xdr_union() translates between a discriminated C union and its corresponding external representation. It first translates the discriminant of the union located at dscmp. This discriminant is always an enum t. Next the union located at unp is translated. The parameter choices is a pointer to an array of xdr discrim structures. Each structure contains an ordered pair of [value, proc]. If the unions discriminant is equal to the associated value, then the proc is called to translate the union. The end of the xdr_discrim structure array is denoted by a routine of value NULL. If the discriminant is not found in the choices array, then the defaultarm procedure is called (if it is not NULL). Returns if it succeeds, otherwise. bool_t xdr_vector(XDR *xdrs, char *arrp, const u int size, const u_int elsize, const xdrproc t elproc); xdr_vector() translates between fixed-length arrays and their corresponding external representations. The parameter arrp is the address of the pointer to the array, while size is the element count of the array. The parameter elsize is the sizeof each of the arrays elements, and elproc is an XDR routine that translates between the array elements C form and their external representation. This routine returns if it succeeds, otherwise. bool_t xdr_wrapstring(XDR *xdrs, char **sp); A routine that calls xdr_string(xdrs, sp, maxuint); where maxuint is the maximum value of an unsigned integer. Many routines, such as xdr_array(), xdr_pointer(), and xdr_vector() take a function pointer of type xdrproc_t(), which takes two arguments. xdr_string(), one of the most frequently used routines, requires three arguments, while xdr_wrapstring() only requires two. For these routines, xdr_wrapstring() is desirable. This routine returns if it succeeds, otherwise. SEE ALSOtc "SEE ALSO" rpc, xdr_admin, xdr_create, xdr_simple xdr_create xdr_createtc "xdr_create xdr_create" NAMEtc "NAME" xdr_create, xdr_destroy, xdrmem_create, xdrrec_create, xdrstdio_create - library routines for external data representation stream creation DESCRIPTIONtc "DESCRIPTION" XDR library routines allow C programmers to describe arbitrary data structures in a machine-independent fashion. Protocols such as remote procedure calls (RPC) use these routines to describe the format of the data. These routines deal with the creation of XDR streams. XDR streams have to be created before any data can be translated into XDR format. Routinestc "Routines" See rpc for the definition of the XDR, CLIENT, and data structures. Note that any buffers passed to the XDR routines must be properly aligned. It is suggested that malloc() be used to allocate these buffers or that the programmer insure that the buffer address is divisible evenly by four. #include void xdr_destroy(XDR *xdrs); A macro that invokes the destroy routine associated with the XDR stream, xdrs. Destruction usually involves freeing private data structures associated with the stream. Using xdrs after invoking xdr_destroy() is undefined. void xdrmem_create(XDR *xdrs, const caddr t addr, const u_int size, const enum xdr op op); This routine initializes the XDR stream object pointed to by xdrs. The streams data is written to, or read from, a chunk of memory at location addr whose length is no less than size bytes long. The op determines the direction of the XDR stream (either XDR_ENCODE, XDR_DECODE, or XDR_FREE). void xdrrec_create(XDR *xdrs, const u int sendsz, const u_int recvsz, const caddr t handle, const int (*readit)(const void *read handle, char *buf, const int len), const int (*writeit) (const void *write handle, const char *buf, const int len)); This routine initializes the read-oriented XDR stream object pointed to by xdrs. The streams data is written to a buffer of size sendsz; a value of 0 indicates the system should use a suitable default. The streams data is read from a buffer of size recvsz; it too can be set to a suitable default by passing a 0 value. When a streams output buffer is full, writeit is called. Similarly, when a streams input buffer is empty, readit is called. The behavior of these two routines is similar to the system calls read() and write(), except that an appropriate handle (read handle or write handle) is passed to the former routines as the first parameter instead of a file descriptor. Note: the XDR streams op field must be set by the caller. Warning: This XDR stream implements an intermediate record stream. Therefore there are additional bytes in the stream to provide record boundary information. void xdrstdio_create(XDR *xdrs, FILE *file, const enum xdr_op op); This routine initializes the XDR stream object pointed to by xdrs. The XDR stream data is written to, or read from, the standard I/O stream file. The parameter op determines the direction of the XDR stream (either XDR_ENCODE, XDR_DECODE, or XDR_FREE). Warning: The destroy routine associated with such XDR streams calls fflush() on the file stream, but never fclose(). Failure of any of these functions can be detected by first initializing the x ops field in the XDR structure (xdrs->x ops) to NULL before calling the xdr* create() function. After the return from the xdr*_create() function, if the x ops field is still NULL , the call has failed. If the x ops field contains some other value, the call can be assumed to have succeeded. SEE ALSOtc "SEE ALSO" rpc, xdr_admin, xdr_complex, xdr_simple xdr_simple xdr_simpletc "xdr_simple xdr_simple" NAMEtc "NAME" xdr_simple, xdr_bool, xdr_char, xdr_double, xdr_enum, xdr_float, xdr_free, xdr_hyper, xdr_int, xdr_long, xdr_longlong_t, xdr_quadruple, xdr_short, xdr_u_char, xdr_u_hyper, xdr_u_int, xdr_u_long, xdr_u_longlong_t, xdr_u_short, xdr_void - library routines for external data representation DESCRIPTIONtc "DESCRIPTION" XDR library routines allow C programmers to describe simple data structures in a machine-independent fashion. Protocols such as remote procedure calls (RPC) use these routines to describe the format of the data. These routines require the creation of XDR streams (see xdr_create). Routinestc "Routines" See rpc for the definition of the data structure. Note that any buffers passed to the XDR routines must be properly aligned. It is suggested that malloc() be used to allocate these buffers or that the programmer insure that the buffer address is divisible evenly by four. #include bool_t xdr_bool(XDR *xdrs, bool t *bp); xdr_bool() translates between booleans (C integers) and their external representations. When encoding data, this filter produces values of either 1 or 0. This routine returns if it succeeds, otherwise. bool_t xdr_char(XDR *xdrs, char *cp); xdr_char() translates between C characters and their external representations. This routine returns if it succeeds, otherwise. Note: encoded characters are not packed, and occupy 4 bytes each. For arrays of characters, it is worthwhile to consider xdr_bytes(), xdr_opaque(), or xdr_string() (see xdr_complex). bool_t xdr_double(XDR *xdrs, double *dp); xdr_double() translates between C double precision numbers and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_enum(XDR *xdrs, enum t *ep); xdr_enum() translates between C enums (actually integers) and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_float(XDR *xdrs, float *fp); xdr_float() translates between C floats and their external representations. This routine returns if it succeeds, otherwise. void xdr_free(xdrproc_t proc, char *objp); Generic freeing routine. The first argument is the XDR routine for the object being freed. The second argument is a pointer to the object itself. Note: the pointer passed to this routine is not freed, but what it points to is freed (recursively, depending on the XDR routine). bool_t xdr_hyper(XDR *xdrs, longlong t *llp); xdr_hyper() translates between ANSI C long long integers and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_int(XDR *xdrs, int *ip); xdr_int() translates between C integers and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_long(XDR *xdrs, long *lp); xdr_long() translates between C long integers and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_longlong_t(XDR *xdrs, longlong t *llp); xdr_longlong_t() translates between ANSI C long long integers and their external representations. This routine returns if it succeeds, otherwise. This routine is identical to xdr_hyper(). bool_t xdr_quadruple(XDR *xdrs, long double *pq); xdr_quadruple() translates between IEEE quadruple precision floating point numbers and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_short(XDR *xdrs, short *sp); xdr_short() translates between C short integers and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_u_char(XDR *xdrs, unsigned char *ucp); xdr_u_char() translates between unsigned C characters and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_u_hyper(XDR *xdrs, u longlong t *ullp); xdr_u_hyper() translates between unsigned ANSI C long long integers and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_u_int(XDR *xdrs, unsigned *up); A filter primitive that translates between a C unsigned integer and its external representation. This routine returns TRUE if it succeeds, FALSE otherwise. bool_t xdr_u_long(XDR *xdrs, unsigned long *ulp); xdr_u_long() translates between C unsigned long integers and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_u_longlong_t(XDR *xdrs, u longlong t *ullp); xdr_u_longlong_t() translates between unsigned ANSI C long long integers and their external representations. This routine returns if it succeeds, otherwise. This routine is identical to xdr_u_hyper(). bool_t xdr_u_short(XDR *xdrs, unsigned short *usp); xdr_u_short() translates between C unsigned short integers and their external representations. This routine returns if it succeeds, otherwise. bool_t xdr_void(void); This routine always returns TRUE. It may be passed to RPC routines that require a function parameter, where nothing is to be done. SEE ALSOtc "SEE ALSO" rpc, xdr_admin, xdr_complex, xdr_create rpc_soc rpc_soctc "rpc_soc rpc_soc" NAMEtc "NAME" rpc_soc, authunix_create, authunix_create_default, callrpc, clnt_broadcast, clntraw_create, clnttcp_create, clntudp_bufcreate, clntudp_create, get_myaddress, pmap_getmaps, pmap_getport, pmap_rmtcall, pmap_set, pmap_unset, registerrpc, svc_fds, svc_getcaller, svc_getreq, svc_register, svc_unregister, svcfd_create, svcraw_create, svctcp_create, svcudp_bufcreate, svcudp_create, xdr_authunix_parms obsolete library routines for RPC DESCRIPTIONtc "DESCRIPTION" RPC routines allow C programs to make procedure calls on other machines across the network. First, the client calls a procedure to send a request to the server. Upon receipt of the request, the server calls a dispatch routine to perform the requested service, and then sends back a reply. Finally, the procedure call returns to the client. The routines described in this manual page have been superseded by other routines. The preferred routine is given after the description of the routine. New programs should use the preferred routines, as support for the older interfaces may be dropped in future releases. File Descriptorstc "File Descriptors" Transport independent RPC uses TLI as its transport interface instead of sockets. Some of the routines described in this section (such as clnttcp_create()) take a pointer to a file descriptor as one of the parameters. If the user wants the file descriptor to be a socket, then the application will have to be linked with both librpcsoc and libnsl. If the user passed as the file descriptor, and the application is linked with libnsl only, then the routine will return a TLI file descriptor and not a socket. Routinestc "Routines" The following routines require that the header be included. The symbol should be defined so that the appropriate function declarations for the old interfaces are included through the header files. #include AUTH * authunix_create(char *host, int uid , int gid, int grouplen, int gidlistp); Create and return an RPC authentication handle that contains authentication information. The parameter host is the name of the machine on which the information was created; uid is the users user ID; gid is the users current group ID; grouplen and gidlistp refer to a counted array of groups to which the user belongs. Warning: It is not very difficult to impersonate a user. Warning: This routine exists for backward compatibility only, and is obsoleted by authsys_create() (see rpc_clnt_auth). AUTH * authunix_create_default(void) Call authunix_create() with the appropriate parameters. Warning: This routine exists for backward compatibility only, and is obsoleted by authsys_create_default() (see rpc_clnt_auth). callrpc(char *host, u long prognum, u long versnum, u long procnum, xdrproc t inproc, char *in, xdrproc t outproc, char *out); Call the remote procedure associated with prognum, versnum, and procnum on the machine, host. The parameter inproc is used to encode the procedures parameters, and outproc is used to decode the procedures results; in is the address of the procedures argument, and out is the address of where to place the result(s). This routine returns 0 if it succeeds, or the value of enum clnt_stat cast to an integer if it fails. The routine clnt_perrno() (see rpc_clnt_calls) is handy for translating failure statuses into messages. Warning: You do not have control of timeouts or authentication using this routine. This routine exists for backward compatibility only, and is obsoleted by rpc_call() (see rpc_clnt_calls). enum clnt_stat clnt_broadcast(u_long prognum, u long versnum, u long procnum, xdrproc t inproc, char *in, xdrproc t outproc, char *out, resultproc t eachresult); Like callrpc(), except the call message is broadcast to all locally connected broadcast nets. Each time the caller receives a response, this routine calls eachresult(), whose form is: eachresult(char *out, struct sockaddr in *addr); where out is the same as out passed to clnt_broadcast(), except that the remote procedures output is decoded there; addr points to the address of the machine that sent the results. If eachresult() returns 0 clnt_broadcast() waits for more replies; otherwise it returns with appropriate status. If eachresult() is NULL, clnt_broadcast() returns without waiting for any replies. Warning: Broadcast packets are limited in size to the maximum transfer unit of the transports involved. For Ethernet, the callers argument size is approximately 1500 bytes. Since the call message is sent to all connected networks, it may potentially lead to broadcast storms. clnt_broadcast() uses SB AUTH_SYS credentials by default (see rpc_clnt_auth). Warning: This routine exists for backward compatibility only, and is obsoleted by rpc_broadcast() (see rpc_clnt_calls). CLIENT * clntraw_create(u_long prognum, u long versnum); This routine creates an internal, memory-based RPC client for the remote program prognum, version versnum. The transport used to pass messages to the service is actually a buffer within the processs address space, so the corresponding RPC server should live in the same address space; see svcraw_create(). This allows simulation of RPC and acquisition of RPC overheads, such as round trip times, without any kernel interference. This routine returns NULL if it fails. Warning: This routine exists for backward compatibility only, and has the same functionality as clnt_raw_create() (see rpc_clnt_create), which obsoletes it. CLIENT * clnttcp_create(struct sockaddr_in *addr, u long prognum, u long versnum, int *fdp, u int *sendsz, u int *recvsz); This routine creates an RPC client for the remote program prognum, version versnum; the client uses TCP/IP as a transport. The remote program is located at Internet address addr. If addr->sin port is 0, then it is set to the actual port that the remote program is listening on (the remote rpcbind service is consulted for this information). The parameter *fdp is a file descriptor, which may be open and bound; if it is RPC_ANYSOCK, then this routine opens a new one and sets *fdp. Refer to the File Descriptor section for more information. Since TCP-based RPC uses buffered I/O, the user may specify the size of the send and receive buffers with the parameters sendsz and recvsz; values of 0 choose suitable defaults. This routine returns NULL if it fails. Warning: This routine exists for backward compatibility only. clnt_create(), clnt_tli_create(), or clnt_vc_create() (see rpc_clnt_create) should be used instead. CLIENT * clntudp_bufcreate(struct sockaddr_in *addr, u long prognum, u long versnum, struct timeval wait, int *fdp, u_int sendsz, u int recvsz); Create a client handle for the remote program prognum, on versnum; the client uses UDP/IP as the transport. The remote program is located at the Internet address addr. If addr->sin port is 0, it is set to port on which the remote program is listening on (the remote rpcbind service is consulted for this information). The parameter *fdp is a file descriptor, which may be open and bound; if it is RPC_ANYSOCK, then this routine opens a new one and sets *fdp. Refer to the File Descriptor section for more information. The UDP transport resends the call message in intervals of wait time until a response is received or until the call times out. The total time for the call to time out is specified by clnt_call() (see rpc_clnt_calls). If successful it returns a client handle, otherwise it returns NULL. The error can be printed using the clnt_pcreateerror() (see rpc_clnt_create) routine. The user can specify the maximum packet size for sending and receiving by using sendsz and recvsz arguments for UDP-based RPC messages. Warning: If addr->sin port is 0 and the requested version number versnum is not registered with the remote portmap service, it returns a handle if at least a version number for the given program number is registered. The version mismatch is discovered by a clnt_call() later (see rpc_clnt_calls). Warning: This routine exists for backward compatibility only. clnt_tli_create() or clnt_dg_create() (see rpc_clnt_create) should be used instead. CLIENT * clntudp_create(struct sockaddr_in *addr, u long prognum, u long versnum, struct timeval wait, int *fdp); This routine creates an RPC client handle for the remote program prognum, version versnum; the client uses UDP/IP as a transport. The remote program is located at Internet address addr. If addr->sin port is 0, then it is set to actual port that the remote program is listening on (the remote rpcbind service is consulted for this information). The parameter *fdp is a file descriptor, which may be open and bound; if it is RPC_ANYSOCK, then this routine opens a new one and sets *fdp. Refer to the File Descriptor section for more information. The UDP transport resends the call message in intervals of wait time until a response is received or until the call times out. The total time for the call to time out is specified by clnt_call() (see rpc_clnt_calls). clntudp_create() returns a client handle on success, otherwise it returns NULL. The error can be printed using the clnt_pcreateerror() (see rpc_clnt_create) routine. Warning: Since UDP-based RPC messages can only hold up to 8 Kbytes of encoded data, this transport cannot be used for procedures that take large arguments or return huge results. Warning: This routine exists for backward compatibility only. clnt_create(), clnt_tli_create(), or clnt_dg_create() (see rpc_clnt_create) should be used instead. void get_myaddress(struct sockaddr_in *addr); Places the local systems IP address into *addr, without consulting the library routines that deal with /etc/hosts. The port number is always set to htons(PMAPPORT). Warning: This routine is only intended for use with the RPC library. It returns the local systems address in a form compatible with the RPC library, and should not be taken as the systems actual IP address. In fact, the *addr buffers host address part is actually zeroed. This address may have only local significance and should NOT be assumed to be an address that can be used to connect to the local system by remote systems or processes. Warning: This routine remains for backward compatibility only. The routine netdir_getbyname() (see netdir) should be used with the name to retrieve the local systems network address as a netbuf structure. struct pmaplist * pmap_getmaps(struct sockaddr_in *addr); A user interface to the portmap service, which returns a list of the current RPC program-to-port mappings on the host located at IP address addr. This routine can return NULL . The command rpcinfo -p uses this routine. Warning: This routine exists for backward compatibility only, enhanced functionality is provided by rpcb_getmaps() (see rpcbind). u_short pmap_getport(struct sockaddr_in *addr, u long prognum, u long versnum, u long protocol); A user interface to the portmap service, which returns the port number on which waits a service that supports program prognum, version versnum, and speaks the transport protocol associated with protocol. The value of protocol is most likely IPPROTO UDP or IPPROTO TCP. A return value of 0 means that the mapping does not exist or that the RPC system failured to contact the remote portmap service. In the latter case, the global variable rpc_createerr contains the RPC status. Warning: This routine exists for backward compatibility only, enhanced functionality is provided by rpcb_getaddr() (see rpcbind). enum clnt_stat pmap_rmtcall(struct sockaddr_in *addr, u long prognum, u long versnum, u long procnum, char *in, xdrproct_t inproc, char *out, xdrproct t outproc, struct timeval tout, u long *portp); Request that the portmap on the host at IP address *addr make an RPC on the behalf of the caller to a procedure on that host. *portp is modified to the programs port number if the procedure succeeds. The definitions of other parameters are discussed in callrpc() and clnt_call() (see rpc_clnt_calls). [Note] This procedure is only available for the UDP transport. Warning: If the requested remote procedure is not registered with the remote portmap then no error response is returned and the call times out. Also, no authentication is done. Warning: This routine exists for backward compatibility only, enhanced functionality is provided by rpcb_rmtcall() (see rpcbind). bool_t pmap_set(u_long prognum, u long versnum, u long protocol, u short port); A user interface to the portmap service, that establishes a mapping between the triple [prognum, versnum, protocol] and port on the machines portmap service. The value of protocol may be or IPPROTO TCP. Formerly, the routine failed if the requested port was found to be in use. Now, the routine only fails if it finds that port is still bound. If port is not bound, the routine completes the requested registration. This routine returns 1 if it succeeds, 0 otherwise. Automatically done by svc_register(). Warning: This routine exists for backward compatibility only, enhanced functionality is provided by rpcb_set() (see rpcbind). bool_t pmap_unset(u_long prognum, u long versnum); A user interface to the portmap service, which destroys all mapping between the triple [prognum, versnum, allprotocols] and port on the machines portmap service. This routine returns one if it succeeds, 0 otherwise. Warning: This routine exists for backward compatibility only, enhanced functionality is provided by rpcb_unset() (see rpcbind). struct sockaddr_in * svc_getcaller(SVCXPRT *xprt); This routine returns the network address, represented as a struct sockaddr_in, of the caller of a procedure associated with the RPC service transport handle, xprt. Warning: This routine exists for backward compatibility only, and is obsolete. The preferred interface is svc_getrpccaller() (see rpc_svc_reg), which returns the address as a struct netbuf. void svc_getreq(int rdfds); This routine is only of interest if a service implementor does not call svc_run(), but instead implements custom asynchronous event processing. It is called when the select() call has determined that an RPC request has arrived on some RPC file descriptors; rdfds is the resultant read file descriptor bit mask. The routine returns when all file descriptors associated with the value of rdfds have been serviced. This routine is similar to svc_getreqset() but is limited to 32 descriptors. Warning: This interface is obsoleted by svc_getreqset(). SVCXPRT * svcfd_create(int fd, u int sendsz, u int recvsz); Create a service on top of any open and bound descriptor. Typically, this descriptor is a connected file descriptor for a stream protocol. Refer to the File Descriptor section for more information. sendsz and recvsz indicate sizes for the send and receive buffers. If they are 0, a reasonable default is chosen. Warning: This interface is obsoleted by svc_fd_create() (see rpc_svc_create). SVCXPRT * svcraw_create(void); This routine creates an internal, memory-based RPC service transport, to which it returns a pointer. The transport is really a buffer within the processs address space, so the corresponding RPC client should live in the same address space; see clntraw_create(). This routine allows simulation of RPC and acquisition of RPC overheads (such as round trip times), without any kernel interference. This routine returns NULL if it fails. Warning: This routine exists for backward compatibility only, and has the same functionality of svc_raw_create() (see rpc_svc_create), which obsoletes it. SVCXPRT * svctcp_create(int fd, u int sendsz, u int recvsz); This routine creates a TCP/IP-based RPC service transport, to which it returns a pointer. The transport is associated with the file descriptor fd, which may be RPC_ANYSOCK, in which case a new file descriptor is created. If the file descriptor is not bound to a local TCP port, then this routine binds it to an arbitrary port. Refer to the File Descriptor section for more information. Upon completion, xprt->xp fd is the transports file descriptor, and xprt->xp port is the transports port number. This routine returns NULL if it fails. Since TCP-based RPC uses buffered I/O, users may specify the size of buffers; values of 0 choose suitable defaults. Warning: This routine exists for backward compatibility only. svc_create(), svc_tli_create(), or svc_vc_create() (see rpc_svc_create) should be used instead. SVCXPRT * svcudp_bufcreate(int fd, u int sendsz, u int recvsz); This routine creates a UDP/IP-based RPC service transport, to which it returns a pointer. The transport is associated with the file descriptor fd. If fd is RPC_ANYSOCK , then a new file descriptor is created. If the file descriptor is not bound to a local UDP port, then this routine binds it to an arbitrary port. Upon completion, xprt->xp fd is the transports file descriptor, and xprt->xp port is the transports port number. Refer to the File Descriptor section for more information. This routine returns NULL if it fails. The user specifies the maximum packet size for sending and receiving UDP-based RPC messages by using the sendsz and recvsz parameters. Warning: This routine exists for backward compatibility only. svc_tli_create(), or svc_dg_create() (see rpc_svc_create) should be used instead. SVCXPRT * svcudp_create(int fd); This routine creates a UDP/IP-based RPC service transport, to which it returns a pointer. The transport is associated with the file descriptor fd, which may be RPC_ANYSOCK , in which case a new file descriptor is created. If the file descriptor is not bound to a local UDP port, then this routine binds it to an arbitrary port. Upon completion, xprt->xp fd is the transports file descriptor, and xprt->xp port is the transports port number. This routine returns NULL if it fails. Warning: Since UDP-based RPC messages can only hold up to 8 Kbytes of encoded data, this transport cannot be used for procedures that take large arguments or return huge results. Warning: This routine exists for backward compatibility only. svc_create(), svc_tli_create(), or svc_dg_create() (see rpc_svc_create) should be used instead. registerrpc(u_long prognum, u long versnum, u long procnum, char *(*procname)(), xdrproc t inproc, xdrproc t outproc); Register program prognum, procedure procname, and version versnum with the RPC service package. If a request arrives for program prognum, version versnum, and procedure procnum, procname is called with a pointer to its parameter(s); procname should return a pointer to its static result(s); inproc is used to decode the parameters while outproc is used to encode the results. This routine returns 0 if the registration succeeded, -1 otherwise. svc_run() must be called after all the services are registered. Warning: This routine exists for backward compatibility only, and is obsoleted by rpc_reg() (see rpc_svc_calls). svc_register(SVCXPRT *xprt, u long prognum, u long versnum, void (*dispatch)(), u long protocol); Associates prognum and versnum with the service dispatch procedure, dispatch. If protocol is 0, the service is not registered with the portmap service. If protocol is non-zero, then a mapping of the triple [prognum, versnum, protocol] to xprt->xp port is established with the local portmap service (generally pro tocol is 0, IPPROTO UDP or IPPROTO TCP). The procedure dispatch has the following form: dispatch(struct svc_req *request, SVCXPRT *xprt); The svc_register() routine returns one if it succeeds, and 0 otherwise. Warning: This routine exists for backward compatibility only; enhanced functionality is provided by svc_reg() (see rpc_svc_calls). void svc_unregister(u_long prognum, u long versnum); Remove all mapping of the double [prognum, versnum] to dispatch routines, and of the triple [prognum, versnum, all-protocols] to port number from portmap. Warning: This routine exists for backward compatibility, enhanced functionality is provided by svc_unreg() (see rpc_svc_calls). xdr_authunix_parms(XDR *xdrs, struct authunix parms *aupp); Used for describing UNIX credentials. This routine is useful for users who wish to generate these credentials without using the RPC authentication package. Warning: This routine exists for backward compatibility only, and is obsoleted by xdr_authsys_parms() (see rpc_xdr). SEE ALSOtc "SEE ALSO" rpc, rpc_clnt_auth, rpc_clnt_create, rpc_clnt_calls, rpc_svc_calls, rpc_svc_create, rpc_svc_err, rpc_svc_reg, rpcbind xdr_extend xdr_extendtc "xdr_extend xdr_extend" NAMEtc "NAME" rpc_init, rpc_init_custom, rpc_set_syslog, rpc_set_user - Windows extensions to TIRPC DESCRIPTIONtc "DESCRIPTION" These routine-like macros are specific to the port of TIRPC to MS-Windows. They are not in the standard TIRPC distribution. Programmers must call either rpc_init() or rpc_init_custom() before using any other TIRPC routines. rpc_init() is the simplest routine which sets up TIRPC to use a lot defaults. If a programmer is unhappy with any of these defaults, he or she may be interested in the other extension routines. Routinestc "Routines" #include #include void FAR * PASCAL FAR rpc_init(HANDLE hInst) This macro initializes TIRPC using a lot of quite sensible defaults. The file MUST be included in order to use rpc_init() and should only be included in the module calling rpc_init(). The single parameter (hInst) is the instance handle of the Windows application. The defaults are set up as follows: allocation: malloc and free error printing: fputs to stderr uid, gid, gid group set, pid: all zero XDR over stdio: uses fwrite, fread, ftell, fseek and fflush The value NULL is returned if initialization failed, non-NULL otherwise. #include void FAR * PASCAL FAR rpc_init_custom( void FAR *(PASCAL FAR *the_alloc)(unsigned long size, void FAR *handle), void (PASCAL FAR *the_free)(void FAR *ptr,void FAR *handle), void FAR *alloc_handle, void (PASCAL FAR *the_print)(const char FAR *str, void FAR *handle), void FAR *print_handle, int (PASCAL FAR *the_fread)(void FAR *ptr, size_t size, size_t nmemb, FILE FAR *stream), int (PASCAL FAR *the_fwrite)(const void FAR *ptr, size_t size, size_t nmemb, FILE FAR *stream), long (PASCAL FAR *the_ftell)(FILE FAR *stream), int (PASCAL FAR *the_fseek)(FILE FAR *stream, long offset, int whence), int (PASCAL FAR *the_fflush)(FILE FAR *stream)); This macro allows the programmer to set up some different defaults upon initialization. the_alloc and the_free are pointers to the programmers allocation routines. They are callback routines which are called by TIRPC from time to time as it needs to allocate or free memory. Both parameters take a handle argument which TIRPC uses to pass back to the application the alloc_handle parameter. Similarly, the_print and print_handle are used for times when TIRPC needs to output a string. Finally, the_fread, the_fwrite, the_ftell, the_fseek and the_fflush are used by the XDR/stdio feature of TIRPC. They follow the same API as the ANSI stdio routines, except that that stream parameter is not required to actually be of type FILE *, but can be any pointer type (cast to FILE * to avoid compiler errors). Except for the allocation parameters, any of the other defaults may be set to NULL which will disable the feature. The value NULL is returned if initialization failed, non-NULL otherwise. #include void PASCAL FAR rpc_set_syslog(syslog_callback_proc the_callback); typedef void (PASCAL FAR*syslog_callback_proc) (int priority,const char FAR *msg, void FAR *handle); Use rpc_set_syslog if you want syslog messages generated by TIRPC to be handled differently than just getting printed using the default print function. The handle argument to the callback syslog procedure is the same as the print_handle passed to rpc_init_custom() or NULL if using rpc_init(). Note that only priorities LOG_ERR and LOG_DEBUG are ever used by TIRPC. #include void PASCAL FAR rpc_set_user( int the_pid, int the_uid, int the_gid, int the_grouplen, int FAR *the_groups); Use rpc_set_user if you want defaults for these values other than zero. The PID (process ID) is only used for generating RPC transaction IDs and is fairly unimportant. It can be any value, but ideally should be a number unique to each instance of an application to insure unique transaction IDs. The uid and gids are used for authentication purposes. Warning: Unlike Unix, Windows has no way to insure the uids and gids are authenticated via a password. Therefore, an application should try to authenticate these values before passing them to rpc_set_user and NOT allow a user to set them to any value. TIRPC DLL Release Notestc "TIRPC DLL Release Notes" Release 2 1. Interface The interface is for the most part, the same as on Unix machines. The differences are the following: a. You must initialize the library before using it. b. Some #include files have different names. c. No support for DES or Kerberos authentication. d. netdir is hardcoded to support UDP and TCP only. More information on this is described later in this section. 2. Bugs There is at least one problem with multiple applications using the same DLL (TIRPC.DLL). If one application is blocked on a WINSOCK call, and then is terminated, the DLL does not get unloaded. This results in errors when other TIRPC applications are started. You normally have to quit Windows to get around this problem. This bug is unlikely to be fixed in the near future, and it is strongly recommended that an application wait for any blocking RPC call to terminate before exiting. 3. Initialization To initialize the library, your code should call rpc_init() with a single argument of an instance handle (received from the Windows function WinMain()). This call sets up default callback routines for use with the TIRPC.DLL. The default will be that allocation will be via malloc/free, error printing (clnt_perror(), etc.) will use fputs to stderr, stdio XDR (xdrstdiocreate()) will used fwrite/fread/ftell/fseek/fflush, uid, gid and pid will be zero, and no syslogs will be output. To set the uid, gid and pid, use rpc_set_user(). To set the syslog output routine, use rpc_set_syslog(). To change the memory allocator or the stdio routines used by XDR stdio, call rpc_init_custom() instead of rpc_init(). Note that if you use the default rpc_init(), you should #include in the file which calls rpc_init(). The include of rpcinit.h will cause the default allocation and stdio routines to be defined in that module. You are only required to set the memory allocation functions. If the other functions are set to NULL, then they will be disabled. For example, setting the error print function to NULL will disable error printing. Also, setting the stdio functions to NULL will disable xdr over stdio. Note that each of the callback routines has a handle argument which is simply something that will be passed back to the application. There is an allocation handle for alloc/free, a print handle for error printing and a stdio handle (a FILE *) for xdr over stdio. Note that there is no stdio handle passed to rpc_init_custom(). The stdio handle is instead passed to xdrstdio_create(). It does not actually have to be a standard FILE pointer, but can be your own creation with the appropriate callbacks. 4. Callback routines All callback routines pointers passed to any TIRPC function should be of the type created by the Windows function MakeProcInstance(). This includes the callback routines used in rpc_init_custom() described above, and most xdr routines. The callback functions should be of type FAR PASCAL and exported in a .DEF file (or automatically via the _export keyword). Note that the Unix rpcgen program will not generate correct code for use with Windows because of restrictions Windows places upon callback routines. The Unix rpcgen output can be hand modified easily enough, however, by finding all references to generated xdr functions used as callback functions, replacing them with pointers returned from MakeProcInstance() and making the original referenced functions be FAR PASCAL _export. 5. Include files The assumption with the include files is that you have defined the rpc directory to be part of your compiler include path. This means that instead of including as you would under Unix, you would include just plain instead. If you need to include any other include files besides rpc.h, you should check to see if they have been renamed to work under DOS 8.3 names. An easy way to do this is to look at the commented out #pragma ident in each include file which contains the original Unix name for the include. 6. Netdir/TLI The netdir, netconfig and netpath and tli routines are all made available to the client, in addition to the standard RPC routines. They are not a complete implementation of netdir, so use them at your own risk. 7. Implementation issues Because RPC contains state, steps were taken to insure that this state was always contained in the application rather than the DLL. The technique for doing this is to pass a state parameter to all stateful routines. For each stateful RPC routine, a macro is defined to call the stateless DLL routine with the parameters plus an added state parameter. This should be transparent to the caller, but will be noticable in any way in which a macro is incompatible with a function, such as in linking or passing the address of a function. You will notice that most of the routines in the DLL start with the prefix sl, such as slclnt_create. This means that clnt_create() was stateful. A stateless version (slcnt_create) is provided in the DLL, and a macro (clnt_create) is provided to pass the state to the stateless routine. 8. Changes since Release 1 a. Calling conventions have been changed from C to PASCAL. Because of this change, you will have to recompile all code, MakeProcInstance() for any callback routines and insure that the callback routines are FAR PASCAL and exported. b. The rpc_init() macro now takes an argument, which is the instance handle of the application (passed in WinMain() function). c. A bug has been fixed with respect to timeouts. Timeouts were restricted to 32 seconds previously because they were stored in 16-bit quantities. Now, you may use very large timeouts since they are stored as 32-bit quantities. SPRY TI-RPC Reference Guide PAGE6 v~:_ V2P   Y n D&&  E CEE(E?`{9g{|o;ͽo{?}`<\?{o|g{?|o`{? | `@}|{???}==}x x?8 8= ?=888x?????|?xx??p? p? pp?p??{{{{&%%MSEPS Preamble 224 366 417 434 0 0 194 69 /pp_save save def /showpage {} def 40 dict begin /pp_clip false def /pp_bbox false def /F { pop } def /S {} def /B { { /pp_dy1 exch def /pp_dx1 exch def /pp_dy2 exch def /pp_dx2 exch def } stopped not { /pp_bbox true def } if } def /CB { { /pp_cy exch def /pp_cx exch def /pp_cht exch def /pp_cwd exch def } stopped not { /pp_clip true def } if } def /pp_bx1 224 def /pp_by1 366 def /pp_bx2 417 def /pp_by2 434 def &&-- E'&&&% pp_clip { pp_cx pp_cy moveto pp_cwd 0 rlineto 0 pp_cht rlineto pp_cwd neg 0 rlineto clip newpath } if pp_bbox { /pp_dy2 pp_dy2 pp_dy1 add def /pp_dx2 pp_dx2 pp_dx1 add def /pp_sx pp_dx2 pp_dx1 sub pp_bx2 pp_bx1 sub div def /pp_sy pp_dy2 pp_dy1 sub pp_by1 pp_by2 sub div def /pp_tx pp_dx1 pp_sx pp_bx1 mul sub def /pp_ty pp_dy1 pp_sy pp_by2 mul sub def pp_tx pp_ty translate pp_sx pp_sy scale } if end &%%!PS-Adobe-2.0 EPSF-1.2 %%Creator: FreeHand 3.11 %%Title: SPRY LOGO %%CreationDate: 12/16/93 10:08 AM %%BoundingBox: 224.1007 366.394 417.4799 434.3588 %%DocumentProcSets: FreeHand_header 3 1 %%DocumentSuppliedProcSets: FreeHand_header 3 1 %%ColorUsage: Color %%DocumentProcessColors: Cyan Magenta Yellow Black %%CMYKProcessColor: 1 0 0.305 0.06 (PANTONE 320 CV) %%FHPathName: AIRMAC:Desktop Folder:Work in Progress:Logo Folder:SPRY LOGO %%EndComments %%BeginProcSet: FreeHand_header 3 0 /FHIODict 30 dict def FHIODict begin /bdf{bind def}bind def /d{setdash}bdf /h{closepath}bdf /H{}bdf /J{setlinecap}bdf /j{setlinejoin}bdf /M{setmiterlimit}bdf /n{newpath}bdf /N{newpath}bdf /q{gsave}bdf /Q{grestore}bdf /w{setlinewidth}bdf /u{}bdf /U{}bdf /sepdef{ dup where not { FreeHandSepDict } if 3 1 roll exch put }bdf /` {false setoverprint end %. FreeHandDict /-save0- save def pop pop pop pop pop concat userdict begin /showpage {} def 0 setgray 0 setlinecap 1 setlinewidth 0 setlinejoin 10 setmiterlimit [] 0 setdash newpath /languagelevel where {pop languagelevel 1 ne{false setstrokeadjust}if}if } bdf /~ {end -save0- restore FreeHandDict begin }bdf /FreeHandDict 191 dict def FreeHandDict begin /currentpacking where{pop true setpacking}if /xdf{exch def}bdf /ndf{1 index where{pop pop pop}{dup xcheck{bind}if def}ifelse}bdf /min{2 copy gt{exch}if pop}bdf /max{2 copy lt{exch}if pop}bdf /isLino statusdict /product get (Lino) anchorsearch{pop pop true}{pop false}ifelse def /dr{transform .25 sub round .25 add exch .25 sub round .25 add exch itransform}bdf /C{dr curveto}bdf /L{dr lineto}bdf /m{dr moveto}bdf /printerRes gsave matrix defaultmatrix setmatrix 72 72 dtransform abs exch abs max grestore def /maxsteps 256 def /calcgraysteps { currentscreen pop exch printerRes exch div exch 2 copy sin mul round dup mul 3 1 roll cos mul round dup mul add 1 add dup maxsteps gt {pop maxsteps} if } bdf /bottom -0 def /delta -0 def /frac -0 def /left -0 def /numsteps -0 def /numsteps1 -0 def /radius -0 def /right -0 def /top -0 def /xt -0 def /yt -0 def /df currentflat def /tempstr 1 string def /clipflatness currentflat def /inverted? 0 currenttransfer exec .5 ge def /level2 /languagelevel where {pop languagelevel 1 ne}{false}ifelse def /colorexists level2 { statusdict/processcolors known {statusdict/processcolors get exec}{1}ifelse 4 eq def } {systemdict/setcmykcolor known def} ifelse /tc1 [0 0 0 1] def /tc2 [0 0 0 1] def /fc [0 0 0 1] def /sc [0 0 0 1] def /concatprocs{ /packedarray where {pop dup type /packedarraytype eq 2 index type /packedarraytype eq or}{false}ifelse { /proc2 exch cvlit def/proc1 exch cvlit def proc1 aload pop proc2 aload pop proc1 length proc2 length add packedarray cvx } { /proc2 exch cvlit def/proc1 exch cvlit def /newproc proc1 length proc2 length add array def newproc 0 proc1 putinterval newproc proc1 length proc2 putinterval newproc cvx }ifelse }bdf /storerect{/top xdf/right xdf/bottom xdf/left xdf}bdf /rectpath{newpath left bottom m left top L right top L right bottom L closepath}bdf /i{dup 0 eq {pop df dup} {dup} ifelse /clipflatness xdf setflat }bdf version cvr 38.0 le {/setrgbcolor{ currenttransfer exec 3 1 roll currenttransfer exec 3 1 roll currenttransfer exec 3 1 roll setrgbcolor}bdf}if /gettint{0 get}bdf /puttint{0 exch put}bdf /vms {/vmsv save def} bdf /vmr {vmsv restore} bdf /vmrs{vmsv restore /vmsv save def}bdf /eomode{ {/filler /eofill load def /clipper /eoclip load def} {/filler /fill load def /clipper /clip load def} ifelse }bdf /CD{/NF exch def{exch dup/FID ne 1 index/UniqueID ne and{exch NF 3 1 roll put} {pop pop}ifelse}forall NF}bdf /MN{1 index length/Len exch def dup length Len add string dup Len 4 -1 roll putinterval dup 0 4 -1 roll putinterval}bdf /RC{4 -1 roll /ourvec xdf 256 string cvs(|______)anchorsearch {1 index MN cvn/NewN exch def cvn findfont dup maxlength dict CD dup/FontName NewN put dup /Encoding ourvec put NewN exch definefont pop}{pop}ifelse}bdf /RF{dup FontDirectory exch known{pop 3 -1 roll pop}{RC}ifelse}bdf /FF{dup 256 string cvs(|______)exch MN cvn dup FontDirectory exch known {exch pop findfon&%t 3 -1 roll pop}{pop dup findfont dup maxlength dict CD dup dup /Encoding exch /Encoding get 256 array copy 7 -1 roll {3 -1 roll dup 4 -2 roll put}forall put definefont}ifelse}bdf userdict begin /BDFontDict 20 dict def end BDFontDict begin /bu{}def /bn{}def /setTxMode{av 70 ge{pop}if pop}def /gm{m}def /show{pop}def /gr{pop}def /fnt{pop pop pop}def /fs{pop}def /fz{pop}def /lin{pop pop}def end /MacVec 256 array def MacVec 0 /Helvetica findfont /Encoding get 0 128 getinterval putinterval MacVec 127 /DEL put MacVec 16#27 /quotesingle put MacVec 16#60 /grave put /NUL/SOH/STX/ETX/EOT/ENQ/ACK/BEL/BS/HT/LF/VT/FF/CR/SO/SI /DLE/DC1/DC2/DC3/DC4/NAK/SYN/ETB/CAN/EM/SUB/ESC/FS/GS/RS/US MacVec 0 32 getinterval astore pop /Adieresis/Aring/Ccedilla/Eacute/Ntilde/Odieresis/Udieresis/aacute /agrave/acircumflex/adieresis/atilde/aring/ccedilla/eacute/egrave /ecircumflex/edieresis/iacute/igrave/icircumflex/idieresis/ntilde/oacute /ograve/ocircumflex/odieresis/otilde/uacute/ugrave/ucircumflex/udieresis /dagger/degree/cent/sterling/section/bullet/paragraph/germandbls /registered/copyright/trademark/acute/dieresis/notequal/AE/Oslash /infinity/plusminus/lessequal/greaterequal/yen/mu/partialdiff/summation /product/pi/integral/ordfeminine/ordmasculine/Omega/ae/oslash /questiondown/exclamdown/logicalnot/radical/florin/approxequal/Delta/guillemotleft /guillemotright/ellipsis/nbspace/Agrave/Atilde/Otilde/OE/oe /endash/emdash/quotedblleft/quotedblright/quoteleft/quoteright/divide/lozenge /ydieresis/Ydieresis/fraction/currency/guilsinglleft/guilsinglright/fi/fl /daggerdbl/periodcentered/quotesinglbase/quotedblbase /perthousand/Acircumflex/Ecircumflex/Aacute /Edieresis/Egrave/Iacute/Icircumflex/Idieresis/Igrave/Oacute/Ocircumflex /apple/Ograve/Uacute/Ucircumflex/Ugrave/dotlessi/circumflex/tilde /macron/breve/dotaccent/ring/cedilla/hungarumlaut/ogonek/caron MacVec 128 128 getinterval astore pop /fps{ currentflat exch dup 0 le{pop 1}if { dup setflat 3 index stopped {1.3 mul dup 3 index gt{pop setflat pop pop stop}if} {exit} ifelse }loop pop setflat pop pop }bdf /fp{100 currentflat fps}bdf /clipper{clip}bdf /W{/clipper load 100 clipflatness fps}bdf end%. FreeHandDict end%. FHIODict %%EndProcSet %%EndProlog %%BeginSetup FHIODict begin FreeHandDict begin 224.1007 366.394 417.4799 434.3588 storerect rectpath clip newpath /onlyk{false}ndf /ccmyk{dup 5 -1 roll sub 0 max exch}ndf /setcmykcolor{1 exch sub ccmyk ccmyk ccmyk pop setrgbcolor}ndf /setcmykcoloroverprint{4{dup -1 eq{pop 0}if 4 1 roll}repeat setcmykcolor}ndf /findcmykcustomcolor{5 /packedarray where{pop packedarray}{array astore readonly}ifelse}ndf /setcustomcolor{exch aload pop pop 4{4 index mul 4 1 roll}repeat setcmykcolor pop}ndf /setseparationgray{1 exch sub dup dup dup setcmykcolor}ndf /setoverprint{pop}ndf /currentoverprint false ndf /colorimage{pop pop [5 -1 roll/exec cvx 6 -1 roll/exec cvx 7 -1 roll/exec cvx 8 -1 roll/exec cvx /cmykbufs2gray cvx]cvx image} %. version 47.1 on Linotronic of Postscript defines colorimage incorrectly (rgb model only) version cvr 47.1 le isLino and{userdict begin bdf end}{ndf}ifelse /customcolorimage{ colorexists { aload pop pop 4 array astore setimagecmyk currentcolortransfer {ik mul ik sub 1 add}concatprocs 4 1 roll {iy mul iy sub 1 add}concatprocs 4 1 roll {im mul im sub 1 add}concatprocs 4 1 roll {ic mul ic sub 1 add}concatprocs 4 1 roll setcolortransfer /magentabuf 0 string def /yellowbuf 0 string def /blackbuf 0 string def {invbuf dup length magentabuf length ne {dup length dup dup /magentabuf exch string def /yellowbuf exch string def /blackbuf exch string def}if dup magentabuf copy yellowbuf copy blackbuf copy pop}concatprocs {magentabuf}{yellowbuf}{blackbuf}true 4 colorimage } { pop image } ifelse }ndf /separationimage{image}ndf /newcmykcustomcolor{6 /packedarray where{pop packedarray}{array astore readonly}ifelse}ndf /inkoverprint false ndf /setinkoverprint{pop}ndf /overprintprocess{pop}ndf /setspotcolor {spots exch get 0 5 getinterval exch setcustomcolor}ndf /currentcolortransfer{currenttransfer dup dup dup}ndf /setcolortransfer{systemdict begin settransf&%er end pop pop pop}ndf /getcmyk { dup length 4 eq {aload pop} {aload pop spots exch get 0 4 getinterval aload pop 4 {4 index mul 4 1 roll}repeat 5 -1 roll pop} ifelse }bdf /setimagecmyk{ getcmyk/ik xdf /iy xdf /im xdf /ic xdf }ndf /autospread{pop}ndf /fhsetspreadsize{pop}ndf /fhsetspreadallow{pop}ndf /strokeopf false def /fillopf false def /R{0 ne /strokeopf xdf}bdf /O{0 ne /fillopf xdf}bdf /filler{fill}bdf /F{fc fhsetcolor fillopf setoverprint false autospread gsave /filler load fp grestore false setoverprint}bdf /f{closepath F}bdf /S{sc fhsetcolor strokeopf setoverprint true autospread {stroke}fp false setoverprint}bdf /s{closepath S}bdf /B{fc fhsetcolor fillopf setoverprint gsave /filler load fp grestore sc fhsetcolor strokeopf setoverprint true autospread {stroke}fp false setoverprint}bdf /b{closepath B}bdf /setcolorscreen where{pop}{/setcolorscreen{setscreen pop pop pop pop pop pop pop pop pop}bdf}ifelse /fhsetcolor{dup length 4 eq {aload overprintprocess setcmykcolor} {aload 1 get spots exch get 5 get setinkoverprint setspotcolor} ifelse }ndf /settextcolor{ dup fhsetcolor textblackopf { dup length 4 eq {onlyk{3 get 1.0 eq{true setinkoverprint}if}{pop}ifelse} {pop} ifelse } {pop}ifelse }ndf /ka{/fc xdf}bdf /Ka{/sc xdf}bdf /xa{/fc xdf} bdf /Xa{/sc xdf} bdf /bc2[0 0]def /bc4[0 0 0 0]def /absmax{2 copy abs exch abs gt{exch}if pop}bdf /calcstep { colorexists not and{calcgraysteps}{maxsteps}ifelse tc1 length 4 eq { 0 1 3 {tc1 1 index get tc2 3 -1 roll get sub }for absmax absmax absmax } { bc2 tc1 1 get 1 exch put tc1 gettint tc2 gettint sub abs } ifelse mul abs round dup 0 eq{pop 1}if dup /numsteps xdf 1 sub dup 0 eq{pop 1}if /numsteps1 xdf }bdf /cblend{ tc1 length 4 eq { 0 1 3 {bc4 exch tc1 1 index get tc2 2 index get 1 index sub frac mul add put }for bc4 } { bc2 tc1 gettint tc2 gettint 1 index sub frac mul add puttint bc2 } ifelse fhsetcolor }bdf /logtaper{/frac frac 9 mul 1 add log def}bdf FHIODict begin /origmtx matrix currentmatrix def /iminv false def /invbuf{0 1 2 index length 1 sub{dup 2 index exch get 255 exch sub 2 index 3 1 roll put}for}bdf /cmykbufs2gray{ dup length 0 1 3 -1 roll 1 sub {4 index 1 index get 4 index 2 index get 4 index 3 index get 4 index 4 index get 255 exch sub ccmyk ccmyk ccmyk pop 5 mul exch 45 mul add exch 14 mul add -6 bitshift 2 index 3 1 roll put}for 4 1 roll pop pop pop }bdf end /radfill { /tc2 xdf /tc1 xdf /radius xdf /yt xdf /xt xdf true calcstep currentflat mark 3 -1 roll currentflat clipflatness { {dup setflat 2 index exec 0 1 numsteps1 {numsteps1 div /frac xdf cblend 1 index setflat{ newpath mark xt yt radius 1 frac sub mul 0 360 {arc fill}stopped {cleartomark exch 1.3 mul dup setflat exch 2 copy gt{stop}if} {cleartomark exit}ifelse }loop }for } gsave stopped grestore {exch pop 3 index exch 1.3 mul dup 100 gt{cleartomark setflat stop}if} {exit}ifelse }loop cleartomark setflat }bdf /currentpacking where{pop false setpacking}if /spots[1 0 0 0 (Process Cyan) false newcmykcustomcolor 0 1 0 0 (Process Magenta) false newcmykcustomcolor 0 0 1 0 (Process Yellow) false newcmykcustomcolor 0 0 0 1 (Process Black) false newcmykcustomcolor 0 0 0 0 (White) false newcmykcustomcolor ]def %%EndSetup [] 0 d 3.863708 M 1 w 0 j 0 J 0 O 0 R 0 i false eomode [0 0 0 1] Ka [0 0 0 1] ka vms u u true eomode u true fhsetspreadallow 225.1136 368.394 m 225.1136 366.9936 L 225.1136 366.758 225.0922 366.6724 224.8566 366.6724 C 224.8566 366.5225 L 226.7518 366.5225 L 226.7518 366.6724 L 226.5163 366.6724 226.4627 366.758 226.4627 366.9936 C 226.4627 368.394 L 225.1136 368.394 L h 230.0262 368.394 m 231.281 367.0471 L 231.4202 366.8972 231.4845 366.8544 231.4845 366.758 C 231.4845 366.6938 231.3774 366.6724 231.2703 366.6724 C 231.2703 366.5225 L 233.2512 366.5225 L 233.2512 366.6724 L 233.037 366.6724 232.9621 366.758 232.9621 366.9936 C 232.9621 368.394 L 230.0262 368.394 L h 235.149 368.394 m 235.149 366.9294 L 235.149 366.7366 235.1169 366.6724 234.9563 366.6724 C 234.9563 366.5225 L 240.8346 366.5225 L 241.0487 366.5225 241.1451 366.4904 241.1451 366.394 C 241.295 366.394 L 241.295 367.7217 L 241.1451 36&%7.7217 L 241.1451 367.6253 241.0487 367.5718 240.8346 367.5718 C 236.4553 367.5718 L 236.4553 368.394 L 235.149 368.394 L h 244.737 368.394 m 244.737 366.9294 L 244.737 366.7366 244.7048 366.6724 244.5228 366.6724 C 244.5228 366.5225 L 246.2681 366.5225 L 246.2681 366.6724 L 246.0861 366.6724 246.0433 366.7366 246.0433 366.9294 C 246.0433 368.394 L 244.737 368.394 L h 250.8598 368.394 m 251.2638 367.2292 L 251.3173 367.09 251.3923 366.8972 251.3923 366.7688 C 251.3923 366.7259 251.328 366.6724 251.2317 366.6724 C 251.2317 366.5225 L 252.9342 366.5225 L 252.9342 366.6724 L 252.795 366.6724 252.7307 366.7259 252.7307 366.7902 C 252.7307 366.8758 252.7843 366.9615 252.8271 367.1007 C 253.268 368.394 L 252.1485 368.394 L 252.1311 368.3427 L 252.1097 368.3427 L 252.0926 368.394 L 250.8598 368.394 L h 255.3261 368.394 m 255.793 367.0471 L 255.8251 366.9615 255.868 366.8758 255.868 366.7795 C 255.868 366.7152 255.793 366.6724 255.6967 366.6724 C 255.6967 366.5225 L 257.4741 366.5225 L 257.4741 366.6724 L 257.3349 366.6724 257.2706 366.7045 257.2706 366.8009 C 257.2706 366.8865 257.3456 367.0257 257.4098 367.2292 C 257.8044 368.394 L 256.6668 368.394 L 256.6496 368.3427 L 256.6282 368.3427 L 256.6104 368.394 L 255.3261 368.394 L h 260.422 368.394 m 261.0191 367.214 262.3768 366.4154 264.1165 366.4154 C 265.8561 366.4154 267.2138 367.214 267.8109 368.39 C 266.4178 368.394 L 265.9353 367.8146 265.1213 367.4647 264.1165 367.4647 C 263.1116 367.4647 262.2977 367.8146 261.8151 368.4005 C 260.422 368.394 L h 269.6974 368.394 m 269.6974 366.9294 L 269.6974 366.7366 269.6653 366.6724 269.4726 366.6724 C 269.4726 366.5225 L 271.1965 366.5225 L 271.1965 366.6724 L 271.0359 366.6724 271.0037 366.7366 271.0037 366.9294 C 271.0037 368.394 L 269.6974 368.394 L h 273.4644 368.394 m 274.2267 367.2506 L 274.3444 367.0686 274.5265 366.8544 274.5265 366.7366 C 274.5265 366.6831 274.4729 366.6724 274.4408 366.6724 C 274.4408 366.5225 L 276.3895 366.5225 L 276.3895 366.6724 L 276.2289 366.6724 276.0897 366.7795 275.9934 366.9187 C 274.96 368.394 L 273.4644 368.394 L h 278.0099 368.394 m 278.0099 366.9294 L 278.0099 366.7366 277.9778 366.6724 277.7958 366.6724 C 277.7958 366.5225 L 279.4982 366.5225 L 279.4982 366.6724 L 279.359 366.6724 279.3162 366.7366 279.3162 366.9294 C 279.3162 368.394 L 278.0099 368.394 L h 281.5049 368.394 m 282.6997 366.9187 L 282.7533 366.8544 282.8175 366.7795 282.8175 366.7473 C 282.8175 366.7045 282.7961 366.6617 282.7211 366.6724 C 282.7211 366.5225 L 284.7769 366.5225 L 284.7769 366.6724 L 284.5949 366.6724 284.4879 366.7152 284.338 366.9079 C 283.1217 368.394 L 281.5049 368.394 L h 286.3652 368.394 m 286.3652 366.9294 L 286.3652 366.7366 286.3331 366.6724 286.0654 366.6724 C 286.0654 366.5225 L 287.9392 366.5225 L 287.9392 366.6724 L 287.7143 366.6724 287.6715 366.7366 287.6715 366.9294 C 287.6715 368.394 L 286.3652 368.394 L h 289.8831 368.394 m 289.8831 366.9294 L 289.8831 366.7366 289.8403 366.6724 289.7118 366.6724 C 289.7118 366.5225 L 291.168 366.5225 L 291.168 366.6724 L 291.0609 366.6724 291.0181 366.7366 291.0181 366.9294 C 291.0181 368.394 L 289.8831 368.394 L h 293.8293 368.394 m 295.0869 367.0471 L 295.194 366.9294 295.2903 366.833 295.2903 366.7795 C 295.2903 366.7152 295.2368 366.6724 295.1511 366.6724 C 295.1511 366.5225 L 296.7679 366.5225 L 296.7679 366.6724 L 296.6287 366.6724 296.5859 366.7366 296.5859 366.9294 C 296.5859 368.394 L 293.8293 368.394 L h 298.3712 368.394 m 298.917 367.0499 300.2977 366.4154 301.9956 366.4154 C 303.3126 366.4154 304.5439 366.7902 305.3898 367.4326 C 305.3898 367.5825 L 305.3042 367.6253 305.272 367.6682 305.272 367.7859 C 305.272 368.394 L 304.03 368.394 L 304.03 367.8716 L 303.7944 367.7003 302.9378 367.4647 302.1669 367.4647 C 301.1505 367.4647 300.2971 367.7734 299.8074 368.3936 C 298.3712 368.394 L h 313.5809 368.394 m 313.5809 366.9936 L 313.5809 366.758 313.5381 366.6724 313.2597 366.6724 C 313.2597 366.5225 L 315.4333 366.5225 L 315.4333 366.6724 L 315.1549 366.6724 315.1013 366.758 315.1013 366.9936 C 315.1013 368.394 L 313.5809 368.394 L h 319.6341 368.394 m 3&%19.6341 366.9294 L 319.6341 366.7366 319.602 366.6724 319.3985 366.6724 C 319.3985 366.5225 L 321.1867 366.5225 L 321.1867 366.6724 L 320.9832 366.6724 320.9404 366.7366 320.9404 366.9294 C 320.9404 368.394 L 319.6341 368.394 L h 324.9664 368.394 m 324.9664 366.9294 L 324.9664 366.7366 324.9342 366.6724 324.7308 366.6724 C 324.7308 366.5225 L 326.5189 366.5225 L 326.5189 366.6724 L 326.3155 366.6724 326.2727 366.7366 326.2727 366.9294 C 326.2727 368.394 L 324.9664 368.394 L h 328.4594 368.394 m 328.4594 366.9294 L 328.4594 366.7366 328.4273 366.6724 328.2667 366.6724 C 328.2667 366.5225 L 334.145 366.5225 L 334.3592 366.5225 334.4555 366.4904 334.4555 366.394 C 334.6054 366.394 L 334.6054 367.7217 L 334.4555 367.7217 L 334.4555 367.6253 334.3592 367.5718 334.145 367.5718 C 329.7657 367.5718 L 329.7657 368.394 L 328.4594 368.394 L h 340.4102 368.394 m 340.4102 366.9936 L 340.4102 366.758 340.3673 366.6724 340.1104 366.6724 C 340.1104 366.5225 L 345.0786 366.5225 L 346.6044 366.5225 347.7613 367.1476 348.3296 368.3908 C 346.6605 368.394 L 346.2959 367.965 345.7572 367.7859 345.0786 367.7859 C 341.9306 367.7859 L 341.9306 368.394 L 340.4102 368.394 L h 350.4455 368.394 m 350.4455 366.9294 L 350.4455 366.7366 350.4134 366.6724 350.2528 366.6724 C 350.2528 366.5225 L 356.1311 366.5225 L 356.3453 366.5225 356.4417 366.4904 356.4417 366.394 C 356.5916 366.394 L 356.5916 367.7217 L 356.4417 367.7217 L 356.4417 367.6253 356.3453 367.5718 356.1311 367.5718 C 351.7518 367.5718 L 351.7518 368.394 L 350.4455 368.394 L h 358.3172 368.394 m 357.603 367.1007 L 357.7422 367.0364 L 357.7957 367.0686 357.8599 367.0793 357.9028 367.0793 C 358.0312 367.0793 358.2347 366.9187 358.6737 366.7473 C 359.1234 366.576 359.7873 366.4154 360.8473 366.4154 C 362.8595 366.4154 364.1826 367.0946 364.2882 368.3963 C 363.0418 368.394 L 362.9579 367.8527 362.3945 367.4647 361.1364 367.4647 C 359.798 367.4647 358.5238 367.9466 358.5238 368.3213 C 358.5238 368.3481 358.5265 368.3722 358.5291 368.3936 C 358.3172 368.394 L h 365.9596 368.394 m 365.9596 366.9294 L 365.9596 366.7366 365.9275 366.6724 365.7455 366.6724 C 365.7455 366.5225 L 367.448 366.5225 L 367.448 366.6724 L 367.3087 366.6724 367.2659 366.7366 367.2659 366.9294 C 367.2659 368.394 L 365.9596 368.394 L h 369.4546 368.394 m 370.6494 366.9187 L 370.703 366.8544 370.7672 366.7795 370.7672 366.7473 C 370.7672 366.7045 370.7458 366.6617 370.6709 366.6724 C 370.6709 366.5225 L 372.7267 366.5225 L 372.7267 366.6724 L 372.5446 366.6724 372.4376 366.7152 372.2877 366.9079 C 371.0714 368.394 L 369.4546 368.394 L h 376.0816 368.394 m 376.0816 366.9294 L 376.0816 366.7366 376.0495 366.6724 375.8675 366.6724 C 375.8675 366.5225 L 377.6128 366.5225 L 377.6128 366.6724 L 377.4308 366.6724 377.3879 366.7366 377.3879 366.9294 C 377.3879 368.394 L 376.0816 368.394 L h 381.0661 368.394 m 381.6633 367.214 383.021 366.4154 384.7606 366.4154 C 386.5003 366.4154 387.858 367.214 388.4551 368.39 C 387.062 368.394 L 386.5794 367.8146 385.7654 367.4647 384.7606 367.4647 C 383.7558 367.4647 382.9418 367.8146 382.4592 368.4005 C 381.0661 368.394 L h 390.3309 368.394 m 390.3309 366.9294 L 390.3309 366.7366 390.2988 366.6724 390.1167 366.6724 C 390.1167 366.5225 L 391.8406 366.5225 L 391.8406 366.6724 L 391.6693 366.6724 391.6372 366.7366 391.6372 366.9294 C 391.6372 368.394 L 390.3309 368.394 L f n 225.1136 371.394 m 225.1136 368.394 L 226.4627 368.394 L 226.4627 371.394 L 225.1136 371.394 L h 227.2312 371.394 m 230.0263 368.3939 L 232.9621 368.394 L 232.9621 371.394 L 231.613 371.394 L 231.613 368.9316 L 229.2949 371.394 L 227.2312 371.394 L h 235.149 371.394 m 235.149 368.394 L 236.4553 368.394 L 236.4553 369.3064 L 239.2499 369.3064 L 239.4641 369.3064 239.5497 369.2207 239.5497 369.1565 C 239.6996 369.1565 L 239.6996 370.5056 L 239.5497 370.5056 L 239.5497 370.4093 239.4641 370.3557 239.2499 370.3557 C 236.4553 370.3557 L 236.4553 371.394 L 235.149 371.394 L h 244.737 371.394 m 244.737 368.394 L 246.0433 368.394 L 246.0433 371.394 L 244.737 371.394 L h 249.8192 371.394 m 250.8598 368.394 L 252.0926 368.394 L 251.0952 371&%.394 L 249.8192 371.394 L h 253.1643 371.394 m 252.1485 368.394 L 253.268 368.394 L 254.2726 371.3408 L 254.3047 371.3408 L 255.3261 368.394 L 256.6104 368.394 L 255.5707 371.394 L 253.1643 371.394 L h 257.6718 371.394 m 256.6668 368.394 L 257.8044 368.394 L 258.8206 371.394 L 257.6718 371.394 L h 260.5356 371.394 m 260.2482 370.9168 260.0905 370.3724 260.0905 369.7882 C 260.0905 369.2863 260.2069 368.8137 260.422 368.39 C 261.8151 368.394 L 261.5057 368.7761 261.3326 369.2487 261.3326 369.7882 C 261.3326 370.4379 261.5836 370.9904 262.0212 371.3935 C 260.5356 371.394 L h 266.2118 371.394 m 266.6493 370.9904 266.9004 370.4379 266.9004 369.7882 C 266.9004 369.2487 266.7272 368.7761 266.4178 368.4005 C 267.8109 368.394 L 268.026 368.8137 268.1425 369.2863 268.1425 369.7882 C 268.1425 370.3724 267.9848 370.9168 267.6973 371.3906 C 266.2118 371.394 L h 269.6974 371.394 m 269.6974 368.394 L 271.0037 368.394 L 271.0037 369.2422 L 272.8989 369.2422 L 273.4644 368.394 L 274.96 368.394 L 274.3659 369.2422 L 275.4473 369.3492 276.1861 370.0773 276.1861 371.0624 C 276.1861 371.1771 276.1793 371.286 276.1659 371.3893 C 274.8483 371.394 L 274.8692 371.3188 274.8798 371.2419 274.8798 371.1588 C 274.8798 370.5913 274.6335 370.2915 273.6913 370.2915 C 271.0037 370.2915 L 271.0037 371.394 L 269.6974 371.394 L h 278.0099 371.394 m 278.0099 368.394 L 279.3162 368.394 L 279.3162 368.8031 L 280.4191 369.7347 L 281.5049 368.394 L 283.1217 368.394 L 281.3934 370.5056 L 282.4864 371.394 L 280.8469 371.394 L 279.3162 370.1523 L 279.3162 371.394 L 278.0099 371.394 L h 286.3652 371.394 m 286.3652 368.394 L 287.6715 368.394 L 287.6715 371.394 L 286.3652 371.394 L h 289.8831 371.394 m 289.8831 368.394 L 291.0181 368.394 L 291.0181 371.394 L 289.8831 371.394 L h 291.0284 371.394 m 293.8294 368.394 L 296.5859 368.394 L 296.5859 371.394 L 295.4509 371.394 L 295.4509 368.4819 L 292.7137 371.394 L 291.0284 371.394 L h 298.5112 371.394 m 298.2599 370.9395 298.1195 370.4028 298.1195 369.7882 C 298.1195 369.2582 298.208 368.7935 298.3712 368.3921 C 299.8074 368.394 L 299.5232 368.7534 299.3616 369.2181 299.3616 369.7882 C 299.3616 370.4626 299.6188 371.0029 300.0306 371.3922 C 298.5112 371.394 L h 304.2009 371.394 m 304.2153 371.3694 304.2227 371.3528 304.2227 371.3408 C 304.2227 371.2658 304.212 371.2337 304.2013 371.2123 C 304.3298 371.1374 L 304.4677 371.394 L 304.2009 371.394 L h 313.5809 371.394 m 313.5809 368.394 L 315.1013 368.394 L 315.1013 371.3939 L 313.5809 371.394 L h 319.6341 371.394 m 319.6341 368.394 L 320.9404 368.394 L 320.9404 369.3064 L 324.9664 369.3064 L 324.9664 368.394 L 326.2727 368.394 L 326.2727 371.394 L 324.9664 371.394 L 324.9664 370.4414 L 320.9404 370.4414 L 320.9404 371.394 L 319.6341 371.394 L h 328.4594 371.394 m 328.4594 368.394 L 329.7657 368.394 L 329.7657 369.3064 L 332.5603 369.3064 L 332.7745 369.3064 332.8601 369.2207 332.8601 369.1565 C 333.01 369.1565 L 333.01 370.5056 L 332.8601 370.5056 L 332.8601 370.4093 332.7745 370.3557 332.5603 370.3557 C 329.7657 370.3557 L 329.7657 371.394 L 328.4594 371.394 L h 340.4102 371.394 m 340.4102 368.394 L 341.9306 368.394 L 341.9306 371.394 L 340.4102 371.394 L h 347.0991 371.394 m 347.164 371.1174 347.1986 370.7932 347.1986 370.42 C 347.1986 369.4673 347.0092 368.8165 346.6605 368.4002 C 348.3296 368.394 L 348.5827 368.9447 348.7191 369.6213 348.7191 370.42 C 348.7191 370.7635 348.6942 371.0899 348.6433 371.397 C 347.0991 371.394 L h 350.4455 371.394 m 350.4455 368.394 L 351.7518 368.394 L 351.7518 369.3064 L 354.5465 369.3064 L 354.7606 369.3064 354.8463 369.2207 354.8463 369.1565 C 354.9962 369.1565 L 354.9962 370.5056 L 354.8463 370.5056 L 354.8463 370.4093 354.7606 370.3557 354.5465 370.3557 C 351.7518 370.3557 L 351.7518 371.394 L 350.4455 371.394 L h 357.8576 371.394 m 357.8232 371.2445 357.8064 371.0903 357.8064 370.9339 C 357.8064 368.2142 363.053 370.0666 363.053 368.5462 C 363.053 368.4952 363.0493 368.4454 363.0418 368.3967 C 364.2882 368.394 L 364.2928 368.4523 364.2951 368.5094 364.2951 368.5676 C 364.2951 371.7584 359.0485 369.6062 359.0485 371.2337 C 359.0485 371&%.2899 359.0556 371.3433 359.0695 371.3939 C 357.8576 371.394 L h 363.3438 371.394 m 363.3497 371.3718 363.3528 371.356 363.3528 371.3408 C 363.3528 371.2123 L 363.5027 371.1159 L 363.6495 371.394 L 363.3438 371.394 L h 365.9596 371.394 m 365.9596 368.394 L 367.2659 368.394 L 367.2659 368.8031 L 368.3688 369.7347 L 369.4546 368.394 L 371.0714 368.394 L 369.3432 370.5056 L 370.4362 371.394 L 368.7966 371.394 L 367.2659 370.1523 L 367.2659 371.394 L 365.9596 371.394 L h 376.0816 371.394 m 376.0816 368.394 L 377.3879 368.394 L 377.3879 371.394 L 376.0816 371.394 L h 381.1798 371.394 m 380.8923 370.9168 380.7347 370.3724 380.7347 369.7882 C 380.7347 369.2863 380.8511 368.8137 381.0661 368.39 C 382.4592 368.394 L 382.1499 368.7761 381.9767 369.2487 381.9767 369.7882 C 381.9767 370.4379 382.2278 370.9904 382.6653 371.3935 C 381.1798 371.394 L h 386.8559 371.394 m 387.2935 370.9904 387.5445 370.4379 387.5445 369.7882 C 387.5445 369.2487 387.3714 368.7761 387.062 368.4005 C 388.4551 368.394 L 388.6702 368.8137 388.7866 369.2863 388.7866 369.7882 C 388.7866 370.3724 388.6289 370.9168 388.3415 371.3906 C 386.8559 371.394 L h 390.3309 371.394 m 390.3309 368.394 L 391.6372 368.394 L 391.6372 369.2636 L 394.3997 369.2636 L 395.9523 369.2636 396.5304 370.0559 396.5304 371.1374 C 396.5304 371.2249 396.527 371.3092 396.5201 371.3903 C 395.21 371.394 L 395.2197 371.323 395.2242 371.2449 395.2242 371.1588 C 395.2242 370.5056 394.9672 370.3129 394.132 370.3129 C 391.6372 370.3129 L 391.6372 371.394 L 390.3309 371.394 L h 305.272 368.394 m 305.272 369.5741 L 305.272 369.7454 305.3042 369.7882 305.3898 369.8203 C 305.3898 369.9702 L 302.4453 369.9702 L 302.274 369.9702 302.1669 370.0452 302.1669 370.1309 C 302.017 370.1309 L 302.017 368.7282 L 302.1669 368.7282 L 302.1669 368.8139 302.274 368.9209 302.4453 368.9209 C 304.03 368.9209 L 304.03 368.394 L 305.272 368.394 L h 358.5291 368.394 m 358.5318 368.415 358.5345 368.4337 358.5345 368.4498 C 358.3953 368.5355 L 358.3172 368.394 L 358.5291 368.394 L f n 310.4865 374.394 m 310.4865 372.7863 L 310.6364 372.7863 L 310.6364 372.9683 310.7435 373.054 311.0004 373.054 C 313.5809 373.054 L 313.5809 371.394 L 315.1013 371.394 L 315.1013 373.054 L 317.6818 373.054 L 317.9388 373.054 318.0459 372.9683 318.0459 372.7863 C 318.1958 372.7863 L 318.1958 374.394 L 317.9808 374.394 L 317.9235 374.3445 317.8264 374.3174 317.6818 374.3174 C 311.0004 374.3174 L 310.8559 374.3174 310.7587 374.3445 310.7014 374.3987 C 310.4865 374.394 L h 226.4627 371.394 m 226.4627 372.2188 L 227.2312 371.394 L 229.2949 371.394 L 226.966 373.8677 L 226.891 373.9427 226.8482 373.9962 226.8482 374.0283 C 226.8482 374.1247 226.9339 374.1675 227.1373 374.1675 C 227.1373 374.3174 L 224.8566 374.3174 L 224.8566 374.1675 L 225.0922 374.1675 225.1136 374.0819 225.1136 373.8463 C 225.1136 371.394 L 226.4627 371.394 L h 232.9621 371.394 m 232.9621 373.8463 L 232.9621 374.0819 233.037 374.1675 233.2512 374.1675 C 233.2512 374.3174 L 231.3346 374.3174 L 231.3346 374.1675 L 231.5916 374.1675 231.613 374.0819 231.613 373.8463 C 231.613 371.394 L 232.9621 371.394 L h 236.4553 371.394 m 236.4553 372.0047 L 240.7596 372.0047 L 240.9845 372.0047 241.0702 371.919 241.0702 371.8119 C 241.2201 371.8119 L 241.2201 373.1825 L 241.0702 373.1825 L 241.0702 373.1075 240.9845 373.054 240.7596 373.054 C 234.9563 373.054 L 234.9563 372.9041 L 235.1169 372.9041 235.149 372.8398 235.149 372.6471 C 235.149 371.394 L 236.4553 371.394 L h 246.0433 371.394 m 246.0433 372.0047 L 248.1633 372.0047 L 248.3775 372.0047 248.4631 371.9832 248.4631 371.8762 C 248.613 371.8762 L 248.613 373.1825 L 248.4631 373.1825 L 248.4631 373.0861 248.3775 373.054 248.1633 373.054 C 242.6169 373.054 L 242.4028 373.054 242.3171 373.0861 242.3171 373.1825 C 242.1672 373.1825 L 242.1672 371.8762 L 242.3171 371.8762 L 242.3171 371.9832 242.4028 372.0047 242.6169 372.0047 C 244.737 372.0047 L 244.737 371.394 L 246.0433 371.394 L h 251.0952 371.394 m 250.707 372.5614 L 250.6642 372.6792 250.6428 372.7435 250.6428 372.7863 C 250.6428 372.8184 250.6856 372.8934 250.8034 372.9041 C 250.8034 &%373.054 L 249.1116 373.054 L 249.1116 372.9041 L 249.2937 372.8719 249.3365 372.8077 249.4328 372.5079 C 249.8192 371.394 L 251.0952 371.394 L h 255.5707 371.394 m 255.2255 372.3901 L 255.172 372.54 255.1077 372.6792 255.1077 372.7649 C 255.1077 372.8505 255.172 372.9041 255.2898 372.9041 C 255.2898 373.054 L 253.4374 373.054 L 253.4374 372.9041 L 253.5552 372.9041 253.6087 372.8398 253.6087 372.7542 C 253.6087 372.6792 253.5552 372.54 253.5016 372.3901 C 253.1643 371.394 L 255.5707 371.394 L h 258.8206 371.394 m 259.198 372.5079 L 259.2836 372.7649 259.3264 372.8505 259.5192 372.9041 C 259.5192 373.054 L 257.9452 373.054 L 257.9452 372.9041 L 258.063 372.9041 258.1272 372.8612 258.1272 372.797 C 258.1272 372.7649 258.0951 372.6685 258.063 372.5614 C 257.6718 371.394 L 258.8206 371.394 L h 262.0212 371.394 m 262.5139 371.8474 263.2431 372.1117 264.1165 372.1117 C 264.9899 372.1117 265.719 371.8474 266.2118 371.3935 C 267.6973 371.394 L 267.0522 372.4539 265.7534 373.161 264.1165 373.161 C 262.4795 373.161 261.1807 372.4539 260.5356 371.3906 C 262.0212 371.394 L h 271.0037 371.394 m 271.0037 372.0047 L 273.4879 372.0047 L 274.2555 372.0047 274.7268 371.8018 274.8484 371.3896 C 276.1659 371.394 L 276.0065 372.6167 274.9105 373.054 273.1131 373.054 C 269.4726 373.054 L 269.4726 372.9041 L 269.6653 372.9041 269.6974 372.8398 269.6974 372.6471 C 269.6974 371.394 L 271.0037 371.394 L h 279.3162 371.394 m 279.3162 372.6471 L 279.3162 372.8398 279.359 372.9041 279.4982 372.9041 C 279.4982 373.054 L 277.7958 373.054 L 277.7958 372.9041 L 277.9778 372.9041 278.0099 372.8398 278.0099 372.6471 C 278.0099 371.394 L 279.3162 371.394 L h 282.4864 371.394 m 283.9097 372.5507 L 284.1024 372.7006 284.3165 372.8398 284.627 372.9041 C 284.627 373.054 L 282.4535 373.054 L 282.4535 372.9041 L 282.5177 372.9041 282.5605 372.8934 282.5605 372.8398 C 282.5605 372.7863 282.4535 372.6899 282.3785 372.6364 C 280.8469 371.394 L 282.4864 371.394 L h 287.6715 371.394 m 287.6715 372.6471 L 287.6715 372.8398 287.7143 372.9041 287.9392 372.9041 C 287.9392 373.054 L 286.0654 373.054 L 286.0654 372.9041 L 286.3331 372.9041 286.3652 372.8398 286.3652 372.6471 C 286.3652 371.394 L 287.6715 371.394 L h 291.0181 371.394 m 291.0181 371.405 L 291.0284 371.394 L 292.7137 371.394 L 291.5963 372.5829 L 291.5106 372.6792 291.425 372.722 291.425 372.8077 C 291.425 372.8827 291.4678 372.9041 291.532 372.9041 C 291.532 373.054 L 289.7118 373.054 L 289.7118 372.9041 L 289.8403 372.9041 289.8831 372.8398 289.8831 372.6471 C 289.8831 371.394 L 291.0181 371.394 L h 296.5859 371.394 m 296.5859 372.6471 L 296.5859 372.8398 296.6287 372.9041 296.7679 372.9041 C 296.7679 373.054 L 295.2796 373.054 L 295.2796 372.9041 L 295.4081 372.9041 295.4509 372.8398 295.4509 372.6471 C 295.4509 371.394 L 296.5859 371.394 L h 300.0306 371.394 m 300.5276 371.8619 301.2499 372.1117 302.017 372.1117 C 303.259 372.1117 304.0614 371.5841 304.2009 371.3895 C 304.4677 371.394 L 305.1007 372.5721 L 304.9401 372.6364 L 304.8973 372.6043 304.8544 372.5829 304.8116 372.5829 C 304.7367 372.5829 304.4368 372.7328 304.0086 372.8719 C 303.5589 373.0219 302.9164 373.161 302.0812 373.161 C 300.4992 373.161 299.1485 372.5441 298.5112 371.3932 C 300.0306 371.394 L h 320.9404 371.394 m 320.9404 372.6471 L 320.9404 372.8398 320.9832 372.9041 321.1867 372.9041 C 321.1867 373.054 L 319.3985 373.054 L 319.3985 372.9041 L 319.602 372.9041 319.6341 372.8398 319.6341 372.6471 C 319.6341 371.394 L 320.9404 371.394 L h 326.2727 371.394 m 326.2727 372.6471 L 326.2727 372.8398 326.3155 372.9041 326.5189 372.9041 C 326.5189 373.054 L 324.7308 373.054 L 324.7308 372.9041 L 324.9342 372.9041 324.9664 372.8398 324.9664 372.6471 C 324.9664 371.394 L 326.2727 371.394 L h 329.7657 371.394 m 329.7657 372.0047 L 334.0701 372.0047 L 334.2949 372.0047 334.3806 371.919 334.3806 371.8119 C 334.5305 371.8119 L 334.5305 373.1825 L 334.3806 373.1825 L 334.3806 373.1075 334.2949 373.054 334.0701 373.054 C 328.2667 373.054 L 328.2667 372.9041 L 328.4273 372.9041 328.4594 372.8398 328.4594 372.6471 C 328.4594 371.394 L 329.7657 371.394 L &%h 341.9306 371.394 m 341.9306 373.054 L 344.7145 373.054 L 345.8739 373.054 346.8027 372.6793 347.0991 371.398 C 348.6433 371.394 L 348.3467 373.1864 347.1643 374.3174 344.843 374.3174 C 340.1104 374.3174 L 340.1104 374.1675 L 340.3673 374.1675 340.4102 374.0819 340.4102 373.8463 C 340.4102 371.394 L 341.9306 371.394 L h 351.7518 371.394 m 351.7518 372.0047 L 356.0562 372.0047 L 356.2811 372.0047 356.3667 371.919 356.3667 371.8119 C 356.5166 371.8119 L 356.5166 373.1825 L 356.3667 373.1825 L 356.3667 373.1075 356.2811 373.054 356.0562 373.054 C 350.2528 373.054 L 350.2528 372.9041 L 350.4134 372.9041 350.4455 372.8398 350.4455 372.6471 C 350.4455 371.394 L 351.7518 371.394 L h 359.0695 371.394 m 359.2042 371.8831 359.9726 372.1117 361.04 372.1117 C 362.1861 372.1117 363.2362 371.6794 363.3437 371.388 C 363.6495 371.394 L 364.2094 372.4544 L 364.0595 372.5079 L 364.0274 372.4865 363.9845 372.4544 363.9417 372.4544 C 363.8775 372.4544 363.567 372.6685 363.1387 372.8077 C 362.4855 373.0219 361.9394 373.161 360.9972 373.161 C 359.0566 373.161 358.0822 372.3719 357.8576 371.3942 C 359.0695 371.394 L h 367.2659 371.394 m 367.2659 372.6471 L 367.2659 372.8398 367.3087 372.9041 367.448 372.9041 C 367.448 373.054 L 365.7455 373.054 L 365.7455 372.9041 L 365.9275 372.9041 365.9596 372.8398 365.9596 372.6471 C 365.9596 371.394 L 367.2659 371.394 L h 370.4362 371.394 m 371.8594 372.5507 L 372.0521 372.7006 372.2663 372.8398 372.5768 372.9041 C 372.5768 373.054 L 370.4032 373.054 L 370.4032 372.9041 L 370.4674 372.9041 370.5103 372.8934 370.5103 372.8398 C 370.5103 372.7863 370.4032 372.6899 370.3282 372.6364 C 368.7966 371.394 L 370.4362 371.394 L h 377.3879 371.394 m 377.3879 372.0047 L 379.508 372.0047 L 379.7221 372.0047 379.8078 371.9832 379.8078 371.8762 C 379.9577 371.8762 L 379.9577 373.1825 L 379.8078 373.1825 L 379.8078 373.0861 379.7221 373.054 379.508 373.054 C 373.9616 373.054 L 373.7474 373.054 373.6618 373.0861 373.6618 373.1825 C 373.5119 373.1825 L 373.5119 371.8762 L 373.6618 371.8762 L 373.6618 371.9832 373.7474 372.0047 373.9616 372.0047 C 376.0816 372.0047 L 376.0816 371.394 L 377.3879 371.394 L h 382.6653 371.394 m 383.158 371.8474 383.8872 372.1117 384.7606 372.1117 C 385.634 372.1117 386.3632 371.8474 386.8559 371.3935 C 388.3415 371.394 L 387.6964 372.4539 386.3976 373.161 384.7606 373.161 C 383.1237 373.161 381.8249 372.4539 381.1798 371.3906 C 382.6653 371.394 L h 391.6372 371.394 m 391.6372 372.0047 L 394.132 372.0047 L 394.8571 372.0047 395.1463 371.8594 395.21 371.3937 C 396.5202 371.394 L 396.4232 372.5401 395.6442 373.054 394.314 373.054 C 390.1167 373.054 L 390.1167 372.9041 L 390.2988 372.9041 390.3309 372.8398 390.3309 372.6471 C 390.3309 371.394 L 391.6372 371.394 L f n 310.7014 374.394 m 310.6569 374.4409 310.6364 374.4995 310.6364 374.5744 C 310.4865 374.5744 L 310.4865 374.394 L 310.7014 374.394 L h 318.1958 374.394 m 318.1958 374.5744 L 318.0459 374.5744 L 318.0459 374.4995 318.0254 374.4409 317.9808 374.3987 C 318.1958 374.394 L f n F n F n U false eomode 1.6167 w S u u 224.4601 433.9994 m 277.9581 433.9994 L 277.9581 382.0518 L 224.4601 382.0518 L 224.4601 433.9994 L 0.7187 w 1 R s U 265.401 382.2053 m 266.3374 382.2053 267.0896 382.9728 267.0896 383.9093 C 267.0896 384.8456 266.3374 385.6133 265.401 385.6133 C 233.6092 384.2009 L 232.6882 384.2009 231.936 384.9685 231.936 385.9049 C 231.936 386.8413 232.6882 387.6088 233.6092 387.6088 C 269.162 386.1965 L 270.0984 386.1965 270.8506 386.9642 270.8506 387.9005 C 270.8506 388.8369 270.0984 389.6045 269.162 389.6045 C 237.493 388.4685 L 236.5719 388.4685 235.6969 389.1746 235.6969 390.1111 C 235.6969 391.0475 236.5719 391.7843 237.493 391.7843 C 272.2782 390.4027 L 273.2146 390.4027 273.9668 391.1703 273.9668 392.1067 C 273.9668 393.043 273.2146 393.8107 272.2782 393.8107 C 238.8132 392.6593 L 237.8921 392.6593 237.2474 393.3655 237.2474 394.3019 C 237.2474 395.2382 237.9996 396.0058 238.9206 396.0058 C 273.8133 394.5935 L 274.7497 394.5935 275.5019 395.3611 275.5019 396.2975 C 275.5019 397.2339 274.7497 398.0014 273.8133 398.0014 C 239.2584 396&%.8656 L 238.3374 396.8656 237.4623 397.5716 237.4623 398.508 C 237.4623 399.4444 238.3374 400.1812 239.2584 400.1812 C 272.923 398.7997 L 273.8594 398.7997 274.6115 399.5673 274.6115 400.5036 C 274.6115 401.44 273.8594 402.2076 272.923 402.2076 C 237.2627 400.8414 L 236.3417 400.8414 235.482 401.5629 235.482 402.4993 C 235.482 403.4356 236.2343 404.2033 237.1553 404.2033 C 269.3922 403.0059 L 270.3286 403.0059 271.0808 403.7734 271.0808 404.7098 C 271.0808 405.6462 270.3286 406.4137 269.3922 406.4137 C 235.4975 405.0476 L 234.5763 405.0476 233.7013 405.7537 233.7013 406.6901 C 233.7013 407.6264 234.4535 408.3941 235.3746 408.3941 C 266.9668 407.212 L 267.9032 407.212 268.6554 407.9795 268.6554 408.9159 C 268.6554 409.8524 267.9032 410.6199 266.9668 410.6199 C 233.0719 409.2383 L 232.1509 409.2383 231.2758 409.9444 231.2758 410.8808 C 231.2758 411.8172 232.1509 412.5541 233.0719 412.5541 C 265.4318 411.1879 L 266.3681 411.1879 267.1203 411.9555 267.1203 412.8919 C 267.1203 413.8283 266.3681 414.5958 265.4318 414.5958 C 229.7561 413.4445 L 228.8351 413.4445 227.9601 414.1506 227.9601 415.087 C 227.9601 416.0234 228.7123 416.791 229.6333 416.791 C 263.4361 415.3941 L 264.3725 415.3941 265.1247 416.1616 265.1247 417.098 C 265.1247 418.0344 264.3725 418.802 263.4361 418.802 C 228.6509 417.6353 L 227.7298 417.6353 226.8548 418.3414 226.8548 419.2779 C 226.8548 420.2143 227.7298 420.951 228.6509 420.951 C 263.2211 419.6002 L 264.1576 419.6002 264.9098 420.3678 264.9098 421.3042 C 264.9098 422.2406 264.1576 423.0082 263.2211 423.0082 C 229.7561 421.8415 L 228.8351 421.8415 227.9601 422.5476 227.9601 423.4841 C 227.9601 424.4205 228.7123 425.1879 229.6333 425.1879 C 264.9866 423.8064 L 265.9229 423.8064 266.6751 424.5739 266.6751 425.5103 C 266.6751 426.4468 265.9229 427.2143 264.9866 427.2143 C 233.2868 426.0476 L 232.3658 426.0476 231.4908 426.7538 231.4908 427.6902 C 231.4908 428.6266 232.3658 429.3634 233.2868 429.3634 C 268.7475 427.9972 L 269.6839 427.9972 270.4361 428.7647 270.4361 429.7012 C 270.4361 430.6375 269.6839 431.4051 268.7475 431.4051 C 236.925 430.1924 L 236.004 430.1924 235.2518 430.9599 235.2518 431.8963 C 235.2518 432.8327 236.004 433.8152 236.925 433.8152 C 237.0478 433.9994 L 224.4294 433.9994 L 224.4294 382.0518 L 265.1311 382.0518 L 265.401 382.2053 L 1 O 0.1704 w b U true eomode u 417.4799 433.7305 m 415.758 433.7305 L 414.6546 430.8324 L 413.5511 433.7305 L 411.8292 433.7305 L 411.8292 428.8316 L 412.8963 428.8316 L 412.8963 432.7847 L 412.9206 432.7847 L 414.3393 428.8316 L 414.9698 428.8316 L 416.3886 432.7847 L 416.4128 432.7847 L 416.4128 428.8316 L 417.4799 428.8316 L 417.4799 433.7305 L h 411.3078 433.7305 m 407.1487 433.7305 L 407.1487 432.7847 L 408.6401 432.7847 L 408.6401 428.8316 L 409.8163 428.8316 L 409.8163 432.7847 L 411.3078 432.7847 L 411.3078 433.7305 L 0 O f n U u u false eomode 300.1255 426.6589 m 310.9705 426.6589 L 313.5883 418.6186 L 313.5883 418.4317 L 303.3042 418.4317 L 302.7617 418.4317 301.9953 418.0202 301.9953 417.3098 C 301.9953 415.1969 314.7103 404.968 314.7103 400.1072 C 314.7103 398.2374 L 314.7103 395.7696 312.1479 390.9451 305.735 390.9451 C 291.5242 390.9451 L 291.5242 398.9853 L 301.8083 398.9853 L 302.8006 398.9853 303.4912 399.939 303.4912 400.2942 C 303.4912 402.0706 291.1503 412.3171 291.1503 416.9358 C 291.1503 418.4317 L 291.1503 420.9564 294.1528 426.6589 300.1255 426.6589 C 1 O f n U u 317.1249 426.6589 m 334.5144 426.6589 L 340.4102 426.6589 343.8636 420.8622 343.8636 417.6837 C 343.8636 415.8138 L 343.8636 406.3713 328.2691 399.7893 326.2871 398.6113 C 326.2871 391.132 L 316.751 391.132 L 316.751 417.3098 L 326.1002 417.3098 L 326.1002 408.1475 L 328.2129 408.5029 333.9535 413.1213 333.9535 415.8138 C 333.9535 416.5618 333.0003 418.6186 330.7747 418.6186 C 315.0681 418.6186 L 315.0681 419.1796 L 317.1249 426.6589 L f n U u 347.2444 417.4967 m 356.7805 417.4967 L 356.7805 391.319 L 347.2444 391.319 L 347.2444 417.4967 L f n 347.9923 426.846 m 368.1865 426.846 L 373.2351 426.846 376.7879 421.8347 376.7879 417.8707 C 376.7879 410.9898 368.7475 406.5582 368.N&%7475 406.0908 C 368.7475 405.642 375.7968 394.0864 379.4055 391.693 C 366.6907 391.693 L 366.0175 392.254 362.8014 396.1619 357.1545 407.9606 C 359.4357 409.7743 365.5687 413.8132 365.5687 416.7489 C 365.5687 417.5715 364.5778 418.8056 363.138 418.8056 C 345.5615 418.8056 L 347.5809 425.8736 347.2818 425.8362 347.9923 426.846 C f n U u 376.194 426.7203 m 387.039 426.7203 L 391.1528 417.5581 L 391.5267 417.5581 L 395.4533 426.7203 L 406.4853 426.7203 L 406.4853 426.5334 L 396.0143 405.2172 L 396.0143 391.1934 L 386.4781 391.1934 L 386.4781 405.4042 L 376.194 426.5334 L 376.194 426.7203 L f n U U U U vmr %%Trailer end % FreeHandDict end % FHIODict &&&%!%MSEPS Trailer pp_save restore   -.]^bBCGWXvw  , - L M vw{ & &Rovy4=BEdg<=AUV_stx`"v"w"{"""""""""''''''''7)I)J)N)`)a)c)e)b1c1g111111111      Q1@2A2E2Q2R2444#4$4445"5w5{555556666666666S7W7777777778888888888999999!9"9999::<<<<<<<==)=0=B=H=X=Z=l=s=}==========>u>{>>^>>??9?cEcOcXcgcoc~ccccdd[dbddeee1e:eue}eeeeeeeeeYh]hhhhiiiiibjhjjjjjjjjjjjkk,k3kkkkk`mfmkmqmmmjnknnnnno%o2o9oq q1r7rQrXrorvrrrrrrdrrrr ss!s(sTs[sashssst tttttttttVu\uauguw ww"w1w8wRwYwwwww xx7x>xxx~yyyyyyyyyyyy4z;zHzOzzzzzD{J{O{U{{{(}*}2}3}7}@}A}}}}}}}}}}}}~~~~~_!*+_cyҀրJK "!39CEͅυ &",QUflߊei)-\c MNRpqswx|JKO[\rsw`ƐȐ(/>ESZ/6;?@AD_`no'+eiєՔ!'5;IO{×їחÛɛ +1~œȜϜМ@HU[Þ̟ӟܟݟ SbSZӠڠߠ ǡ͡¢Ǣ͢ lmqz{£ãǣߣʤˤݥޥSWnq NR"|.2KLPhikoptyz _ \]ajkήծ,2DKY`u|NV}ǰΰCJʱѱ /6;Bhpv}òʲ"$-óҳٳ!#*,/0:aҴݴ/6(.5uylw'+STXhikoptyz67;GH237@Aʽ̽¾ھ޾^btxw{LPoqgkHIMVWrsw^%&*67)*,biw{!KO%)|&)0sw")8?NUgm}!^4;+2LS MTV]_bcmQRV_` RSWklrsw|}*+/;<gh_hluvpt#&}gk| OSrv./3KLRSW\]!-.#);ALSciMQ`DF eisu  !%tv?A\]-1:<JQMO 4;OY,-KNmt!,0d0W[cguy"UY~xy}  gk#hl|=A_cuw&,:@NYadp`psLR4;z   !   [ _ p t |      ' + < >   [ ` }        0 5             459EFlmqz{`,08<os+/68rvJNWYQUfi-1  . 1 k!l!p!y!z!!!!!!!!!!!!#####%&&&*&;&<&F(G(K(T(U(U)Y)_)b)i)l)r)z)))_))):*=*U*X*y****o,s,|,,,,,,,,,,,,,, ----!-(-9-=-N-T-------////// 0000%0,04070F0P01"181<1F1I1Y1\1114444'5.585?5w7{777777777778888u8y88888.919d1999b:h:m:s:;;;;;;;;;;;;;;(</<4<;<<<<<<<I=L===?>D>????@@@@E@L@AAAB BB#B'B.B1BvB}BBBBBBBBCCCDD[G_GGGHHJJJJaKeK`LdLmLtL}LLLLMM M'M[McMsM{MMMdMMM,O0O9O@OIOPOYO`OhOjOwO}OOOOOOOOOOODPIPRRRRRRRRSSS$S&S.S4S8ShSpSSSSSTTTT T"T#T&T'T,T.T1T2T9TTU[UdUkUUUUUUUUUVVWWwX|XYYZ ZZZZZZZ[[[[^^_ ___d___````````tbvb~bbbb&c(c.c0cccccddd%deee%eeewfyfCgGgIgNgwg{g}gg5iT]_  " T h !:!S!o!!!!!"0"U"`""""""""##%#4#j#####$"$@$Y$u$$$$$ %%(%R%a%%%%%%&9&O&r&&&&&&')'P'c'' H^''''''(&(J(^(((((()3)7)c)g)z)))G*K*Z*j*z*****B+F+++$,j,,,,,--P-------.C.^.....4/O/y////00C0O0o00000 1#1?1G11152T22 4&44445 ( *HW55y66(8M88889$99:9;;<<<<=J@@A.BkBBCC$D^EELFGHH?IIoJeKKIM)N?OOPTQqS9TRTwTTTUV\WuWWWW%YaYY ZZZ[{[[6\ ]\]]]]^4^Z^x^^_}_`bc  p Rccf?hahiAjjmmnnp$qqrruv]ww]yy{U|z|*}C}g}}}~~A-?)<׃&Iw*ld0s?^jȐ^ /Sɖۗ[{T5g~ѡd}Y}ͤXե!3u,Vר& 6#4k|Tmd$^ݳwĸԹ Dk|+J*CvнH|_-uN@Yc9,-Sd[z?WIbSh/E[q1G_v4Pj ?n>_xZt|N_  U_0ENi)U]@cpx?QoP  V         )Hd}#m@Y<eX4]p:m[m5 5   c!|!!!!##%&>&&>(W(&)8))*++++a,,./T0 1@12#4446K77:h;;{?@.AA5BEF4GcG HIJJK7LLyNNOP5QQkRRT;UoUIVVVWcXXZmZZZ \ R \o\\D^^_aUbbd3eeegh"iiYkk loln8nno;ooXpp3qqq9rnrrrrtttt uEvbvvvv3wEwGwpwwxxixxxyz<}}}}~X~~.@_n}º񺺺Hp @P  IOZhЃ4hۄΆÇ"ѐ 9U?ΙЙҙԙ߳ @ p  p  p   p" Heading 1How To Description Body TextNoteCautionBullet Command text Heading 3How To Description How To StepsTable Heading Table ItemWarning Heading 2B Code textBulletF$ 0@ E<  D  "=D D D D @ B D  h x! " &(*(*p0 pp(s  ! H( *  p p! & ( *  &(*x@ (*;p) @ jg&PM@ 0x!  Tԙ2 6 * ]%',/k5P7k?HRRRZbKmw{{nv+]Ĺh )1E % X(v2=IS`]gBppv ';T ! + ! /  3   + ,  ?= C > Gd & '? NY C 7 - 7 !"' #E$' %L& '(/ )*7 +, -3. /30) 1,2' 34- 5>6; 7'8> 9E:w ;5< =>7 ?@~ A)/1>N_rS h0p)19M_OmҙM'()*+,-./0123456789:;<=>?3'5c}_m \ԙ@ABCDEFGHIJKMTimes Symbol "Helvetica5Courier New&ArialTimes New Roman -Eev@`vT9999999"$/!COMPAQ PAGEMARQ 15 v2012.015LPT2:pscriptCOMPAQ PAGEMARQ 15 v2012.015 UD[ od, Ze !5!aa G܅܅܅ Zo:6@P!generated by an Aldus applicationDana ArmstrongDana Armstrong