windows-server-2003/inetcore/wininet/gopher/sockets.cxx

/*++

Copyright (c) 1995  Microsoft Corporation

Module Name:

    sockets.cxx

Abstract:

    Contains functions to interface between gopher APIs and Winsock

    Contents:
        GopherConnect
        GopherDisconnect
        GopherSendRequest
        GopherReceiveResponse

Author:

    Richard L Firth (rfirth) 11-Oct-1994

Environment:

    Win32(s) user-mode DLL

Revision History:

    11-Oct-1994 rfirth
        Created

--*/

#include <wininetp.h>
#include "gfrapih.h"

//
// manifests
//

#define DEFAULT_RESPONSE_BUFFER_LENGTH  (4 K)

//
// functions
//


DWORD
GopherConnect(
    IN LPVIEW_INFO ViewInfo
    )

/*++

Routine Description:

    Makes a connection to a (gopher) server. Sets a receive timeout on the
    connected socket

Arguments:

    ViewInfo    - pointer to VIEW_INFO containing pointer to SESSION_INFO which
                  describes server to connect to

Return Value:

    DWORD
        Success - ERROR_SUCCESS

        Failure - WSA error

--*/

{
    DEBUG_ENTER((DBG_SOCKETS,
                Dword,
                "GopherConnect",
                "%#x",
                ViewInfo
                ));

    DWORD error;
    BOOL  fSuccess;
    INTERNET_CONNECT_HANDLE_OBJECT *pConnect;
    PROXY_STATE *pProxyState = NULL;

    INET_ASSERT(ViewInfo->BufferInfo != NULL);
    INET_ASSERT(ViewInfo->SessionInfo != NULL);

    //
    // determine sync or async
    //

    LPINTERNET_THREAD_INFO lpThreadInfo = InternetGetThreadInfo();

    if (lpThreadInfo == NULL) {

        INET_ASSERT(FALSE);

        error = ERROR_INTERNET_INTERNAL_ERROR;
        goto quit;
    }

    DWORD asyncFlags;

    asyncFlags = 0;
    //asyncFlags = lpThreadInfo->IsAsyncWorkerThread ? SF_NON_BLOCKING : 0;

    //
    // Set the port we're using on the socket object.
    //

    ViewInfo->BufferInfo->Socket->SetPort((INTERNET_PORT) ViewInfo->SessionInfo->Port);

    //
    // Using the object handle, check to see if we have a socks proxy.
    //  If so, use it to do our connections.
    //

    INTERNET_HANDLE_OBJECT * pInternet;
    HINTERNET hConnectMapped;

    INET_ASSERT(lpThreadInfo != NULL);
    INET_ASSERT(lpThreadInfo->hObjectMapped != NULL);
    INET_ASSERT(ViewInfo->SessionInfo->Host != NULL);

    //
    // Get the Mapped Connect Handle Object...
    //

    INET_ASSERT( (ViewInfo->ViewType == ViewTypeFile) ||
                 (ViewInfo->ViewType == ViewTypeFind) );

    hConnectMapped = ((HANDLE_OBJECT *)lpThreadInfo->hObjectMapped)->GetParent();

    INET_ASSERT(hConnectMapped);

    //
    // Finally get the Internet Object, so we can query proxy information
    //  out of it.
    //

    pConnect = (INTERNET_CONNECT_HANDLE_OBJECT *) hConnectMapped;

    pInternet = (INTERNET_HANDLE_OBJECT *)
                    ((INTERNET_CONNECT_HANDLE_OBJECT *)hConnectMapped)->GetParent();

    INET_ASSERT(pInternet);

    {

        AUTO_PROXY_ASYNC_MSG proxyInfoQuery(
                                    INTERNET_SCHEME_GOPHER,
                                    pConnect->GetURL(),
                                    lstrlen(pConnect->GetURL()),
                                    ViewInfo->SessionInfo->Host,
                                    lstrlen(ViewInfo->SessionInfo->Host),
                                    (INTERNET_PORT) ViewInfo->SessionInfo->Port
                                    );

        AUTO_PROXY_ASYNC_MSG *pProxyInfoQuery;

        proxyInfoQuery.SetBlockUntilCompletetion(TRUE);

        pProxyInfoQuery = &proxyInfoQuery;

        error = pInternet->GetProxyInfo(
                                &pProxyInfoQuery
                                );

        if ( error != ERROR_SUCCESS )
        {
            goto quit;
        }

        if (pProxyInfoQuery->IsUseProxy() &&
            pProxyInfoQuery->GetProxyScheme() == INTERNET_SCHEME_SOCKS &&
            pProxyInfoQuery->_lpszProxyHostName )
        {
            //
            //  If there is Socks enabled, then turned it on.
            //

            error = ViewInfo->BufferInfo->Socket->EnableSocks(
                                                               pProxyInfoQuery->_lpszProxyHostName,
                                                               pProxyInfoQuery->_nProxyHostPort
                                                               );
        }

        if ( pProxyInfoQuery && pProxyInfoQuery->IsAlloced() )
        {
            delete pProxyInfoQuery;
            pProxyInfoQuery = NULL;
        }

        if ( error != ERROR_SUCCESS )
        {
            goto quit;
        }

    }


    error = ViewInfo->BufferInfo->Socket->Connect(
                          GetTimeoutValue(INTERNET_OPTION_CONNECT_TIMEOUT),
                          GetTimeoutValue(INTERNET_OPTION_CONNECT_RETRIES),
                          SF_INDICATE | asyncFlags
                          );

    if (error == ERROR_SUCCESS) {

        DEBUG_PRINT(SOCKETS,
                    INFO,
                    ("GopherConnect(): ConnectSocket() returns socket %#x\n",
                    //ViewInfo->BufferInfo->ConnectedSocket.Socket
                    ViewInfo->BufferInfo->Socket->GetSocket()
                    ));

        //
        // we have made a connection with the server. Set the receive timeout.
        // If this fails for any reason, ignore it (although the socket is
        // probably bad if this is true)
        //

        ViewInfo->BufferInfo->Socket->SetTimeout(
                                RECEIVE_TIMEOUT,
                                GetTimeoutValue(INTERNET_OPTION_RECEIVE_TIMEOUT)
                                );
    } else {

        DEBUG_PRINT(SOCKETS,
                    ERROR,
                    ("GopherConnect(): ConnectSocket() returns %d\n",
                    error
                    ));

    }

quit:

    DEBUG_LEAVE(error);

    return error;
}


