Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

565 lines
19 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="RequestResponse.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Services.Protocols
{
using System.IO;
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Reflection;
using System.Threading;
using System.Text;
using System.Runtime.InteropServices;
using System.Net;
using System.Globalization;
using System.Diagnostics;
using System.Web.Services.Diagnostics;
internal class RequestResponseUtils
{
private RequestResponseUtils() { }
/*
internal static string UTF8StreamToString(Stream stream) {
long position = 0;
if (stream.CanSeek)
position = stream.Position;
StreamReader reader = new StreamReader(stream, new System.Text.UTF8Encoding());
string result = reader.ReadToEnd();
if (stream.CanSeek)
stream.Position = position;
return result;
}
*/
//
internal static Encoding GetEncoding(string contentType)
{
string charset = ContentType.GetCharset(contentType);
Encoding e = null;
try
{
if (charset != null && charset.Length > 0)
e = Encoding.GetEncoding(charset);
}
catch (Exception ex)
{
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, typeof(RequestResponseUtils), "GetEncoding", ex);
}
// default to ASCII encoding per RFC 2376/3023
return e == null ? new ASCIIEncoding() : e;
}
internal static Encoding GetEncoding2(string contentType)
{
// default to old text/* behavior for non-application base
if (!ContentType.IsApplication(contentType))
return GetEncoding(contentType);
string charset = ContentType.GetCharset(contentType);
Encoding e = null;
try
{
if (charset != null && charset.Length > 0)
e = Encoding.GetEncoding(charset);
}
catch (Exception ex)
{
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, typeof(RequestResponseUtils), "GetEncoding2", ex);
}
// no default per application/* mime type
return e;
}
internal static string ReadResponse(WebResponse response)
{
return ReadResponse(response, response.GetResponseStream());
}
internal static string ReadResponse(WebResponse response, Stream stream)
{
Encoding e = GetEncoding(response.ContentType);
if (e == null) e = Encoding.Default;
StreamReader reader = new StreamReader(stream, e, true);
try
{
return reader.ReadToEnd();
}
finally
{
stream.Close();
}
}
// used to copy an unbuffered stream to a buffered stream.
internal static Stream StreamToMemoryStream(Stream stream)
{
MemoryStream memoryStream = new MemoryStream(1024);
byte[] buffer = new byte[1024];
int count;
while ((count = stream.Read(buffer, 0, buffer.Length)) != 0)
{
memoryStream.Write(buffer, 0, count);
}
memoryStream.Position = 0;
return memoryStream;
}
internal static string CreateResponseExceptionString(WebResponse response)
{
return CreateResponseExceptionString(response, response.GetResponseStream());
}
internal static string CreateResponseExceptionString(WebResponse response, Stream stream)
{
if (response is HttpWebResponse)
{
HttpWebResponse httpResponse = (HttpWebResponse)response;
int statusCode = (int)httpResponse.StatusCode;
if (statusCode >= 400 && statusCode != 500)
return Res.GetString(Res.WebResponseKnownError, statusCode, httpResponse.StatusDescription);
}
//
string content = (stream != null) ? ReadResponse(response, stream) : string.Empty;
if (content.Length > 0)
{
content = HttpUtility.HtmlDecode(content);
StringBuilder sb = new StringBuilder();
sb.Append(Res.GetString(Res.WebResponseUnknownError));
sb.Append(Environment.NewLine);
sb.Append("--");
sb.Append(Environment.NewLine);
sb.Append(content);
sb.Append(Environment.NewLine);
sb.Append("--");
sb.Append(".");
return sb.ToString();
}
else
return Res.GetString(Res.WebResponseUnknownErrorEmptyBody);
}
internal static int GetBufferSize(int contentLength)
{
int bufferSize;
if (contentLength == -1)
bufferSize = 8000;
else if (contentLength <= 16000)
bufferSize = contentLength;
else
bufferSize = 16000;
return bufferSize;
}
static class HttpUtility
{
internal static string HtmlDecode(string s)
{
if (s == null)
return null;
// See if this string needs to be decoded at all. If no
// ampersands are found, then no special HTML-encoded chars
// are in the string.
if (s.IndexOf('&') < 0)
return s;
StringBuilder builder = new StringBuilder();
StringWriter writer = new StringWriter(builder, CultureInfo.InvariantCulture);
HtmlDecode(s, writer);
return builder.ToString();
}
private static char[] s_entityEndingChars = new char[] { ';', '&' };
public static void HtmlDecode(string s, TextWriter output)
{
if (s == null)
return;
if (s.IndexOf('&') < 0)
{
output.Write(s); // good as is
return;
}
int l = s.Length;
for (int i = 0; i < l; i++)
{
char ch = s[i];
if (ch == '&')
{
// We found a '&'. Now look for the next ';' or '&'. The idea is that
// if we find another '&' before finding a ';', then this is not an entity,
// and the next '&' might start a real entity (VSWhidbey 275184)
int index = s.IndexOfAny(s_entityEndingChars, i + 1);
if (index > 0 && s[index] == ';')
{
string entity = s.Substring(i + 1, index - i - 1);
if (entity.Length > 1 && entity[0] == '#')
{
try
{
// The # syntax can be in decimal or hex, e.g.
// &#229; --> decimal
// &#xE5; --> same char in hex
// See http://www.w3.org/TR/REC-html40/charset.html#entities
if (entity[1] == 'x' || entity[1] == 'X')
ch = (char)Int32.Parse(entity.Substring(2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
else
ch = (char)Int32.Parse(entity.Substring(1), CultureInfo.InvariantCulture);
i = index; // already looked at everything until semicolon
}
catch (System.FormatException e)
{
i++; //if the number isn't valid, ignore it
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, typeof(HttpUtility), "HtmlDecode", e);
}
catch (System.ArgumentException e)
{
i++; // if there is no number, ignore it.
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, typeof(HttpUtility), "HtmlDecode", e);
}
}
else
{
i = index; // already looked at everything until semicolon
char entityChar = HtmlEntities.Lookup(entity);
if (entityChar != (char)0)
{
ch = entityChar;
}
else
{
output.Write('&');
output.Write(entity);
output.Write(';');
continue;
}
}
}
}
output.Write(ch);
}
}
// helper class for lookup of HTML encoding entities
static class HtmlEntities
{
private static object _lookupLockObject = new object();
// The list is from http://www.w3.org/TR/REC-html40/sgml/entities.html
private static String[] _entitiesList = new String[] {
"\x0022-quot",
"\x0026-amp",
"\x003c-lt",
"\x003e-gt",
"\x00a0-nbsp",
"\x00a1-iexcl",
"\x00a2-cent",
"\x00a3-pound",
"\x00a4-curren",
"\x00a5-yen",
"\x00a6-brvbar",
"\x00a7-sect",
"\x00a8-uml",
"\x00a9-copy",
"\x00aa-ordf",
"\x00ab-laquo",
"\x00ac-not",
"\x00ad-shy",
"\x00ae-reg",
"\x00af-macr",
"\x00b0-deg",
"\x00b1-plusmn",
"\x00b2-sup2",
"\x00b3-sup3",
"\x00b4-acute",
"\x00b5-micro",
"\x00b6-para",
"\x00b7-middot",
"\x00b8-cedil",
"\x00b9-sup1",
"\x00ba-ordm",
"\x00bb-raquo",
"\x00bc-frac14",
"\x00bd-frac12",
"\x00be-frac34",
"\x00bf-iquest",
"\x00c0-Agrave",
"\x00c1-Aacute",
"\x00c2-Acirc",
"\x00c3-Atilde",
"\x00c4-Auml",
"\x00c5-Aring",
"\x00c6-AElig",
"\x00c7-Ccedil",
"\x00c8-Egrave",
"\x00c9-Eacute",
"\x00ca-Ecirc",
"\x00cb-Euml",
"\x00cc-Igrave",
"\x00cd-Iacute",
"\x00ce-Icirc",
"\x00cf-Iuml",
"\x00d0-ETH",
"\x00d1-Ntilde",
"\x00d2-Ograve",
"\x00d3-Oacute",
"\x00d4-Ocirc",
"\x00d5-Otilde",
"\x00d6-Ouml",
"\x00d7-times",
"\x00d8-Oslash",
"\x00d9-Ugrave",
"\x00da-Uacute",
"\x00db-Ucirc",
"\x00dc-Uuml",
"\x00dd-Yacute",
"\x00de-THORN",
"\x00df-szlig",
"\x00e0-agrave",
"\x00e1-aacute",
"\x00e2-acirc",
"\x00e3-atilde",
"\x00e4-auml",
"\x00e5-aring",
"\x00e6-aelig",
"\x00e7-ccedil",
"\x00e8-egrave",
"\x00e9-eacute",
"\x00ea-ecirc",
"\x00eb-euml",
"\x00ec-igrave",
"\x00ed-iacute",
"\x00ee-icirc",
"\x00ef-iuml",
"\x00f0-eth",
"\x00f1-ntilde",
"\x00f2-ograve",
"\x00f3-oacute",
"\x00f4-ocirc",
"\x00f5-otilde",
"\x00f6-ouml",
"\x00f7-divide",
"\x00f8-oslash",
"\x00f9-ugrave",
"\x00fa-uacute",
"\x00fb-ucirc",
"\x00fc-uuml",
"\x00fd-yacute",
"\x00fe-thorn",
"\x00ff-yuml",
"\x0152-OElig",
"\x0153-oelig",
"\x0160-Scaron",
"\x0161-scaron",
"\x0178-Yuml",
"\x0192-fnof",
"\x02c6-circ",
"\x02dc-tilde",
"\x0391-Alpha",
"\x0392-Beta",
"\x0393-Gamma",
"\x0394-Delta",
"\x0395-Epsilon",
"\x0396-Zeta",
"\x0397-Eta",
"\x0398-Theta",
"\x0399-Iota",
"\x039a-Kappa",
"\x039b-Lambda",
"\x039c-Mu",
"\x039d-Nu",
"\x039e-Xi",
"\x039f-Omicron",
"\x03a0-Pi",
"\x03a1-Rho",
"\x03a3-Sigma",
"\x03a4-Tau",
"\x03a5-Upsilon",
"\x03a6-Phi",
"\x03a7-Chi",
"\x03a8-Psi",
"\x03a9-Omega",
"\x03b1-alpha",
"\x03b2-beta",
"\x03b3-gamma",
"\x03b4-delta",
"\x03b5-epsilon",
"\x03b6-zeta",
"\x03b7-eta",
"\x03b8-theta",
"\x03b9-iota",
"\x03ba-kappa",
"\x03bb-lambda",
"\x03bc-mu",
"\x03bd-nu",
"\x03be-xi",
"\x03bf-omicron",
"\x03c0-pi",
"\x03c1-rho",
"\x03c2-sigmaf",
"\x03c3-sigma",
"\x03c4-tau",
"\x03c5-upsilon",
"\x03c6-phi",
"\x03c7-chi",
"\x03c8-psi",
"\x03c9-omega",
"\x03d1-thetasym",
"\x03d2-upsih",
"\x03d6-piv",
"\x2002-ensp",
"\x2003-emsp",
"\x2009-thinsp",
"\x200c-zwnj",
"\x200d-zwj",
"\x200e-lrm",
"\x200f-rlm",
"\x2013-ndash",
"\x2014-mdash",
"\x2018-lsquo",
"\x2019-rsquo",
"\x201a-sbquo",
"\x201c-ldquo",
"\x201d-rdquo",
"\x201e-bdquo",
"\x2020-dagger",
"\x2021-Dagger",
"\x2022-bull",
"\x2026-hellip",
"\x2030-permil",
"\x2032-prime",
"\x2033-Prime",
"\x2039-lsaquo",
"\x203a-rsaquo",
"\x203e-oline",
"\x2044-frasl",
"\x20ac-euro",
"\x2111-image",
"\x2118-weierp",
"\x211c-real",
"\x2122-trade",
"\x2135-alefsym",
"\x2190-larr",
"\x2191-uarr",
"\x2192-rarr",
"\x2193-darr",
"\x2194-harr",
"\x21b5-crarr",
"\x21d0-lArr",
"\x21d1-uArr",
"\x21d2-rArr",
"\x21d3-dArr",
"\x21d4-hArr",
"\x2200-forall",
"\x2202-part",
"\x2203-exist",
"\x2205-empty",
"\x2207-nabla",
"\x2208-isin",
"\x2209-notin",
"\x220b-ni",
"\x220f-prod",
"\x2211-sum",
"\x2212-minus",
"\x2217-lowast",
"\x221a-radic",
"\x221d-prop",
"\x221e-infin",
"\x2220-ang",
"\x2227-and",
"\x2228-or",
"\x2229-cap",
"\x222a-cup",
"\x222b-int",
"\x2234-there4",
"\x223c-sim",
"\x2245-cong",
"\x2248-asymp",
"\x2260-ne",
"\x2261-equiv",
"\x2264-le",
"\x2265-ge",
"\x2282-sub",
"\x2283-sup",
"\x2284-nsub",
"\x2286-sube",
"\x2287-supe",
"\x2295-oplus",
"\x2297-otimes",
"\x22a5-perp",
"\x22c5-sdot",
"\x2308-lceil",
"\x2309-rceil",
"\x230a-lfloor",
"\x230b-rfloor",
"\x2329-lang",
"\x232a-rang",
"\x25ca-loz",
"\x2660-spades",
"\x2663-clubs",
"\x2665-hearts",
"\x2666-diams",
};
// Double-checked locking pattern requires volatile for read/write synchronization
private static volatile Hashtable _entitiesLookupTable;
internal /*public*/ static char Lookup(String entity)
{
if (_entitiesLookupTable == null)
{
// populate hashtable on demand
lock (_lookupLockObject)
{
if (_entitiesLookupTable == null)
{
Hashtable t = new Hashtable();
foreach (String s in _entitiesList)
t[s.Substring(2)] = s[0]; // 1st char is the code, 2nd '-'
_entitiesLookupTable = t;
}
}
}
Object obj = _entitiesLookupTable[entity];
if (obj != null)
return (char)obj;
else
return (char)0;
}
}
}
}
}