/// <summary>sets up the correct credentials for this call, pending
/// security scheme</summary>
protected override void EnsureCredentials()
{
Tracing.Assert(this.Request != null, "We should have a webrequest now");
if (this.Request == null)
{
return;
}
// if the token is NULL, we need to get a token.
if (this.factory.GAuthToken == null)
{
// we will take the standard credentials for that
GDataCredentials gc = this.Credentials;
Tracing.TraceMsg(gc == null ? "No Network credentials set" : "Network credentials found");
if (gc != null)
{
// only now we have something to do...
this.factory.GAuthToken = QueryAuthToken(gc);
}
}
if (this.factory.GAuthToken != null && this.factory.GAuthToken.Length > 0)
{
// Tracing.Assert(this.factory.GAuthToken != null, "We should have a token now");
Tracing.TraceMsg("Using auth token: " + this.factory.GAuthToken);
string strHeader = GoogleAuthentication.Header + this.factory.GAuthToken;
this.Request.Headers.Add(strHeader);
}
}
/// <summary>goes to the Google auth service, and gets a new auth token</summary>
/// <returns>the auth token, or NULL if none received</returns>
internal string QueryAuthToken(GDataCredentials gc)
{
Uri authHandler = null;
// need to copy this to a new object to avoid that people mix and match
// the old (factory) and the new (requestsettings) and get screwed. So
// copy the settings from the gc passed in and mix with the settings from the factory
GDataCredentials gdc = new GDataCredentials(gc.Username, gc.getPassword());
gdc.CaptchaToken = this.factory.CaptchaToken;
gdc.CaptchaAnswer = this.factory.CaptchaAnswer;
gdc.AccountType = gc.AccountType;
try
{
authHandler = new Uri(this.factory.Handler);
}
catch
{
throw new GDataRequestException("Invalid authentication handler URI given");
}
return(Utilities.QueryClientLoginToken(
gdc,
this.factory.Service,
this.factory.ApplicationName,
this.factory.KeepAlive,
this.factory.Proxy,
authHandler));
}
/// <summary>goes to the Google auth service, and gets a new auth token</summary>
/// <returns>the auth token, or NULL if none received</returns>
public static string QueryClientLoginToken(GDataCredentials gc,
string serviceName,
string applicationName,
bool fUseKeepAlive,
Uri clientLoginHandler)
{
return(QueryClientLoginToken(gc, serviceName, applicationName, fUseKeepAlive, null, clientLoginHandler));
}
/// <summary>
/// Sets the credentials of the user to authenticate requests
/// to the server.
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
public void setUserCredentials(String username, String password)
{
this.Credentials = new GDataCredentials(username, password);
}
/// <summary>
/// a constructor for client login use cases
/// </summary>
/// <param name="applicationName">The name of the application</param>
/// <param name="credentials">the user credentials</param>
/// <returns></returns>
public RequestSettings(string applicationName, GDataCredentials credentials)
{
this.authType = AuthenticationType.clientLogin;
this.applicationName = applicationName;
this.credentials = credentials;
}
/// <summary>Gets an authentication token for the current credentials</summary>
public string QueryAuthToken(GDataCredentials gc)
{
GDataGAuthRequest request = new GDataGAuthRequest(GDataRequestType.Query, null, this);
return(request.QueryAuthToken(gc));
}
/// <summary>goes to the Google auth service, and gets a new auth token</summary>
/// <returns>the auth token, or NULL if none received</returns>
public static string QueryClientLoginToken(GDataCredentials gc,
string serviceName,
string applicationName,
bool fUseKeepAlive,
IWebProxy proxyServer,
Uri clientLoginHandler)
{
Tracing.Assert(gc != null, "Do not call QueryAuthToken with no network credentials");
if (gc == null)
{
throw new System.ArgumentNullException("nc", "No credentials supplied");
}
HttpWebRequest authRequest = WebRequest.Create(clientLoginHandler) as HttpWebRequest;
authRequest.KeepAlive = fUseKeepAlive;
if (proxyServer != null)
{
authRequest.Proxy = proxyServer;
}
string accountType = GoogleAuthentication.AccountType;
if (!String.IsNullOrEmpty(gc.AccountType))
{
accountType += gc.AccountType;
}
else
{
accountType += GoogleAuthentication.AccountTypeDefault;
}
WebResponse authResponse = null;
HttpWebResponse response = null;
string authToken = null;
try
{
authRequest.ContentType = HttpFormPost.Encoding;
authRequest.Method = HttpMethods.Post;
ASCIIEncoding encoder = new ASCIIEncoding();
string user = gc.Username == null ? "" : gc.Username;
string pwd = gc.getPassword() == null ? "" : gc.getPassword();
// now enter the data in the stream
string postData = GoogleAuthentication.Email + "=" + Utilities.UriEncodeUnsafe(user) + "&";
postData += GoogleAuthentication.Password + "=" + Utilities.UriEncodeUnsafe(pwd) + "&";
postData += GoogleAuthentication.Source + "=" + Utilities.UriEncodeUnsafe(applicationName) + "&";
postData += GoogleAuthentication.Service + "=" + Utilities.UriEncodeUnsafe(serviceName) + "&";
if (gc.CaptchaAnswer != null)
{
postData += GoogleAuthentication.CaptchaAnswer + "=" + Utilities.UriEncodeUnsafe(gc.CaptchaAnswer) + "&";
}
if (gc.CaptchaToken != null)
{
postData += GoogleAuthentication.CaptchaToken + "=" + Utilities.UriEncodeUnsafe(gc.CaptchaToken) + "&";
}
postData += accountType;
byte[] encodedData = encoder.GetBytes(postData);
authRequest.ContentLength = encodedData.Length;
Stream requestStream = authRequest.GetRequestStream();
requestStream.Write(encodedData, 0, encodedData.Length);
requestStream.Close();
authResponse = authRequest.GetResponse();
response = authResponse as HttpWebResponse;
}
catch (WebException e)
{
response = e.Response as HttpWebResponse;
if (response == null)
{
Tracing.TraceMsg("QueryAuthtoken failed " + e.Status + " " + e.Message);
throw;
}
}
if (response != null)
{
// check the content type, it must be text
if (!response.ContentType.StartsWith(HttpFormPost.ReturnContentType))
{
throw new GDataRequestException("Execution of authentication request returned unexpected content type: " + response.ContentType, response);
}
TokenCollection tokens = Utilities.ParseStreamInTokenCollection(response.GetResponseStream());
authToken = Utilities.FindToken(tokens, GoogleAuthentication.AuthToken);
if (authToken == null)
{
throw Utilities.getAuthException(tokens, response);
}
// failsafe. if getAuthException did not catch an error...
int code = (int)response.StatusCode;
if (code != 200)
{
throw new GDataRequestException("Execution of authentication request returned unexpected result: " + code, response);
}
}
Tracing.Assert(authToken != null, "did not find an auth token in QueryAuthToken");
if (authResponse != null)
{
authResponse.Close();
}
return(authToken);
}
