1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
//------------------------------------------------------------------------------
// <copyright file="WebServiceHandlerFactory.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Services.Protocols {
using System.Diagnostics;
using System;
using Microsoft.Win32;
//using System.Reflection;
using System.Web.UI;
using System.ComponentModel; // for CompModSwitches
using System.IO;
using System.Web.Services.Configuration;
using System.Security.Permissions;
using System.Threading;
using System.Web.Services.Diagnostics;
/// <include file='doc\WebServiceHandlerFactory.uex' path='docs/doc[@for="WebServiceHandlerFactory"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
[PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
public class WebServiceHandlerFactory : IHttpHandlerFactory {
/*
static WebServiceHandlerFactory() {
Stream stream = new FileStream("c:\\out.txt", FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite); //(FileMode.OpenOrCreate);
TraceListener listener = new TextWriterTraceListener(stream);
Debug.AutoFlush = true;
Debug.Listeners.Add(listener);
Debug.WriteLine("--------------");
}
*/
#if DEBUG
void DumpRequest(HttpContext context) {
HttpRequest request = context.Request;
Debug.WriteLine("Process Request called.");
Debug.WriteLine("Path = " + request.Path);
Debug.WriteLine("PhysicalPath = " + request.PhysicalPath);
Debug.WriteLine("Query = " + request.Url.Query);
Debug.WriteLine("HttpMethod = " + request.HttpMethod);
Debug.WriteLine("ContentType = " + request.ContentType);
Debug.WriteLine("PathInfo = " + request.PathInfo);
Debug.WriteLine("----Http request headers: ----");
System.Collections.Specialized.NameValueCollection headers = request.Headers;
foreach (string name in headers) {
string value = headers[name];
if (value != null && value.Length > 0)
Debug.WriteLine(name + "=" + headers[name]);
}
}
#endif
/// <include file='doc\WebServiceHandlerFactory.uex' path='docs/doc[@for="WebServiceHandlerFactory.GetHandler"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public IHttpHandler GetHandler(HttpContext context, string verb, string url, string filePath) {
TraceMethod method = Tracing.On ? new TraceMethod(this, "GetHandler") : null;
if (Tracing.On) Tracing.Enter("IHttpHandlerFactory.GetHandler", method, Tracing.Details(context.Request));
new AspNetHostingPermission(AspNetHostingPermissionLevel.Minimal).Demand();
//if (CompModSwitches.Remote.TraceVerbose) DumpRequest(context);
//System.Diagnostics.Debugger.Break();
#if DEBUG
if (CompModSwitches.Remote.TraceVerbose) DumpRequest(context);
#endif
Type type = GetCompiledType(url, context);
IHttpHandler handler = CoreGetHandler(type, context, context.Request, context.Response);
if (Tracing.On) Tracing.Exit("IHttpHandlerFactory.GetHandler", method);
return handler;
}
// Asserts security permission.
// Reason: System.Web.UI.WebServiceParser.GetCompiledType() demands SecurityPermission.
// Justification: The type returned is only used to get the IHttpHandler.
[SecurityPermission(SecurityAction.Assert, Unrestricted = true)]
private Type GetCompiledType(string url, HttpContext context)
{
return WebServiceParser.GetCompiledType(url, context);
}
internal IHttpHandler CoreGetHandler(Type type, HttpContext context, HttpRequest request, HttpResponse response) {
TraceMethod caller = Tracing.On ? new TraceMethod(this, "CoreGetHandler") : null;
ServerProtocolFactory[] protocolFactories = GetServerProtocolFactories();
ServerProtocol protocol = null;
bool abort = false;
for (int i = 0; i < protocolFactories.Length; i++) {
try {
protocol = protocolFactories[i].Create(type, context, request, response, out abort);
if ((protocol != null && protocol.GetType() != typeof(UnsupportedRequestProtocol)) || abort)
break;
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
throw;
}
throw Tracing.ExceptionThrow(caller, new InvalidOperationException(Res.GetString(Res.FailedToHandleRequest0), e));
}
}
if (abort)
return new NopHandler();
if (protocol == null) {
if (request.PathInfo != null && request.PathInfo.Length != 0) {
throw Tracing.ExceptionThrow(caller, new InvalidOperationException(Res.GetString(Res.WebUnrecognizedRequestFormatUrl,
new object[] { request.PathInfo })));
}
else {
throw Tracing.ExceptionThrow(caller, new InvalidOperationException(Res.GetString(Res.WebUnrecognizedRequestFormat)));
}
}
else if (protocol is UnsupportedRequestProtocol) {
throw Tracing.ExceptionThrow(caller, new HttpException(((UnsupportedRequestProtocol)protocol).HttpCode, Res.GetString(Res.WebUnrecognizedRequestFormat)));
}
bool isAsync = protocol.MethodInfo.IsAsync;
bool requiresSession = protocol.MethodAttribute.EnableSession;
if (isAsync) {
if (requiresSession) {
return new AsyncSessionHandler(protocol);
}
else {
return new AsyncSessionlessHandler(protocol);
}
}
else {
if (requiresSession) {
return new SyncSessionHandler(protocol);
}
else {
return new SyncSessionlessHandler(protocol);
}
}
}
// Asserts FullTrust permission.
// Justification: FullTrust is used only to create the objects of type SoapServerProtocolFactory and for nothing else.
[PermissionSet(SecurityAction.Assert, Name = "FullTrust")]
private ServerProtocolFactory[] GetServerProtocolFactories()
{
return WebServicesSection.Current.ServerProtocolFactories;
}
/// <include file='doc\WebServiceHandlerFactory.uex' path='docs/doc[@for="WebServiceHandlerFactory.ReleaseHandler"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void ReleaseHandler(IHttpHandler handler) {
}
}
internal class UnsupportedRequestProtocol : ServerProtocol {
int httpCode;
internal UnsupportedRequestProtocol(int httpCode) {
this.httpCode = httpCode;
}
internal int HttpCode { get { return httpCode; } }
internal override bool Initialize() { return true; }
internal override bool IsOneWay {
get { return false; }
}
internal override LogicalMethodInfo MethodInfo {
get { return null; }
}
internal override ServerType ServerType {
get { return null; }
}
internal override object[] ReadParameters() {
return new object[0];
}
internal override void WriteReturns(object[] returnValues, Stream outputStream) { }
internal override bool WriteException(Exception e, Stream outputStream) { return false; }
}
internal class NopHandler : IHttpHandler {
/// <include file='doc\WebServiceHandlerFactory.uex' path='docs/doc[@for="NopHandler.IsReusable"]/*' />
/// <devdoc>
/// IHttpHandler.IsReusable.
/// </devdoc>
public bool IsReusable {
get { return false; }
}
/// <include file='doc\WebServiceHandlerFactory.uex' path='docs/doc[@for="NopHandler.ProcessRequest"]/*' />
/// <devdoc>
/// IHttpHandler.ProcessRequest.
/// </devdoc>
public void ProcessRequest(HttpContext context) {
}
}
}
|
