Liren Large Software Subsidy 5/05.iso/a/a025/6.ddi/SRVSTRUC.H

C/C++ Source or Header | 1992-09-15 | 13.6 KB | 335 lines

#pragma pack( 2 )   // pack structures on word boundries

//
// define structures
//

typedef struct translation_info
{
    BOOL flag;                // data translation flag
    void (*int2)(short*);        // 2-byte integer swap function
    void (*int4)(long*);            // 4-byte integer swap function
    void (*recvflt)(float*);    // receive 8-byte float translation function
    void (*sendflt)(float*);    // send 8-byte float translation function
   void (*recvflt4)(float*);    // receive 4-byte float translation function
    void (*sendflt4)(float*);    // send 4-byte float translation function
    void (*recvchar)(char *, int);     // ASCII translation function
    void (*sendchar)(char *, int);     // ASCII translation function
    void (*twoint4)(char *);    // 2 4-byte integer swap function
    void (*twoint2)(char *);    // 2 2-byte interger swap function
} TRANSLATION_INFO;

//  SRV_LOGIN
//     The (TDS 4.0) login record received from the server client at login time.
//

typedef struct srv_loginrec {
    BYTE lhostname[SRV_MAXNAME];    // name of host or generic
    BYTE lhostnlen;         // length of lhostname
    BYTE lusername[SRV_MAXNAME];    // name of user
    BYTE lusernlen;         // length of lusername
    BYTE lpw[SRV_MAXNAME];  // password (plaintext)
    BYTE lpwnlen;           // length of lpw
    BYTE lhostproc[SRV_MAXNAME];    // host process identification
    BYTE lhplen;            // length of host process id
    BYTE lint2;             // type of int2 on this host
    BYTE lint4;             // type of int4 on this host
    BYTE lchar;             // type of char
    BYTE lflt;              // type of float
    BYTE ldate;             // type of datetime
    BYTE lusedb;            // notify on exec of use db cmd
    BYTE ldmpld;            // disallow use of dump/load and bulk insert
    BYTE linterface;        // SQL interface type
    BYTE ltype;             // type of network connection
    BYTE spare[7];          // spare fields
    BYTE lappname[SRV_MAXNAME]; // application name
    BYTE lappnlen;          // length of appl name
    BYTE lservname[SRV_MAXNAME];    // name of server
    BYTE lservnlen;         // length of lservname
    BYTE lrempw[0xff];      // passwords for remote servers
    BYTE lrempwlen;         // length of lrempw
    BYTE ltds[4];           // tds version
    BYTE lprogname[DBPROGNLEN]; // client program name
    BYTE lprognlen;         // length of client program name
    BYTE lprogvers[4];      // client program version
    BYTE lnoshort;          // NEW: auto convert of short datatypes
    BYTE lflt4;             // NEW: type of flt4 on this host
    BYTE ldate4;            // NEW: type of date4 on this host
    BYTE llanguage[SRV_MAXNAME];    // NEW: initial language
    BYTE llanglen;          // NEW: length of language
    BYTE lsetlang;          // NEW: notify on language change
    short slhier;           // NEW: security label hierarchy
    BYTE slcomp[8];         // NEW: security components
    short slspare;          // NEW: security label spare
    BYTE slrole;            // NEW: security login role
    BYTE ldummy[2];         // NEW: pad to longword
    int extra_data_len;     // length of extra data
    void FAR *extra_data;   // pointer to extra data

} SRV_LOGINREC;

//
//  SRV_LOGIN_OLDTDS
//     The login record received from "old" TDS 2.0 or 3.4 server clients.
//     The format is basically the same as 4.0, it is just shorter (no server
//     name or password, etc appended at the end).
//
typedef struct srv_login_oldtds {
    BYTE lhostname[SRV_MAXNAME];    // name of host or generic
    BYTE lhostnlen;         // length of lhostname
    BYTE lusername[SRV_MAXNAME];    // name of user
    BYTE lusernlen;         // length of lusername
    BYTE lpw[SRV_MAXNAME];  // password (plaintext)
    BYTE lpwnlen;           // length of lpw
    BYTE lhostproc[SRV_MAXNAME];    // host process identification
    BYTE lhplen;            // length of host process id
    BYTE lint2;             // type of int2 on this host
    BYTE lint4;             // type of int4 on this host
    BYTE lchar;             // type of char
    BYTE lflt;              // type of float
    BYTE ldate;             // type of datetime
    BYTE lusedb;            // notify on exec of use db cmd
    BYTE ldmpld;            // disallow use of dump/load and bulk insert
    BYTE linterface;        // SQL interface type
    BYTE spare[8];          // spare fields
    BYTE lappname[SRV_MAXNAME]; // application name
    BYTE lappnlen;          // length of appl name
    BYTE ldummy;            // pad length to even boundary

} SRV_LOGIN_OLDTDS;

