home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 February / CHIP_2_98.iso / software / pelne / optionp / iis4_07.cab / areadcli.c < prev    next >
C/C++ Source or Header  |  1997-10-25  |  20KB  |  837 lines
  1. /*++
  2.  
  3. Copyright (c) 1997  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     AReadCli.c
  8.  
  9. Abstract:
  10.  
  11.     This module demonstrates using asynchronous ReadClient call
  12.     to read data sent from client. On return, this sends the 
  13.     followings back to client:
  14.     
  15.     1) the number of bytes intended to send
  16.     2) the number of bytes actually read.
  17.     3) data content 
  18.  
  19. Author:
  20.  
  21.     Stanley Tam (stanleyt)   4-June 1997
  22.     
  23. Revision History:
  24.   
  25. --*/
  26. #include <windows.h>
  27. #include <stdio.h>
  28. #include <httpext.h>
  29.  
  30.  
  31. #define MAX_BUF_SIZE        (49152)                 // Max number of bytes for each read - 48K
  32. #define MEM_ALLOC_THRESHOLD (1024 * 1024)           // Default heap size is 1M
  33.  
  34.  
  35. typedef struct _IO_WORK_ITEM {
  36.  
  37.     PBYTE                       pbDATAFromClient;   // Grand read data holder
  38.     DWORD                       cbReadSoFar;        // Number of bytes read so far, 
  39.                                                     // and is used as index for pbDATAFromClient
  40.     EXTENSION_CONTROL_BLOCK *   pecb;
  41.  
  42. }  IO_WORK_ITEM, * PIOWI;
  43.  
  44.  
  45. //
  46. //  Sample Form for doing a POST method
  47. //
  48.  
  49. static CHAR             g_szPostForm[] =
  50.                         "<h2>Asychronous ReadClient Sample Post Form</h2><p>\r\n\r\n"
  51.                         "This demonstrates a post request being sent by this form to the sample ISAPI - AReadCli.dll<p>\r\n\r\n"
  52.                         "AReadCli.dll reads data posted by this form and send it back to the browser.<p>\r\n"
  53.                         "<h3>Post Form</h3>\r\n"
  54.                         "Please enter data below:<br>\r\n"
  55.                         "<form method=POST action=\"areadcli.dll\">\r\n"
  56.                         "<textarea name=\"Data\" cols=48 rows=4></textarea>\r\n\r\n"
  57.                         "<input type=submit> <input type=reset>\r\n"
  58.                         "</form>";
  59.  
  60. //
  61. //  Report read data
  62. //
  63.  
  64. static CHAR             g_szReport[] = 
  65.                         "Bytes count including \"Data=\"  \r\n"
  66.                         "ECB Total Bytes:    %d.\r\n"
  67.                         "Actual Read Bytes:  %d.\r\n";
  68.                 
  69. DWORD
  70. DoInit(IN OUT PIOWI piowi);
  71.  
  72. VOID
  73. DoCleanUp(IN PIOWI piowi);
  74.  
  75. DWORD
  76. DoAsyncReadClient(IN PIOWI piowi);
  77.              
  78. VOID WINAPI
  79. AsyncReadClientIoCompletion(IN LPEXTENSION_CONTROL_BLOCK pecb, 
  80.                             IN PVOID pContext,
  81.                             IN DWORD cbIO,
  82.                             IN DWORD dwError);
  83.  
  84. DWORD
  85. SendMSGToClient(IN LPEXTENSION_CONTROL_BLOCK pecb, 
  86.                 IN LPCSTR pszErrorMsg);
  87.  
  88. LPVOID 
  89. AR_Allocate(IN LPEXTENSION_CONTROL_BLOCK pecb, IN DWORD dwSize);
  90.  
  91. BOOL 
  92. AR_Free(IN LPEXTENSION_CONTROL_BLOCK pecb, IN LPVOID pvData);
  93.  
  94.  
  95.  
  96. DllMain(
  97.      IN HINSTANCE hinstDll,
  98.      IN DWORD     fdwReason,
  99.      IN LPVOID    lpvContext OPTIONAL)
  100. /*++
  101.  
  102.  Routine Description:
  103.  
  104.    This function DllLibMain() is the main initialization function for
  105.     this DLL. It initializes local variables and prepares it to be invoked
  106.     subsequently.
  107.  
  108.  Arguments:
  109.  
  110.    hinstDll          Instance Handle of the DLL
  111.    fdwReason         Reason why NT called this DLL
  112.    lpvReserved       Reserved parameter for future use.
  113.  
  114.  fReturn Value:
  115.  
  116.     fReturns TRUE if successful; otherwise FALSE is fReturned.
  117.  
  118. --*/
  119. {
  120.   BOOL    fReturn = TRUE;
  121.  
  122.  
  123.   switch ( fdwReason) {
  124.  
  125.     case DLL_PROCESS_ATTACH:
  126.       {
  127.           OutputDebugString( "Initializing the global data for areadcli.dll\n");
  128.  
  129.           //
  130.           // Prevent the system from calling DllMain
  131.           // when threads are created or destroyed.
  132.           //
  133.  
  134.           DisableThreadLibraryCalls( hinstDll);
  135.  
  136.           //
  137.           // Initialize various data and modules.
  138.           //
  139.  
  140.           break;
  141.  
  142.       } // case DLL_PROCESS_ATTACH
  143.  
  144.     case DLL_PROCESS_DETACH:
  145.       {
  146.  
  147.           if ( lpvContext != NULL) { }
  148.  
  149.           break;
  150.       } // case DLL_PROCESS_DETACH
  151.  
  152.     default:
  153.       break;
  154.   }   // switch
  155.  
  156.   return (fReturn);
  157. }  // DllLibMain()
  158.  
  159.  
  160.  
  161.  
  162. BOOL WINAPI
  163. GetExtensionVersion(HSE_VERSION_INFO * Version)
  164. /*++
  165.  
  166. Routine Description:
  167.  
  168.     Sets the ISAPI extension version information.
  169.  
  170. Arguments:
  171.  
  172.     Version     pointer to HSE_VERSION_INFO structure
  173.  
  174. Return Value:
  175.  
  176.     TRUE
  177.  
  178. --*/
  179. {
  180.     Version->dwExtensionVersion = 
  181.     MAKELONG(HSE_VERSION_MINOR, HSE_VERSION_MAJOR);
  182.  
  183.     strcpy(Version->lpszExtensionDesc, "Asynchronous Read Client Sample ISAPI DLL");
  184.  
  185.     return TRUE;
  186. }
  187.  
  188.  
  189.  
  190.  
  191. DWORD WINAPI
  192. HttpExtensionProc(LPEXTENSION_CONTROL_BLOCK pecb)
  193. /*++
  194.  
  195. Routine Description:
  196.  
  197.     This is the main routine for any ISAPI application. Inside DoASyncReadClient,
  198.     proper action will be performed to read data from client asynchronously. Any data 
  199.     read from client will be sent back to the client by using synchronous WriteClient.
  200.  
  201. Arguments:
  202.  
  203.     pecb        pointer to ECB containing parameters related to the request.
  204.  
  205. Return Value:
  206.  
  207.     HSE_STATUS_SUCCESS  or
  208.     HSE_STATUS_PENDING  or 
  209.     HSE_STATUS_ERROR
  210.  
  211. --*/
  212. {
  213.     PIOWI   piowi;
  214.     DWORD   hseStatus = HSE_STATUS_SUCCESS;
  215.     
  216.     //
  217.     // The string length of textarea name "Data=" is 5. 
  218.     // Available bytes <= 5 indicates that no user-
  219.     // entered data has been sent, and the post form 
  220.     // is shown.
  221.     //
  222.  
  223.     if ( pecb->cbAvailable <= 5) {  
  224.  
  225.         hseStatus = SendMSGToClient(pecb, g_szPostForm);
  226.     
  227.     } else {
  228.  
  229.         piowi  = (PIOWI ) LocalAlloc( LMEM_FIXED, sizeof( IO_WORK_ITEM));
  230.  
  231.         if ( NULL == piowi) {
  232.  
  233.             SetLastError( ERROR_NOT_ENOUGH_MEMORY);
  234.             return (HSE_STATUS_ERROR);
  235.         }
  236.  
  237.         piowi->pecb = pecb;
  238.  
  239.         //
  240.         // Init Grand data holder, assign the first chunk(read-ahead chunk)
  241.         // and update the index (cbRreadSoFar) of the grand data holder.
  242.         //
  243.  
  244.         hseStatus = DoInit( piowi);
  245.         
  246.         if ( HSE_STATUS_ERROR != hseStatus) {
  247.             
  248.             //
  249.             // Now we are ready to do asynchronous readclient here
  250.             //
  251.  
  252.             hseStatus = DoAsyncReadClient( piowi);
  253.         
  254.             if (hseStatus != HSE_STATUS_PENDING) {
  255.  
  256.                 //
  257.                 //  When IO finishes, tell IIS we will end the
  258.                 //  session. Also clean up other resources here
  259.                 //
  260.  
  261.                 DoCleanUp( piowi);
  262.  
  263.             }
  264.         
  265.         }
  266.  
  267.     }
  268.        
  269.     return (hseStatus);
  270. }
  271.  
  272.  
  273.  
  274.  
  275. BOOL WINAPI
  276. TerminateExtension(DWORD dwFlags)
  277. /*++
  278.  
  279. Routine Description:
  280.  
  281.     This function is called when the WWW service is shutdown
  282.  
  283. Arguments:
  284.  
  285.     dwFlags - HSE_TERM_ADVISORY_UNLOAD or HSE_TERM_MUST_UNLOAD
  286.  
  287. Return Value:
  288.  
  289.     TRUE
  290.  
  291. --*/
  292. {
  293.     return TRUE;
  294. }
  295.  
  296.  
  297.  
  298.  
  299. DWORD
  300. SendMSGToClient(IN LPEXTENSION_CONTROL_BLOCK  pecb, IN LPCSTR pszMsg)
  301. /*++
  302.  
  303. Routine Description:
  304.  
  305.     Prepare header, SendHeaderExInfo struct and write whatever
  306.     message is intended to send to the client.
  307.  
  308. Arguments:
  309.  
  310.     pecb        - pointer to ECB containing parameters related to the request.
  311.     pszMsg      - pointer to the body of the message that is sent to the content.
  312.  
  313. Return Value:
  314.  
  315.     HSE_STATUS_SUCCESS  or HSE_STATUS_ERROR
  316.  
  317. --*/
  318. {
  319.     HSE_SEND_HEADER_EX_INFO    SHEI;
  320.  
  321.     BOOL    fReturn;
  322.     DWORD   cbText;
  323.     DWORD   hseStatus = HSE_STATUS_SUCCESS;
  324.     CHAR    *pszText = NULL;
  325.     
  326.     CHAR    szStatus[] = "200 OK";
  327.     CHAR    szHeaderBase[] = "Content-type: text/html\r\n\r\n";
  328.     
  329.     //
  330.     //  Populate SendHeaderExInfo struct
  331.     //
  332.     //  NOTE we must send Content-Length header with correct 
  333.     //  byte count in order for keep-alive to work.
  334.     //
  335.     //
  336.  
  337.     SHEI.pszStatus = szStatus;
  338.     SHEI.pszHeader = szHeaderBase;
  339.     SHEI.cchStatus = lstrlen(szStatus);
  340.     SHEI.cchHeader = lstrlen(szHeaderBase);
  341.     SHEI.fKeepConn = FALSE;
  342.     
  343.     //
  344.     //  Build page 
  345.     //
  346.     
  347.     cbText = strlen("<head><title>Simple Async Read Client Sample</title></head>\n<body></body>\n")
  348.              + strlen(pszMsg)
  349.              + 1;
  350.  
  351.     pszText = (PCHAR) AR_Allocate(pecb, cbText);
  352.  
  353.     if ( NULL == pszText) {
  354.  
  355.         SetLastError( ERROR_NOT_ENOUGH_MEMORY);
  356.         return (HSE_STATUS_ERROR);
  357.     }
  358.     
  359.     strcpy(pszText, "<head><title>Simple Async Read Client Sample</title></head>\n");
  360.     strcat(pszText, "<body>");
  361.     strcat(pszText, pszMsg);
  362.     strcat(pszText, "</body>\n");
  363.     cbText = (DWORD)strlen(pszText); 
  364.         
  365.     //
  366.     // Send header and body text to client
  367.     //
  368.  
  369.     fReturn = 
  370.     pecb->ServerSupportFunction( pecb->ConnID,
  371.                                  HSE_REQ_SEND_RESPONSE_HEADER_EX,  
  372.                                  &SHEI,
  373.                                  NULL,
  374.                                  NULL) 
  375.                                             
  376.                                  &&
  377.  
  378.     pecb->WriteClient( pecb->ConnID,
  379.                        pszText,
  380.                        &cbText,
  381.                        0 );
  382.  
  383.     if ( !fReturn)  {
  384.         hseStatus = HSE_STATUS_ERROR;
  385.     }
  386.  
  387.     
  388.     AR_Free( pecb, pszText);
  389.     
  390.     return ( hseStatus);
  391. } 
  392.  
  393.  
  394.  
  395.  
  396. DWORD
  397. DoAsyncReadClient(IN PIOWI piowi)
  398. /*++
  399.  
  400. Routine Description:
  401.  
  402.     The caller of the asynchrnous read client.
  403.  
  404. Arguments:
  405.  
  406.     piowi       pointer to the work item
  407.     
  408. Return Value:
  409.  
  410.     HSE_STATUS_SUCCESS  or
  411.     HSE_STATUS_PENDING  or 
  412.     HSE_STATUS_ERROR
  413.  
  414. --*/
  415. {   
  416.     BOOL    fReturn;
  417.     BYTE    *pbData = NULL;
  418.     CHAR    szTmp[MAX_BUF_SIZE];
  419.     DWORD   dwFlags;
  420.     DWORD   cbTotalToRead = MAX_BUF_SIZE;
  421.     DWORD   hseStatus =  HSE_STATUS_PENDING;
  422.     
  423.     //
  424.     // Check if cbTotalBytes == cbAvailable
  425.     // if so lpbData contains all the data sent by 
  426.     // the client, and complete the session. 
  427.     //
  428.  
  429.     if (piowi->pecb->cbTotalBytes == piowi->pecb->cbAvailable) {
  430.         
  431.         //
  432.         // Construct the report and write it to client
  433.         //
  434.  
  435.         pbData = (PBYTE) AR_Allocate(piowi->pecb, piowi->pecb->cbAvailable + MAX_BUF_SIZE);
  436.             
  437.         if ( NULL == pbData) {
  438.  
  439.             SetLastError( ERROR_NOT_ENOUGH_MEMORY);
  440.             return (HSE_STATUS_ERROR);
  441.         }
  442.  
  443.         wsprintf ( pbData,
  444.                    g_szReport,
  445.                    piowi->pecb->cbTotalBytes,
  446.                    piowi->pecb->cbAvailable );
  447.                     
  448.         strcat( pbData, piowi->pecb->lpbData);  
  449.  
  450.         hseStatus = SendMSGToClient( piowi->pecb, pbData);
  451.  
  452.  
  453.         AR_Free( piowi->pecb, pbData);
  454.         DoCleanUp( piowi);
  455.         
  456.         return ( hseStatus); // HSE_STATUS_SUCCESS or HSE_STATUS_ERROR;
  457.     }
  458.  
  459.     //
  460.     //  More to read...
  461.     //
  462.  
  463.     //
  464.     //  Set a call back function and context that will 
  465.     //  be used for handling asynchrnous IO operations.
  466.     //  This only needs to set up once.
  467.     //
  468.  
  469.     fReturn =
  470.     piowi->pecb->ServerSupportFunction(
  471.                     piowi->pecb->ConnID,
  472.                     HSE_REQ_IO_COMPLETION,
  473.                     AsyncReadClientIoCompletion,
  474.                     0,
  475.                     (LPDWORD)piowi );  
  476.     
  477.     if ( !fReturn) {
  478.  
  479.         wsprintf ( szTmp, "Problem occurred at ServerSupportFunction() sending HSE_REQ_IO_COMPLETION request.");
  480.         SendMSGToClient( piowi->pecb, szTmp);
  481.         
  482.         return ( HSE_STATUS_ERROR);
  483.     }
  484.     
  485.  
  486.     //
  487.     //  Fire off the call to perform an asynchronus read from the client. 
  488.     //
  489.     
  490.     // 
  491.     // We need to first check if the size of the remaining chunk 
  492.     // is less than MAX_BUF_SIZE, if so just read what is available, 
  493.     // otherwise read MAX_BUF_SIZE bytes of data.
  494.     // 
  495.  
  496.     cbTotalToRead = piowi->pecb->cbTotalBytes - piowi->cbReadSoFar;
  497.     if ( cbTotalToRead > MAX_BUF_SIZE )  {
  498.  
  499.         cbTotalToRead = MAX_BUF_SIZE;
  500.     }
  501.  
  502.     dwFlags = HSE_IO_ASYNC;
  503.     fReturn = 
  504.     piowi->pecb->ServerSupportFunction(
  505.                         piowi->pecb->ConnID
  506.                       , HSE_REQ_ASYNC_READ_CLIENT
  507.                       , piowi->pbDATAFromClient + // append the new chunk to buffer, cbReadSoFar indexes
  508.                         piowi->cbReadSoFar        // the byte right after the last written byte in the buffer
  509.                       , &cbTotalToRead
  510.                       , &dwFlags);
  511.  
  512.     if (!fReturn) {
  513.         
  514.         wsprintf ( szTmp, "Problem occurred at ServerSupportFunction() sending HSE_REQ_ASYNC_READ_CLIENT request.");
  515.         SendMSGToClient( piowi->pecb, szTmp);
  516.         
  517.         hseStatus = HSE_STATUS_ERROR;
  518.     }
  519.  
  520.     return ( hseStatus); // HSE_STATUS_PENDING or HSE_STATUS_ERROR;
  521.     
  522. }
  523.  
  524.  
  525.  
  526.  
  527. VOID WINAPI
  528. AsyncReadClientIoCompletion(
  529.             IN LPEXTENSION_CONTROL_BLOCK pECB,
  530.             IN PVOID pContext,
  531.             IN DWORD cbIO,
  532.             IN DWORD dwError)
  533. /*++
  534.  
  535. Routine Description:
  536.  
  537.     This is the callback function for handling completions of asynchronous ReadClient.
  538.     This function resubmits additional IO to read the next chunk of data from the 
  539.     client. If there is no more data to read or problem during operation, this function 
  540.     will inform IIS that it is about to end the request session.
  541.     
  542.  
  543. Arguments:
  544.  
  545.     pecb        - extension control block
  546.     pContext    - this is a IO_WORK_ITEM
  547.     cbIO        - bytes just read
  548.     dwError     - Win32 error status code
  549.  
  550. fReturn Value:
  551.  
  552.     None
  553.  
  554. --*/
  555. {
  556.     BOOL    fReturn;
  557.     BYTE    *pbData = NULL;
  558.     CHAR    szTmp[MAX_BUF_SIZE];
  559.     DWORD   dwFlags;
  560.     DWORD   cbTotalToRead;
  561.     
  562.     PIOWI   piowi = ( PIOWI) pContext;
  563.     EXTENSION_CONTROL_BLOCK   * pecb = piowi->pecb;
  564.     
  565.  
  566.     if (ERROR_SUCCESS == dwError) {
  567.  
  568.         //
  569.         // Read successfully, so update current 
  570.         // total bytes read (aka index of grand data holder)
  571.         //
  572.  
  573.         piowi->cbReadSoFar += cbIO;     
  574.                                
  575.         //
  576.         // If they are equal, we finish reading all bytes from client
  577.         //
  578.         
  579.         if ( piowi->cbReadSoFar == pecb->cbTotalBytes ) { 
  580.  
  581.             //
  582.             // Construct the report and write it to client
  583.             //
  584.  
  585.             pbData = (PBYTE) AR_Allocate( pecb, piowi->cbReadSoFar + MAX_BUF_SIZE);
  586.                 
  587.             if ( NULL == pbData) {
  588.  
  589.                 SetLastError( ERROR_NOT_ENOUGH_MEMORY);
  590.                 wsprintf ( szTmp, "Failed to allocate memory inside AsyncReadClientIoCompletion().");
  591.                 SendMSGToClient( pecb, szTmp);
  592.                 
  593.                 DoCleanUp( piowi);
  594.  
  595.                 return;
  596.             }
  597.             
  598.             wsprintf ( pbData, g_szReport, pecb->cbTotalBytes, piowi->cbReadSoFar );
  599.             piowi->pbDATAFromClient[piowi->cbReadSoFar] = 0; 
  600.             strcat( pbData, piowi->pbDATAFromClient);
  601.             SendMSGToClient( pecb, pbData);
  602.             
  603.  
  604.             AR_Free( piowi->pecb, pbData);
  605.             DoCleanUp( piowi);
  606.             
  607.             return;
  608.             
  609.         } else {
  610.  
  611.             // 
  612.             // Still have more data to read... 
  613.             // 
  614.             // We need to first check if the size of the remaining chunk 
  615.             // is less than MAX_BUF_SIZE, if so just read what is available, 
  616.             // otherwise read MAX_BUF_SIZE bytes of data.
  617.             // 
  618.  
  619.             cbTotalToRead = pecb->cbTotalBytes - piowi->cbReadSoFar;
  620.             if ( cbTotalToRead > MAX_BUF_SIZE )  {
  621.  
  622.                 cbTotalToRead = MAX_BUF_SIZE;
  623.             }
  624.             
  625.             // 
  626.             // Fire off another call to perform an asynchronus read from the client. 
  627.             //
  628.  
  629.             dwFlags = HSE_IO_ASYNC;
  630.             fReturn = 
  631.             pecb->ServerSupportFunction(
  632.                           pecb->ConnID
  633.                         , HSE_REQ_ASYNC_READ_CLIENT
  634.                         , piowi->pbDATAFromClient + // append the new chunk to buffer, cbReadSoFar indexes
  635.                           piowi->cbReadSoFar        // the byte right after the last written byte in the buffer
  636.                         , &cbTotalToRead
  637.                         , &dwFlags);
  638.  
  639.             if ( !fReturn) {
  640.                 wsprintf ( szTmp, "Problem occurred at ServerSupportFunction() sending HSE_REQ_ASYNC_READ_CLIENT request.");
  641.                 SendMSGToClient( pecb, szTmp);
  642.  
  643.                 DoCleanUp( piowi);
  644.                 
  645.                 return;
  646.             }
  647.  
  648.         }
  649.     
  650.     } else {
  651.  
  652.         //
  653.         // Error on read
  654.         //
  655.  
  656.         SetLastError(dwError);
  657.         
  658.         DoCleanUp( piowi);
  659.     }
  660.         
  661.     return;
  662.         
  663. } // AsyncReadClientIoCompletion
  664.  
  665.  
  666.  
  667.  
  668. DWORD
  669. DoInit(IN OUT PIOWI piowi)
  670. /*++
  671.  
  672. Routine Description:
  673.  
  674.     Initialize the  Grand data holder, assign the first chunk(read-ahead chunk)
  675.     and update the index (cbRreadSoFar) of the grand data holder.
  676.     
  677. Arguments:
  678.  
  679.     piowi       pointer to the work item
  680.  
  681. fReturn Value:
  682.  
  683.     HSE_STATUS_SUCCESS or HSE_STATUS_ERROR
  684.  
  685. --*/
  686. {
  687.  
  688.     piowi->pbDATAFromClient = 
  689.     (PBYTE) AR_Allocate( piowi->pecb, piowi->pecb->cbTotalBytes + MAX_BUF_SIZE);
  690.     
  691.     if ( NULL == piowi->pbDATAFromClient) {
  692.  
  693.         SetLastError( ERROR_NOT_ENOUGH_MEMORY);
  694.         return (HSE_STATUS_ERROR);
  695.     }
  696.  
  697.     //
  698.     // The first chunk (read-ahead chunk) has arrived.  
  699.     //
  700.     
  701.     strcpy ( piowi->pbDATAFromClient, piowi->pecb->lpbData);
  702.     piowi->cbReadSoFar = piowi->pecb->cbAvailable;
  703.  
  704.     return (HSE_STATUS_SUCCESS);
  705. }
  706.  
  707.  
  708.  
  709.  
  710. VOID
  711. DoCleanUp(IN PIOWI piowi)
  712. /*++
  713.  
  714. Routine Description:
  715.  
  716.     End the session with IIS and clean up other previous allocated resources.
  717.     
  718. Arguments:
  719.  
  720.     piowi       pointer to the work item
  721.  
  722. fReturn Value:
  723.  
  724.     None
  725.  
  726. --*/
  727. {
  728.     
  729.     
  730.     if ( piowi->pbDATAFromClient != NULL) {
  731.  
  732.         AR_Free( piowi->pecb, piowi->pbDATAFromClient);
  733.  
  734.     }
  735.  
  736.     piowi->pecb->ServerSupportFunction( piowi->pecb->ConnID,
  737.                                         HSE_REQ_DONE_WITH_SESSION,
  738.                                         NULL,
  739.                                         NULL,
  740.                                         NULL);
  741.  
  742.     LocalFree( piowi);
  743.  
  744.     return;
  745.  
  746. }
  747.  
  748.  
  749.  
  750.  
  751. LPVOID 
  752. AR_Allocate(IN LPEXTENSION_CONTROL_BLOCK pecb, IN DWORD dwSize)
  753. /*++
  754.  
  755. Routine Description:
  756.  
  757.     Memory allocation routine. Two different Win32 API's to allocate
  758.     bytes in memory, which is based on the number of bytes coming from 
  759.     the client. If the size is greater than 1 M bytes VirtualAllocate is 
  760.     used, otherwise HeapAllocate is used.
  761.     
  762. Arguments:
  763.  
  764.     pecb        - pointer to ECB containing parameters related to the request.
  765.     dwSize      - number of bytes to allocate
  766.  
  767. fReturn Value:
  768.  
  769.     Pointer to void
  770.  
  771. --*/
  772. {
  773.     LPVOID pvData = NULL;
  774.     
  775.  
  776.     if ( pecb->cbTotalBytes > MEM_ALLOC_THRESHOLD) {
  777.  
  778.         pvData = 
  779.         VirtualAlloc( NULL, 
  780.                       dwSize,
  781.                       MEM_RESERVE | MEM_COMMIT, 
  782.                       PAGE_READWRITE);
  783.  
  784.     } else {
  785.  
  786.         pvData = 
  787.         HeapAlloc( GetProcessHeap(), 
  788.                    HEAP_ZERO_MEMORY,
  789.                    dwSize);
  790.                            
  791.     }
  792.  
  793.     return ( pvData);
  794.  
  795. }
  796.  
  797.  
  798.  
  799.  
  800. BOOL
  801. AR_Free( IN LPEXTENSION_CONTROL_BLOCK pecb, IN LPVOID pvData)
  802. /*++
  803.  
  804. Routine Description:
  805.  
  806.     Freeing memory routine, a complementary routine to AR_Allocate. 
  807.     Two different Win32 API's will be used to free up bytes in memory,
  808.     which is based on the number of bytes coming from the client. If 
  809.     the size is greater than 1 M bytes VirtualFree is used. Otherwise, 
  810.     HeapFree is used.
  811.     
  812. Arguments:
  813.  
  814.     pecb        - pointer to ECB containing parameters related to the request.
  815.     pvData      - pointer to the data to be freed.
  816.  
  817. fReturn Value:
  818.  
  819.     TRUE or FALSE
  820.  
  821. --*/
  822. {
  823.     BOOL fReturn = FALSE;
  824.  
  825.  
  826.     if ( pecb->cbTotalBytes > MEM_ALLOC_THRESHOLD) {
  827.         
  828.         fReturn = VirtualFree( pvData, 0, MEM_RELEASE);
  829.  
  830.     } else {
  831.  
  832.         fReturn = HeapFree( GetProcessHeap(), 0, pvData);
  833.     }
  834.  
  835.     return (fReturn);
  836. }
  837.