2 // System.Web.HttpRequest
\r
5 // Patrik Torstensson (Patrik.Torstensson@labs2.com)
\r
6 // Gonzalo Paniagua Javier (gonzalo@ximian.com)
\r
8 // (c) 2001, 2002 Patrick Torstensson
\r
9 // (c) 2002 Ximian, Inc. (http://www.ximian.com)
\r
12 using System.Collections;
\r
13 using System.Collections.Specialized;
\r
16 using System.Web.Configuration;
\r
17 using System.Web.Util;
\r
19 namespace System.Web {
\r
20 [MonoTODO("Review security in all path access function")]
\r
21 public sealed class HttpRequest {
\r
22 private string [] _arrAcceptTypes;
\r
23 private string [] _arrUserLanguages;
\r
25 private byte [] _arrRawContent;
\r
26 private int _iContentLength;
\r
28 private string _sContentType;
\r
29 private string _sHttpMethod;
\r
30 private string _sRawUrl;
\r
31 private string _sUserAgent;
\r
32 private string _sUserHostAddress;
\r
33 private string _sUserHostName;
\r
34 private string _sPath;
\r
35 private string _sPathInfo;
\r
36 private string _sFilePath;
\r
37 private string _sPathTranslated;
\r
38 private string _sQueryStringRaw;
\r
39 private string _sRequestType;
\r
40 private string _sRequestRootVirtualDir;
\r
42 private Encoding _oContentEncoding;
\r
44 private Uri _oUriReferrer;
\r
47 private int _iTotalBytes;
\r
49 private HttpContext _oContext;
\r
51 private HttpWorkerRequest _WorkerRequest;
\r
52 private HttpRequestStream _oInputStream;
\r
53 private HttpClientCertificate _ClientCert;
\r
55 private HttpValueCollection _oServerVariables;
\r
56 private HttpValueCollection _oHeaders;
\r
57 private HttpValueCollection _oQueryString;
\r
58 private HttpValueCollection _oFormData;
\r
59 private HttpValueCollection _oParams;
\r
61 private HttpBrowserCapabilities _browser;
\r
63 private HttpCookieCollection cookies;
\r
65 public HttpRequest(string Filename, string Url, string Querystring) {
\r
66 _iContentLength = -1;
\r
69 _WorkerRequest = null;
\r
70 _sPathTranslated = Filename;
\r
71 _sRequestType = "GET";
\r
73 _oUrl = new Uri(Url);
\r
74 _sPath = _oUrl.AbsolutePath;
\r
76 _sQueryStringRaw = Querystring;
\r
77 _oQueryString = new HttpValueCollection(Querystring, true, WebEncoding.Encoding);
\r
80 internal HttpRequest(HttpWorkerRequest WorkRequest, HttpContext Context) {
\r
81 _WorkerRequest = WorkRequest;
\r
82 _oContext = Context;
\r
84 _iContentLength = -1;
\r
88 static private string MakeServerVariableFromHeader(string header) {
\r
89 return "HTTP_" + header.ToUpper().Replace("-", "_");
\r
92 [MonoTODO("Need to support non-raw mode also..")]
\r
93 private string GetAllHeaders(bool Raw) {
\r
94 StringBuilder oData;
\r
96 if (null == _WorkerRequest) {
\r
100 oData = new StringBuilder(512);
\r
102 string sHeaderValue;
\r
103 string sHeaderName;
\r
106 // Add all know headers
\r
107 for (; iCount != 40; iCount++) {
\r
108 sHeaderValue = _WorkerRequest.GetKnownRequestHeader(iCount);
\r
109 if (null != sHeaderValue && sHeaderValue.Length > 0) {
\r
110 sHeaderName = _WorkerRequest.GetKnownRequestHeader(iCount);
\r
111 if (null != sHeaderName && sHeaderName.Length > 0) {
\r
112 oData.Append(sHeaderName);
\r
113 oData.Append(": ");
\r
114 oData.Append(sHeaderValue);
\r
115 oData.Append("\r\n");
\r
120 // Get all other headers
\r
121 string [][] arrUnknownHeaders = _WorkerRequest.GetUnknownRequestHeaders();
\r
122 if (null != arrUnknownHeaders) {
\r
123 for (iCount = 0; iCount != arrUnknownHeaders.Length; iCount++) {
\r
124 oData.Append(arrUnknownHeaders[iCount][0]);
\r
125 oData.Append(": ");
\r
126 oData.Append(arrUnknownHeaders[iCount][1]);
\r
127 oData.Append("\r\n");
\r
131 return oData.ToString();
\r
134 [MonoTODO("We need to handly 'dynamic' variables like AUTH_USER, that can be changed during runtime... special collection")]
\r
135 private void ParseServerVariables() {
\r
136 if (null == _WorkerRequest) {
\r
140 if (_oServerVariables == null) {
\r
143 _oServerVariables = new HttpValueCollection();
\r
145 _oServerVariables.Add("ALL_HTTP", GetAllHeaders(false));
\r
146 _oServerVariables.Add("ALL_RAW", GetAllHeaders(true));
\r
148 _oServerVariables.Add("APPL_MD_PATH", _WorkerRequest.GetServerVariable("APPL_MD_PATH"));
\r
149 _oServerVariables.Add("AUTH_PASSWORD", _WorkerRequest.GetServerVariable("AUTH_PASSWORD"));
\r
150 _oServerVariables.Add("CERT_COOKIE", _WorkerRequest.GetServerVariable("CERT_COOKIE"));
\r
151 _oServerVariables.Add("CERT_FLAGS", _WorkerRequest.GetServerVariable("CERT_FLAGS"));
\r
152 _oServerVariables.Add("CERT_ISSUER", _WorkerRequest.GetServerVariable("CERT_ISSUER"));
\r
153 _oServerVariables.Add("CERT_KEYSIZE", _WorkerRequest.GetServerVariable("CERT_KEYSIZE"));
\r
154 _oServerVariables.Add("CERT_SECRETKEYSIZE", _WorkerRequest.GetServerVariable("CERT_SECRETKEYSIZE"));
\r
155 _oServerVariables.Add("CERT_SERIALNUMBER", _WorkerRequest.GetServerVariable("CERT_SERIALNUMBER"));
\r
156 _oServerVariables.Add("CERT_SERVER_ISSUER", _WorkerRequest.GetServerVariable("CERT_SERVER_ISSUER"));
\r
157 _oServerVariables.Add("CERT_SERVER_SUBJECT", _WorkerRequest.GetServerVariable("CERT_SERVER_SUBJECT"));
\r
158 _oServerVariables.Add("CERT_SUBJECT", _WorkerRequest.GetServerVariable("CERT_SUBJECT"));
\r
160 _oServerVariables.Add("GATEWAY_INTERFACE", _WorkerRequest.GetServerVariable("GATEWAY_INTERFACE"));
\r
161 _oServerVariables.Add("HTTPS", _WorkerRequest.GetServerVariable("HTTPS"));
\r
162 _oServerVariables.Add("HTTPS_KEYSIZE", _WorkerRequest.GetServerVariable("HTTPS_KEYSIZE"));
\r
163 _oServerVariables.Add("HTTPS_SECRETKEYSIZE", _WorkerRequest.GetServerVariable("HTTPS_SECRETKEYSIZE"));
\r
165 _oServerVariables.Add("CONTENT_TYPE", ContentType);
\r
166 _oServerVariables.Add("HTTPS_SERVER_ISSUER", _WorkerRequest.GetServerVariable("HTTPS_SERVER_ISSUER"));
\r
167 _oServerVariables.Add("HTTPS_SERVER_SUBJECT", _WorkerRequest.GetServerVariable("HTTPS_SERVER_SUBJECT"));
\r
168 _oServerVariables.Add("INSTANCE_ID", _WorkerRequest.GetServerVariable("INSTANCE_ID"));
\r
169 _oServerVariables.Add("INSTANCE_META_PATH", _WorkerRequest.GetServerVariable("INSTANCE_META_PATH"));
\r
170 _oServerVariables.Add("LOCAL_ADDR", _WorkerRequest.GetLocalAddress());
\r
171 _oServerVariables.Add("REMOTE_ADDR", UserHostAddress);
\r
172 _oServerVariables.Add("REMOTE_HOST", UserHostName);
\r
173 _oServerVariables.Add("REQUEST_METHOD", HttpMethod);
\r
174 _oServerVariables.Add("SERVER_NAME", _WorkerRequest.GetServerName());
\r
175 _oServerVariables.Add("SERVER_PORT", _WorkerRequest.GetLocalPort().ToString());
\r
176 _oServerVariables.Add("SERVER_PROTOCOL", _WorkerRequest.GetHttpVersion());
\r
177 _oServerVariables.Add("SERVER_SOFTWARE", _WorkerRequest.GetServerVariable("SERVER_SOFTWARE"));
\r
179 if (_WorkerRequest.IsSecure()) {
\r
180 _oServerVariables.Add("SERVER_PORT_SECURE", "1");
\r
182 _oServerVariables.Add("SERVER_PORT_SECURE", "0");
\r
185 sTmp = _WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentLength);
\r
186 if (null != sTmp) {
\r
187 _oServerVariables.Add("CONTENT_LENGTH", sTmp);
\r
190 // TODO: Should be dynamic
\r
191 if (null != _oContext.User && _oContext.User.Identity.IsAuthenticated) {
\r
192 _oServerVariables.Add("AUTH_TYPE", _oContext.User.Identity.AuthenticationType);
\r
193 _oServerVariables.Add("AUTH_USER", _oContext.User.Identity.Name);
\r
195 _oServerVariables.Add("AUTH_TYPE", "");
\r
196 _oServerVariables.Add("AUTH_USER", "");
\r
199 _oServerVariables.Add("PATH_INFO", PathInfo);
\r
200 _oServerVariables.Add("PATH_TRANSLATED", PhysicalPath);
\r
201 _oServerVariables.Add("QUERY_STRING", QueryStringRaw);
\r
202 _oServerVariables.Add("SCRIPT_NAME", FilePath);
\r
205 _oServerVariables.MakeReadOnly();
\r
209 [MonoTODO("Handle multipart/form-data")]
\r
210 private void ParseFormData ()
\r
212 if (_oFormData != null)
\r
215 string contentType = ContentType;
\r
216 if (0 != String.Compare (contentType, "application/x-www-form-urlencoded", true)) {
\r
217 Console.WriteLine ("Content-Type -> {0} not supported", contentType);
\r
218 _oFormData = new HttpValueCollection ();
\r
222 byte [] arrData = GetRawContent ();
\r
223 Encoding enc = ContentEncoding;
\r
224 string data = enc.GetString (arrData);
\r
225 _oFormData = new HttpValueCollection (data, true, enc);
\r
228 [MonoTODO("void Dispose")]
\r
229 internal void Dispose() {
\r
232 private byte [] GetRawContent ()
\r
234 if (_arrRawContent != null)
\r
235 return _arrRawContent;
\r
237 if (null == _WorkerRequest) {
\r
238 if (QueryStringRaw == null)
\r
240 char [] q = QueryStringRaw.ToCharArray ();
\r
241 _arrRawContent = new byte [q.Length];
\r
242 for (int i = 0; i < q.Length; i++)
\r
243 _arrRawContent [i] = (byte) q [i];
\r
244 return _arrRawContent;
\r
247 _arrRawContent = _WorkerRequest.GetPreloadedEntityBody ();
\r
248 if (_arrRawContent == null)
\r
249 _arrRawContent = new byte [0];
\r
251 int length = ContentLength;
\r
252 if (_WorkerRequest.IsEntireEntityBodyIsPreloaded () || length <= _arrRawContent.Length)
\r
253 return _arrRawContent;
\r
255 byte [] arrBuffer = new byte [Math.Min (16384, length)];
\r
256 MemoryStream ms = new MemoryStream (arrBuffer.Length);
\r
257 ms.Write (_arrRawContent, 0, _arrRawContent.Length);
\r
259 for (int loaded = _arrRawContent.Length; loaded < length; loaded += read) {
\r
260 read = _WorkerRequest.ReadEntityBody (arrBuffer, arrBuffer.Length);
\r
264 ms.Write (arrBuffer, 0, read);
\r
267 _arrRawContent = ms.GetBuffer ();
\r
268 return _arrRawContent;
\r
271 public string [] AcceptTypes {
\r
273 if (null == _arrAcceptTypes && null != _WorkerRequest) {
\r
274 _arrAcceptTypes = HttpHelper.ParseMultiValueHeader(_WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderAccept));
\r
277 return _arrAcceptTypes;
\r
282 public string ApplicationPath {
\r
284 if (null != _WorkerRequest) {
\r
285 return _WorkerRequest.GetAppPath();
\r
292 public HttpBrowserCapabilities Browser {
\r
294 if (_browser == null)
\r
295 _browser = new HttpBrowserCapabilities ();
\r
300 set { _browser = value; }
\r
303 public HttpClientCertificate ClientCertificate {
\r
305 if (null == _ClientCert) {
\r
306 _ClientCert = new HttpClientCertificate(_oContext);
\r
309 return _ClientCert;
\r
313 private string GetValueFromHeader (string header, string attr)
\r
315 int where = header.IndexOf (attr + '=');
\r
319 where += attr.Length + 1;
\r
320 int max = header.Length;
\r
322 return String.Empty;
\r
324 char ending = header [where];
\r
328 int end = header.Substring (where + 1).IndexOf (ending);
\r
330 return (ending == '"') ? null : header.Substring (where);
\r
332 return header.Substring (where, end);
\r
335 public Encoding ContentEncoding
\r
338 if (_oContentEncoding == null) {
\r
339 if (_WorkerRequest != null &&
\r
340 (!_WorkerRequest.HasEntityBody () || ContentType != String.Empty)) {
\r
341 _oContentEncoding = WebEncoding.Encoding;
\r
344 charset = GetValueFromHeader (_sContentType, "charset");
\r
346 _oContentEncoding = Encoding.GetEncoding (charset);
\r
348 _oContentEncoding = WebEncoding.Encoding;
\r
353 return _oContentEncoding;
\r
357 _oContentEncoding = value;
\r
361 public int ContentLength {
\r
363 if (_iContentLength == -1 && null != _WorkerRequest) {
\r
364 string sLength = _WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentLength);
\r
365 if (sLength != null) {
\r
367 _iContentLength = Int32.Parse(sLength);
\r
374 if (_iContentLength < 0) {
\r
375 _iContentLength = 0;
\r
378 return _iContentLength;
\r
382 public string ContentType {
\r
384 if (null == _sContentType) {
\r
385 if (null != _WorkerRequest) {
\r
386 _sContentType = _WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentType);
\r
389 if (null == _sContentType) {
\r
390 _sContentType = string.Empty;
\r
394 return _sContentType;
\r
398 static private string GetCookieValue (string str, int length, ref int i)
\r
404 while (k < length && Char.IsWhiteSpace (str [k]))
\r
408 while (k < length && str [k] != ';')
\r
412 return str.Substring (begin, i - begin).Trim ();
\r
415 static private string GetCookieName (string str, int length, ref int i)
\r
421 while (k < length && Char.IsWhiteSpace (str [k]))
\r
425 while (k < length && str [k] != ';' && str [k] != '=')
\r
429 return str.Substring (begin, k - begin).Trim ();
\r
432 private void GetCookies ()
\r
434 string header = _WorkerRequest.GetKnownRequestHeader (HttpWorkerRequest.HeaderCookie);
\r
435 if (header == null || header.Length == 0)
\r
439 * cookie = "Cookie:" cookie-version
\r
440 * 1*((";" | ",") cookie-value)
\r
441 * cookie-value = NAME "=" VALUE [";" path] [";" domain]
\r
442 * cookie-version = "$Version" "=" value
\r
445 * path = "$Path" "=" value
\r
446 * domain = "$Domain" "=" value
\r
448 * MS ignores $Version!
\r
449 * ',' as a separator produces errors.
\r
452 cookies = new HttpCookieCollection (_oContext.Response, false);
\r
453 string [] name_values = header.Trim ().Split (';');
\r
454 int length = name_values.Length;
\r
455 HttpCookie cookie = null;
\r
457 for (int i = 0; i < length; i++) {
\r
459 string name_value = name_values [i].Trim ();
\r
460 string name = GetCookieName (name_value, name_value.Length, ref pos);
\r
461 string value = GetCookieValue (name_value, name_value.Length, ref pos);
\r
462 if (cookie != null) {
\r
463 if (name == "$Path") {
\r
464 cookie.Path = value;
\r
466 } else if (name == "$Domain") {
\r
467 cookie.Domain = value;
\r
470 cookies.Add (cookie);
\r
474 cookie = new HttpCookie (name, value);
\r
477 if (cookie != null)
\r
478 cookies.Add (cookie);
\r
481 public HttpCookieCollection Cookies
\r
484 if (cookies == null) {
\r
485 cookies = new HttpCookieCollection (null, false);
\r
486 if (_WorkerRequest != null)
\r
495 public string CurrentExecutionFilePath {
\r
497 throw new NotImplementedException();
\r
501 public string FilePath {
\r
503 if (null == _sFilePath && null != _WorkerRequest) {
\r
504 _sFilePath = _WorkerRequest.GetFilePath();
\r
512 public HttpFileCollection Files {
\r
514 throw new NotImplementedException();
\r
518 [MonoTODO("Use stream filter in the request stream")]
\r
519 public Stream Filter {
\r
521 throw new NotImplementedException();
\r
525 throw new NotImplementedException();
\r
530 public NameValueCollection Form {
\r
534 return (NameValueCollection) _oFormData;
\r
538 public NameValueCollection Headers {
\r
540 if (_oHeaders == null) {
\r
541 _oHeaders = new HttpValueCollection();
\r
543 if (null != _WorkerRequest) {
\r
544 string sHeaderValue;
\r
545 string sHeaderName;
\r
548 // Add all know headers
\r
549 for (; iCount != 40; iCount++) {
\r
550 sHeaderValue = _WorkerRequest.GetKnownRequestHeader(iCount);
\r
551 if (null != sHeaderValue && sHeaderValue.Length > 0) {
\r
552 sHeaderName = _WorkerRequest.GetKnownRequestHeader(iCount);
\r
553 if (null != sHeaderName && sHeaderName.Length > 0) {
\r
554 _oHeaders.Add(sHeaderName, sHeaderValue);
\r
559 // Get all other headers
\r
560 string [][] arrUnknownHeaders = _WorkerRequest.GetUnknownRequestHeaders();
\r
561 if (null != arrUnknownHeaders) {
\r
562 for (iCount = 0; iCount != arrUnknownHeaders.Length; iCount++) {
\r
563 _oHeaders.Add(arrUnknownHeaders[iCount][0], arrUnknownHeaders[iCount][1]);
\r
568 // Make headers read-only
\r
569 _oHeaders.MakeReadOnly();
\r
572 return (NameValueCollection) _oHeaders;
\r
576 public string HttpMethod {
\r
578 if (null == _sHttpMethod) {
\r
579 if (null != _WorkerRequest) {
\r
580 _sHttpMethod = _WorkerRequest.GetHttpVerbName().ToUpper();
\r
583 if (_sHttpMethod == null) {
\r
584 if (RequestType != null)
\r
585 _sHttpMethod = RequestType;
\r
587 _sHttpMethod = "GET";
\r
591 return _sHttpMethod;
\r
595 public Stream InputStream {
\r
597 if (_oInputStream == null) {
\r
598 byte [] arrInputData = GetRawContent ();
\r
600 if (null != arrInputData) {
\r
601 _oInputStream = new HttpRequestStream(arrInputData, 0, arrInputData.Length);
\r
603 _oInputStream = new HttpRequestStream(null, 0, 0);
\r
607 return _oInputStream;
\r
611 public bool IsAuthenticated {
\r
613 if (_oContext != null && _oContext.User != null && _oContext.User.Identity != null) {
\r
614 return _oContext.User.Identity.IsAuthenticated;
\r
621 public bool IsSecureConnection {
\r
623 if (null != _WorkerRequest) {
\r
624 return _WorkerRequest.IsSecure();
\r
631 [MonoTODO("Call item in querystring, form, cookie and servervariables")]
\r
632 public string this [string sKey] {
\r
634 throw new NotImplementedException();
\r
638 [MonoTODO("Add cookie collection to our Params collection via merge")]
\r
639 public NameValueCollection Params {
\r
641 if (_oParams == null) {
\r
642 _oParams = new HttpValueCollection();
\r
644 _oParams.Merge(QueryString);
\r
645 _oParams.Merge(Form);
\r
646 _oParams.Merge(ServerVariables);
\r
649 _oParams.MakeReadOnly();
\r
652 return (NameValueCollection) _oParams;
\r
656 public string Path {
\r
658 if (_sPath == null) {
\r
659 if (null != _WorkerRequest) {
\r
660 _sPath = _WorkerRequest.GetUriPath();
\r
663 if (_sPath == null) {
\r
664 _sPath = string.Empty;
\r
672 public string PathInfo {
\r
674 if (_sPathInfo == null) {
\r
675 if (null != _WorkerRequest) {
\r
676 _sPathInfo = _WorkerRequest.GetPathInfo();
\r
679 if (_sPathInfo == null) {
\r
680 _sPathInfo = string.Empty;
\r
688 public string PhysicalApplicationPath {
\r
690 if (null != _WorkerRequest) {
\r
691 return _WorkerRequest.GetAppPathTranslated();
\r
698 public string PhysicalPath {
\r
700 if (null != _WorkerRequest) {
\r
701 _sPathTranslated = _WorkerRequest.GetFilePathTranslated();
\r
702 if (null == _sPathTranslated) {
\r
703 _sPathTranslated = _WorkerRequest.MapPath(FilePath);
\r
707 return _sPathTranslated;
\r
711 public NameValueCollection QueryString {
\r
713 if (_oQueryString == null) {
\r
714 _oQueryString = new HttpValueCollection(QueryStringRaw, true,
\r
715 WebEncoding.Encoding);
\r
718 return _oQueryString;
\r
722 // Used to parse the querystring
\r
723 internal string QueryStringRaw {
\r
725 if (_sQueryStringRaw == null && null != _WorkerRequest) {
\r
726 byte [] arrQuerystringBytes = _WorkerRequest.GetQueryStringRawBytes();
\r
727 if (null != arrQuerystringBytes && arrQuerystringBytes.Length > 0) {
\r
728 _sQueryStringRaw = ContentEncoding.GetString(arrQuerystringBytes);
\r
730 _sQueryStringRaw = _WorkerRequest.GetQueryString();
\r
734 if (_sQueryStringRaw == null) {
\r
735 _sQueryStringRaw = string.Empty;
\r
738 return _sQueryStringRaw;
\r
742 public string RawUrl {
\r
744 if (null == _sRawUrl) {
\r
745 if (null != _WorkerRequest) {
\r
746 _sRawUrl = _WorkerRequest.GetRawUrl();
\r
749 if (QueryStringRaw != null && QueryStringRaw.Length > 0) {
\r
750 _sRawUrl = _sRawUrl + "?" + QueryStringRaw;
\r
759 public string RequestType {
\r
761 if (null == _sRequestType) {
\r
765 return _sRequestType;
\r
769 _sRequestType = value;
\r
774 public NameValueCollection ServerVariables {
\r
776 ParseServerVariables();
\r
778 return (NameValueCollection) _oServerVariables;
\r
782 public int TotalBytes {
\r
784 if (_iTotalBytes == -1) {
\r
785 if (null != InputStream) {
\r
786 _iTotalBytes = (int) InputStream.Length;
\r
792 return _iTotalBytes;
\r
798 if (null == _oUrl) {
\r
799 _oUrl = new Uri(RawUrl);
\r
806 public Uri UrlReferrer {
\r
808 if (null == _oUriReferrer && null != _WorkerRequest) {
\r
809 string sReferrer = _WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderReferer);
\r
810 if (null != sReferrer && sReferrer.Length > 0) {
\r
812 if (sReferrer.IndexOf("://") >= 0) {
\r
813 _oUriReferrer = new Uri(sReferrer);
\r
815 _oUriReferrer = new Uri(this.Url, sReferrer);
\r
818 catch (Exception) {
\r
823 return _oUriReferrer;
\r
827 public string UserAgent {
\r
829 if (_sUserAgent == null && _WorkerRequest != null) {
\r
830 _sUserAgent = _WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderUserAgent);
\r
833 if (_sUserAgent == null) {
\r
834 _sUserAgent = string.Empty;
\r
837 return _sUserAgent;
\r
841 public string UserHostAddress {
\r
843 if (_sUserHostAddress == null && null != _WorkerRequest) {
\r
844 _sUserHostAddress = _WorkerRequest.GetRemoteAddress();
\r
847 if (_sUserHostAddress == null || _sUserHostAddress.Length == 0) {
\r
848 _sUserHostAddress = "127.0.0.1";
\r
851 return _sUserHostAddress;
\r
855 public string UserHostName {
\r
857 if (_sUserHostName == null && null != _WorkerRequest) {
\r
858 _sUserHostName = _WorkerRequest.GetRemoteName();
\r
861 if (_sUserHostName == null || _sUserHostName.Length == 0) {
\r
862 _sUserHostName = UserHostAddress;
\r
865 return _sUserHostName;
\r
869 public string [] UserLanguages {
\r
871 if (_arrUserLanguages == null && null != _WorkerRequest) {
\r
872 _arrUserLanguages = HttpHelper.ParseMultiValueHeader(_WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderAcceptLanguage));
\r
875 return _arrUserLanguages;
\r
879 public byte [] BinaryRead(int count) {
\r
880 int iSize = TotalBytes;
\r
882 throw new ArgumentException();
\r
885 byte [] arrData = new byte[iSize];
\r
887 int iRetSize = InputStream.Read(arrData, 0, iSize);
\r
888 if (iRetSize != iSize) {
\r
889 byte [] tmpData = new byte[iRetSize];
\r
890 if (iRetSize > 0) {
\r
891 Array.Copy(arrData, 0, tmpData, 0, iRetSize);
\r
900 public int [] MapImageCoordinates(string ImageFieldName) {
\r
901 NameValueCollection oItems;
\r
903 if (HttpMethod == "GET" || HttpMethod == "HEAD") {
\r
904 oItems = QueryString;
\r
905 } else if (HttpMethod == "POST") {
\r
911 int [] arrRet = null;
\r
913 string sX = oItems.Get(ImageFieldName + ".x");
\r
914 string sY = oItems.Get(ImageFieldName + ".y");
\r
916 if (null != sX && null != sY) {
\r
917 int [] arrTmp = new Int32[2];
\r
918 arrRet[0] = Int32.Parse(sX);
\r
919 arrRet[1] = Int32.Parse(sY);
\r
924 catch (Exception) {
\r
930 public string MapPath(string VirtualPath)
\r
932 return MapPath (VirtualPath, _sRequestRootVirtualDir, true);
\r
936 public string MapPath(string virtualPath, string baseVirtualDir, bool allowCrossAppMapping)
\r
938 if (_WorkerRequest == null)
\r
939 throw new HttpException ("No HttpWorkerRequest!!!");
\r
941 if (virtualPath == null || virtualPath.Length == 0)
\r
944 virtualPath = System.IO.Path.Combine (baseVirtualDir, virtualPath);
\r
945 return _WorkerRequest.MapPath (virtualPath);
\r
948 public void SaveAs(string filename, bool includeHeaders) {
\r
950 TextWriter oWriter;
\r
951 HttpRequestStream oData;
\r
953 oFile = new FileStream(filename, FileMode.CreateNew);
\r
954 if (includeHeaders) {
\r
955 oWriter = new StreamWriter(oFile);
\r
956 oWriter.Write(HttpMethod + " " + Path);
\r
958 if (QueryStringRaw != null && QueryStringRaw.Length > 0)
\r
959 oWriter.Write("?" + QueryStringRaw);
\r
960 if (_WorkerRequest != null) {
\r
961 oWriter.Write(" " + _WorkerRequest.GetHttpVersion() + "\r\n");
\r
962 oWriter.Write(GetAllHeaders(true));
\r
964 oWriter.Write("\r\n");
\r
967 oWriter.Write("\r\n");
\r
971 oData = (HttpRequestStream) InputStream;
\r
973 if (oData.DataLength > 0) {
\r
974 oFile.Write(oData.Data, oData.DataOffset, oData.DataLength);
\r