DWORD
GopherDisconnect(
    IN LPVIEW_INFO ViewInfo,
    IN BOOL AbortConnection
    )

/*++

Routine Description:

    Disconnects from the gopher server if the session is not flagged as
    persistent. The socket is closed

Arguments:

    ViewInfo        - pointer to VIEW_INFO containing pointer to SESSION_INFO
                      which describes connection to gopher server

    AbortConnection - TRUE if the connection is to be terminated, even if it is
                      a persistent connection

Return Value:

    DWORD
        Success - ERROR_SUCCESS

        Failure - WSA error

--*/

{
    DEBUG_ENTER((DBG_SOCKETS,
                Dword,
                "GopherDisconnect",
                "%#x, %B",
                ViewInfo,
                AbortConnection
                ));

    DWORD error;
    LPSESSION_INFO sessionInfo;

    INET_ASSERT(ViewInfo->SessionInfo != NULL);

    sessionInfo = ViewInfo->SessionInfo;
    if (!(sessionInfo->Flags & SI_PERSISTENT) || AbortConnection) {

        LPBUFFER_INFO bufferInfo;

        INET_ASSERT(ViewInfo->BufferInfo != NULL);

        bufferInfo = ViewInfo->BufferInfo;

        DEBUG_PRINT(SOCKETS,
                    INFO,
                    ("GopherDisconnect(): closing socket %#x\n",
                    //bufferInfo->ConnectedSocket.Socket
                    bufferInfo->Socket->GetSocket()
                    ));

        error = bufferInfo->Socket->Disconnect();

        if (error != ERROR_SUCCESS) {

            DEBUG_PRINT(SOCKETS,
                        ERROR,
                        ("GopherDisconnect(): Disconnect(%#x) returns %d\n",
                        ViewInfo->BufferInfo->Socket->GetSocket(),
                        error
                        ));

        }
    } else {
        error = ERROR_SUCCESS;
    }

    DEBUG_LEAVE(error);

    return error;
}


