//------------------------------------------------------------------------------
// <copyright file="StateWorkerRequest.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------

/*
 * StateHttpWorkerRequest
 * 
 * Copyright (c) 1998-1999, Microsoft Corporation
 * 
 */

namespace System.Web.SessionState {

    using System.Text;
    using System.Configuration.Assemblies;
    using System.Runtime.InteropServices;   
    using System.Collections;    
    using System.Web;
    using System.Web.Util;
    using System.Globalization;

    class StateHttpWorkerRequest : HttpWorkerRequest {

        /* long enough to hold the string representation of an IPv4 or IPv6 address; keep in sync with tracker.cxx */
        private const int ADDRESS_LENGTH_MAX = 64;

        IntPtr                                  _tracker;
        string                                  _uri;              
        UnsafeNativeMethods.StateProtocolExclusive    _exclusive;        
        int                                     _extraFlags;
        int                                     _timeout;           
        int                                     _lockCookie;        
        bool                                    _lockCookieExists;  
        int                                     _contentLength;     
        byte[]                                  _content;           


        UnsafeNativeMethods.StateProtocolVerb   _methodIndex;
        string                                  _method;         
                                                                 
        string                                  _remoteAddress;  
        int                                     _remotePort;     
        string                                  _localAddress;   
        int                                     _localPort;      
                                                                 
        StringBuilder                           _status;         
        int                                     _statusCode;     
        StringBuilder                           _headers;        
        IntPtr                           _unmanagedState; 
        bool                                    _sent;           

        internal StateHttpWorkerRequest(
                   IntPtr tracker,
                   UnsafeNativeMethods.StateProtocolVerb methodIndex,
                   string uri,
                   UnsafeNativeMethods.StateProtocolExclusive exclusive,
                   int extraFlags,
                   int timeout,
                   int lockCookieExists,
                   int lockCookie,
                   int contentLength,
                   IntPtr content
                   ) {
            _tracker = tracker;
            _methodIndex = methodIndex;
            switch (_methodIndex) {
                case UnsafeNativeMethods.StateProtocolVerb.GET:
                    _method = "GET";
                    break;

                case UnsafeNativeMethods.StateProtocolVerb.PUT:
                    _method = "PUT";
                    break;

                case UnsafeNativeMethods.StateProtocolVerb.HEAD:
                    _method = "HEAD";
                    break;

                case UnsafeNativeMethods.StateProtocolVerb.DELETE:
                    _method = "DELETE";
                    break;

                default:
                    Debug.Assert(false, "Shouldn't get here!");
                    break;
            }

            _uri = uri;
            // Handle the ASP1.1 case which prepends an extra / to the URI
            if (_uri.StartsWith("//", StringComparison.Ordinal)) {
                _uri = _uri.Substring(1);
            }
            _exclusive = exclusive;
            _extraFlags = extraFlags;
            _timeout = timeout;
            _lockCookie = lockCookie;
            _lockCookieExists = lockCookieExists != 0;
            _contentLength = contentLength;
            if (contentLength != 0) {
                Debug.Assert(_contentLength == IntPtr.Size);
                // Need to convert 'content', which is a ptr to native StateItem,
                // into a byte array because that's what GetPreloadedEntityBody
                // must return, and GetPreloadedEntityBody is what the pipeline uses
                // to read the body of the request, which in our case is just a pointer
                // to a native StateItem object.
#if WIN64
                ulong p = (ulong) content; 
                _content = new byte[8] 
                {
                    (byte) ((p & 0x00000000000000ff)),
                    (byte) ((p & 0x000000000000ff00) >> 8),
                    (byte) ((p & 0x0000000000ff0000) >> 16),
                    (byte) ((p & 0x00000000ff000000) >> 24),
                    (byte) ((p & 0x000000ff00000000) >> 32),
                    (byte) ((p & 0x0000ff0000000000) >> 40),
                    (byte) ((p & 0x00ff000000000000) >> 48),
                    (byte) ((p & 0xff00000000000000) >> 56),
                };
#else
                uint p = (uint) content; 
                _content = new byte[4] 
                {
                    (byte) ((p & 0x000000ff)),
                    (byte) ((p & 0x0000ff00) >> 8),
                    (byte) ((p & 0x00ff0000) >> 16),
                    (byte) ((p & 0xff000000) >> 24),
                };
#endif                
            }

            _status  = new StringBuilder(256);
            _headers = new StringBuilder(256);
        }

        public override string GetUriPath() {
            return HttpUtility.UrlDecode(_uri);
        }

