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
293 get { return _browser; }
\r
295 set { _browser = value; }
\r
298 public HttpClientCertificate ClientCertificate {
\r
300 if (null == _ClientCert) {
\r
301 _ClientCert = new HttpClientCertificate(_oContext);
\r
304 return _ClientCert;
\r
308 private string GetValueFromHeader (string header, string attr)
\r
310 int where = header.IndexOf (attr + '=');
\r
314 where += attr.Length + 1;
\r
315 int max = header.Length;
\r
317 return String.Empty;
\r
319 char ending = header [where];
\r
323 int end = header.Substring (where + 1).IndexOf (ending);
\r
325 return (ending == '"') ? null : header.Substring (where);
\r
327 return header.Substring (where, end);
\r
330 public Encoding ContentEncoding
\r
333 if (_oContentEncoding == null) {
\r
334 if (_WorkerRequest != null &&
\r
335 (!_WorkerRequest.HasEntityBody () || ContentType != String.Empty)) {
\r
336 _oContentEncoding = WebEncoding.Encoding;
\r
339 charset = GetValueFromHeader (_sContentType, "charset");
\r
341 _oContentEncoding = Encoding.GetEncoding (charset);
\r
343 _oContentEncoding = WebEncoding.Encoding;
\r
348 return _oContentEncoding;
\r
352 _oContentEncoding = value;
\r
356 public int ContentLength {
\r
358 if (_iContentLength == -1 && null != _WorkerRequest) {
\r
359 string sLength = _WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentLength);
\r
360 if (sLength != null) {
\r
362 _iContentLength = Int32.Parse(sLength);
\r
369 if (_iContentLength < 0) {
\r
370 _iContentLength = 0;
\r
373 return _iContentLength;
\r
377 public string ContentType {
\r
379 if (null == _sContentType) {
\r
380 if (null != _WorkerRequest) {
\r
381 _sContentType = _WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentType);
\r
384 if (null == _sContentType) {
\r
385 _sContentType = string.Empty;
\r
389 return _sContentType;
\r
393 static private string GetCookieValue (string str, int length, bool allowComma, ref int i)
\r
399 while (k < length && Char.IsWhiteSpace (str [k]))
\r
403 while (k < length && (str [k] != ';' || (allowComma && str [k] == ',')))
\r
407 return str.Substring (begin, i - begin).Trim ();
\r
410 static private string GetCookieName (string str, int length, ref int i)
\r
416 while (k < length && Char.IsWhiteSpace (str [k]))
\r
420 while (k < length && str [k] != ';' && str [k] != '=')
\r
424 return str.Substring (begin, k - begin).Trim ();
\r
427 private void GetCookies ()
\r
429 string header = _WorkerRequest.GetKnownRequestHeader (HttpWorkerRequest.HeaderCookie);
\r
430 if (header == null || header.Length == 0)
\r
434 * cookie = "Cookie:" cookie-version
\r
435 * 1*((";" | ",") cookie-value)
\r
436 * cookie-value = NAME "=" VALUE [";" path] [";" domain]
\r
437 * cookie-version = "$Version" "=" value
\r
440 * path = "$Path" "=" value
\r
441 * domain = "$Domain" "=" value
\r
443 * MS ignores $Version!
\r
444 * ',' as a separator produces errors.
\r
447 cookies = new HttpCookieCollection (_oContext.Response, false);
\r
448 string [] name_values = header.Trim ().Split (';');
\r
449 int length = name_values.Length;
\r
450 HttpCookie cookie = null;
\r
452 for (int i = 0; i < length; i++) {
\r
454 string name_value = name_values [i].Trim ();
\r
455 string name = GetCookieName (name_value, name_value.Length, ref pos);
\r
456 string value = GetCookieName (name_value, name_value.Length, ref pos);
\r
457 if (cookie != null) {
\r
458 if (name == "$Path") {
\r
459 cookie.Path = value;
\r
461 } else if (name == "$Domain") {
\r
462 cookie.Domain = value;
\r
465 cookies.Add (cookie);
\r
469 cookie = new HttpCookie (name, value);
\r
472 if (cookie != null)
\r
473 cookies.Add (cookie);
\r
476 public HttpCookieCollection Cookies
\r
479 if (cookies == null) {
\r
480 cookies = new HttpCookieCollection (null, false);
\r
481 if (_WorkerRequest != null)
\r
490 public string CurrentExecutionFilePath {
\r
492 throw new NotImplementedException();
\r
496 public string FilePath {
\r
498 if (null == _sFilePath && null != _WorkerRequest) {
\r
499 _sFilePath = _WorkerRequest.GetFilePath();
\r
507 public HttpFileCollection Files {
\r
509 throw new NotImplementedException();
\r
513 [MonoTODO("Use stream filter in the request stream")]
\r
514 public Stream Filter {
\r
516 throw new NotImplementedException();
\r
520 throw new NotImplementedException();
\r
525 public NameValueCollection Form {
\r
529 return (NameValueCollection) _oFormData;
\r
533 public NameValueCollection Headers {
\r
535 if (_oHeaders == null) {
\r
536 _oHeaders = new HttpValueCollection();
\r
538 if (null != _WorkerRequest) {
\r
539 string sHeaderValue;
\r
540 string sHeaderName;
\r
543 // Add all know headers
\r
544 for (; iCount != 40; iCount++) {
\r
545 sHeaderValue = _WorkerRequest.GetKnownRequestHeader(iCount);
\r
546 if (null != sHeaderValue && sHeaderValue.Length > 0) {
\r
547 sHeaderName = _WorkerRequest.GetKnownRequestHeader(iCount);
\r
548 if (null != sHeaderName && sHeaderName.Length > 0) {
\r
549 _oHeaders.Add(sHeaderName, sHeaderValue);
\r
554 // Get all other headers
\r
555 string [][] arrUnknownHeaders = _WorkerRequest.GetUnknownRequestHeaders();
\r
556 if (null != arrUnknownHeaders) {
\r
557 for (iCount = 0; iCount != arrUnknownHeaders.Length; iCount++) {
\r
558 _oHeaders.Add(arrUnknownHeaders[iCount][0], arrUnknownHeaders[iCount][1]);
\r
563 // Make headers read-only
\r
564 _oHeaders.MakeReadOnly();
\r
567 return (NameValueCollection) _oHeaders;
\r
571 public string HttpMethod {
\r
573 if (null == _sHttpMethod) {
\r
574 if (null != _WorkerRequest) {
\r
575 _sHttpMethod = _WorkerRequest.GetHttpVerbName().ToUpper();
\r
578 if (_sHttpMethod == null) {
\r
579 if (RequestType != null)
\r
580 _sHttpMethod = RequestType;
\r
582 _sHttpMethod = "GET";
\r
586 return _sHttpMethod;
\r
590 public Stream InputStream {
\r
592 if (_oInputStream == null) {
\r
593 byte [] arrInputData = GetRawContent ();
\r
595 if (null != arrInputData) {
\r
596 _oInputStream = new HttpRequestStream(arrInputData, 0, arrInputData.Length);
\r
598 _oInputStream = new HttpRequestStream(null, 0, 0);
\r
602 return _oInputStream;
\r
606 public bool IsAuthenticated {
\r
608 if (_oContext != null && _oContext.User != null && _oContext.User.Identity != null) {
\r
609 return _oContext.User.Identity.IsAuthenticated;
\r
616 public bool IsSecureConnection {
\r
618 if (null != _WorkerRequest) {
\r
619 return _WorkerRequest.IsSecure();
\r
626 [MonoTODO("Call item in querystring, form, cookie and servervariables")]
\r
627 public string this [string sKey] {
\r
629 throw new NotImplementedException();
\r
633 [MonoTODO("Add cookie collection to our Params collection via merge")]
\r
634 public NameValueCollection Params {
\r
636 if (_oParams == null) {
\r
637 _oParams = new HttpValueCollection();
\r
639 _oParams.Merge(QueryString);
\r
640 _oParams.Merge(Form);
\r
641 _oParams.Merge(ServerVariables);
\r
644 _oParams.MakeReadOnly();
\r
647 return (NameValueCollection) _oParams;
\r
651 public string Path {
\r
653 if (_sPath == null) {
\r
654 if (null != _WorkerRequest) {
\r
655 _sPath = _WorkerRequest.GetUriPath();
\r
658 if (_sPath == null) {
\r
659 _sPath = string.Empty;
\r
667 public string PathInfo {
\r
669 if (_sPathInfo == null) {
\r
670 if (null != _WorkerRequest) {
\r
671 _sPathInfo = _WorkerRequest.GetPathInfo();
\r
674 if (_sPathInfo == null) {
\r
675 _sPathInfo = string.Empty;
\r
683 public string PhysicalApplicationPath {
\r
685 if (null != _WorkerRequest) {
\r
686 return _WorkerRequest.GetAppPathTranslated();
\r
693 public string PhysicalPath {
\r
695 if (null != _WorkerRequest) {
\r
696 _sPathTranslated = _WorkerRequest.GetFilePathTranslated();
\r
697 if (null == _sPathTranslated) {
\r
698 _sPathTranslated = _WorkerRequest.MapPath(FilePath);
\r
702 return _sPathTranslated;
\r
706 public NameValueCollection QueryString {
\r
708 if (_oQueryString == null) {
\r
709 _oQueryString = new HttpValueCollection(QueryStringRaw, true,
\r
710 WebEncoding.Encoding);
\r
713 return _oQueryString;
\r
717 // Used to parse the querystring
\r
718 internal string QueryStringRaw {
\r
720 if (_sQueryStringRaw == null && null != _WorkerRequest) {
\r
721 byte [] arrQuerystringBytes = _WorkerRequest.GetQueryStringRawBytes();
\r
722 if (null != arrQuerystringBytes && arrQuerystringBytes.Length > 0) {
\r
723 _sQueryStringRaw = ContentEncoding.GetString(arrQuerystringBytes);
\r
725 _sQueryStringRaw = _WorkerRequest.GetQueryString();
\r
729 if (_sQueryStringRaw == null) {
\r
730 _sQueryStringRaw = string.Empty;
\r
733 return _sQueryStringRaw;
\r
737 public string RawUrl {
\r
739 if (null == _sRawUrl) {
\r
740 if (null != _WorkerRequest) {
\r
741 _sRawUrl = _WorkerRequest.GetRawUrl();
\r
744 if (QueryStringRaw != null && QueryStringRaw.Length > 0) {
\r
745 _sRawUrl = _sRawUrl + "?" + QueryStringRaw;
\r
754 public string RequestType {
\r
756 if (null == _sRequestType) {
\r
760 return _sRequestType;
\r
764 _sRequestType = value;
\r
769 public NameValueCollection ServerVariables {
\r
771 ParseServerVariables();
\r
773 return (NameValueCollection) _oServerVariables;
\r
777 public int TotalBytes {
\r
779 if (_iTotalBytes == -1) {
\r
780 if (null != InputStream) {
\r
781 _iTotalBytes = (int) InputStream.Length;
\r
787 return _iTotalBytes;
\r
793 if (null == _oUrl) {
\r
794 _oUrl = new Uri(RawUrl);
\r
801 public Uri UrlReferrer {
\r
803 if (null == _oUriReferrer && null != _WorkerRequest) {
\r
804 string sReferrer = _WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderReferer);
\r
805 if (null != sReferrer && sReferrer.Length > 0) {
\r
807 if (sReferrer.IndexOf("://") >= 0) {
\r
808 _oUriReferrer = new Uri(sReferrer);
\r
810 _oUriReferrer = new Uri(this.Url, sReferrer);
\r
813 catch (Exception) {
\r
818 return _oUriReferrer;
\r
822 public string UserAgent {
\r
824 if (_sUserAgent == null && _WorkerRequest != null) {
\r
825 _sUserAgent = _WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderUserAgent);
\r
828 if (_sUserAgent == null) {
\r
829 _sUserAgent = string.Empty;
\r
832 return _sUserAgent;
\r
836 public string UserHostAddress {
\r
838 if (_sUserHostAddress == null && null != _WorkerRequest) {
\r
839 _sUserHostAddress = _WorkerRequest.GetRemoteAddress();
\r
842 if (_sUserHostAddress == null || _sUserHostAddress.Length == 0) {
\r
843 _sUserHostAddress = "127.0.0.1";
\r
846 return _sUserHostAddress;
\r
850 public string UserHostName {
\r
852 if (_sUserHostName == null && null != _WorkerRequest) {
\r
853 _sUserHostName = _WorkerRequest.GetRemoteName();
\r
856 if (_sUserHostName == null || _sUserHostName.Length == 0) {
\r
857 _sUserHostName = UserHostAddress;
\r
860 return _sUserHostName;
\r
864 public string [] UserLanguages {
\r
866 if (_arrUserLanguages == null && null != _WorkerRequest) {
\r
867 _arrUserLanguages = HttpHelper.ParseMultiValueHeader(_WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderAcceptLanguage));
\r
870 return _arrUserLanguages;
\r
874 public byte [] BinaryRead(int count) {
\r
875 int iSize = TotalBytes;
\r
877 throw new ArgumentException();
\r
880 byte [] arrData = new byte[iSize];
\r
882 int iRetSize = InputStream.Read(arrData, 0, iSize);
\r
883 if (iRetSize != iSize) {
\r
884 byte [] tmpData = new byte[iRetSize];
\r
885 if (iRetSize > 0) {
\r
886 Array.Copy(arrData, 0, tmpData, 0, iRetSize);
\r
895 public int [] MapImageCoordinates(string ImageFieldName) {
\r
896 NameValueCollection oItems;
\r
898 if (HttpMethod == "GET" || HttpMethod == "HEAD") {
\r
899 oItems = QueryString;
\r
900 } else if (HttpMethod == "POST") {
\r
906 int [] arrRet = null;
\r
908 string sX = oItems.Get(ImageFieldName + ".x");
\r
909 string sY = oItems.Get(ImageFieldName + ".y");
\r
911 if (null != sX && null != sY) {
\r
912 int [] arrTmp = new Int32[2];
\r
913 arrRet[0] = Int32.Parse(sX);
\r
914 arrRet[1] = Int32.Parse(sY);
\r
919 catch (Exception) {
\r
925 public string MapPath(string VirtualPath)
\r
927 return MapPath (VirtualPath, _sRequestRootVirtualDir, true);
\r
931 public string MapPath(string virtualPath, string baseVirtualDir, bool allowCrossAppMapping)
\r
933 if (_WorkerRequest == null)
\r
934 throw new HttpException ("No HttpWorkerRequest!!!");
\r
936 if (virtualPath == null || virtualPath.Length == 0)
\r
939 virtualPath = System.IO.Path.Combine (baseVirtualDir, virtualPath);
\r
940 return _WorkerRequest.MapPath (virtualPath);
\r
943 public void SaveAs(string filename, bool includeHeaders) {
\r
945 TextWriter oWriter;
\r
946 HttpRequestStream oData;
\r
948 oFile = new FileStream(filename, FileMode.CreateNew);
\r
949 if (includeHeaders) {
\r
950 oWriter = new StreamWriter(oFile);
\r
951 oWriter.Write(HttpMethod + " " + Path);
\r
953 if (QueryStringRaw != null && QueryStringRaw.Length > 0)
\r
954 oWriter.Write("?" + QueryStringRaw);
\r
955 if (_WorkerRequest != null) {
\r
956 oWriter.Write(" " + _WorkerRequest.GetHttpVersion() + "\r\n");
\r
957 oWriter.Write(GetAllHeaders(true));
\r
959 oWriter.Write("\r\n");
\r
962 oWriter.Write("\r\n");
\r
966 oData = (HttpRequestStream) InputStream;
\r
968 if (oData.DataLength > 0) {
\r
969 oFile.Write(oData.Data, oData.DataOffset, oData.DataLength);
\r