DWORD
GopherSendRequest(
    IN LPVIEW_INFO ViewInfo
    )

/*++

Routine Description:

    Sends a gopher request to the server we are currently connected to. The
    request is the selector string used to tell the gopher server what to return

Arguments:

    ViewInfo    - pointer to VIEW_INFO describing request. Contains pointer to
                  CR/LF terminated text string gopher request

Return Value:

    DWORD
        Success - ERROR_SUCCESS

        Failure - WSA error

--*/

{
    DEBUG_ENTER((DBG_SOCKETS,
                Dword,
                "GopherSendRequest",
                "%#x",
                ViewInfo
                ));

    DWORD error;

    //
    // determine sync or async
    //

    LPINTERNET_THREAD_INFO lpThreadInfo = InternetGetThreadInfo();

    if (lpThreadInfo == NULL) {

        INET_ASSERT(FALSE);

        error = ERROR_INTERNET_INTERNAL_ERROR;
        goto quit;
    }

    DWORD asyncFlags;

    asyncFlags = 0;
    //asyncFlags = lpThreadInfo->IsAsyncWorkerThread ? SF_NON_BLOCKING : 0;

    error = ViewInfo->BufferInfo->Socket->Send(ViewInfo->Request,
                                               ViewInfo->RequestLength,
                                               SF_INDICATE
                                               );

quit:

    DEBUG_LEAVE(error);

    return error;
}


DWORD
GopherReceiveResponse(
    IN OUT LPVIEW_INFO ViewInfo,
    OUT LPDWORD BytesReceived
    )

/*++

Routine Description:

    This function is called iteratively to receive the gopher response data. The
    first time this function is called, we determine the type of response -
    success or failure, gopher0 or gopher+.

    The buffer information passed in can refer to a buffer that we maintain
    internally (for directories), or to a buffer that the caller supplies to the
    GopherReadFile() function. In the latter case, the buffer address and length
    may be 0.

    This function assumes that directory responses will be received into a
    buffer which we allocate in this function, and that file requests are
    received into caller-supplied (user-supplied) buffers

Arguments:

    ViewInfo        - pointer to VIEW_INFO structure (including BUFFER_INFO)
                      describing the gopher request and the response from the
                      server

    BytesReceived   - number of bytes received in this response

Return Value:

     DWORD
        Success - ERROR_SUCCESS

        Failure - ERROR_INTERNET_EXTENDED_ERROR
                    The server sent us some form of error text. The app should
                    use InternetGetLastResponseInfo() to get the text

--*/

