Tricks of the Windows Game Programming Gurus (2nd Edition)

home *** CD-ROM | disk | FTP | other *** search

/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / srvstruc.h < prev next >

Wrap

C/C++ Source or Header | 1998-04-25 | 26.9 KB | 807 lines

// // Structure related defines // #define SRV_SERVBSIZE(a) \ ((WORD)(a->srvio.packetsize) > (WORD)0 \ ? (WORD)(a->srvio.packetsize) \ : (WORD)512) #define SRV_DEFAULT_SERVBSIZE 512 #define MAX_NETLIBS 16 // Maximum server side net-libs #define SRV_SERVNETFUNCS 11 #ifdef BRIDGE #define SRV_CLIENTNETFUNCS 12 #endif typedef long (CDECL *LGFARPROC)(); typedef struct srv_handler { struct srv_handler * previous; struct srv_handler * next; struct srv_handler * last; int (* handler)(void *); } SRV_HANDLER; typedef struct srv_pevents { SRV_HANDLER * srv_attention; SRV_HANDLER * srv_connect; SRV_HANDLER * srv_disconnect; SRV_HANDLER * srv_rpc; SRV_HANDLER * srv_language; SRV_HANDLER * srv_start; SRV_HANDLER * srv_stop; SRV_HANDLER * srv_sleep; SRV_HANDLER * srv_restart; SRV_HANDLER * srv_transmgr; SRV_HANDLER * srv_oledb; } SRV_PEVENTS; typedef struct srv_events { int (*srv_hndl_attention)(void *); // ( SRV_PROC * ) int (*srv_hndl_connect)(void *); // ( SRV_PROC * ) int (*srv_hndl_disconnect)(void *); // ( SRV_PROC * ) int (*srv_hndl_restart)(void *); // ( SRV_SERVER * ) int (*srv_hndl_rpc)(void *); // ( SRV_PROC * ) int (*srv_hndl_sleep)(void *); // ( SRV_SERVER * ) int (*srv_hndl_language)(void *); // ( SRV_PROC * ) int (*srv_hndl_start)(void *); // ( SRV_SERVER * ) int (*srv_hndl_stop)(void *); // ( SRV_SERVER * ) int (*srv_hndl_attention_ack)(void *); // ( SRV_PROC * ) int (*srv_hndl_transmgr)(void *); // ( SRV_PROC * ) int (*srv_hndl_insertexec)(void *); // ( SRV_PROC * ) int (*srv_hndl_oledb)(void *); // ( SRV_PROC * ) } SRV_EVENTS; typedef struct srv_subchannel { struct srv_proc * srvproc; HANDLE threadHDL; THREAD threadID; HANDLE ss_handle; HANDLE cs_handle; HANDLE hEvent; BOOL status; struct srv_proc * site_srvproc; DWORD index; struct srv_proc ** master_list; } SRV_SUBCHANNEL; // // 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; typedef struct srv_params { struct srv_server * server; struct srv_proc * srvproc; struct srv_queuehead * queuehead; struct srv_comport * comport; THREAD threadID; HANDLE threadHDL; } SRV_PARAMS; #if defined( _MSSQLRISC_) #pragma pack(2) #endif // 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_HOSTIDLEN]; // host process identification BYTE lunused[SRV_MAXNAME-SRV_HOSTIDLEN - 6]; // unused BYTE lapptype [6]; // Application specific. 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]; // NOTE: Apparently used by System-10 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 lcharset[SRV_MAXNAME]; // character set name (unused) BYTE lcharsetlen; // length of character set (unused) BYTE lsetcharset; // notify on character set change (unused) BYTE lpacketsize[SRV_PKTLEN]; // length of TDS packets BYTE lpacketsizelen; // length of lpacketsize BYTE ldummy[3]; // NEW: pad to longword } 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; #if defined( _MSSQLRISC_) #pragma pack() #endif // Define structure for ODS statistics typedef struct srv_stats { int NumReads; int NumWrites; } SRV_STATS; // Define list elements used in queuing // network request. typedef struct srv_queuehead { struct srv_queuehead * Flink; struct srv_queuehead * Blink; struct srv_listhead * ListHead; } SRV_QUEUEHEAD, *PSRV_QUEUEHEAD; typedef struct srv_listhead { struct srv_listentry * Flink; struct srv_listentry * Blink; int NumListEntries; int NumReadRequest; int MaxQueueLength; long ListLock; HANDLE ListEvent; } SRV_LISTHEAD, *PSRV_LISTHEAD; typedef struct srv_listentry { struct srv_listentry * Flink; struct srv_listentry * Blink; struct srv_proc * pSrvProc; } SRV_LISTENTRY, *PSRV_LISTENTRY; // Define routines to manage list entries. // // VOID // InitializeListHead( // PSRV_LISTENTRY ListHead // ); // #define InitializeListHead(TYPE, ListHead) (\ (ListHead)->Flink = (ListHead)->Blink = (TYPE)(ListHead)) // // BOOLEAN // IsListEmpty( // PSRV_LISTENTRY ListHead // ); // #define IsListEmpty(ListHead) (\ ( ((ListHead)->Flink == (ListHead)) ? TRUE : FALSE ) ) // // SRV_LISTENTRY // RemoveHeadList( // TYPE, // TYPE ListHead // ); // #define RemoveHeadList(TYPE,ListHead) \ (TYPE)(ListHead)->Flink;\ {\ TYPE FirstEntry;\ FirstEntry = (ListHead)->Flink;\ FirstEntry->Flink->Blink = (TYPE)(ListHead);\ (ListHead)->Flink = FirstEntry->Flink;\ } // // VOID // RemoveEntryList( // PSRV_LISTENTRY Entry // ); // #define RemoveEntryList(Entry) {\ PSRV_LISTENTRY _EX_Entry;\ _EX_Entry = (Entry);\ _EX_Entry->Blink->Flink = _EX_Entry->Flink;\ _EX_Entry->Flink->Blink = _EX_Entry->Blink;\ } // // VOID // InsertTailList( // PSRV_LISTHEAD ListHead, // PSRV_LISTENTRY Entry // ); // #define InsertTailList(ListHead,Entry) \ (Entry)->Flink = (ListHead);\ (Entry)->Blink = (ListHead)->Blink;\ (ListHead)->Blink->Flink = (Entry);\ (ListHead)->Blink = (Entry);\ InterlockedIncrement(&(ListHead)->NumListEntries); // // VOID // InsertHeadList( // PSRV_LISTHEAD ListHead, // PSRV_LISTENTRY Entry // ); // #define InsertHeadList(ListHead,Entry) \ (Entry)->Flink = (ListHead)->Flink;\ (Entry)->Blink = (ListHead);\ (ListHead)->Flink->Blink = (Entry);\ (ListHead)->Flink = (Entry);\ InterlockedIncrement(&(ListHead)->NumListEntries); // // VOID // InsertHeadQueue( // PSRV_QUEUEHEAD ListHead, // PSRV_QUEUEHEAD Entry // ); // #define InsertHeadQueue(ListHead,Entry) \ (Entry)->Flink = (ListHead)->Flink;\ (Entry)->Blink = (ListHead);\ (ListHead)->Flink->Blink = (Entry);\ (ListHead)->Flink = (Entry); // // VOID // InsertTailQueue( // PSRV_QUEUEHEAD ListHead, // PSRV_QUEUEHEAD Entry // ); // #define InsertTailQueue(ListHead,Entry) \ (Entry)->Flink = (ListHead);\ (Entry)->Blink = (ListHead)->Blink;\ (ListHead)->Blink->Flink = (Entry);\ (ListHead)->Blink = (Entry); // // VOID // RemoveEntryQueue( // PSRV_QUEUEHEAD Entry // ); // #define RemoveEntryQueue(Entry) {\ PSRV_QUEUEHEAD _EX_Entry;\ _EX_Entry = (Entry);\ _EX_Entry->Blink->Flink = _EX_Entry->Flink;\ _EX_Entry->Flink->Blink = _EX_Entry->Blink;\ } // Configuration structure. 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 HANDLE log_handle; // handle of openned log file char log_file_name[SRV_MAXFILENAME]; // name of log file BOOL print_recv; // dump reads to screen BOOL print_send; // dump sends to screen BOOL remote_access; // flag indicating remote server access unsigned max_remote_sites; // simultaneous remote sites accessing unsigned max_remote_connections; // maximum allowed in/out remote connections WORD numConnectsPerThread; // Number of connections to monitor per network thread WORD MaxWorkingThreads; // Max number of working threads WORD MinWorkingThreads; // Min Number of working threads WORD ConcurrentThreads; // Min Number of working threads DWORD WorkingThreadTimeout; // Time to wait before exiting when idle unsigned max_packets; // maximum number of network packets buffered // // Multi Server Side Net-Library support // WORD numNetLibs; WORD spare; LGFARPROC SSNetLibs[MAX_NETLIBS][SRV_SERVNETFUNCS]; // NetLib Function ptrs HANDLE SSModules[MAX_NETLIBS]; // NetLib Module handles char connect_names[MAX_NETLIBS][SRV_MAXFILENAME]; // NetLib connection names char connect_dlls[MAX_NETLIBS][SRV_MAXFILENAME]; // NetLib names char connect_versions[MAX_NETLIBS][SRV_MAXFILENAME]; // NetLib versions char server_name[SRV_MAXFILENAME]; // Server name BOOL local_only; // flag indicating local access only BOOL unpack_rpc; // flag indicating if RPCs should be unpacked unsigned max_packetsize; // maximum network packet size unsigned dflt_packetsize; // The default packet size. int ThreadPriority; // Priority of thread in class. BOOL ansi; // flag indicating if ANSI codepage is used BYTE tdsversion[4]; BYTE progversion[4]; DWORD threadaffinity; // thread affinity option #ifdef BRIDGE HANDLE CSModule; // Client NetLib Module handle LGFARPROC CSNetLib[SRV_CLIENTNETFUNCS]; // NetLib Function ptrs char client_name[SRV_MAXFILENAME]; // Client side name BOOL bAuditConnects; // flag indicating if connects should be logged #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; // SRV_INPUTBUF // This structure maintains the read information when // pre-reading packets. // typedef struct srv_inputbuf { BYTE * pBuffer; DWORD ioStatus; DWORD ioRecvCnt; struct srv_inputbuf * pNext; } SRV_INPUTBUF; // SRV_COMPORT_QUEUE // Queue entry for completion port requests. // typedef struct srv_comport_queue { struct srv_comport_queue* Flink; struct srv_comport_queue* Blink; } SRV_COMPORT_QUEUE; // SRV_COMPORT_BUF // Description of a buffer passed through the srv_post_completion_queue // entry point. These buffers are typically posted by the server to // perform work on a worker thread that can't be handled by the currently // executing thread. // typedef struct srv_comportbuf { SRV_COMPORT_QUEUE queue; // Overlapped structure passed through srv_post_completion_queue // overlapped.Offset contains the address of this structure such that // OVERLAPPED overlapped; DWORD message_size; BYTE message [1]; } SRV_COMPORT_BUF; // WARNING! There is code that assumes it can get to the "last" input // buffer by looking at the current->pNext buffer. (i.e. It assumes // SRV_NUMINPUTBUFS == 2). // #define SRV_NUMINPUTBUFS 2 // // SRV_IO // This is the data structure used for reading and writing client // connection data for a particular server task. // typedef struct srv_io { void * server_ep; // server side endpoint #ifdef BRIDGE void * client_ep; // client side endpoint BOOL fCSerror; // flag indicate client-side error #endif HANDLE cs_sub_handle; // client-side subchannel local handle BYTE * outbuff; // send: start of send buffer BYTE * p_outbuff; // send: next place in buffer WORD n_outbuff; // send: room left in send buffer BYTE * inbuff; // recv: start of read buffer BYTE * p_inbuff; // recv: next place in buffer WORD 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 HANDLE ioEvent; // io event handle OVERLAPPED ioOverlapped; // io overlapped structure. SRV_INPUTBUF * pNextInBuf; // current io input buffer index SRV_INPUTBUF ioInputBuffers[SRV_NUMINPUTBUFS]; // io input buffers HANDLE ss_sub_handle; // server-side subchannel local handle WORD packetsize; // TDS packet 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 *data; // data buffer address DBINT user_type; // user-defined data type BYTE precision; // precision BYTE scale; // scale } SRV_COLDESC; // // SRV_RPCp: RPC parameter information // typedef struct srv_rpcp { BYTE len; // length of RPC parameter name BYTE * 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 * value; // the actual data } SRV_RPCp; typedef struct srv_comport { HANDLE hdl; DWORD cpu; } SRV_COMPORT; // // SRV_PROC: This is the main connection structure // typedef struct srv_proc { WORD tdsversion; // version of tds detected from client // 0x3400 = 3.4, 0x4000 = 4.0 WORD status; // status of this SRV_PROC SRV_IO srvio; // I/O structure of srvproc SRV_LOGINREC login; // login record received from the client void * langbuff; // pointer to language buffer unsigned long langlen; // length of language buffer unsigned int event; // event variable void * server; // pointer to associated SRV_SERVER structure char * threadstack; // stack pointer of event thread stack THREAD threadID; // thead ID associated with this SRV_PROC HANDLE threadHDL; // thread handle for resume and suspend HANDLE iowakeup; // event handle to wait on for overlapped io // and more. Passed on to SQL Server and netlibs. HANDLE exited; // semaphore indicating that thread // associated with this SRV_PROC has exited DBINT rowsent; // # of rows sent to client SRV_COLDESC * coldescp; // pointer to column description array DBUSMALLINT coldescno; // count of column descriptions BYTE * colnamep; // pointer to column name list WORD colnamelen; // length of column name list void * userdata; // pointer to user's private data area void * event_data; // pointer to event data area BYTE serverlen; // length of server name BYTE * 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 * rpc_server; // name of RPC server BYTE rpc_database_len; // length of RPC database name BYTE * rpc_database; // name of RPC database BYTE rpc_owner_len; // length of RPC owner name BYTE * rpc_owner; // name of RPC owner BYTE rpc_proc_len; // length of RPC or stored procecedure name BYTE * 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 ** 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 ** non_rpc_params; // temporary work buffer // char temp_buffer[100]; // array of subchannel structures // SRV_SUBCHANNEL * (*subprocs); // Data Translation information // TRANSLATION_INFO translation_info; struct srv_listentry IOListEntry; struct srv_listentry CommandListEntry; PSRV_LISTHEAD pNetListHead; BOOL bNewPacket; long StatusCrit; // critical section to check attentions void * serverdata; // private data area used ONLY by SQL Server SRV_SUBCHANNEL * subchannel; // Pre && Post Handler pointers // SRV_PEVENTS * pre_events; SRV_PEVENTS * post_events; // current position in language buffer used by processRPC // void * p_langbuff; BOOL fSecureLogin; // Set by the server when making an outbound call to an XP. // BOOL fInExtendedProc; // If TRUE indicates the current buffer is from // srv_post_completion_queue and the buffer should be // deallocated when the current work is completed. If // FALSE the current buffer came from the network and a // new read should be posted on the net. // unsigned fLocalPost:1; // If TRUE an XP associated with this srvproc made a call back into // the server on a bound connection. This flag is used to allow the // calling session to wait for logout processing of the XP to complete // unsigned fMadeBoundCall:1; // Filler to align after flags above. // unsigned uFill1:30; // List of requests posted using srv_post_completion_queue. Entries are // dynamically allocated inside srv_post_completion_queue and enqueued // in netIOCompletionRoutine. After the request has been processed the // entry is removed from this queue and deallocated. // // NOTE: Must hold SRV_PROC spinlock while altering queue. // SRV_COMPORT_QUEUE comport_queue; // Data pointers reserved for the Starfighter team // void * pSF1; // Currently in use by SQLTrace void * pSF2; // Reserved // Pre and Post handler semephores used during handler instals // and deinstals. // HANDLE hPreHandlerMutex; HANDLE hPostHandlerMutex; BOOL bSAxp; // Used by XP's to determine if running as SA } SRV_PROC; typedef struct srv_control { unsigned int status; // status of process unsigned int connects; // current number of connections SRV_PROC * (* srvprocs); // array of SRV_PROC connection structures // semaphore indicating that the connects counter is being accessed or // modified // HANDLE connects_sem; // semaphore indicating that thread has started // HANDLE start_sem; // semaphore indicating that some event has occurred // HANDLE event_sem; // semaphore indicating that log file is being written to // HANDLE log_sem; // shutdown critical section // long ShutDownCrit; // Network list critical section // long NetQueueCrit; // Thread Pool critical section // long ThreadPoolCrit; // print screen critical section // long ScrnPrnt; unsigned int remote_sites; // current number of remote sites connected unsigned int remote_connects; // current number of in/out remote connections // semaphore indicating that the remote sites counter is being accessed or // modified // HANDLE remote_sites_sem; // semaphore indicating that the remote connections counter is being accessed or // modified // HANDLE remote_connects_sem; // network request queue list // SRV_QUEUEHEAD netQueueList; int numNetQueueEntries; int maxNetQueueEntries; // command queue list // PSRV_LISTHEAD CommandQueueHead; // Server statistics. // SRV_STATS Stats; DWORD * pSharedCounter; HANDLE srvproc_mutex; DWORD dwWorkingThreadCnt; DWORD maxWorkingThreadCnt; SRV_COMPORT *comport; BYTE num_comports; BYTE ProcessorCnt; } SRV_CONTROL; typedef struct srv_server { LGFARPROC SSNetLib[SRV_SERVNETFUNCS]; // Server Side NetLib functions HANDLE SSModule; // Server Side DLL DWORD ep_size; void * listen_ep; #ifdef BRIDGE LGFARPROC CSNetLib[SRV_CLIENTNETFUNCS]; // Client Side NetLib functions HANDLE CSModule; // Client Side DLL char client_name[SRV_MAXFILENAME]; #endif THREAD net_threadID; // thead ID of client network event thread HANDLE net_threadHDL; // thread handle for resume and suspend // // connection information // char connect_name[SRV_MAXFILENAME]; char connect_dll[SRV_MAXFILENAME]; char connect_version[SRV_MAXFILENAME]; // // temporary work buffer // char temp_buffer[100]; // // server configuration information // SRV_CONFIG config; // server control information // SRV_CONTROL * control; // define the event handlers // SRV_EVENTS * events; // Pre && Post Handler pointers SRV_PEVENTS * pre_events; SRV_PEVENTS * post_events; // Pre and Post handler semephores // HANDLE hPreHandlerMutex; // Single writer HANDLE hPostHandlerMutex; HANDLE hPreHandlerSem; // Multiple reader HANDLE hPostHandlerSem; } SRV_SERVER; // Private structure used to export server entry points as ODS callbacks // for SQLServer use only. // typedef struct ods_callbacks { int (*sql_getbindtoken) (void*, char*); void (*sql_getdtcxact) (void*, void**); int (*sql_startinexec) (void*); void (*sql_stopinexec) (void*); // Place new callbacks at the end of the structure. } ODS_CALLBACKS;