typedef struct srv_config {
    unsigned connections;   // maximum allowed client connections
    unsigned stacksize;     // stack size of new threads created
    BOOL log_file_open;     // flag indicating log file open
    unsigned short log_handle;  // handle of openned log file
    char log_file_name[SRV_MAXFILENAME];    // name of log file
    BOOL coexist;
#ifdef BRIDGE
    char remote_name[SRV_MAXFILENAME]; // Client side name
#endif
} SRV_CONFIG;

//
//  SRV_TDSHDR
//  The first 8 bytes of each network packet constitute the packet
//  header.
//
typedef struct srv_tdshdr {
    BYTE type;              // io packet type
    BYTE status;            // io packet status
    DBUSMALLINT length;     // io packet length
    DBUSMALLINT channel;    // io packet subchannel
    BYTE packet;            // io packet number
    BYTE window;            // io packet window size

} SRV_TDSHDR;

// Packet size
#define SRV_SERVBSIZE  512

#ifdef NETLIBS
#define SRV_SERVNETFUNCS    8
#define SRV_CLIENTNETFUNCS    10
typedef long (pascal *LGFARPROC)();
#endif

//
//  SRV_IO
//  This is the data structure used for reading and writing client
//  connection data for a particular server task.
//
typedef struct srv_io {
#ifdef NETLIBS
     void FAR *    server_ep;  // server side endpoint
#else
    unsigned int handle;   // named pipe handle
#endif
#ifdef BRIDGE
     void FAR *    client_ep;  // client side endpoint
#endif
    unsigned int subchannel_handle;    // subchannel local handle
    BYTE FAR *outbuff;      // send: start of send buffer
    BYTE FAR *p_outbuff;    // send: next place in buffer
    int n_outbuff;          // send: room left in send buffer
    BYTE FAR *inbuff;       // recv: start of read buffer
    BYTE FAR *p_inbuff;     // recv: next place in buffer
    int n_inbuff;           // recv: room left in read buffer
    int SQLspanned;         // flag indicating that the SQL command
                            //  has spanned more that 1 network buffer.
    int cbflag;             // flag indicating that a client buffer is
                            //  available.
    DBUSMALLINT channel;    // io packet subchannel
    BYTE packet;            // io packet number
    BYTE window;            // io packet window size
} SRV_IO;

//
//  SRV_COLDESC: column description array (used by srv_describe & srv_sendrow)
//
typedef struct srv_coldesc {
    unsigned long otype;    // output data type
    unsigned long olen;     // length
    unsigned long itype;    // input data type
    unsigned long ilen;     // length
    BYTE FAR *data;         // data buffer address
    DBINT user_type;        // user-defined data type

} SRV_COLDESC;

//
//  SRV_RPCp: RPC parameter information
//
typedef struct srv_rpcp {
    BYTE len;                  // length of RPC parameter name
    BYTE FAR *rpc_name;        // pointer to the RPC parameter name
    BYTE status;               // return status, 1 = passed by reference
    unsigned long user_type;   // User-defined data type
    BYTE type;                 // data type
    unsigned long maxlen;      // maximum possible data length
    unsigned long actual_len;  // actual data length
    void FAR *value;           // the actual data
} SRV_RPCp;

