home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a025 / 6.ddi / PROCCBS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-15  |  38.1 KB  |  1,507 lines
  1. // This module defines all of the "callback" functions.  These modules
  2. // are defined here due to the fact that they must be mult-threaded and
  3. // therefore completely reentrant.  They must be linked with the proper
  4. // C Runtime Multi-Threaded Library (LLIBCDLL.LIB).
  5.  
  6. #include <stdlib.h>
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <ctype.h>
  10.  
  11. #define INCL_BASE
  12. #include <os2.h>
  13. #include <srv.h>
  14.  
  15. #ifdef LMPTK
  16. #define INCL_NETMAILSLOT
  17. #define INCL_NETERRORS
  18. #include <lan.h>
  19. #endif
  20.  
  21. // Define some user message codes.
  22. //
  23. #define  SRV_MAXERROR           20000
  24. #define  SP_UNKNOWN             SRV_MAXERROR + 1
  25. #define  INVALID_SP_SYNTAX      SRV_MAXERROR + 2
  26. #define  BAD_SP_PARAMETER       SRV_MAXERROR + 3
  27. #define  BROADCAST              SRV_MAXERROR + 4
  28. #define  EXEC                   SRV_MAXERROR + 5
  29.  
  30. // Miscellaneous defines used by sp-handling routines.
  31. //
  32. #define  EXEC_CMD "exec"
  33. #define  MAXNAME  32
  34. #define  MAXLEN   80
  35. #define  MAXPARAMS  4
  36. #define  SP_EXT   ";1"      // Default extension when Server initiated
  37. #define  VALUE 0x0000
  38. #define  REFERENCE 0x0001
  39.  
  40. #define BUF_SIZE    2048
  41. #define XBASE_HDR_SIZE  32
  42. #define XBASE_MAX_COLUMNS 128
  43.  
  44. // Event handlers for SP requests.
  45. //
  46. RETCODE proclist();        // List SP associated with Server
  47. RETCODE sp_exec();            // Execute the specified command string
  48. RETCODE sp_exec_trig();    // Execute the specified command string
  49. RETCODE diskfree();        // Return the space on a given drive
  50. RETCODE disklist();        // List available drives and their space
  51. RETCODE scan_xbase();         // Open and read an xBase file
  52.  
  53. #ifdef LMPTK
  54. RETCODE broadcast();        // Broadcast message to specifed mailslot
  55. #endif
  56.  
  57. // Global arguments
  58. //
  59. DBCHAR FAR *ProcSrvrName;    // The server name 
  60.  
  61. // Stored Procedure parameter information structure.
  62. //
  63. typedef struct sp_params {
  64.     DBCHAR name[MAXNAME + 1];    // Parameter name
  65.     int type;                    // Parameter data type
  66.     DBINT length;                // Parameter type length
  67.     int status;                    // Parameter return status
  68.     DBCHAR defaultvalue[MAXLEN * 10]; // Optional default value
  69. } SP_PARAMS;
  70.  
  71. // Stored Procedure information structure.
  72. //
  73. typedef struct sp_info {
  74.     DBCHAR name[MAXNAME + 1];                // Procedure name
  75.     DBCHAR usage[MAXLEN];                    // Usage string
  76.     int numparams;                            // Number of parameters
  77.     SP_PARAMS params[MAXPARAMS];            // Parameter array
  78.     RETCODE(FAR *handler) (void FAR *, ...);// Pointer to function with
  79.                                             // variable arguments
  80. } SP_INFO;
  81.  
  82. // Array of Stored Procedure handlers.
  83. //
  84. SP_INFO Sps[] = 
  85. {
  86.     "sp_exec",                // Procedure name
  87.     "usage: sp_exec <[@command =] command string>",    // Procedure usage
  88.     1,                        // Number of parameters 
  89.    {   // Parameter definitions
  90.         "command",            // Parameter name
  91.         SRVCHAR,            // Parameter type
  92.         MAXLEN,                // Parameter length (0 if fixed)
  93.         VALUE,                // Pass by value
  94.         "dir *.*",            // Default parameter value
  95.     },
  96.     sp_exec,                // Procedure function pointer
  97.  
  98.     "sp_exec_trig",                // Procedure name
  99.     "usage: sp_exec_trig <[@command =] command string>",    // Procedure usage
  100.     1,                        // Number of parameters 
  101.    {   // Parameter definitions
  102.         "command",            // Parameter name
  103.         SRVCHAR,            // Parameter type
  104.         MAXLEN,                // Parameter length (0 if fixed)
  105.         VALUE,                // Pass by value
  106.         "dir *.*",            // Default parameter value
  107.     },
  108.     sp_exec_trig,                // Procedure function pointer
  109.  
  110.     "proclist",
  111.     "usage: proclist",
  112.     0, 
  113.    {
  114.        0
  115.    },
  116.     proclist,
  117.  
  118.     "disklist",
  119.     "usage: disklist",
  120.     0, 
  121.    {
  122.         0
  123.     },
  124.     disklist,
  125.  
  126.     "diskfree",
  127.     "usage: diskfree <[@drive =] drive letter> [,] <[@space =] free space>",
  128.     2, 
  129.    {
  130.         "drive",
  131.         SRVCHAR,
  132.         1,
  133.         VALUE,                // pass by value
  134.         "c",
  135.  
  136.         "space",
  137.         SRVINT4,
  138.         8,
  139.         REFERENCE,            // pass by reference
  140.         "0",
  141.     },
  142.     diskfree,
  143.  
  144.     "scan_xbase",                // rpc name
  145.     "usage: scan_xbase <[@file_name =] xbase file name>",    // rpc usage
  146.     1,                        // number of parameters 
  147.    {   // parameter definitions
  148.         "file_name",            // parameter name
  149.         SRVCHAR,                // parameter type
  150.         MAXLEN,                    // parameter length (0 if fixed)
  151.         VALUE,                    // pass by value
  152.         "\\sql\\opends\\samples\\procsrv\\build\\sales.dbf", // default parameter value
  153.     },
  154.     scan_xbase,                    // rpc function pointer
  155.  
  156. #ifdef LMPTK
  157.     "broadcast",
  158.     "usage: broadcast <[@mailslot =] mailslot> [,] <[@message =] message>",
  159.     2, 
  160.    {
  161.         "mailslot",
  162.         SRVCHAR,
  163.         MAXLEN,
  164.         VALUE,                // pass by value
  165.         "\\\\*\\mailslot\\broadcast",
  166.  
  167.         "message",
  168.         SRVCHAR,
  169.         MAXLEN,
  170.         VALUE,                // pass by value
  171.         "This is a default broadcast msg.\n"
  172.     },
  173.     broadcast,
  174. #endif
  175. };
  176.  
  177.  
  178. #define Rpcnumber sizeof(Sps) / sizeof(SP_INFO)
  179.  
  180. // Prototype dblib API's
  181. //
  182. RETCODE attn_handler(SRV_PROC FAR *srvproc);
  183.  
  184. RETCODE chk_err(SRV_SERVER FAR *server, 
  185.                  SRV_PROC FAR *srvproc, 
  186.                  int srverror,
  187.                  BYTE severity, 
  188.                  BYTE state, 
  189.                  int oserrnum, 
  190.                  DBCHAR FAR *errtext,
  191.                  int errtextlen, 
  192.                  DBCHAR FAR *oserrtext, 
  193.                  int oserrtextlen);
  194.  
  195. RETCODE init_remote(SRV_PROC FAR *srvproc);
  196.  
  197. RETCODE init_server(SRV_SERVER FAR *server);
  198.  
  199. RETCODE sp_execute(SRV_PROC FAR *srvproc);
  200.  
  201. RETCODE exit_remote(SRV_PROC FAR *srvproc);
  202.  
  203. RETCODE lang_execute(SRV_PROC FAR *srvproc);
  204.  
  205. void set_remote_server_name(char FAR *name);
  206.  
  207. // Miscellaneous prototypes for sp language events
  208. //
  209. RETCODE lang_parser(SRV_PROC FAR *srvproc, 
  210.                     SP_INFO **sp,
  211.                      DBCHAR paramvalues[MAXPARAMS][MAXLEN]);
  212.  
  213. DBCHAR *scan_next(DBCHAR *string, DBCHAR *word);
  214.  
  215. //
  216. // This section defines the "call-back" functions supplied to the procedure server
  217. // application.
  218. //
  219. #pragma check_stack(off)  // turn off stack checking
  220.  
  221. //
  222. // SET_REMOTE_SERVER_NAME
  223. //    This function sets the name of the procedure server.
  224. //
  225. // Parameters:
  226. //     name - Pointer to name of server.
  227. //
  228. // Returns:
  229. //    none
  230. //
  231. void set_remote_server_name(name)
  232. char FAR *name;
  233. {
  234.     ProcSrvrName = name;
  235.     return;
  236. }
  237.  
  238. //
  239. // INIT_SERVER
  240. //    Initialize the server on a SRV_START event.
  241. //    Event handlers for the server are installed.
  242. //
  243. // Parameters:
  244. //    server - Pointer to SRV_SERVER structure
  245. //
  246. // Returns:
  247. //    SRV_CONTINUE
  248. //
  249. RETCODE init_server(server)
  250. SRV_SERVER FAR *server;
  251. {
  252.     char log_buffer[256];
  253.  
  254.     //  When we get a connection request from a client, we want to
  255.     //  call "init_remote()" to make a connection to the remote
  256.     //  server.
  257.     //
  258.     srv_handle(server, (DBINT)SRV_CONNECT, init_remote);
  259.  
  260.     // When the client issues a language request, call
  261.     // "lang_execute()" to send the SQL statement to the remote DBMS.
  262.     //
  263.     srv_handle(server, (DBINT)SRV_LANGUAGE, lang_execute);
  264.  
  265.     // When the client issues an RSP, call "sp_execute()"
  266.     // to send the RSP to the remote DBMS (the SQL Server).
  267.     //
  268.     srv_handle(server, (DBINT)SRV_RPC, sp_execute);
  269.  
  270.     // When a disconnect request is issued, call "exit_remote()"
  271.     // to close the connection to the remote DBMS.
  272.     //
  273.     srv_handle(server, (DBINT)SRV_DISCONNECT, exit_remote);
  274.  
  275.     // Log Server information to log file
  276.     //
  277.     sprintf(log_buffer, "Server pipe name = %s", 
  278.            srv_sfield(server, SRV_SERVERNAME, (int *)NULL));
  279.  
  280.     srv_log(server, FALSE, log_buffer, SRV_NULLTERM);
  281.     printf("%s\n", log_buffer);
  282.  
  283.     sprintf(log_buffer, "Client connections allowed = %s",
  284.             srv_sfield(server, SRV_CONNECTIONS, (int *)NULL));
  285.  
  286.     srv_log(server, FALSE, log_buffer, SRV_NULLTERM);
  287.     printf("%s\n", log_buffer);
  288.  
  289.     return(SRV_CONTINUE);
  290. }
  291.  
  292. // INIT_REMOTE
  293. //    Event handler for a SRV_CONNECT event.
  294. //    A connection is made to the procedure server.
  295. //
  296. // Parameters:
  297. //    srvproc - the handle to the client connection that got the SRV_CONNECT.
  298. //
  299. // Returns:
  300. //    SRV_CONTINUE
  301. //
  302. // Side Effects:
  303. //    If the connection to the remote dbms cannot be made, then issue
  304. //    a SRV_DISCONNECT request.
  305. //
  306. //
  307. RETCODE init_remote(srvproc)
  308. SRV_PROC FAR *srvproc;
  309. {
  310.     char *string;
  311.     int len;
  312.  
  313.     // Set server name
  314.     //
  315.     srvproc->serverlen = (BYTE)strlen(ProcSrvrName);
  316.     srvproc->servername = srv_alloc((DBINT)srvproc->serverlen);
  317.     strcpy(srvproc->servername, ProcSrvrName);
  318.  
  319.     // Display info on console
  320.     //
  321.     string = srv_pfield(srvproc, SRV_CPID, &len);
  322.    string[len] = '\0';
  323.     printf("\nClient process ID: %s\n", string);
  324.  
  325.    string = srv_pfield(srvproc, SRV_USER, &len);
  326.    string[len] = '\0';
  327.    printf("User name: %s\n", string);
  328.  
  329.    string = srv_pfield(srvproc, SRV_APPLNAME, &len);
  330.    string[len] = '\0';
  331.    if (len > 0)
  332.        printf("Application program name: %s\n", string);
  333.  
  334.    string = srv_pfield(srvproc, SRV_RMTSERVER, &len);
  335.    string[len] = '\0';
  336.    if (len > 0)
  337.        printf("Remote Server: %s\n", string);
  338.  
  339.     return(SRV_CONTINUE);
  340. }
  341.  
  342. //
  343. // LANG_EXECUTE
  344. //    Execute a client language request on the procedure server.
  345. //
  346. // Parameters:
  347. //    srvproc - process handle to the current client connection.
  348. //
  349. // Returns:
  350. //    SRV_CONTINUE
  351. //
  352.  
  353. RETCODE lang_execute(srvproc)
  354. SRV_PROC FAR *srvproc;
  355. {
  356.     int i;
  357.     DBCHAR paramvalues[MAXPARAMS][MAXLEN];
  358.     BYTE convertvalues[MAXPARAMS][MAXLEN];
  359.     SP_INFO *sp = NULL;
  360.  
  361.     // Initialize parameter storage      
  362.     //
  363.     for (i = 0; i < MAXPARAMS; i++) {
  364.         memset(paramvalues[i], 0, MAXLEN);
  365.         memset(convertvalues[i], 0, MAXLEN);
  366.     }
  367.     if (lang_parser(srvproc, &sp, paramvalues) == SUCCEED) {
  368.         for (i = 0; i < sp->numparams; i++) {
  369.             if (sp->params[i].status == REFERENCE) {
  370.                 srv_sendstatus(srvproc, 1);
  371.                 srv_sendmsg(srvproc,    
  372.                            SRV_MSG_ERROR, 
  373.                            INVALID_SP_SYNTAX,
  374.                             SRV_INFO, 
  375.                            (DBTINYINT)0, 
  376.                            NULL, 
  377.                            0, 
  378.                            0, 
  379.                            "Procedure contains a return parameter.\
  380.                             Unable to execute as a language event.",
  381.                             SRV_NULLTERM);
  382.                 srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  383.                 return(SRV_CONTINUE);
  384.  
  385.             }
  386.             if (strlen(paramvalues[i]) == 0 &&
  387.                 strlen(sp->params[i].defaultvalue) == 0) {
  388.                 srv_sendstatus(srvproc, 1);
  389.                 srv_sendmsg(srvproc, 
  390.                            SRV_MSG_ERROR, 
  391.                            INVALID_SP_SYNTAX,
  392.                             SRV_INFO, 
  393.                            (DBTINYINT)0, 
  394.                            NULL, 
  395.                            0, 
  396.                            0, 
  397.                            sp->usage,
  398.                             SRV_NULLTERM);
  399.                 srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  400.                 return(SRV_CONTINUE);
  401.             }
  402.             if (strlen(paramvalues[i]) == 0 &&
  403.                 strlen(sp->params[i].defaultvalue) != 0)
  404.                 strcpy(paramvalues[i], sp->params[i].defaultvalue);
  405.  
  406.             // convert parameters from character string to parmeter type
  407.             //
  408.             srv_convert(srvproc, 
  409.                        SRVCHAR, 
  410.                        paramvalues[i], 
  411.                        -1,
  412.                         sp->params[i].type, 
  413.                        &convertvalues[i],
  414.                         sp->params[i].length);
  415.         }
  416.  
  417.        // Execute the procedure 
  418.         //
  419.         (sp->handler)(srvproc, 
  420.                      &convertvalues[0], 
  421.                      &convertvalues[1],
  422.                       &convertvalues[2], 
  423.                      &convertvalues[3]);
  424.     }
  425.     return(SRV_CONTINUE);
  426. }
  427.  
  428. //
  429. // LANG_PARSER
  430. //    A procedure server specific language event parser.
  431. //
  432. // Parameters:
  433. //    srvproc - process handle to the current client connection.
  434. //    sp - Pointer to the stored procedure structure
  435. //    paramvalues - An array of the values of the parameters.
  436. //
  437. // Returns:
  438. //    SUCCEED
  439. //
  440. RETCODE lang_parser(srvproc, sp, paramvalues)
  441. SRV_PROC FAR *srvproc;
  442. SP_INFO **sp;
  443. DBCHAR paramvalues[MAXPARAMS][MAXLEN];
  444. {
  445.     DBCHAR FAR *query;        // pointer to language buffer
  446.     int i;
  447.     int numparams;
  448.     DBCHAR msg[MAXLEN * 5];
  449.     DBINT msgnum;
  450.     DBCHAR spname[MAXLEN];
  451.     BOOL paramsyntax = FALSE;
  452.     DBCHAR paramname[MAXLEN];
  453.     DBCHAR equalstring[2];
  454.     DBCHAR *paramvalue = NULL;
  455.  
  456.     query = srv_langptr(srvproc);
  457.  
  458.     query = scan_next(query,
  459.     spname);
  460.     if (strlen(spname) == 0) {
  461.         srv_senddone(srvproc, SRV_DONE_FINAL, 0, 0);
  462.         return(FAIL);
  463.     }
  464.     if (strnicmp(spname, EXEC_CMD, (sizeof(EXEC_CMD) - 1)) == 0) {
  465.         // stored procedure name
  466.         //
  467.         query = scan_next(query,
  468.         spname);
  469.         if (strlen(spname) == 0)
  470.             goto syntax_error;
  471.     }
  472.  
  473.     // Check for existence
  474.     //
  475.     for (i = 0; i < Rpcnumber; i++)
  476.         if (strcmp(Sps[i].name, spname) == 0) {
  477.             *sp = &Sps[i];
  478.             break;
  479.         }
  480.     if (*sp == NULL) {
  481.         sprintf(msg, "Procedure \'%s \' not found.", spname);
  482.         msgnum = SP_UNKNOWN;
  483.         goto error;
  484.     }
  485.  
  486.     // Parameters
  487.     //
  488.     numparams = 0;
  489.     while (*query != '\0') {
  490.         if (++numparams > (*sp)->numparams) {
  491.             sprintf(msg, (*sp)->usage);
  492.             msgnum = INVALID_SP_SYNTAX;
  493.             goto error;
  494.         }
  495.         if (!paramsyntax && *query == '@')
  496.             paramsyntax = TRUE;    // parameter name mode
  497.  
  498.         if (!paramsyntax)
  499.             if (paramvalue == NULL)
  500.                 paramvalue = paramvalues[0];
  501.             else
  502.                 paramvalue += MAXLEN;
  503.  
  504.         if (paramsyntax) {
  505.             if (*query != '@') {
  506.                 sprintf(msg, "Once the form '@name = value' has been used, \
  507.                              all subsequent parameters must be passed in \
  508.                              the form '@name = value'."
  509.                         );
  510.                 msgnum = INVALID_SP_SYNTAX;
  511.                 goto error;
  512.             } 
  513.            else
  514.                 query++;
  515.  
  516.             query = scan_next(query,
  517.             paramname);
  518.             if (strlen(paramname) == 0)
  519.                 goto syntax_error;
  520.  
  521.             // Get parameter index
  522.             //
  523.             paramvalue = NULL;
  524.             for (i = 0; i < (*sp)->numparams; i++)
  525.                 if (strcmp((*sp)->params[i].name, paramname) == 0) {
  526.                     paramvalue = paramvalues[i];
  527.                     break;
  528.                 }
  529.             if (paramvalue == NULL) {
  530.                 sprintf(msg,
  531.                         "Procedure '%s' does not recognize parameter name: %s",
  532.                         spname, 
  533.                        paramname);
  534.                 msgnum = BAD_SP_PARAMETER;
  535.                 goto error;
  536.             }
  537.  
  538.             // Already assigned value
  539.             //
  540.             if (strlen(paramvalue) > 0)
  541.                 goto syntax_error;
  542.  
  543.             // Check for '='
  544.             //
  545.             query = scan_next(query,
  546.             equalstring);
  547.             if (*equalstring != '=')
  548.                 goto syntax_error;
  549.  
  550.         }
  551.         query = scan_next(query,
  552.         paramvalue);
  553.         if (strlen(paramvalue) == 0)
  554.             goto syntax_error;
  555.  
  556.         if (*query == ',') {
  557.             query++;
  558.             while (*query == ' ' || *query == '\t')
  559.                 query++;
  560.         }
  561.     }
  562.     return(SUCCEED);
  563.  
  564. syntax_error:
  565.     sprintf(msg, "Incorrect syntax found near '%s'.", query);
  566.     msgnum = INVALID_SP_SYNTAX;
  567.  
  568. error:
  569.     srv_sendstatus(srvproc, 1);
  570.     srv_sendmsg(srvproc, 
  571.                SRV_MSG_ERROR, 
  572.                msgnum, 
  573.                SRV_INFO, 
  574.                (DBTINYINT)0, 
  575.                NULL,
  576.                 0, 
  577.                0, 
  578.                msg, 
  579.                SRV_NULLTERM);
  580.     srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  581.     return(FAIL);
  582. }
  583.  
  584. //
  585. // SCAN_NEXT
  586. //    Reads the next token in a string, ignoring whitespace.
  587. //
  588. // Parameters:
  589. //    string - The language event string
  590. //    word - The next token the string
  591. //
  592. // Returns:
  593. //    The string incremented passed the token.
  594. //
  595. DBCHAR *scan_next(string, word)
  596. DBCHAR *string;
  597. DBCHAR *word;
  598. {
  599.     DBCHAR *p;
  600.  
  601.     word[0] = '\0';
  602.     if (*string == '\"' || *string == '\'') {
  603.         // check for unclosed quote
  604.         //
  605.         p = strchr(string + 1,
  606.         *string);
  607.         if (p == NULL)
  608.             return(string);
  609.         strncpy(word, string + 1, p - (string + 1));
  610.         word[p - (string + 1)] = '\0';
  611.         string += 2;
  612.     } 
  613.    else {
  614.         // clear proceeding white space
  615.         //
  616.         while (*string == ' ' || *string == '\t' || *string == '\n')
  617.             string++;
  618.         sscanf(string, "%s", word);
  619.  
  620.         // ignore comments
  621.         //
  622.         while (strncmp(word, "/*", 2) == 0) {
  623.             string = strstr(string, "*/");
  624.             if (string != NULL) {
  625.                 string += 2;
  626.                 word[0] = '\0';
  627.                 while (*string == ' ' || *string == '\t' || *string == '\n')
  628.                     string++;
  629.                 sscanf(string, "%s", word);
  630.             } 
  631.            else
  632.                 return(string);
  633.         }
  634.     }
  635.     if (strlen(word) > 0)
  636.         string += strlen(word);
  637.  
  638.     // clear trailing white space
  639.     //
  640.     while (*string == ' ' || *string == '\t' || *string == '\n')
  641.         string++;
  642.  
  643.     return(string);
  644. }
  645.  
  646. //
  647. // SP_EXECUTE
  648. //    Execute a client stored procedure.
  649. //
  650. //    Scans the list of defined stored procedures, checks the parameters and
  651. //    executes the procedure. If results are returned it is the responsiblity
  652. //    of the underlying proedure.
  653. //
  654. // Parameters:
  655. //    srvproc - The process handle to use to send results to the client.
  656. //
  657. // Returns:
  658. //    SRV_CONTINUE
  659. //
  660. RETCODE sp_execute(srvproc)
  661. SRV_PROC FAR *srvproc;
  662. {
  663.     int i;
  664.     int x;
  665.     int y;
  666.     int len;
  667.     int numparams;
  668.     SP_INFO *sp = NULL;
  669.     DBCHAR msg[MAXLEN];
  670.     DBINT msgnum;
  671.     DBCHAR paramvalues[MAXPARAMS][MAXLEN];
  672.     BOOL paramnamemode = FALSE;
  673.     DBCHAR *paramname;
  674.     DBINT paramtype;
  675.     DBCHAR *value;
  676.     DBINT type;
  677.     DBINT status;
  678.     DBCHAR server_spname[MAXNAME + 1];
  679.  
  680.     // Initialize parameter storage
  681.     //
  682.     for (i = 0; i < MAXPARAMS; i++) {
  683.         memset(paramvalues[i], 0, MAXLEN);
  684.     }
  685.     for (i = 0; i < Rpcnumber; i++) {
  686.         // Create name generated by calling server
  687.         //
  688.         if (strcmp(Sps[i].name, srv_rpcname(srvproc, (int *)NULL)) == 0 ||
  689.             strcmp(srv_rpcname(srvproc, (int *)NULL),
  690.                    strcat(strcpy(server_spname, Sps[i].name),
  691.                           SP_EXT)) == 0) {
  692.             sp = &Sps[i];
  693.             break;
  694.         }
  695.     }
  696.     if (sp == NULL) {
  697.         sprintf(msg, "Procedure \'%s \' not found.",
  698.                 srv_rpcname(srvproc, (int *)NULL));
  699.         msgnum = SP_UNKNOWN;
  700.         goto error;
  701.     }
  702.     numparams = srv_rpcparams(srvproc);
  703.     if (srv_paramname(srvproc, 1, &len) && len > 0)
  704.         paramnamemode = TRUE;
  705.     for (y = 1; y <= numparams; y++) {
  706.         // Find parameter number 
  707.        //
  708.         if (paramnamemode) {
  709.             paramname = srv_paramname(srvproc, y, &len);
  710.             if (strlen(paramname) == 0)
  711.                 goto parameter_error;
  712.  
  713.             if (*paramname == '@')
  714.                 paramname++;
  715.             else
  716.                 goto parameter_error;
  717.             value = NULL;
  718.             for (x = 0; x < sp->numparams; x++) {
  719.                 if (strcmp(sp->params[x].name, paramname) == 0) {
  720.                     value = paramvalues[x];
  721.                     type = sp->params[x].type;
  722.                     status = sp->params[x].status;
  723.                     break;
  724.                 }
  725.             }
  726.             if (value == NULL)
  727.                 goto parameter_error;
  728.         } 
  729.        else {
  730.             value = paramvalues[y - 1];
  731.             type = sp->params[y - 1].type;
  732.             status = sp->params[y - 1].status;
  733.         }
  734.  
  735.         // Check parameters for correct type
  736.         //
  737.         paramtype = srv_paramtype(srvproc, y);
  738.         switch (paramtype) {
  739.             case SRVVARCHAR:        // Type sent by Servers instead of SRVCHAR
  740.                 paramtype = SRVCHAR;
  741.                 break;
  742.             case SRVINTN:            // Type sent by Servers instead of SRVINT
  743.                  paramtype = SRVINT4;
  744.                 break;
  745.             default:
  746.                 break;
  747.         }
  748.  
  749.         if (type != paramtype) {
  750.             if (paramnamemode)
  751.                 sprintf(msg, "Parameter \'%s \' is incorrect type.", paramname);
  752.             else
  753.                 sprintf(msg, "Parameter \'%d \' is incorrect type.", y);
  754.             msgnum = BAD_SP_PARAMETER;
  755.             goto error;
  756.         }
  757.  
  758.         // Check parameters for correct status
  759.         //
  760.         if ((DBINT)srv_paramstatus(srvproc, y) != status) {
  761.             if (paramnamemode)
  762.                 sprintf(msg, "Parameter \'%s \' has incorrect status.", 
  763.                        paramname);
  764.             else
  765.                 sprintf(msg, "Parameter \'%d \' had incorrect status.", y);
  766.             msgnum = BAD_SP_PARAMETER;
  767.             goto error;
  768.         }
  769.  
  770.         // Move SP parameters to local variables
  771.         //
  772.         srv_bmove(srv_paramdata(srvproc, y), value, srv_paramlen(srvproc, y));
  773.         value[srv_paramlen(srvproc, y)] = '\0';
  774.  
  775.     }
  776.  
  777.     // If unspecified, use default value
  778.     //
  779.     for (i = 0; i < sp->numparams; i++) {
  780.         if (strlen(paramvalues[i]) == 0 &&
  781.             strlen(sp->params[i].defaultvalue) == 0) {
  782.             strcpy(msg, sp->usage);
  783.             msgnum = INVALID_SP_SYNTAX;
  784.             goto error;
  785.         }
  786.         if (strlen(paramvalues[i]) == 0 &&
  787.             strlen(sp->params[i].defaultvalue) != 0)
  788.             strcpy(paramvalues[i], sp->params[i].defaultvalue);
  789.     }
  790.  
  791.    // Execute procedure
  792.    //
  793.     (*sp->handler)(srvproc, 
  794.                    paramvalues[0], 
  795.                    paramvalues[1], 
  796.                    paramvalues[2],
  797.                     paramvalues[3]);
  798.     return(SRV_CONTINUE);
  799.  
  800. parameter_error:
  801.     sprintf(msg, "Procedure '%s' does not recognize parameter name: %s",
  802.             sp->name, paramname);
  803.     msgnum = BAD_SP_PARAMETER;
  804.  
  805. error:
  806.     srv_sendstatus(srvproc, 1);
  807.     srv_sendmsg(srvproc, 
  808.                SRV_MSG_ERROR, 
  809.                msgnum, 
  810.                SRV_INFO, 
  811.                (DBTINYINT)0, 
  812.                NULL,
  813.                 0, 
  814.                0, 
  815.                msg, 
  816.                SRV_NULLTERM);
  817.     srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  818.     return(SRV_CONTINUE);
  819. }
  820.  
  821. // EXIT_REMOTE
  822. //    Handler for SRV_DISCONNECT events.
  823. //
  824. //    The code to disconnect from the procedure server.
  825. //
  826. // Parameters:
  827. //    srvproc - the handle to the client connection
  828. //
  829. // Returns:
  830. //    SRV_DISCONNECT
  831. ///
  832. RETCODE exit_remote(srvproc)
  833. SRV_PROC FAR *srvproc;
  834. {
  835.     char *string;
  836.     int len;
  837.  
  838.     // Display info on console
  839.     //
  840.     string = srv_pfield(srvproc, SRV_CPID, &len);
  841.    string[len] = '\0';
  842.       printf("\nClient connection closed, process ID: %s\n", string);
  843.  
  844.     return(SRV_CONTINUE);
  845. }
  846.  
  847. // CHK_ERR
  848. //    Print out errors.
  849. //
  850. // Parameters:
  851. //    server        - pointer to procedure server server structure.
  852. //    srvproc      - pointer to client connection structure
  853. //    errornum     - error number.
  854. //    severity     - error severity.
  855. //    state        - error state.
  856. //    oserrnum     - operating system error number, if any.
  857. //    errtext      - the text of the error message.
  858. //    errtextlen   - length of the errtext message
  859. //    oserrtext    - the text of the operating system error message.
  860. //    oserrtextlen - length of the errtext message
  861. //
  862. // Returns:
  863. //    SRV_CONTINUE, SRV_CANCEL, or SRV_EXIT_PROGRAM
  864. //
  865.  
  866. RETCODE chk_err(server, srvproc, errornum, severity, state, oserrnum, errtext,
  867.                 errtextlen, oserrtext, oserrtextlen)
  868. SRV_SERVER FAR *server;
  869. SRV_PROC FAR *srvproc;
  870. int errornum;
  871. BYTE severity;
  872. BYTE state;
  873. int oserrnum;
  874. DBCHAR FAR *errtext;
  875. int errtextlen;
  876. DBCHAR FAR *oserrtext;
  877. int oserrtextlen;
  878. {
  879.     char log_buffer[256];
  880.  
  881.     // Operating system error?
  882.     //
  883.     if (oserrnum != SRV_ENO_OS_ERR) {
  884.         sprintf(log_buffer, "SERVER OS ERROR: %d: %s.", oserrnum, oserrtext);
  885.  
  886.         srv_log(server, TRUE, log_buffer, SRV_NULLTERM);
  887.     }
  888.  
  889.     // Is this a fatal error for the server?
  890.     //
  891.     if (severity >= SRV_FATAL_SERVER) {
  892.         sprintf(log_buffer,
  893.                "SERVER: FATAL SERVER ERROR: errornum = %d, "
  894.                "severity = %d, state = %d: %s.",
  895.                 errornum, 
  896.                severity, 
  897.                state, 
  898.                errtext);
  899.  
  900.         srv_log(server, TRUE, log_buffer, SRV_NULLTERM);
  901.         return(SRV_EXIT);
  902.     } 
  903.    else {
  904.         //
  905.         // Did the "srvproc" get a fatal error?
  906.         //
  907.         if (severity >= SRV_FATAL_PROCESS) {
  908.             sprintf(log_buffer,
  909.            "SERVER: FATAL CONNECT ERROR: errornum = %d, "
  910.            "severity = %d, state = %d: %s.",
  911.              errornum, 
  912.             severity, 
  913.             state, 
  914.             errtext);
  915.  
  916.             srv_log(server, TRUE, log_buffer, SRV_NULLTERM);
  917.  
  918.             return(SRV_CANCEL);
  919.         }
  920.     }
  921.  
  922.     // A non-fatal error or an information message received.
  923.     // We'll pass it through to the client.
  924.     //
  925.     if (srvproc != (SRV_PROC *)NULL && (server != NULL))
  926.         if (severity < 10) {    // if informational message
  927.             srv_sendmsg(srvproc, 
  928.                        SRV_MSG_INFO, 
  929.                        (DBINT)errornum, 
  930.                        severity, 
  931.                        0,
  932.                         NULL, 
  933.                        0, 
  934.                        0, 
  935.                        errtext, 
  936.                        SRV_NULLTERM);
  937.      } 
  938.     else {            // must be an error message
  939.             srv_sendmsg(srvproc, 
  940.                        SRV_MSG_ERROR, 
  941.                        (DBINT)errornum, 
  942.                        severity, 
  943.                        0,
  944.                         NULL, 
  945.                        0, 
  946.                        0, 
  947.                        errtext, 
  948.                        SRV_NULLTERM);
  949.     } 
  950.    else {
  951.         sprintf(log_buffer, "GATEWAY ERROR: errornum = %d, severity = %d: %s",
  952.                 errornum, severity, errtext);
  953.  
  954.         srv_log(server, TRUE, log_buffer, SRV_NULLTERM);
  955.     }
  956.     return(SRV_CONTINUE);
  957. }
  958.  
  959. // The following are the supported store procedure functions
  960. //
  961.  
  962. //
  963. // PROCLIST
  964. //    Returns the usage for all defined stored procedures
  965. //
  966. // Parameters:
  967. //    srvproc - the handle to the client connection that got the SRV_CONNECT.
  968. //
  969. // Returns:
  970. //    SUCCEED
  971. //
  972. // Side Effects:
  973. //    Returns a result set to client
  974. //
  975. RETCODE proclist(srvproc)
  976. SRV_PROC FAR *srvproc;
  977. {
  978.     DBCHAR colname1[MAXNAME + 1];
  979.     DBCHAR colname2[MAXNAME + 1];
  980.     int i;
  981.  
  982.     sprintf(colname1, "spname");
  983.     srv_describe(srvproc, 1, colname1, SRV_NULLTERM, SRVCHAR, MAXNAME + 1,
  984.                  SRVCHAR, 0, NULL);
  985.  
  986.     sprintf(colname2, "spusage");
  987.     srv_describe(srvproc, 2, colname2, SRV_NULLTERM, SRVCHAR, MAXLEN, SRVCHAR,
  988.                  0, NULL);
  989.  
  990.     // Return each SP handler as a row
  991.     //
  992.     for (i = 0; i < Rpcnumber; i++) {
  993.         srv_setcoldata(srvproc, 1, Sps[i].name);
  994.         srv_setcollen(srvproc, 1, strlen(Sps[i].name));
  995.  
  996.         srv_setcoldata(srvproc, 2, Sps[i].usage);
  997.         srv_setcollen(srvproc, 2, strlen(Sps[i].usage));
  998.  
  999.         srv_sendrow(srvproc);
  1000.     }
  1001.     srv_senddone(srvproc, (SRV_DONE_COUNT | SRV_DONE_FINAL), 0, i);
  1002.  
  1003.     return(SUCCEED);
  1004. }
  1005.  
  1006. //
  1007. // SP_EXEC
  1008. //    Execute a given command string and returns any output as rows of
  1009. //       text.
  1010. //
  1011. // Parameters:
  1012. //    srvproc - the handle to the client connection that got the SRV_CONNECT.
  1013. //       command - the command string to execute
  1014. //
  1015. // Returns:
  1016. //    SUCCEED or FAIL
  1017. //
  1018. // Side Effects:
  1019. //    Returns messages and/or a result set to client
  1020. //
  1021. RETCODE sp_exec(srvproc, command)
  1022. SRV_PROC FAR *srvproc;
  1023. DBCHAR *command;
  1024. {
  1025.     DBCHAR buf[MAXLEN * 5];
  1026.     FILE *cmdpipe;
  1027.     int length;
  1028.     DBINT rows;
  1029.     int status;
  1030.  
  1031.     // Execute string
  1032.     //
  1033.     if ((cmdpipe = _popen(command, "r")) == NULL) {
  1034.         srv_sendstatus(srvproc, 1);
  1035.         srv_sendmsg(srvproc, 
  1036.                    SRV_MSG_ERROR, 
  1037.                    EXEC, 
  1038.                    SRV_INFO, 
  1039.                    (DBTINYINT)0,
  1040.                     NULL, 
  1041.                    0, 
  1042.                    0, 
  1043.                    "Error executing command", 
  1044.                    SRV_NULLTERM);
  1045.         srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  1046.         return(FAIL);
  1047.     }
  1048.  
  1049.     // Command successful
  1050.     //
  1051.     for (rows = 0; !feof(cmdpipe); ) {
  1052.         if (fgets(buf, sizeof(buf), cmdpipe) != NULL) {
  1053.             if (rows == 0) {
  1054.                 // Describe result row:
  1055.                 // it will be one column of size sizeof(buf)
  1056.                 // We do this in the retrieval loop to ensure that the
  1057.                 // row description will occur only if there are rows to be
  1058.                 // outputted
  1059.                 srv_describe(srvproc, 1, command, SRV_NULLTERM, SRVCHAR,
  1060.                              sizeof(buf), SRVCHAR, sizeof(buf), buf);
  1061.             }
  1062.             length = strlen(buf) - 1;
  1063.             // get rid of new line character
  1064.             //
  1065.             buf[length] = '\0';
  1066.             srv_setcollen(srvproc, 1, length);
  1067.             srv_sendrow(srvproc);
  1068.             rows++;
  1069.         }
  1070.     }
  1071.     status = _pclose(cmdpipe);
  1072.     if (rows == 0) {
  1073.         if (status == 0) {
  1074.             srv_sendstatus(srvproc, 0);
  1075.             srv_sendmsg(srvproc, 
  1076.                        SRV_MSG_INFO, 
  1077.                        EXEC, 
  1078.                        SRV_INFO, 
  1079.                        (DBTINYINT)0,
  1080.                         NULL, 
  1081.                        0, 
  1082.                        0, 
  1083.                        "Command executed successfully",
  1084.                         SRV_NULLTERM);
  1085.         } 
  1086.        else {
  1087.             sprintf(buf, "Error with command %s: OS error = %d", command,
  1088.                     status);
  1089.             srv_sendstatus(srvproc, 1);
  1090.             srv_sendmsg(srvproc, 
  1091.                        SRV_MSG_ERROR, 
  1092.                        EXEC, 
  1093.                        SRV_INFO, 
  1094.                        (DBTINYINT)0,
  1095.                         NULL, 
  1096.                        0, 
  1097.                        0, 
  1098.                        buf, 
  1099.                        SRV_NULLTERM);
  1100.         }
  1101.     }
  1102.     srv_senddone(srvproc, SRV_DONE_FINAL | SRV_DONE_COUNT, 0, rows);
  1103.     return(SUCCEED);
  1104. }
  1105.  
  1106. //
  1107. // SP_EXEC_TRIG
  1108. //    Execute a given command string without returning any output.
  1109. //
  1110. // Parameters:
  1111. //    srvproc - the handle to the client connection that got the SRV_CONNECT.
  1112. //       command - the command string to execute
  1113. //
  1114. // Returns:
  1115. //    SUCCEED or FAIL
  1116. //
  1117. // Side Effects:
  1118. //    Returns success, error messages to client
  1119. //
  1120. RETCODE sp_exec_trig(srvproc, command)
  1121. SRV_PROC FAR *srvproc;
  1122. DBCHAR *command;
  1123. {
  1124.     int status;
  1125.     DBCHAR buf[MAXLEN * 5];
  1126.  
  1127.     // Execute string
  1128.     //
  1129.     if ((status = system(command)) != 0) {
  1130.            sprintf(buf, "Error with command '%s': OS error = %d", command,
  1131.                 status);
  1132.         srv_sendstatus(srvproc, 1);
  1133.         srv_sendmsg(srvproc, 
  1134.                        SRV_MSG_ERROR, 
  1135.                        EXEC, 
  1136.                        SRV_INFO, 
  1137.                        (DBTINYINT)0,
  1138.                         NULL, 
  1139.                        0, 
  1140.                        0, 
  1141.                        buf, 
  1142.                        SRV_NULLTERM);
  1143.  
  1144.         srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  1145.         return(FAIL);
  1146.     }
  1147.     srv_senddone(srvproc, SRV_DONE_FINAL, 0, 0);
  1148.     return(SUCCEED);
  1149. }
  1150.  
  1151.  
  1152. //
  1153. // DISKLIST
  1154. //       Returns a row for each defined drive containing its name and the
  1155. //       amount of disk space available.
  1156. //
  1157. // Parameters:
  1158. //    srvproc - the handle to the client connection that got the SRV_CONNECT.
  1159. //
  1160. // Returns:
  1161. //    SUCCEED
  1162. //
  1163. // Side Effects:
  1164. //     Returns a result set to client
  1165. //
  1166. RETCODE disklist(srvproc)
  1167. SRV_PROC FAR *srvproc;
  1168. {
  1169.     DBCHAR colname1[MAXNAME + 1];
  1170.     DBCHAR colname2[MAXNAME + 1];
  1171.     DBCHAR drivename;
  1172.     int drivenum;
  1173.     unsigned short disk;
  1174.     unsigned long drivenums;
  1175.     FSALLOCATE data;
  1176.     long space_remaining;
  1177.     int i = 0;
  1178.  
  1179.     sprintf(colname1, "drive");
  1180.     srv_describe(srvproc, 1, colname1, SRV_NULLTERM, SRVCHAR, 1, SRVCHAR, 1,
  1181.                  (BYTE *)&drivename);
  1182.  
  1183.     sprintf(colname2, "bytes free");
  1184.     srv_describe(srvproc, 2, colname2, SRV_NULLTERM, SRVINT4, 4, SRVINT4, 4,
  1185.                  (BYTE *)&space_remaining);
  1186.  
  1187.     DosQCurDisk(&disk, &drivenums);
  1188.  
  1189.     drivenums >>= 2;        //Ignore drives A and B
  1190.     for (drivename = 'C', drivenum = 3; drivename <= 'Z';
  1191.          drivename++, drivenum++) {
  1192.         if (drivenums & 1) {
  1193.             i++;
  1194.             DosQFSInfo(drivenum, 1, (char far *)&data, sizeof(data));
  1195.             space_remaining = (long)data.cSectorUnit * (long)data.cUnitAvail;
  1196.             space_remaining *= (long)data.cbSector;
  1197.             srv_sendrow(srvproc);
  1198.         }
  1199.         drivenums >>= 1;
  1200.     }
  1201.     srv_senddone(srvproc, (SRV_DONE_COUNT | SRV_DONE_FINAL), 0, i);
  1202.     return(SUCCEED);
  1203. }
  1204.  
  1205. //
  1206. // DISKFREE
  1207. //    Returns the amount of space available on a given drive. The value
  1208. //       is placed into the defined return parameter of the stored procedure.
  1209. //    
  1210. //       NOTE: This routine can not be called via a language event.
  1211. //
  1212. // Parameters:
  1213. //    srvproc - the handle to the client connection that got the SRV_CONNECT.
  1214. //       drive - the drive letter to check
  1215. //
  1216. // Returns:
  1217. //    SUCCEED
  1218. //
  1219. // Side Effects:
  1220. //    Returns messages and/or a result set to client. Returns a value in the
  1221. //       defined return parameter.
  1222. //
  1223. RETCODE diskfree(srvproc, drive)
  1224. SRV_PROC FAR *srvproc;
  1225. DBCHAR *drive;
  1226. {
  1227.     DBCHAR colname1[MAXNAME + 1];
  1228.     int drivenum;
  1229.     unsigned short disk;
  1230.     unsigned long drivenums;
  1231.     FSALLOCATE data;
  1232.     long space_remaining = -1;
  1233.     int i = 0;
  1234.  
  1235.     drive = strupr(drive);
  1236.  
  1237.     sprintf(colname1, "drive");
  1238.     srv_describe(srvproc, 1, colname1, SRV_NULLTERM, SRVCHAR, 1, SRVCHAR, 1,
  1239.                  (BYTE *)drive);
  1240.     srv_sendrow(srvproc);
  1241.     srv_senddone(srvproc, (SRV_DONE_COUNT | SRV_DONE_MORE), 0, 1);
  1242.  
  1243.     DosQCurDisk(&disk, &drivenums);
  1244.  
  1245.     drivenum = drive[0] - 'A' + 1;
  1246.  
  1247.     drivenums >>= drivenum - 1;    //Ignore drives A and B
  1248.     if (drivenums & 0x01) {
  1249.         DosQFSInfo(drivenum, 1, (char far *)&data, sizeof(data));
  1250.         space_remaining = (long)data.cSectorUnit * (long)data.cUnitAvail;
  1251.         space_remaining *= (long)data.cbSector;
  1252.     }
  1253.  
  1254.     // Process return parameter
  1255.     //
  1256.     if (srv_paramstatus(srvproc, 2) & 0x0001)
  1257.         srv_paramset(srvproc, 2, (BYTE *)&space_remaining, 4);
  1258.  
  1259.     srv_senddone(srvproc, SRV_DONE_FINAL, 0, 0);
  1260.     return(SUCCEED);
  1261. }
  1262.  
  1263.  
  1264. //
  1265. // SCAN_XBASE
  1266. //    Reads an xBase file and sends it to the client as if it were a SQL 
  1267. //    Server query result set (the equivalent of a 'SELECT * FROM
  1268. //    tablename' SQL statement).
  1269. //
  1270. // Parameters:
  1271. //    srvproc - the handle to the client connection that got the SRV_CONNECT.
  1272. //    szFileName - dbase file path name
  1273. //
  1274. // Returns:
  1275. //    SUCCEED or FAIL
  1276. //
  1277. // Side Effects:
  1278. //    Returns messages and/or a result set to client
  1279. //
  1280. RETCODE scan_xbase(srvproc, filename)
  1281. SRV_PROC FAR *srvproc;
  1282. char *filename;
  1283. {
  1284.     FILE *xbasefile;
  1285.     size_t count;
  1286.     char buffer[BUF_SIZE];
  1287.     int numrecords;
  1288.     int headerlength;
  1289.     int recordlength;
  1290.     int lengthlist[XBASE_MAX_COLUMNS];
  1291.     long i;
  1292.     int j;
  1293.    int position;
  1294.     int    numcolumns;
  1295.  
  1296.     // now read the database header info
  1297.     //
  1298.     if ((xbasefile = fopen(filename, "r")) == NULL){
  1299.           srv_sendstatus(srvproc, 1);
  1300.         srv_sendmsg(srvproc, 
  1301.                    SRV_MSG_ERROR, 
  1302.                    EXEC, 
  1303.                    SRV_INFO, 
  1304.                    (DBTINYINT)0,
  1305.                     NULL, 
  1306.                    0, 
  1307.                    0, 
  1308.                    "Error reading xBase file", 
  1309.                    SRV_NULLTERM);
  1310.         srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  1311.         return(FAIL);
  1312.    }
  1313.     count = fread(buffer, XBASE_HDR_SIZE, 1, xbasefile);
  1314.  
  1315.     if (count == 0) {
  1316.           srv_sendstatus(srvproc, 1);
  1317.         srv_sendmsg(srvproc, 
  1318.                    SRV_MSG_ERROR, 
  1319.                    EXEC, 
  1320.                    SRV_INFO, 
  1321.                    (DBTINYINT)0,
  1322.                     NULL, 
  1323.                    0, 
  1324.                    0, 
  1325.                    "Error reading xBase file", 
  1326.                    SRV_NULLTERM);
  1327.         srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  1328.         fclose (xbasefile);
  1329.         return(FAIL);
  1330.     }
  1331.  
  1332.     numrecords = *((unsigned int *) &buffer[4]);
  1333.     headerlength = *((unsigned int *)  &buffer[8]);
  1334.     recordlength = *((unsigned int *) &buffer[10]);
  1335.     numcolumns = (headerlength - 32 -1) / 32;
  1336.  
  1337.    // now get the column header information
  1338.     //
  1339.    for (j = 0;  j < numcolumns; j++) {
  1340.        count = fread(buffer, XBASE_HDR_SIZE, 1, xbasefile);
  1341.        if ( count == 0 ) {
  1342.            srv_sendstatus(srvproc, 1);
  1343.             srv_sendmsg(srvproc, 
  1344.                        SRV_MSG_ERROR, 
  1345.                        EXEC, 
  1346.                        SRV_INFO, 
  1347.                        (DBTINYINT)0,
  1348.                         NULL, 
  1349.                        0, 
  1350.                          0, 
  1351.                       "Error reading xBase file", 
  1352.                       SRV_NULLTERM);
  1353.             srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  1354.             fclose (xbasefile);
  1355.             return(FAIL);
  1356.         }
  1357.         
  1358.        // we need to NULL terminate the column name (if it is a
  1359.        // full 11 characters long)
  1360.         //
  1361.        buffer[11] = '\0';
  1362.  
  1363.        // now find our the column length for this data buffer
  1364.         //
  1365.         lengthlist[j] = (int) buffer[16];
  1366.  
  1367.        // now 'describe' this column 
  1368.         //
  1369.         srv_describe(srvproc, 
  1370.                     j + 1,          // column number
  1371.                     buffer,         // pointer to column name
  1372.                     SRV_NULLTERM,   // column name is NULL terminated
  1373.                     SRVCHAR,        // datatype is char (xBase numbers are ASCII
  1374.                        lengthlist[j],  // column length
  1375.                     SRVCHAR,        // destination datatype is also char
  1376.                     lengthlist[j],  // destination column length
  1377.                     NULL);          // pointer to where the data will be
  1378.     
  1379.     }
  1380.    // now read the one byte 'column header seperator'
  1381.     //
  1382.    count = fread(buffer, 1, 1, xbasefile);
  1383.     if (count == 0) {
  1384.           srv_sendstatus(srvproc, 1);
  1385.         srv_sendmsg(srvproc, 
  1386.                    SRV_MSG_ERROR, 
  1387.                    EXEC, 
  1388.                    SRV_INFO, 
  1389.                    (DBTINYINT)0,
  1390.                     NULL, 
  1391.                    0, 
  1392.                    0, 
  1393.                    "Error reading xBase file", 
  1394.                    SRV_NULLTERM);
  1395.         srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  1396.         fclose (xbasefile);
  1397.         return(FAIL);
  1398.    }
  1399.  
  1400.     for (i = 0; i < numrecords; i++) {
  1401.         count = fread(buffer, recordlength, 1, xbasefile);
  1402.         if (count == 0) {
  1403.               srv_sendstatus(srvproc, 1);
  1404.             srv_sendmsg(srvproc, 
  1405.                        SRV_MSG_ERROR, 
  1406.                        EXEC, 
  1407.                        SRV_INFO, 
  1408.                        (DBTINYINT)0,
  1409.                         NULL, 
  1410.                        0, 
  1411.                        0, 
  1412.                        "Error reading xBase file", 
  1413.                        SRV_NULLTERM);
  1414.             srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  1415.             fclose (xbasefile);
  1416.             return(FAIL);
  1417.         }
  1418.  
  1419.        // check to see if this is a deleted row        
  1420.         //
  1421.        if (buffer[0] == '*')
  1422.            break;
  1423.  
  1424.           // Now set the length and data pointers for each column
  1425.        for (j = 0, position = 1; j < numcolumns; j++) {
  1426.             srv_setcollen(srvproc, j+1, lengthlist[j]);
  1427.            srv_setcoldata(srvproc, j+1, &buffer[position]);
  1428.            position += lengthlist[j];
  1429.        }
  1430.  
  1431.        // send the row to the client.
  1432.         //
  1433.        srv_sendrow(srvproc); 
  1434.     }
  1435.     srv_senddone(srvproc, SRV_DONE_COUNT | SRV_DONE_FINAL, 0, i);
  1436.     fclose (xbasefile);
  1437.     return(SUCCEED);
  1438. }
  1439.  
  1440.  
  1441.  
  1442. #ifdef LMPTK
  1443. //
  1444. // BROADCAST
  1445. //    Send the given message to the specified mailslot.
  1446. //    This is a Lan Manager specific stored procedure.
  1447. //
  1448. // Parameters:
  1449. //    srvproc - the handle to the client connection that got the SRV_CONNECT.
  1450. //       mailslot - the mailslot to broadcast to
  1451. //       msg - the text message
  1452. //
  1453. // Returns:
  1454. //    SUCCEED or FAIL
  1455. //
  1456. // Side Effects:
  1457. //     Returns a message to client
  1458. //
  1459. RETCODE broadcast(srvproc, mailslot, msg)
  1460. SRV_PROC FAR *srvproc;
  1461. DBCHAR *mailslot;
  1462. DBCHAR *msg;
  1463. {
  1464.     unsigned retcode;
  1465.     DBCHAR errmsg[MAXLEN];
  1466.  
  1467.     // Send message as second class mail
  1468.     //
  1469.     retcode = DosWriteMailslot(mailslot, msg, strlen(msg), 0, 2, 0);
  1470.     if (retcode) {
  1471.         sprintf(errmsg, "Unable to broadcast message. Error: %u", retcode);
  1472.         srv_sendstatus(srvproc, 1);
  1473.         srv_sendmsg(srvproc, 
  1474.                    SRV_MSG_ERROR, 
  1475.                    BROADCAST, 
  1476.                    SRV_INFO, 
  1477.                    (DBTINYINT)0,
  1478.                     NULL, 
  1479.                    0, 
  1480.                    0, 
  1481.                    errmsg, 
  1482.                    SRV_NULLTERM);
  1483.         srv_senddone(srvproc, (SRV_DONE_ERROR | SRV_DONE_FINAL), 0, 0);
  1484.         return(FAIL);
  1485.     }
  1486.  
  1487.     // Broadcast successful
  1488.     //
  1489.     srv_sendstatus(srvproc, 0);
  1490.     srv_sendmsg(srvproc, 
  1491.                SRV_MSG_INFO, 
  1492.                BROADCAST, 
  1493.                (DBTINYINT)0, 
  1494.                (DBTINYINT)0,
  1495.                 NULL, 
  1496.                0, 
  1497.                0, 
  1498.                "Broadcast complete.", 
  1499.                SRV_NULLTERM);
  1500.     srv_senddone(srvproc, SRV_DONE_FINAL, 0, 0);
  1501.     return(SUCCEED);
  1502. }
  1503. #endif
  1504.  
  1505.  
  1506. #pragma check_stack()   // set stack checking to its default setting
  1507.