


      MAD(7)                     (Bull-SPS9)                     MAD(7)



      NAME
           mad - distributed access method

      DESCRIPTION
           The MAD driver is a distributed access method which  allows
           communications based on exchange of messages between
           programs located in the same system or in different systems.
           In the same system the programs can be located in the same
           processor or in different processors. The messages are
           carried into requests, responses or requests without
           responses; The reference model for these exchanges of
           messages is the client-server model of CCITT.
           The MAD driver special device provides users (client
           programs) with a mechanism to exchange request and response
           parameter blocks with servers (server programs) in a
           monoprocessor or multiprocessor environment.
           A client sends requests (one or more) and wait or check for
           responses.
           A server receives requests and sends responses.
           A program  can be both a client of several services and a
           server which offers one or several services.

           Parameter blocks

           Request and responses reference parameter blocks, these
           blocks must be allocated in the user memory space and
           formatted by the user program. A  block referenced by a
           request is called a request block, a block referenced by a
           response is called a response block. Excepted if the "move"
           mode is used, a request block is updated by the
           corresponding response. It is important to note that a
           request block is not reusable before the response overcomes
           (excepted if the 'move' mode is used).

           Definition of a service

           A service is defined by a sequence of contiguous numbers of
           function codes or request codes. Each request is
           characterized by a different function code. A program can
           offer one or more services simultaneously. Each service is
           described in a service-table of 255 entries (corresponding
           to the service numbers 1 to 255).

           To activate a service, a server program  must issue an ioctl
           (ACTISER) and then, ioctls (RECEPTION) followed by ioctl
           (REPONSE) to ensure the service. When the server wants no
           longer to offer the service, it must make an ioctl
           (DESACTISER) to desactivate it. Then a response is
           automatically returned, with an error return code, for the
           pending requests.

            The ioctl (DESACTISER) must be issued by the same minor



      Page 1                                         (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



           device as the minor device previously used in the
           corresponding ioctl (ACTISER).


           Telecommunication and network services

           The telecommunication and network services which  are
           available are:

           - ISO8802.2 ( link level on an Ethernet network )

           - X25-2     ( link level on telecommunication lines )

           - X25-3     ( network level )

           - TRANSPORT ISO ( classes: 0, 2, 3 and 4 )

           - SESSION ISO ( BCS, BSS, BAS )

           - UFT


            User services

           The user can develop services with that mechanism. They must
           refer to the document NETWORK CONFIGURATOR to generate and
           install their services.

           Description of MAD special files

           A special device file /dev/mad? identifies a MAD driver
           minor device.  A minor device corresponds to an event queue.
           An user process can deposit reference of parameter blocks in
           it and receive reference of parameter blocks from it. The
           user process can decide to be suspended or not when it wants
           to get a response and if there are no responses available,
           by using a wait or a check option. A special file, once
           opened, permits to access at different services located on
           several modules  and to ensure services for anywhere located
           clients. A service can be accessed simultaneously by several
           special files. Several programs can use the same special
           files (Only the father process must issue an s_open system
           call) but the responses to the requests of different
           programs will be mixed.

           The special files are defined by mknod(1M). The number of
           special files that can be opened simultaneously for the MAD
           driver is a parameter of configuration (refer to the network
           configurator manual).

           Addressing




      Page 2                                         (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



           The address  of the module where the requests are sent is
           either explicit or implicit (as described below) while the
           responses are automatically returned to their emitter.

                For the requests, two modes of addressing can be used:

           explicit address  The routing type parameters of the control
                             field of  a parameter block contains the
                             characteristics of the destination:
                             address of the physical module, of the
                             system and, if it is not the local system,
                             the number of the gateway unit. A byte is
                             reserved in the control field of the
                             parameter block for each of these three
                             numbers. In this case, the minor
                             associated with the special file is
                             without any particular signification.
                             Zero is the implicit value for the local
                             unit and for the local system.

           implicit address  The parameter 'destination physical
                             module' of the parameter block is set to
                             0xff. In that case a routing table is
                             accessed by the MAD driver at the entry
                             corresponding to the minor associated with
                             the special file and provides the routing
                             type parameters that are directly given by
                             the user in the parameter block with the
                             explicit addressing. A standard table,
                             described below, exists at the
                             initialization of the system.

           abort of a client

           All the server programs are notified of  a MAD user
           termination ( normally or abnormally ) by the reception of a
           specialised parameter block with the 0xffff function code
           and the identification of the terminated client. Either the
           server can ignore these parameter blocks,or it can  process
           it to release the resources allocated to the terminated
           process if it was a client. The server must memorize the
           identification of each client to can compare to that of the
           received parameter block. This identication does not change
           during the life of the client-server relationship and is
           associated to a minor and then is unique on a physical
           module.

           USER INTERFACE FILE

           The interface file maduif.h contains the declaration of the
           structures needed for ioctl system calls, the definition of
           the error values returned on the different system calls the



      Page 3                                         (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



           value of ioctl codes and the value of input or output
           parameters of the argument table.

           MAD SYSTEM CALLS

           The MAD special device files are accessed by user programs
           through s_open(2), s_close(2), s_ioctl(2) system calls.

           open system call



           At first, the user process must open a special file to send
           or receive request or responses.

           This system call has the following syntax:
                     #include <maduif.h>
                        int fd;
                        char *name;
                        int mode;
                     fd= s_open ( name,mode)

           "name" is a pointer on a character string  terminated with
           the NULL character. This name identifies a MAD special file.

           "mode" must be set to 0.

           s_open(2) returns a file descriptor "fd" if sucessful.

           s_open(2) returns -1 on error; in this latter case,
           additional information is given by the external errno :
              ER_DEVOCCUPE: if the special file is already opened.
              ENXIO: if there are more MAD special files requested than
              the value given at generation.  ER_GSME_NON_INIT: memory
              manager not initialized.



           ioctl system calls



           Five s_ioctl(2) system calls apply to the MAD special files.

           If the call is successfull, 0 is returned else -1. The
           return code can be found in the external int errno variable.

           The s_ioctl(2) system calls are the following:

           - activation of a service:

           activates an unactivated service



      Page 4                                         (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



           This s_ioctl system call has the following syntax:


                     #include <maduif.h>
                     rc= s_ioctl(fd,ACTISER,arg)

           "arg" is a integer which contains the number of the service
           to be activated. This number corresponds with an entry into
           the service-table where the service is described.

           The following return codes may be set up on return from the
           call in the errno variable:
              ER_SERV_INC: undefined service
              ER_SERV_ACTIF: already activated service (with an other
              minor)
              ER_TAB_SAT: saturated system tables

           desactivation of a service: desactivates an active service

           This s_ioctl system call has the following syntax:
                     #include <maduif.h>
                     rc= s_ioctl(fd,DESACTISER,arg)

           "arg" is a integer which contains the number of the service
           to be desactivated.

           The following return codes may be set up on return from the
           call in the errno variable:
              ER_UTI_INC: unknown server
              ER_CMDINV: this service has not been activated


           - request: send a request

           There are two modes to send a request:

           the standard mode The response's parameter block, when
                             received, will be copied, on the s_ioctl
                             (RECEPTION), in the corresponding
                             request's parameter block and the
                             associated data, in the buffers indicated
                             by the address type parameters of the
                             request's parameter block.

           the 'move' mode   The corresponding response's parameter
                             block will be copied, on the s_ioctl
                             (RECEPTION), in a buffer provided in the
                             arguments table of this system call. So
                             the request's parameter block can be used
                             again just after the s_ioctl (REQUETE). It
                             is a facility for parent programs using
                             the same special file, one of them sending



      Page 5                                         (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



                             the request's parameter block by issuing
                             s_ioctl (REQUETE) and the other one
                             receiving response's parameter block by
                             making an s_ioctl (RECEPTION). So they do
                             not need shared memory for user parameter
                             blocks.

           This s_ioctl system call has the following syntax:
                     #include <maduif.h>
                        int rc;
                        int fd;
                        struct madrequete *arg;

                     rc= s_ioctl(fd,REQUETE,arg)

           "arg" is a pointer on the following structure:
                 struct madrequete {
                      struct ucb_util *adrucb;
                      int   move;
                 };


           The following parameters must be set up, as described,
           before issuing the call:

           adrucb must contain the address of a parameter block.

           move indicates the used mode: 0 for the standard mode and 1
           for the 'move' mode.

           The following return codes may be set up on return from the
           call in the errno variable:
              ER_UN_INC: wrong address parameters in the parameter
              block.
              ER_UN_NON: non initialized destination physical module
              ER_LGTAMPUE: exchange memory too small to receive the
              parameter block
              ER_TYPBLOC_INC: the block to be sent is not an parameter
              block
              ER_CODREQINV: unknown function code
              ER_LGINFOINV: invalid length of information field in
              parameter block
              ER_SC7INAC: communication system out of order
              ER_TAB_SAT: saturated system tables (too many opened MAD
              special files)
              EFAULT: invalid user address (arg/ucb/associated datas)



           - response: send a response to a client

           This s_ioctl system call has the following syntax:



      Page 6                                         (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



                     #include <maduif.h>
                     rc= s_ioctl(fd,REPONSE,arg)

           "arg" is a pointer on the following structure:
                 struct madreponse {
                      struct ucb_util *adrucb;
                 };


           The following parameter must be set up, as described, before
           issuing the call:

           adrucb must contain the address of a response's parameter
           block.

           The following return codes may be set up on return from the
           call in the errno variable:
              ER_UN_INC: wrong address parameters in the parameter
              block.
              ER_UN_NON: non initialized destination physical module
              ER_LGTAMPUE: exchange memory too small to receive the
              parameter block
              ER_TYPBLOC_INC: the block to be sent is not an parameter
              block
              ER_LGINFOINV: invalid length of information field in
              parameter block
              ER_SC7INAC: communication system out of order
              ER_TAB_SAT: saturated system tables (too many opened MAD
              special files)
              EFAULT: invalid user address (arg/ucb/associated datas)



           - wait/check: Wait or test for a request or a response and
           get it.

           Server programs, which wait for requests issued by client
           programs, or client programs which use the 'move' mode to
           send requests, must provide this system callwith a reception
           buffer where the complete parameter block, followed by the
           associated data, will be copied.

           Client programs, which use the standard mode do not need to
           specify a reception buffer. On return of the s_ioctl
           (RECEPTION), it will obtain the address of the response's
           parameter block.

           This s_ioctl system call has the following syntax:
                     #include <maduif.h>
                     rc= s_ioctl(fd,RECEPTION,arg)

           "arg" is a pointer on the following structure:



      Page 7                                         (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



                 struct madreception {
                      int delai;
                      struct ucb_util *adrucb;
                      int   lgucb;
                      int   type_ucb;
                 };


           The following parameter must be set up, as described, before
           issuing the call:

           delai must be set with 0 for the check option or a value
           different from 0 for the wait option.

           adrucb,lgucb must contain the address and the length of a
           reception buffer if the process is a client by using the
           'move' mode or a server

           The following parameter must be examined on return from the
           call:

           adrucb contains the address of an parameter block when the
           call is successful, otherwise a null pointer.

           type_ucb indicates the type of received parameter block:
           UCB_REQ for a request's UCB and UCB_REP for a response's UCB

           The following return codes can be set up on return from the
           call in the errno variable:
              ER_DON_TRONQ: reception buffer too small to contain the
              received parameter block. It is truncated.
              EFAULT: invalid address of the reception buffer or arg
              table
              ER_TAB_SAT: system tables overflow
              ER-SC7INAC: communication system out of order
              EINTR: interrupted system call
              ER_UN_NON: non initialized destination physical module
              ER_LGTAMPUE: input/output buffer overflow
              ER_LGINFOINV: invalid length of information field in a
              RQB.
              ER_TYPBLOC_INC: invalid type of parameter block.

           If the s_ioctl (RECEPTION) was successfull, the received
           response's parameter block  can contain an internal return
           code (see 'description of an UCB') set to 0x901 for the two
           left bytes and, for the two right bytes, set to one of the
           following error codes:
              ER_SERV_INC: the requested service is inexistent
              ER_SERV_NON_ACTIV: the requested service is unactivated

           An other return code can be set up on return from any
           s_ioctl(2) :



      Page 8                                         (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



              ER_CMDINV wrong parameter 'command' of the s_ioctl(2)

           close

           When the processing is ended, the user closes his special
           file by issuing a s_close(2)

           This s_ioctl system call has the following syntax:
                     #include <maduif.h>
                        int rc;
                        int fd;

                     rc= s_close( fd);

           If parameter block's have been received and are not
           delivered yet, the requests are discarded while the
           associated responses are generated by the MAD and are sent
           back with an error code. Once closed, the special file can
           be reopened and allocated to a new user.

           When a MAD special file is closed, all the active server
           programs are notified by the reception of a special
           parameter block (see "abort of a client").



      MACHINE DEPENDANCIES
           SPS7

           The system calls: open, close, ioctl are accepted, but it is
           recommended to use s_open, s_close, s_ioctl to ease the port
           of programs in another environments.

           The returned error codes from 1 to 37, like EFAULT and
           ENXIO, are standard UNIX error codes and so can be founded
           in the /usr/include/sys/errno.h file. Others errors, from
           101 to 124, are error codes returned in the dialog SPIX-
           SPART and are described in the /usr/include/sys/smrt_err.h
           file.

           A process can be killed at any time by the kill signals or
           interrupted by the other signals and treat them by an
           appendix (see signal (2) ). The system call returns with an
           error status ( EINTR ) and the user process may then re-
           execute the call.

           MAD major number  The MAD major number is 18

           number of unit    It is the physical number of the unit,
                             increased by 0x10 for the treatment
                             modules (MT) and by 0x80 for the exchange
                             modules (ME). So, the value of the



      Page 9                                         (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



                             treatment modules varies from 0x10 to 0x17
                             and the value of the exchange modules from
                             0x80 to 0x8f.


           The standard routing table only allows to address the local
           system and has the following values:
            for minor 0 to  19, access to the module 0x10 (MT no 0)
              "   "    20 to  39, access to the module 0x11 (MT no 1)
              "   "    40 to  59, access to the module 0x12 (MT no 2)
              "   "    60 to  79, access to the module 0x13 (MT no 3)
              "   "    80 to  99, access to the module 0x87 (ME no 7)
              "   "   100 to 119, access to the module 0x88 (ME no 8)
              "   "   120 to 139, access to the module 0x89 (ME no 9)
              "   "   140 to 159, access to the module 0x8a (ME no a)
              "   "   160 to 179, access to the module 0x8b (ME no b)
              "   "   180 to 199, access to the module 0x8c (ME no c)
              "   "   200 to 219, access to the module 0x8d (ME no d)
              "   "   220 to 239, access to the module 0x8e (ME no e)
              "   "   240 to 255, access to the module 0x8f (ME no f)



           SPS9



           For ROS system, the returned error codes from 1 to 29, are
           standard ROS error codes and so can be founded in the
           /usr/include/sys/errors.h file.

           For SPIX system, the returned error codes from 1 to 37, are
           standard UNIX error codes and so can be founded in the
           /usr/include/sys/errors.h file.

           A process can be killed at any time by the kill signals or
           interrupted by the other signals and treat them by an
           appendix (see signal (2) ). The system call returns with an
           error status ( EINTR ) and the user process may then re-
           execute the call.

           MAD major number  The MAD major number is 129.

           number of unit    It is the physical number of the unit
                             which can be the CPU or a controller SAS.
                             Up to four controller SAS can be present
                             on a SPS9.


           The standard routing table only allows to address the local
           system and has the following values:
            for minor 0 to  39, access to the CPU



      Page 10                                        (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



              "   "    40 to  59, access to the controller SAS 1 (0x80
           to 0x83)
              "   "    60 to  79, access to the controller SAS 2 (0x84
           to 0x87)
              "   "    80 to  99, access to the controller SAS 3 (0x88
           to 0x8B)
              "   "   100 to 119, access to the controller SAS 4 (0x8C
           to 0x8F)



           Q700


           An access to the starnet services is available on Q700; a
           list of the differences is given in the following.

           Format of the parameter blocks

           Refer to the CTOS REFERENCE MANUAL; the parameters blocks
           are called RQB.



           addressing

           When an user process sends a request, the associated RQB can
           contain either a specification or a file handle In the first
           case, the MAD driver retrieves the local Ethernet  board
           which must be used to access the remote server, by
           consulting a local routing table which contains associations
           between specifications and adresses of Ethernet board.

           In the second case (routing by file handle ) , the MAD
           driver directly retrieves the local Ethernet board, because
           the file handle has been built up with a byte which
           identifies that board.

           abort of a client

           All the server programs are notified of the  abort of a
           client by the reception of a specialised  RQB with the net-
           abort function code.

           swapping of a client

           All the server programs are notified of the swapp of a
           client by the reception of a specialized RQB with the
           swapping function code.

           termination of a client




      Page 11                                        (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



           All the server programs are notified of the termination of a
           client by the reception of a specialized RQB with the
           termination function code specific to each server.

           Each active server must respond to those special requests.
           The specific function code of each server for the swapping,
           termination and abort requests are described in the service
           table.

           user interface files

           The interface files maduif.h and madcuif.h contain the
           declaration of the structures needed for ioctl system calls,
           the definition of the error values returned on the different
           system calls, the value of ioctl codes and the value of
           input or output parameters of the argument table.  The MAD
           special device files are accessed by user programs through
           open(2), close(2), ioctl(2) system calls.

           OPEN SYSTEM CALL

           At first, the user process must open a special file to
           exchange RQB's.  The mode parameter must be set to: ox80 to
           select a STARNET special file.

           An open(2) returns -1 on error; in this latter case,
           additional information is given by the external errno :
              ER_DEVOCCUPE: if the special file is already opened.
              ER_OPEN_INCORRECT: if the rw parameter is neither 0x80 or
              0.
              ENXIO: if there is more MAD special files than the value
              given at generation.




           IOCTL SYSTEM CALL

           Five ioctl(2) system calls apply to the MAD special files.

           If the call is successfull, 0 is returned else -1. The
           return code can be found in the external int errno variable.

           The ioctl(2) system calls are the following:



           ACTIVATION OF A SERVICE: activates an unactivated service

           This ioctl system call has the following syntax:
                     #include <madcuif.h>
                     rc= ioctl(fd,CTOS_ACTISER,arg)



      Page 12                                        (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



           "arg" is a integer which contains the number of the service
           to be activated. This number corresponds with an entry into
           the service-table where the service is described.

           The following return codes may be set up on return from the
           call in the errno variable:
              ER_CTOS_SERV_INC: undefined service
              ER_CTOS_SERV_ACTIF: already activated service (with an
              other minor)
              ER_TAB_SAT: saturated system tables



           SERVICE'S DESACTIVATION: desactivates an active service

           This ioctl system call has the following syntax:
                     #include <madcuif.h>
                     rc= ioctl(fd,CTOS_DESACTISER,arg)

           "arg" is a integer which contains the number of the service
           to be desactivated.

           The following return codes may be set up on return from the
           call in the errno variable:
              ER_CTOS_SERV_INC: unknown server
              ER_CTOS_SERV_NON_ACTIF: this service has not been
              activated


           REQUEST: send a request

           There is only one mode to send a request:

           the standard mode The response's RQB, when received, will be
                             copied, on the ioctl (RECEPTION), in the
                             corresponding request's RQB and the
                             associated data, in the buffers indicated
                             by the address type parameters of the
                             request's RQB.

           This ioctl system call has the following syntax:
                     #include <maduif.h>
                     rc= ioctl(fd,REQUETE,arg)

           "arg" is a pointer on the following structure:
                 struct madrequete {
                      struct ucb_util *adrucb;
                      int   move;
                 };


           The following parameters must be set up, as described,



      Page 13                                        (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



           before issuing the call:

           adrucb must contain the address of a RQB.

           move indicates the used mode: 0.

           The following return codes may be set up on return from the
           call in the errno variable:
              ER_UN_INC: wrong address parameters in the RQB.
              ER_UN_NON: non initialized destination physical module
              ER_LGTAMPUE: exchange memory too small to receive the
              RQB.
              ER_TYPRQB_INC: unknown destination in RQB.
              ER_CODEREQINV: unknown function code
              ER_LGINFOINV: invalid length of information field in a
              RQB.
              ER_SC7INAC: communication system out of order
              ER_TAB_SAT: saturated system tables (too many opened MAD
              special files)
              ER_TABUSER_SAT: system tables overflow ( too many client
              programs).
              EFAULT: invalid user address (arg/ucb/associated datas)



           RESPONSE: return a response to the client

           This ioctl system call has the following syntax:
                     #include <maduif.h>
                     rc= ioctl(fd,REPONSE,arg)

           "arg" is a pointer on the following structure:
                 struct madreponse {
                      struct ucb_util *adrucb;
                 };


           The following parameter must be set up, as described, before
           issuing the call:

           adrucb must contain the address of a RQB response.

           The following return codes may be set up on return from the
           call in the errno variable:
              ER_UN_INC: wrong address parameters in the RQB.
              ER_UN_NON: non initialized destination physical module
              ER_LGTAMPUE: exchange memory too small to receive the
              RQB.
              ER_LGINFOINV: invalid length of information field in a
              RQB.
              ER_SC7INAC: communication system out of order
              EFAULT: invalid user address (arg/ucb/associated datas)



      Page 14                                        (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



           WAIT/CHECK: Wait or test for a response and get it.

           the client process does not need to indicate a reception
           buffer. On return of the ioctl (RECEPTION), it will obtain
           the address of the RQB response.

           This ioctl system call has the following syntax:
                     #include <maduif.h>
                     rc= ioctl(fd,RECEPTION,arg)

           "arg" is a pointer on the following structure:
                 struct madreception {
                      int delai;
                      struct ucb_util *adrucb;
                      int   lgucb;
                      int   type_ucb;
                 };


           The following parameter must be set up, as described, before
           issuing the call:

           delai must be set with 0 for the check option or a value
           different from 0 for the wait option.

           adrucb and lgucb must contain the address and the length of
           a reception buffer if the process is a server.

           The following parameter must be examined on return from the
           call:

           adrucb contains the address of a RQB  when the call is
           successful, otherwise a null pointer.

           type_ucb indicates the type of the RQB received: RQB_REQ for
           a RQB request and RQB_REP for a RQB response.

           The following return codes can be set up on return from the
           call in the errno variable:
              ER_DON_TRONQ: reception buffer too small to contain the
              received RQB. It is truncated.
              EFAULT: invalid address of the reception buffer or arg
              table
              ER_TAB_SAT: saturated system tables
              ER-SC7INAC: communication system out of order

           If the ioctl (RECEPTION) was successfull, the RQB response
           received  can containan internal return code (see
           'description of a RQB) set to 0x901 for the two left bytes
           and, for the two right bytes, set to one of the following
           error codes:
              ER_CTOS_SERV_INC: the requested service does not exist.



      Page 15                                        (73 A2 02MTA REV1)






      MAD(7)                     (Bull-SPS9)                     MAD(7)



              ER_CTOS_SERV_NON_ACTIV: the requested service is not
              active.

           Another return code can be set up on return from any
           ioctl(2) :
              ER_CMDINV: wrong parameter 'command' of the ioctl(2)



           CLOSE SYSTEM CALL

           When the processing is ended, the user closes his special
           file by issuing a close(2) system call. If RQB' s were
           received and not delivered, the RQB requests are discarded
           while the RQB responses are returned with an error code.
           Once closed, the special file can be reopened and allocated
           to a new user.

           When a MAD special file is closed, all the active server
           process are notified by the reception of a special RQB (see
           "Notification of the termination of a client").

           The following return code may be set up on return from the
           close call, in the errno variable.
           ER_USER_UNKNOWN: the client program is unknown.


      SEE ALSO
           SPS7 documentation

           SC7-RLE3                    72F256MS
           SC7-X25                     72F290MT
           SC7-STID                    72F258MS
           SC7-UFT                     72F258MS

           SPS9 documentation

           SC9 PRESENTATION ET UTILISATION73F276MS
           SC9-X25                     73F273MS
           SC9-STID                    73F274MS
           SC9-UFT                     73F275MS














      Page 16                                        (73 A2 02MTA REV1)