{
    DEBUG_ENTER((DBG_SOCKETS,
                Dword,
                "GopherReceiveResponse",
                "%#x, %#x",
                ViewInfo,
                BytesReceived
                ));

    LPBUFFER_INFO bufferInfo;
    DWORD error;
    int bufferLength;
    LPBYTE buffer;
    LPBYTE responseBuffer;
    int bytesReceived;
    BOOL discardBuffer;
    BOOL terminateConnection;
    BOOL checkResponse;

    *BytesReceived = 0;

    bytesReceived = 0;
    terminateConnection = FALSE;
    checkResponse = FALSE;

    //
    // variables for SocketReceive()
    //

    LPVOID psrBuffer;
    DWORD srLength;
    DWORD srLeft;
    DWORD srReceived;
    BOOL eof;

    bufferInfo = ViewInfo->BufferInfo;

    INET_ASSERT(bufferInfo != NULL);

    //
    // determine sync or async
    //

    LPINTERNET_THREAD_INFO lpThreadInfo = InternetGetThreadInfo();

    if (lpThreadInfo == NULL) {

        INET_ASSERT(FALSE);

        error = ERROR_INTERNET_INTERNAL_ERROR;
        goto cleanup;
    }

    DWORD asyncFlags;

    asyncFlags = 0;
    //asyncFlags = lpThreadInfo->IsAsyncWorkerThread ? SF_NON_BLOCKING : 0;

    //
    // if this is the first receive for this buffer then figure out what we
    // received. At this point we may have no buffer (GopherOpenFile()) so we
    // set up the BUFFER_INFO with the required information for the next
    // GopherReadFile()
    //

    if (bufferInfo->Flags & BI_FIRST_RECEIVE) {

        //
        // determine what we have received
        //

        psrBuffer = (LPVOID)bufferInfo->ResponseInfo;
        srLength = sizeof(bufferInfo->ResponseInfo);
        srLeft = sizeof(bufferInfo->ResponseInfo);
        srReceived = 0;

        error = bufferInfo->Socket->Receive(&psrBuffer,
                                            &srLength,
                                            &srLeft,
                                            &srReceived,
                                            0,    // dwExtraSpace
                                            SF_INDICATE,
                                            &eof
                                            );
        if (error != ERROR_SUCCESS) {
            goto cleanup;
        } else if (srReceived == 0) {

            INET_ASSERT(eof);

            //
            // the server has closed the connection already.  We either end up
            // with a zero-length file, or return ERROR_NO_MORE_FILES from a
            // directory listing
            //

            DEBUG_PRINT(SOCKETS,
                        ERROR,
                        ("SocketsReceive() returns 0 bytes on initial read\n"
                        ));

            bufferInfo->Flags |= BI_RECEIVE_COMPLETE;
            goto cleanup;
        }

        //
        // BytesRemaining is the number of data bytes in ResponseInfo
        //

        bufferInfo->BytesRemaining = srReceived;
        bufferInfo->DataBytes = (LPBYTE)bufferInfo->ResponseInfo;

        if (ViewInfo->Flags & VI_GOPHER_PLUS) {

            //
            // gopher+ request: expecting gopher+ response: +/-#\r\n
            //

            if (bufferInfo->ResponseInfo[0] == GOPHER_PLUS_ERROR_INDICATOR) {
                bufferInfo->Flags |= BI_ERROR_RESPONSE;
            } else if (bufferInfo->ResponseInfo[0] != GOPHER_PLUS_SUCCESS_INDICATOR) {

                //
                // buffer does not start with + or -; assume we received a
                // gopher0 response, and down-grade the request
                //

                ViewInfo->Flags &= ~VI_GOPHER_PLUS;

                DEBUG_PRINT(SOCKETS,
                            WARNING,
                            ("Gopher+ request resulted in gopher0 response!\n"
                            ));

            }
        } else if ((ViewInfo->ViewType != ViewTypeFile)
        && (bufferInfo->ResponseInfo[0] == GOPHER_PLUS_ERROR_INDICATOR)) {

            //
            // if this is a gopher+ error response then we promote the request/
            // response to gopher+ and handle the error below. If it actually
            // turns out that someone has invented a locator that starts '-'
            // then we will again down-grade the request
            //

            bufferInfo->Flags |= BI_ERROR_RESPONSE;
            ViewInfo->Flags |= VI_GOPHER_PLUS;

            DEBUG_PRINT(SOCKETS,
                        WARNING,
                        ("Gopher0 request resulted in gopher+ response!\n"
                        ));

        }

        //
        // if we still think the request/response is gopher+ then extract the
        // response length
        //

        if (ViewInfo->Flags & VI_GOPHER_PLUS) {

            BOOL ok;
            LPSTR pNumber;

            pNumber = &bufferInfo->ResponseInfo[1];
            ok = ExtractInt(&pNumber,
                            0,
                            &bufferInfo->ResponseLength
                            );
            if (!ok || (*pNumber != '\r') || (*(pNumber + 1) != '\n')) {
                ViewInfo->Flags &= ~VI_GOPHER_PLUS;

                DEBUG_PRINT(SOCKETS,
                            WARNING,
                            ("Gopher+ request resulted in gopher0 response!\n"
                            ));

                //
                // probably isn't an error either
                //

                bufferInfo->Flags &= ~BI_ERROR_RESPONSE;
            } else {

                int numberLength;

                //
                // this is the number of bytes we copied to the ResponseInfo
                // buffer that belong in the response proper
                //

                numberLength = (int) (pNumber - bufferInfo->ResponseInfo) + 2;
                bufferInfo->DataBytes = (LPBYTE)&bufferInfo->ResponseInfo[numberLength];
                bufferInfo->BytesRemaining -= numberLength;
            }
        }

        //
        // if we are receiving a gopher0 (directory) response then we need to
        // check below if we really received an error
        //

        if (!(ViewInfo->Flags & VI_GOPHER_PLUS)) {
            checkResponse = TRUE;
        }

        //
        // no longer the first time receive
        //

        bufferInfo->Flags &= ~BI_FIRST_RECEIVE;
    }

    //
    // either get the user buffer pointer, or allocate/resize a moveable buffer
    // (for directory listings and errors)
    //
    // N.B. A special case here is an error received in response to a gopher0
    // directory request: we don't know at this point if a gopher0 directory
    // request has resulted in an error, but we have to allocate a buffer
    // anyway, so we will determine error status after we have received the
    // data
    //

    discardBuffer = FALSE;
    if (!(bufferInfo->Flags & (BI_BUFFER_RESPONSE | BI_ERROR_RESPONSE))) {
        buffer = bufferInfo->Buffer;
        bufferLength = bufferInfo->BufferLength;

        //
        // if we are given a zero length user buffer then quit now; the bytes
        // received parameter has already been zeroed
        //

        if (bufferLength == 0) {
            goto quit;
        }
    } else {

        //
        // if we know how much data is in the response AND it is less than the
        // default length, then allocate a buffer that will exactly fit the
        // response. Otherwise allocate a buffer large enough to fit the default
        // response length
        //

        if (bufferInfo->ResponseLength > 0) {
            bufferLength = min(bufferInfo->ResponseLength,
                               DEFAULT_RESPONSE_BUFFER_LENGTH
                               );
        } else {

            //
            // the response length is -1 or -2, or its a gopher0 response: we
            // don't know how large it is
            //

            bufferLength = DEFAULT_RESPONSE_BUFFER_LENGTH;
        }

        //
        // if this is the first time we have called this function, allocate the
        // buffer, else grow it to the new size
        //

        bufferInfo->Buffer = (LPBYTE)ResizeBuffer(bufferInfo->Buffer,
                                                  bufferInfo->BufferLength
                                                  + bufferLength,
                                                  FALSE
                                                  );
        if (bufferInfo->Buffer == NULL) {
            terminateConnection = TRUE;

            INET_ASSERT(FALSE);

            goto last_error_exit;
        }

        bufferInfo->Flags |= BI_OWN_BUFFER;

        //
        // start receiving the next chunk at the end of the previous one
        //

        buffer = bufferInfo->Buffer + bufferInfo->BufferLength;
    }

    //
    // if we haven't already received all the data (in DetermineGopherResponse)
    // then receive the next chunk
    //

    responseBuffer = buffer;
    bytesReceived = bufferLength;

    //
    // receive the data. N.B. Don't change this loop without first examining
    // the checks below
    //

    int n;

    for (n = 0; bufferLength > 0; ) {

        //
        // if there is still data to copy in ResponseInfo then copy that
        //

        if (bufferInfo->BytesRemaining) {
            n = min(bufferInfo->BytesRemaining, bufferLength);
            memcpy(buffer, bufferInfo->DataBytes, n);
            bufferInfo->BytesRemaining -= n;
            bufferInfo->DataBytes += n;
        } else {

            //
            // if there is data left to copy in the look-ahead buffer that we
            // allocated in DetermineGopherResponse() then copy that data to
            // the response buffer
            //

            psrBuffer = (LPVOID)buffer;
            srLength = bufferLength;
            srLeft = bufferLength;
            srReceived = 0;

            error = bufferInfo->Socket->Receive(&psrBuffer,
                                                &srLength,
                                                &srLeft,
                                                &srReceived,
                                                0,    // dwExtraSpace
                                                SF_INDICATE,
                                                &eof
                                                );
            if (error != ERROR_SUCCESS) {
                discardBuffer = TRUE;
                terminateConnection = TRUE;
                goto cleanup;
            }
            n = srReceived;
            if (n == 0) {
                break;
            }
        }
        bufferLength -= n;
        buffer += n;
    }

    //
    // at this point we have one of the following:
    //
    //  * we reached the end of the response (n == 0)
    //  * we reached the end of the buffer (n != 0 && bufferLength == 0)
    //

    //
    // get the actual number of bytes received for this iteration
    //

    bytesReceived -= bufferLength;

    //
    // if we are receiving a gopher0 directory response then we need to check
    // whether we actually received an error
    //

    if (checkResponse) {

        //
        // allow for long locators (!)
        //

        char locator[2 * MAX_GOPHER_LOCATOR_LENGTH + 1];
        LPSTR destination;
        LPSTR source;
        DWORD destinationLength;
        DWORD sourceLength;

        //
        // we have a gopher0 error if the response starts with a '3' but there
        // is only one locator, or the response data is unformatted
        //

        //
        // N.B. We are making an assumption here that the locator(s) in the
        // response is(are) not larger than our buffer above. This should be a
        // safe assumption, but this test could fail if we get a large locator
        // but then a large locator will probably break all other gopher
        // clients? The reason we copy the locator is so that we get a zero-
        // terminated string for IsValidLocator(), and CopyToEol() compresses
        // multiple carriage-returns which some servers are uninteligent to
        // return
        //

        source = (LPSTR)responseBuffer;
        sourceLength = bytesReceived;
        destination = locator;
        destinationLength = sizeof(locator);
        if (CopyToEol(&destination,
                      &destinationLength,
                      &source,
                      &sourceLength)) {

            if (IsValidLocator(locator, sizeof(locator))) {

                //
                // response contains at least one valid locator. If it starts
                // with the gopher0 error indicator ('3') and its the only one
                // then this is an error response (although it *could* be the
                // one and only locator describing the directory, and the admin
                // decided to make it an error for some reason. We can't
                // differentiate in this case)
                //

                if (locator[0] == GOPHER_CHAR_ERROR) {
                    destination = locator;
                    destinationLength = sizeof(locator);
                    if (!CopyToEol(&destination,
                                   &destinationLength,
                                   &source,
                                   &sourceLength)) {
                        bufferInfo->Flags |= BI_ERROR_RESPONSE;
                    } else if (!IsValidLocator(locator, sizeof(locator))) {
                        bufferInfo->Flags |= BI_ERROR_RESPONSE;
                    }
                }
            } else {

                //
                // response doesn't contain a valid locator: must be an error
                //

                bufferInfo->Flags |= BI_ERROR_RESPONSE;
            }
        } else {

            //
            // we are receiving 4K but couldn't find an end-of-line? Must be an
            // error
            //

            bufferInfo->Flags |= BI_ERROR_RESPONSE;
        }
    }

    //
    // if we finished receivig the response then we can set the error code or
    // shrink the buffer
    //

    if ((n == 0)
    || (bytesReceived == bufferInfo->ResponseLength)
    || (bufferInfo->Flags & BI_ERROR_RESPONSE)) {

        //
        // no more data in the response. We have completed the transfer
        //

        bufferInfo->Flags |= BI_RECEIVE_COMPLETE;

        //
        // if this response type is terminated with a line containing only a dot
        // then remove the dot
        //

        if (bufferInfo->Flags & BI_DOT_AT_END) {

            //
            // BUGBUG - this is insufficient - need to check for different line
            //          termination schemes ('\n', '\r\r\n', '\r\n', etc.)
            //

            if ((bytesReceived >= 3) && (memcmp(buffer - 3, ".\r\n", 3) == 0)) {
                bytesReceived -= 3;
            }
            bufferInfo->Flags &= ~BI_DOT_AT_END;
        }

        //
        // if we received an error response then we must set the last error
        // response data
        //

        if (bufferInfo->Flags & BI_ERROR_RESPONSE) {
            if (bytesReceived > 0) {
                InternetSetLastError(0,
                                     (LPSTR)responseBuffer,
                                     bytesReceived,
                                     SLE_ZERO_TERMINATE
                                     );

                //
                // let the app know that it needs to call InternetGetLastResponseInfo()
                // to retrieve the error text
                //

                error = ERROR_INTERNET_EXTENDED_ERROR;
            } else {
                error = ERROR_SUCCESS;
            }

            //
            // we have copied the data in the error response, no more need for
            // the buffer
            //

            discardBuffer = TRUE;

            //
            // need to indicate to the caller that they need to get the last
            // error response
            //

        } else {
            error = ERROR_SUCCESS;
        }
    } else {

        //
        // this chunk received OK, more to go
        //

        error = ERROR_SUCCESS;
    }

cleanup:

    //
    // if we no longer need the buffer then discard it, else if we have completed
    // receiving the response, shrink the buffer to free up any unused space
    //

    if (bufferInfo->Flags & BI_OWN_BUFFER) {

        DWORD newBufferLength;
        BOOL resize;

        if (discardBuffer) {
            newBufferLength = 0;
            resize = TRUE;
        } else {

            //
            // update the amount of data received - i.e. the number of bytes in
            // the buffer (excluding header info)
            //

            bufferInfo->BufferLength += bytesReceived;
            if (bufferInfo->Flags & BI_RECEIVE_COMPLETE) {
                newBufferLength = bufferInfo->BufferLength;
                resize = TRUE;

                DEBUG_PRINT(SOCKETS,
                            ERROR,
                            ("received 0 bytes in response\n"
                            ));

            } else {
                resize = FALSE;
            }
        }

        //
        // if resize is TRUE then we are either shrinking the data buffer to
        // exclude any unused space, or we are shrinking it to nothing because
        // we have no data or it is being discarded
        //

        if (resize) {
            bufferInfo->Buffer = (LPBYTE)ResizeBuffer(bufferInfo->Buffer,
                                                      newBufferLength,
                                                      FALSE
                                                      );

            if (newBufferLength == 0) {

                //
                // we no longer own the buffer
                //

                bufferInfo->Flags &= ~BI_OWN_BUFFER;

                //
                // DEBUG version: ensure that the buffer has really been freed
                //

                INET_ASSERT(bufferInfo->Buffer == NULL);

            }
        }
    }

    //
    // if this is a gopher+ response and we know the length of the response then
    // reduce the outstanding size of the response by the amount we received
    //

    if (bufferInfo->ResponseLength > 0) {
        bufferInfo->ResponseLength -= bytesReceived;
    }

    //
    // if we completed the response and the connection is not persistent, or an
    // error occurred, close the connection
    //

    if ((bufferInfo->Flags & BI_RECEIVE_COMPLETE) || (error != ERROR_SUCCESS)) {

        //
        // let the app know we have finished receiving data
        //

        InternetIndicateStatus(INTERNET_STATUS_RESPONSE_RECEIVED,
                               &bytesReceived,
                               sizeof(bytesReceived)
                               );

        GopherDisconnect(ViewInfo, terminateConnection);
    }

    //
    // if we didn't receive error text from the server then we return the amount
    // of data received. This is only interesting to ReadData()
    //

    if (!(bufferInfo->Flags & BI_ERROR_RESPONSE)) {
        *BytesReceived = bytesReceived;
    }

quit:

    DEBUG_LEAVE(error);

    return error;

last_error_exit:

    error = GetLastError();

    INET_ASSERT(error != ERROR_SUCCESS);

    goto cleanup;
}