        // The file path is used as the path for configuration.
        // This path should always be null, in order to retrieve
        // the machine configuration.
        public override string GetFilePath() {
            return null;
        }

        public override string GetQueryString() {
            return null;
        }

        public override string GetRawUrl() {
            return _uri;
        }

        public override string GetHttpVerbName() {
            return _method;
        }

        public override string GetHttpVersion() {
            return "HTTP/1.0";
        }

        public override string GetRemoteAddress() {
            StringBuilder   buf;

            if (_remoteAddress == null) {
                buf = new StringBuilder(ADDRESS_LENGTH_MAX);
                UnsafeNativeMethods.STWNDGetRemoteAddress(_tracker, buf);
                _remoteAddress = buf.ToString();
            }

            return _remoteAddress;
        }

        public override int GetRemotePort() {
            if (_remotePort == 0) {
                _remotePort = UnsafeNativeMethods.STWNDGetRemotePort(_tracker);
            }

            return _remotePort;
        }

        public override string GetLocalAddress() {
            StringBuilder   buf;

            if (_localAddress == null) {
                buf = new StringBuilder(ADDRESS_LENGTH_MAX);
                UnsafeNativeMethods.STWNDGetLocalAddress(_tracker, buf);
                _localAddress = buf.ToString();
            }

            return _localAddress;
        }

        public override int GetLocalPort() {
            if (_localPort == 0) {
                _localPort = UnsafeNativeMethods.STWNDGetLocalPort(_tracker);
            }

            return _localPort;
        }

        public override byte[] GetPreloadedEntityBody() {
            return _content;
        }


        public override bool IsEntireEntityBodyIsPreloaded() {
            /* Request is always preloaded */
            return true;
        }


        public override string MapPath(string virtualPath) {
            /*
             * Physical and virtual are identical to state server.
             */
            return virtualPath;
        }

        public override int ReadEntityBody(byte[] buffer, int size) {
            /* pretend everything is preloaded */
            return 0;
        }

        public override long GetBytesRead() {
            /* State web doesn't support partial reads */
            throw new NotSupportedException(SR.GetString(SR.Not_supported));
        }

        public override string GetKnownRequestHeader(int index) {
            string s = null;

            switch (index) {
                /* special case important ones */
                case HeaderContentLength:
                    s = (_contentLength).ToString(CultureInfo.InvariantCulture);
                    break;
            }

            return s;
        }

        public override string GetUnknownRequestHeader(string name) {
            string s = null;

            if (name.Equals(StateHeaders.EXCLUSIVE_NAME)) {
                switch (_exclusive) {
                    case UnsafeNativeMethods.StateProtocolExclusive.ACQUIRE:
                        s = StateHeaders.EXCLUSIVE_VALUE_ACQUIRE;
                        break;

                    case UnsafeNativeMethods.StateProtocolExclusive.RELEASE:
                        s = StateHeaders.EXCLUSIVE_VALUE_RELEASE;
                        break;
                }
            }
            else if (name.Equals(StateHeaders.TIMEOUT_NAME)) {
                if (_timeout != -1) {
                    s = (_timeout).ToString(CultureInfo.InvariantCulture);
                }
            }
            else if (name.Equals(StateHeaders.LOCKCOOKIE_NAME)) {
                if (_lockCookieExists) {
                    s = (_lockCookie).ToString(CultureInfo.InvariantCulture);
                }
            }
            else if (name.Equals(StateHeaders.EXTRAFLAGS_NAME)) {
                if (_extraFlags != -1) {
                    s = (_extraFlags).ToString(CultureInfo.InvariantCulture);
                }
            }

            return s;
        }

        public override string[][] GetUnknownRequestHeaders() {
            string [][] ret;
            int         c, i;

            c = 0;
            if (_exclusive != (UnsafeNativeMethods.StateProtocolExclusive) (-1)) {
                c++;
            }

            if (_extraFlags != -1) {
                c++;
            }

            if (_timeout != -1) {
                c++;
            }

            if (_lockCookieExists) {
                c++;
            }

            if (c == 0)
                return null;

            ret = new string[c][];
            i = 0;
            if (_exclusive != (UnsafeNativeMethods.StateProtocolExclusive) (-1)) {
                ret[0] = new string[2];
                ret[0][0] = StateHeaders.EXCLUSIVE_NAME;
                if (_exclusive == UnsafeNativeMethods.StateProtocolExclusive.ACQUIRE) {
                    ret[0][1] = StateHeaders.EXCLUSIVE_VALUE_ACQUIRE;
                }
                else {
                    Debug.Assert(_exclusive == UnsafeNativeMethods.StateProtocolExclusive.RELEASE, "_exclusive == UnsafeNativeMethods.StateProtocolExclusive.RELEASE");
                    ret[0][1] = StateHeaders.EXCLUSIVE_VALUE_RELEASE;
                }

                i++;
            }

            if (_timeout != -1) {
                ret[i] = new string[2];
                ret[i][0] = StateHeaders.TIMEOUT_NAME;
                ret[i][1] = (_timeout).ToString(CultureInfo.InvariantCulture);

                i++;
            }

            if (_lockCookieExists) {
                ret[i] = new string[2];
                ret[i][0] = StateHeaders.LOCKCOOKIE_NAME;
                ret[i][1] = (_lockCookie).ToString(CultureInfo.InvariantCulture);

                i++;
            }

            if (_extraFlags != -1) {
                ret[i] = new string[2];
                ret[i][0] = StateHeaders.EXTRAFLAGS_NAME;
                ret[i][1] = (_extraFlags).ToString(CultureInfo.InvariantCulture);

                i++;
            }

            return ret;
        }