//
//  SRV_PROC:   This is the main connection structure
//
typedef struct srv_proc {
    unsigned long start_sem;
    unsigned int tdsversion;   // version of tds detected from client
                               //   0x3400 = 3.4, 0x4000 = 4.0
    unsigned int status;       // status of this SRV_PROC
    SRV_IO srvio;              // I/O structure of srvproc
    SRV_LOGINREC login;        // login record received from the client
    void FAR *langbuff;        // pointer to language buffer
    unsigned int langlen;      // length of language buffer
    unsigned int event;        // event variable
    void FAR *server;          // pointer to associated SRV_SERVER structure
#ifdef _ASYNC_ATTENTIONS
    char FAR *WCthreadstack;    // stack pointer of watch_client thread stack
    unsigned long WCstartedSEM; // watch_client function started semaphore
    unsigned long WCexitedSEM;  // watch_client function exited semaphore
    unsigned long WCwaitSEM;    // watch_client function wait semaphore
    unsigned long WCholdSEM;    // watch_client function hold semaphore
#endif
    char FAR *threadstack;     // stack pointer of event thread stack
    unsigned short threadID;   // thead ID associated with this SRV_PROC
    unsigned long exited;      // semaphore indicating that thread
                               //  associated with this SRV_PROC has exited
    DBINT rowsent;             // # of rows sent to client
    SRV_COLDESC FAR *coldescp; // pointer to column description array
    unsigned int coldescno;    // count of column descriptions
    BYTE FAR *colnamep;        // pointer to column name list
    unsigned int colnamelen;   // length of column name list
    void FAR *userdata;        // pointer to user's private data area
    void FAR *event_data;      // pointer to event data area

    BYTE serverlen;            // length of server name
    BYTE FAR *servername;      // name of server
    //
    //  RPC info
    //
    BYTE rpc_active;           // flag indicating active RPC (TRUE=active)
    BYTE rpc_server_len;       // length of RPC server name
    BYTE FAR *rpc_server;      // name of RPC server
    BYTE rpc_database_len;     // length of RPC database name
    BYTE FAR *rpc_database;    // name of RPC database
    BYTE rpc_owner_len;        // length of RPC owner name
    BYTE FAR *rpc_owner;       // name of RPC owner
    BYTE rpc_proc_len;         // length of RPC or stored procecedure name
    BYTE FAR *rpc_proc_name;   // name of RPC or stored procedure
    unsigned int rpc_proc_number;  // number of RPC "procedure_name;number"
    unsigned int rpc_linenumber;   // line number batch error occurred on.
    unsigned short rpc_options;    // recompile option flag (bit 0)
    unsigned short rpc_num_params; // number of RPC parameters
    SRV_RPCp FAR *FAR *rpc_params; // array of pointers to each RPC paramater
    //
    // Return information for non-remote procedure call client command.
    // This information is provided by the function srv_returnval().
    // flag indicating active non-RPC values (TRUE = active)
    BYTE non_rpc_active;
    // number of non-RPC parameters
    //
    unsigned short non_rpc_num_params;

    // array of pointers to each non-RPC paramater
    //
    SRV_RPCp FAR *FAR *non_rpc_params;

    //
    // temporary work buffer
    //
    char temp_buffer[100];

    struct srv_proc FAR *(FAR *subprocs); // array of subchannel SRV_PROC structures

     // Data Translation information
     //
     TRANSLATION_INFO translation_info;

} SRV_PROC;

typedef struct srv_server {
#ifdef NETLIBS
     LGFARPROC SSNetLib[SRV_SERVNETFUNCS]; // Server Side NetLib functions
    unsigned short SSModule; // Server Side DLL
     int ep_size;
    void FAR * listen_ep;
#endif
#ifdef BRIDGE
     LGFARPROC CSNetLib[SRV_CLIENTNETFUNCS]; // Client Side NetLib functions
    unsigned short CSModule; // Client Side DLL
    char remote_connect_name[SRV_MAXFILENAME];
#endif
    unsigned int net_started;   // flag indicating the Gateway being "net started"
    unsigned short net_threadID;   // thead ID of client network event thread
    unsigned int status;           // status of SRV_SERVER process
    unsigned int connects;         // current number of connections
    SRV_PROC FAR *(FAR *srvprocs); // array of SRV_PROC connection structures
    //
    // connection name
    //
    char connect_name[SRV_MAXFILENAME];
    //
    // temporary work buffer
    //
    char temp_buffer[100];
    //
    // semaphore indicating that there is an open slot available for client
    //   connection.
    //
    unsigned long slot_avail_sem;
    //
    // semaphore indicating that thread has started
    //
    unsigned long start_sem;
    //
    // semaphore indicating that some event has occurred
    //
    unsigned long event_sem;
    //
    // semaphore indicating that log file is being written to
    //
    unsigned long log_sem;
    //
    // server configuration information
    //
    SRV_CONFIG config;
    //
    // define the event handlers
    //
    int (FAR *srv_hndl_attention)(void FAR *);  // ( SRV_PROC   FAR * )
    int (FAR *srv_hndl_connect)(void FAR *);    // ( SRV_PROC   FAR * )
    int (FAR *srv_hndl_disconnect)(void FAR *); // ( SRV_PROC   FAR * )
    int (FAR *srv_hndl_restart)(void FAR *);    // ( SRV_SERVER FAR * )
    int (FAR *srv_hndl_rpc)(void FAR *);        // ( SRV_PROC   FAR * )
    int (FAR *srv_hndl_sleep)(void FAR *);      // ( SRV_SERVER FAR * )
    int (FAR *srv_hndl_language)(void FAR *);   // ( SRV_PROC   FAR * )
    int (FAR *srv_hndl_start)(void FAR *);      // ( SRV_SERVER FAR * )
    int (FAR *srv_hndl_stop)(void FAR *);       // ( SRV_SERVER FAR * )
} SRV_SERVER;

#pragma pack( )     // use default packing