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
|
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.Web;
namespace DotNetOpenId.Provider
{
/// <summary>
/// Represents any OpenId-protocol request that may come to the provider.
/// </summary>
[DebuggerDisplay("Mode: {Mode}, OpenId: {Protocol.Version}")]
abstract class Request : IRequest {
protected Request(OpenIdProvider provider) {
if (provider == null) throw new ArgumentNullException("provider");
Provider = provider;
Query = provider.Query;
Protocol = Protocol.Detect(Query);
IncomingExtensions = ExtensionArgumentsManager.CreateIncomingExtensions(Query);
OutgoingExtensions = ExtensionArgumentsManager.CreateOutgoingExtensions(Protocol);
}
/// <summary>
/// The detected protocol of the calling OpenId relying party.
/// </summary>
protected internal Protocol Protocol;
protected IDictionary<string, string> Query { get; private set; }
protected internal OpenIdProvider Provider { get; private set; }
internal abstract string Mode { get; }
/// <summary>
/// Extension arguments to pass to the Relying Party.
/// </summary>
protected ExtensionArgumentsManager OutgoingExtensions { get; private set; }
/// <summary>
/// Extension arguments received from the Relying Party.
/// </summary>
protected ExtensionArgumentsManager IncomingExtensions { get; private set; }
/// <summary>
/// Tests whether a given dictionary represents an incoming OpenId request.
/// </summary>
/// <param name="query">The name/value pairs in the querystring or Form submission. Cannot be null.</param>
/// <returns>True if the request is an OpenId request, false otherwise.</returns>
internal static bool IsOpenIdRequest(IDictionary<string, string> query) {
Debug.Assert(query != null);
Protocol protocol = Protocol.Detect(query);
foreach (string key in query.Keys) {
if (key.StartsWith(protocol.openid.Prefix, StringComparison.OrdinalIgnoreCase)) {
return true;
}
}
return false;
}
/// <summary>
/// Creates the appropriate Request-derived type based on the request dictionary.
/// </summary>
/// <param name="provider">The Provider instance that called this method.</param>
/// <returns>A Request-derived type appropriate for this stage in authentication.</returns>
internal static Request CreateRequest(OpenIdProvider provider) {
if (provider == null) throw new ArgumentNullException("provider");
Debug.Assert(provider.Protocol != null, "This should have been set already.");
string mode = Util.GetRequiredArg(provider.Query, provider.Protocol.openid.mode);
Request request;
try {
if (mode == provider.Protocol.Args.Mode.checkid_setup ||
mode == provider.Protocol.Args.Mode.checkid_immediate)
request = new CheckIdRequest(provider);
else if (mode == provider.Protocol.Args.Mode.check_authentication)
request = new CheckAuthRequest(provider);
else if (mode == provider.Protocol.Args.Mode.associate)
request = new AssociateRequest(provider);
else
throw new OpenIdException(string.Format(CultureInfo.CurrentCulture,
Strings.InvalidOpenIdQueryParameterValue, provider.Protocol.openid.mode,
mode), provider.Query);
} catch (OpenIdException ex) {
request = new FaultyRequest(provider, ex);
}
return request;
}
/// <summary>
/// Indicates whether this request has all the information necessary to formulate a response.
/// </summary>
public abstract bool IsResponseReady { get; }
internal abstract IEncodable CreateResponse();
/// <summary>
/// Called whenever a property changes that would cause the response to need to be
/// regenerated if it had already been generated.
/// </summary>
protected void InvalidateResponse() {
response = null;
}
Response response;
/// <summary>
/// The authentication response to be sent to the user agent or the calling
/// OpenId consumer.
/// </summary>
public Response Response {
get {
if (!IsResponseReady) throw new InvalidOperationException(Strings.ResponseNotReady);
if (response == null) {
var encodableResponse = CreateResponse();
EncodableResponse extendableResponse = encodableResponse as EncodableResponse;
if (extendableResponse != null) {
foreach (var pair in OutgoingExtensions.GetArgumentsToSend(false)) {
extendableResponse.Fields.Add(pair.Key, pair.Value);
extendableResponse.Signed.Add(pair.Key);
}
}
response = Provider.Encoder.Encode(encodableResponse);
}
return response;
}
}
IResponse IRequest.Response { get { return this.Response; } }
public void AddResponseExtension(DotNetOpenId.Extensions.IExtensionResponse extension) {
OutgoingExtensions.AddExtensionArguments(extension.TypeUri, extension.Serialize(this));
}
/// <summary>
/// Attempts to load an extension from an OpenId message.
/// </summary>
/// <param name="extension">The extension to attempt to load.</param>
/// <returns>
/// True if the extension was found in the message and successfully loaded.
/// False otherwise.
/// </returns>
bool getExtension(DotNetOpenId.Extensions.IExtensionRequest extension) {
var fields = IncomingExtensions.GetExtensionArguments(extension.TypeUri);
if (fields != null) {
// The extension was found using the preferred TypeUri.
return extension.Deserialize(fields, this, extension.TypeUri);
} else {
// The extension may still be found using secondary TypeUris.
if (extension.AdditionalSupportedTypeUris != null) {
foreach (string typeUri in extension.AdditionalSupportedTypeUris) {
fields = IncomingExtensions.GetExtensionArguments(typeUri);
if (fields != null) {
// We found one of the older ones.
return extension.Deserialize(fields, this, typeUri);
}
}
}
}
return false;
}
public T GetExtension<T>() where T : DotNetOpenId.Extensions.IExtensionRequest, new() {
T extension = new T();
return getExtension(extension) ? (T)extension : default(T);
}
public DotNetOpenId.Extensions.IExtensionRequest GetExtension(Type extensionType) {
if (extensionType == null) throw new ArgumentNullException("extensionType");
if (!typeof(DotNetOpenId.Extensions.IExtensionRequest).IsAssignableFrom(extensionType))
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
Strings.TypeMustImplementX, typeof(DotNetOpenId.Extensions.IExtensionRequest).FullName),
"extensionType");
var extension = (DotNetOpenId.Extensions.IExtensionRequest)Activator.CreateInstance(extensionType);
return getExtension(extension) ? extension : null;
}
public override string ToString() {
string returnString = @"Request.Mode = {0}";
return string.Format(CultureInfo.CurrentCulture, returnString, Mode);
}
}
}
|