        public override void SendStatus(int statusCode, string statusDescription) {
            Debug.Assert(!_sent);
            _statusCode = statusCode;
            _status.Append((statusCode).ToString(CultureInfo.InvariantCulture) + " " + statusDescription + "\r\n");
        }

        public override void SendKnownResponseHeader(int index, string value) {
            Debug.Assert(!_sent);
            _headers.Append(GetKnownResponseHeaderName(index));
            _headers.Append(": ");
            _headers.Append(value);
            _headers.Append("\r\n");
        }

        public override void SendUnknownResponseHeader(string name, string value) {
            Debug.Assert(!_sent);
            _headers.Append(name);
            _headers.Append(": ");
            _headers.Append(value);
            _headers.Append("\r\n");
        }

        public override void SendCalculatedContentLength(int contentLength) {
            Debug.Assert(!_sent);
            /*
             * Do nothing - we append the content-length in STWNDSendResponse.
             */
        }

        public override bool HeadersSent() {
            return _sent;
        }

        public override bool IsClientConnected() {
            return UnsafeNativeMethods.STWNDIsClientConnected(_tracker);
        }

        public override void CloseConnection() {
            UnsafeNativeMethods.STWNDCloseConnection(_tracker);
        }

        private void SendResponse() {
            if (!_sent) {
                _sent = true;
                UnsafeNativeMethods.STWNDSendResponse(
                                    _tracker, 
                                    _status, 
                                    _status.Length, 
                                    _headers, 
                                    _headers.Length, 
                                    _unmanagedState);
            }
        }

        public override void SendResponseFromMemory(byte[] data, int length) {
            /*
             * The only content besides error message text is the pointer
             * to the state item in unmanaged memory.
             */
            if (_statusCode == 200) {
                Debug.Assert(_unmanagedState == IntPtr.Zero, "_unmanagedState == 0");
                Debug.Assert(length == IntPtr.Size, "length == IntPtr.Size");
                Debug.Assert(_methodIndex == UnsafeNativeMethods.StateProtocolVerb.GET, "verb == GET");
                Debug.Assert(_exclusive != UnsafeNativeMethods.StateProtocolExclusive.RELEASE,
                             "correct exclusive method");

                if (IntPtr.Size == 4) {
                    _unmanagedState = (IntPtr)
                        (((int)data[0])       |
                         ((int)data[1] << 8)  |
                         ((int)data[2] << 16) |
                         ((int)data[3] << 24));
                }
                else {
                    _unmanagedState = (IntPtr)
                        (((long)data[0])       |
                         ((long)data[1] << 8)  |
                         ((long)data[2] << 16) |
                         ((long)data[3] << 24) |
                         ((long)data[4] << 32) |
                         ((long)data[5] << 40) |
                         ((long)data[6] << 48) |
                         ((long)data[7] << 56));
                }

                Debug.Assert(_unmanagedState != IntPtr.Zero, "_unmanagedState != 0");
            }

            SendResponse();
        }

        public override void SendResponseFromFile(string filename, long offset, long length) {
            /* Not needed by state application */
            throw new NotSupportedException(SR.GetString(SR.Not_supported));
        }

        public override void SendResponseFromFile(IntPtr handle, long offset, long length) {
            /* Not needed by state application */
            throw new NotSupportedException(SR.GetString(SR.Not_supported));
        }

        public override void FlushResponse(bool finalFlush) {
            SendResponse();
        }

        public override void EndOfRequest() {
            SendResponse();
            UnsafeNativeMethods.STWNDEndOfRequest(_tracker);
        }
    }
}