protected virtual bool TryGetSharePointSiteUrlAndTitle(Uri collectionUrl, Guid webId, out Uri siteUrl, out string siteTitle, out Exception ex)
{
ex = null;
siteUrl = null;
siteTitle = string.Empty;
try
{
using (ClientContext clientContext = new ClientContext(collectionUrl))
{
TeamMailboxClientOperations.ConfigureClientContext(clientContext, this.credential, this.isOAuthCredential, this.enableHttpDebugProxy, 60000);
Site site = clientContext.Site;
Web web = site.OpenWebById(webId);
clientContext.Load <Web>(web, new Expression <Func <Web, object> >[]
{
(Web x) => x.Url,
(Web x) => x.Title
});
clientContext.ExecuteQuery();
string uriString = null;
if (MaintenanceSynchronizer.TryEscapeAndGetWellFormedUrl(web.Url, out uriString))
{
siteUrl = new Uri(uriString);
siteTitle = web.Title;
}
else
{
ex = new SharePointException(web.Url, ClientStrings.ErrorSharePointSiteHasNoValidUrl(web.Url));
}
}
}
catch (ClientRequestException ex2)
{
ex = ex2;
}
catch (ServerException ex3)
{
ex = ex3;
}
catch (TimeoutException ex4)
{
ex = ex4;
}
catch (IOException ex5)
{
ex = ex5;
}
catch (WebException ex6)
{
ex = ex6;
}
return(ex == null);
}
private XmlTextReader EndGetUsers(ICancelableAsyncResult asyncResult, out Exception exception)
{
try
{
exception = null;
DownloadResult downloadResult = this.httpClient.EndDownload(asyncResult);
if (!downloadResult.IsSucceeded)
{
WebException ex = downloadResult.Exception as WebException;
if (ex != null)
{
exception = new SharePointException((this.httpClient.LastKnownRequestedUri != null) ? this.httpClient.LastKnownRequestedUri.AbsoluteUri : string.Empty, ex, true);
}
else
{
exception = downloadResult.Exception;
}
}
else
{
if (downloadResult.ResponseStream == null)
{
exception = new SharePointException((this.httpClient.LastKnownRequestedUri != null) ? this.httpClient.LastKnownRequestedUri.AbsoluteUri : string.Empty, ServerStrings.ErrorTeamMailboxGetUsersNullResponse);
return(null);
}
downloadResult.ResponseStream.Position = 0L;
return(SafeXmlFactory.CreateSafeXmlTextReader(downloadResult.ResponseStream));
}
}
finally
{
if (this.httpSessionConfig.RequestStream != null)
{
this.httpSessionConfig.RequestStream.Flush();
this.httpSessionConfig.RequestStream.Dispose();
this.httpSessionConfig.RequestStream = null;
}
}
return(null);
}
private LinkSharePointSiteResult InternalLinkSharePointSite(Uri sharePointUrl, out string sharePointTeamMailboxKey, bool siteChecked, bool forceToUnlink)
{
LinkSharePointSiteResult linkSharePointSiteResult = LinkSharePointSiteResult.Success;
sharePointTeamMailboxKey = "N/A";
bool flag = sharePointUrl == null;
Uri uri = sharePointUrl ?? this.teamMailbox.SharePointUrl;
Exception ex = null;
if (flag)
{
if (this.teamMailbox.SharePointUrl == null)
{
return(LinkSharePointSiteResult.CurrentlyNotLinked);
}
sharePointUrl = this.teamMailbox.SharePointUrl;
}
try
{
using (ClientContext clientContext = new ClientContext(sharePointUrl.AbsoluteUri))
{
clientContext.RequestTimeout = 60000;
bool flag2;
TeamMailboxHelper.GetCredentialAndConfigureClientContext(this.actAsUser, this.actAsUserOrgId, clientContext, true, out flag2);
Web web = clientContext.Web;
clientContext.Load <Web>(web, new Expression <Func <Web, object> >[]
{
(Web x) => x.AllProperties,
(Web x) => (object)x.Id
});
Site site = clientContext.Site;
clientContext.Load <Site>(site, new Expression <Func <Site, object> >[]
{
(Site x) => x.Url
});
clientContext.ExecuteQuery();
if (!siteChecked && clientContext.ServerVersion.Major < 15)
{
return(LinkSharePointSiteResult.SPServerVersionNotCompatible);
}
string text = this.teamMailbox.PrimarySmtpAddress.ToString();
if (web.AllProperties.FieldValues.ContainsKey("ExchangeTeamMailboxEmailAddress"))
{
sharePointTeamMailboxKey = (string)web.AllProperties["ExchangeTeamMailboxEmailAddress"];
if (!string.Equals(text, sharePointTeamMailboxKey, StringComparison.OrdinalIgnoreCase))
{
linkSharePointSiteResult = LinkSharePointSiteResult.LinkedByOthers;
}
else if (flag)
{
web.AllProperties["ExchangeTeamMailboxEmailAddress"] = null;
web.Update();
clientContext.ExecuteQuery();
this.teamMailbox.SharePointUrl = null;
this.teamMailbox.SetSharePointSiteInfo(null, Guid.Empty);
this.teamMailbox.SharePointLinkedBy = null;
}
else
{
if (this.actAsUser.Id.Equals(this.teamMailbox.SharePointLinkedBy))
{
linkSharePointSiteResult = LinkSharePointSiteResult.AlreadyLinkedBySelf;
}
else
{
this.teamMailbox.SharePointLinkedBy = this.actAsUser.Id;
}
this.teamMailbox.SharePointUrl = sharePointUrl;
}
}
else if (flag)
{
this.teamMailbox.SharePointUrl = null;
this.teamMailbox.SetSharePointSiteInfo(null, Guid.Empty);
this.teamMailbox.SharePointLinkedBy = null;
}
else
{
Uri url = TeamMailbox.GetUrl(site.Url);
if (url == null)
{
throw new RecipientTaskException(Strings.ErrorSharePointSiteHasNoValidWebCollectionUrl(site.Url));
}
web.AllProperties["ExchangeTeamMailboxEmailAddress"] = text;
web.AllProperties["ExchangeTeamMailboxSharePointUrl"] = sharePointUrl.AbsoluteUri;
web.AllProperties["ExchangeTeamMailboxSiteID"] = web.Id.ToString();
web.AllProperties["ExchangeTeamMailboxSiteCollectionUrl"] = site.Url;
web.Update();
clientContext.ExecuteQuery();
this.teamMailbox.SharePointUrl = sharePointUrl;
this.teamMailbox.SetSharePointSiteInfo(url, web.Id);
this.teamMailbox.SharePointLinkedBy = this.actAsUser.Id;
}
}
}
catch (ClientRequestException ex2)
{
ex = new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(uri.AbsoluteUri, ex2.Message));
}
catch (ServerException ex3)
{
ex = new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSiteWithCorrelationId(uri.AbsoluteUri, ex3.Message, ex3.ServerErrorTraceCorrelationId));
}
catch (TimeoutException ex4)
{
ex = new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(uri.AbsoluteUri, ex4.Message));
}
catch (IOException ex5)
{
ex = new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(uri.AbsoluteUri, ex5.Message));
}
catch (WebException e)
{
SharePointException ex6 = new SharePointException(uri.AbsoluteUri, e, false);
ex = new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(uri.AbsoluteUri, ex6.DiagnosticInfo));
}
catch (FormatException ex7)
{
ex = new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(uri.AbsoluteUri, ex7.Message));
}
if (flag && forceToUnlink)
{
if (ex != null || linkSharePointSiteResult == LinkSharePointSiteResult.LinkedByOthers)
{
this.teamMailbox.SharePointUrl = null;
this.teamMailbox.SetSharePointSiteInfo(null, Guid.Empty);
this.teamMailbox.SharePointLinkedBy = null;
linkSharePointSiteResult = LinkSharePointSiteResult.Success;
}
}
else if (ex != null)
{
throw ex;
}
return(linkSharePointSiteResult);
}
internal static MultiValuedProperty <CultureInfo> CheckSharePointSite(SmtpAddress teamMailboxEmailAddress, ref Uri sharePointUrl, ADRawEntry actAsUser, OrganizationId actAsUserOrgId, ADUser executingUser, out SharePointMemberShip executingUserMembership, out Uri webCollectionUrl, out Guid webId)
{
MultiValuedProperty <CultureInfo> multiValuedProperty = new MultiValuedProperty <CultureInfo>();
executingUserMembership = SharePointMemberShip.Others;
try
{
using (ClientContext clientContext = new ClientContext(sharePointUrl.AbsoluteUri))
{
clientContext.RequestTimeout = 60000;
bool flag;
TeamMailboxHelper.GetCredentialAndConfigureClientContext(actAsUser, actAsUserOrgId, clientContext, true, out flag);
Web web = clientContext.Web;
clientContext.Load <Web>(web, new Expression <Func <Web, object> >[]
{
(Web x) => x.AllProperties,
(Web x) => x.Url,
(Web x) => (object)x.Language,
(Web x) => x.Features,
(Web x) => (object)x.Id
});
Feature byId = web.Features.GetById(new Guid("{502A2D54-6102-4757-AAA0-A90586106368}"));
clientContext.Load <Feature>(byId, new Expression <Func <Feature, object> > [0]);
Group associatedOwnerGroup = clientContext.Web.AssociatedOwnerGroup;
Group associatedMemberGroup = clientContext.Web.AssociatedMemberGroup;
clientContext.Load <UserCollection>(associatedOwnerGroup.Users, new Expression <Func <UserCollection, object> > [0]);
clientContext.Load <UserCollection>(associatedMemberGroup.Users, new Expression <Func <UserCollection, object> > [0]);
Site site = clientContext.Site;
clientContext.Load <Site>(site, new Expression <Func <Site, object> >[]
{
(Site x) => x.Url
});
bool flag2 = false;
try
{
clientContext.ExecuteQuery();
if (byId.ServerObjectIsNull != null)
{
flag2 = !byId.ServerObjectIsNull.Value;
}
}
catch (UnauthorizedAccessException)
{
}
if (!flag2)
{
throw new RecipientTaskException(Strings.ErrorTeamMailboxFeatureNotInstalled(web.Url));
}
if (clientContext.ServerVersion.Major < 15)
{
throw new RecipientTaskException(Strings.ErrorTeamMailboxSharePointServerVersionInCompatible);
}
if (web.AllProperties.FieldValues.ContainsKey("ExchangeTeamMailboxEmailAddress") && (teamMailboxEmailAddress == SmtpAddress.Empty || !string.Equals(teamMailboxEmailAddress.ToString(), (string)web.AllProperties["ExchangeTeamMailboxEmailAddress"], StringComparison.OrdinalIgnoreCase)))
{
throw new RecipientTaskException(Strings.ErrorTeamMailboxSharePointSiteAlreadyLinkedWithOtherTM(sharePointUrl.ToString(), (string)web.AllProperties["ExchangeTeamMailboxEmailAddress"]));
}
webCollectionUrl = TeamMailbox.GetUrl(site.Url);
webId = web.Id;
if (webCollectionUrl == null)
{
throw new RecipientTaskException(Strings.ErrorSharePointSiteHasNoValidWebCollectionUrl(site.Url));
}
multiValuedProperty.Add(new CultureInfo((int)web.Language));
try
{
foreach (User spUser in associatedOwnerGroup.Users)
{
if (TeamMailboxHelper.ExchangeSharePointUserMatch(executingUser, spUser))
{
executingUserMembership = SharePointMemberShip.Owner;
break;
}
}
if (executingUserMembership == SharePointMemberShip.Others)
{
foreach (User spUser2 in associatedMemberGroup.Users)
{
if (TeamMailboxHelper.ExchangeSharePointUserMatch(executingUser, spUser2))
{
executingUserMembership = SharePointMemberShip.Member;
break;
}
}
}
}
catch (CollectionNotInitializedException)
{
executingUserMembership = SharePointMemberShip.Others;
}
string uriString = null;
if (!MaintenanceSynchronizer.TryEscapeAndGetWellFormedUrl(web.Url, out uriString))
{
throw new RecipientTaskException(Strings.ErrorSharePointSiteHasNoValidUrl(web.Url));
}
Uri uri = new Uri(uriString);
if (uri != sharePointUrl)
{
sharePointUrl = uri;
}
}
}
catch (ClientRequestException ex)
{
throw new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(sharePointUrl.AbsoluteUri, ex.Message));
}
catch (ServerException ex2)
{
throw new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSiteWithCorrelationId(sharePointUrl.AbsoluteUri, ex2.Message, ex2.ServerErrorTraceCorrelationId));
}
catch (TimeoutException ex3)
{
throw new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(sharePointUrl.AbsoluteUri, ex3.Message));
}
catch (IOException ex4)
{
throw new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(sharePointUrl.AbsoluteUri, ex4.Message));
}
catch (WebException e)
{
SharePointException ex5 = new SharePointException(sharePointUrl.AbsoluteUri, e, false);
throw new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(sharePointUrl.AbsoluteUri, ex5.DiagnosticInfo));
}
catch (FormatException ex6)
{
throw new RecipientTaskException(Strings.ErrorTeamMailboxContactSharePointSite(sharePointUrl.AbsoluteUri, ex6.Message));
}
return(multiValuedProperty);
}
protected virtual void OnGetDocumentLibraryListsComplete(IAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw new InvalidOperationException("OnGetDocumentLibraryListsComplete: asyncResult cannot be null here.");
}
ProtocolLog.LogInformation(this.loggingComponent, this.loggingContext, string.Format("SiteSynchronizer.BeginExecute", new object[0]));
bool flag = (base.SyncOption & SyncOption.CurrentDocumentLibsOnly) == SyncOption.CurrentDocumentLibsOnly;
Dictionary <Guid, List> dictionary = new Dictionary <Guid, List>();
if (!flag)
{
try
{
this.InitializeDocumentLibraryList(dictionary);
if (base.HandleShutDown())
{
return;
}
}
catch (WebException e)
{
SharePointException value = new SharePointException(this.siteUri.AbsoluteUri, e, false);
this.executionAsyncResult.InvokeCallback(value);
return;
}
catch (IOException value2)
{
this.executionAsyncResult.InvokeCallback(value2);
return;
}
catch (ClientRequestException value3)
{
this.executionAsyncResult.InvokeCallback(value3);
return;
}
catch (ServerException value4)
{
this.executionAsyncResult.InvokeCallback(value4);
return;
}
}
List <StoreObjectId> list = new List <StoreObjectId>();
List <List> list2 = new List <List>();
Dictionary <StoreObjectId, List> dictionary2 = new Dictionary <StoreObjectId, List>();
try
{
using (Folder folder = Folder.Bind(this.mailboxSession, DefaultFolderType.Root))
{
using (QueryResult queryResult = folder.FolderQuery(FolderQueryFlags.None, new ExistsFilter(FolderSchema.LinkedId), null, new PropertyDefinition[]
{
FolderSchema.LinkedId,
FolderSchema.Id,
FolderSchema.DisplayName,
FolderSchema.LinkedUrl,
FolderSchema.LinkedSiteAuthorityUrl
}))
{
object[][] rows;
do
{
rows = queryResult.GetRows(10000);
for (int i = 0; i < rows.Length; i++)
{
Guid guid = (Guid)rows[i][0];
StoreObjectId objectId = ((VersionedId)rows[i][1]).ObjectId;
string a = rows[i][2] as string;
string text = rows[i][3] as string;
string text2 = rows[i][4] as string;
Uri uri = null;
if (!string.IsNullOrEmpty(text2))
{
uri = new Uri(text2);
}
if (string.IsNullOrEmpty(text))
{
this.executionAsyncResult.InvokeCallback(new ArgumentNullException("LinkedUrl is null for folder " + objectId.ToString()));
}
if (!flag)
{
List list3 = null;
if (dictionary.TryGetValue(guid, out list3))
{
if (!string.Equals(a, list3.Title, StringComparison.Ordinal) || (uri != null && !UriComparer.IsEqual(uri, this.siteUri)) || (this.Job.SyncOption & SyncOption.FullSync) == SyncOption.FullSync)
{
dictionary2[objectId] = dictionary[guid];
}
this.documentLibraryInfos.Enqueue(new DocumentLibraryInfo(objectId, list3.Id, list3.RootFolder.ServerRelativeUrl));
dictionary.Remove(guid);
}
else
{
list.Add(objectId);
}
}
else
{
this.documentLibraryInfos.Enqueue(new DocumentLibraryInfo(objectId, guid, new Uri(text).AbsolutePath));
}
}
}while (rows.Length != 0);
list2.AddRange(dictionary.Values);
}
if (list.Count > 0)
{
folder.DeleteObjects(DeleteItemFlags.HardDelete, list.ToArray());
}
foreach (KeyValuePair <StoreObjectId, List> keyValuePair in dictionary2)
{
if (base.HandleShutDown())
{
return;
}
using (Folder folder2 = Folder.Bind(this.mailboxSession, keyValuePair.Key))
{
Uri uri2 = new Uri(new Uri(this.siteUri.GetLeftPart(UriPartial.Authority)), keyValuePair.Value.RootFolder.ServerRelativeUrl);
bool flag2 = Utils.HasFolderUriChanged(folder2, uri2);
if (flag2)
{
folder2[FolderSchema.SharePointChangeToken] = string.Empty;
folder2[FolderSchema.LinkedUrl] = uri2.AbsoluteUri;
folder2[FolderSchema.LinkedSiteUrl] = this.siteUri.AbsoluteUri;
string valueOrDefault = folder2.PropertyBag.GetValueOrDefault <string>(FolderSchema.LinkedUrl, string.Empty);
ProtocolLog.LogInformation(this.loggingComponent, this.loggingContext, string.Format("SiteSynchronizer: Document Library URL has changed from {0} to {1}", valueOrDefault, uri2.AbsoluteUri));
}
folder2.DisplayName = keyValuePair.Value.Title;
folder2[FolderSchema.LinkedSiteAuthorityUrl] = this.siteUri.AbsoluteUri;
folder2.Save();
}
}
foreach (List list4 in list2)
{
if (base.HandleShutDown())
{
return;
}
using (Folder folder3 = Folder.Create(this.mailboxSession, folder.Id.ObjectId, StoreObjectType.ShortcutFolder, list4.Title, CreateMode.OpenIfExists))
{
folder3[FolderSchema.LinkedId] = list4.Id;
Uri uri3 = new Uri(new Uri(this.siteUri.GetLeftPart(UriPartial.Authority)), list4.RootFolder.ServerRelativeUrl);
folder3[FolderSchema.LinkedUrl] = uri3.AbsoluteUri;
folder3[FolderSchema.LinkedSiteUrl] = this.siteUri.AbsoluteUri;
folder3[FolderSchema.LinkedListId] = list4.Id;
folder3[FolderSchema.IsDocumentLibraryFolder] = true;
folder3[FolderSchema.LinkedSiteAuthorityUrl] = this.siteUri.AbsoluteUri;
folder3.Save();
folder3.Load();
ProtocolLog.LogInformation(this.loggingComponent, this.loggingContext, string.Format("SiteSynchronizer: Create or update top level document library Name:{0}, LinkedUrl: {1}, LinkedId {2}, ListId {3}", new object[]
{
folder3.DisplayName,
folder3[FolderSchema.LinkedUrl],
folder3[FolderSchema.LinkedId],
folder3[FolderSchema.LinkedListId]
}));
this.documentLibraryInfos.Enqueue(new DocumentLibraryInfo(folder3.Id.ObjectId, list4.Id, list4.RootFolder.ServerRelativeUrl));
}
}
}
base.SyncResult = this.documentLibraryInfos;
this.executionAsyncResult.InvokeCallback(null);
}
catch (StorageTransientException value5)
{
this.executionAsyncResult.InvokeCallback(value5);
}
catch (StoragePermanentException value6)
{
this.executionAsyncResult.InvokeCallback(value6);
}
}
protected override void InternalProcessRecord()
{
ValidationResultCollector validationResultCollector = new ValidationResultCollector();
LocalConfiguration localConfiguration = LocalConfiguration.Load(validationResultCollector);
foreach (ValidationResultNode sendToPipeline in validationResultCollector.Results)
{
base.WriteObject(sendToPipeline);
}
SharePointException ex = null;
Uri uri = this.SharePointUrl ?? this.tmADObject.SharePointUrl;
OAuthCredentials oauthCredentials = null;
try
{
using (ClientContext clientContext = new ClientContext(uri))
{
bool flag = false;
ICredentials credentialAndConfigureClientContext = TeamMailboxHelper.GetCredentialAndConfigureClientContext(this.requestor, (this.requestor != null) ? this.requestor.OrganizationId : base.CurrentOrganizationId, clientContext, this.UseAppTokenOnly, out flag);
if (!flag)
{
base.WriteError(new InvalidOperationException(Strings.OauthIsTurnedOff), ErrorCategory.InvalidOperation, null);
}
oauthCredentials = (credentialAndConfigureClientContext as OAuthCredentials);
oauthCredentials.Tracer = new TestSiteMailbox.TaskOauthOutboundTracer();
oauthCredentials.LocalConfiguration = localConfiguration;
Web web = clientContext.Web;
clientContext.Load <Web>(web, new Expression <Func <Web, object> > [0]);
clientContext.ExecuteQuery();
}
}
catch (ClientRequestException e)
{
ex = new SharePointException(uri.AbsoluteUri, e);
}
catch (ServerException e2)
{
ex = new SharePointException(uri.AbsoluteUri, e2);
}
catch (IOException ex2)
{
ex = new SharePointException(uri.AbsoluteUri, new LocalizedString(ex2.Message));
}
catch (WebException e3)
{
ex = new SharePointException(uri.AbsoluteUri, e3, true);
}
if (ex != null)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine(Strings.TestTeamMailboxOutboundOauthLog);
stringBuilder.AppendLine(oauthCredentials.Tracer.ToString());
stringBuilder.AppendLine(Strings.TestTeamMailboxSharePointResponseDetails);
stringBuilder.AppendLine(ex.DiagnosticInfo);
ValidationResultNode sendToPipeline2 = new ValidationResultNode(Strings.TestTeamMailboxSharepointCallUnderOauthTask, new LocalizedString(stringBuilder.ToString()), ResultType.Error);
base.WriteObject(sendToPipeline2);
return;
}
StringBuilder stringBuilder2 = new StringBuilder();
stringBuilder2.AppendLine(Strings.TestTeamMailboxSharepointCallUnderOauthSuccess(uri.AbsoluteUri));
stringBuilder2.AppendLine(Strings.TestTeamMailboxOutboundOauthLog);
stringBuilder2.AppendLine(oauthCredentials.Tracer.ToString());
ValidationResultNode sendToPipeline3 = new ValidationResultNode(Strings.TestTeamMailboxSharepointCallUnderOauthTask, new LocalizedString(stringBuilder2.ToString()), ResultType.Success);
base.WriteObject(sendToPipeline3);
}
private bool UpdateAccessTokenIfNeeded(Uri sharepointUrl, ExchangePrincipal siteMailbox, ICredentials accessingUserCredential, ClientSecurityContext accessingUserSecurityContext, int sessionHashCode, out Exception exception, bool isTest = false)
{
exception = null;
if (siteMailbox == null)
{
throw new ArgumentNullException("siteMailbox");
}
if (accessingUserSecurityContext == null)
{
throw new ArgumentNullException("accessingUserSecurityContext");
}
if (sharepointUrl == null)
{
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug <string>((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Skip site mailbox {0} because its Sharepoint URL is null", siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString());
return(false);
}
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug <ClientSecurityContext, string, string>((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Entered with user {0}, site mailbox {1}, URL {2}", accessingUserSecurityContext, siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString(), sharepointUrl.AbsoluteUri);
LoggingContext loggingContext = new LoggingContext(siteMailbox.MailboxInfo.MailboxGuid, sharepointUrl.AbsoluteUri, accessingUserSecurityContext.ToString(), null);
AccessState accessState = AccessState.Denied;
bool flag = false;
SharepointAccessManager.Key key = this.GetKey(accessingUserSecurityContext.UserSid, siteMailbox.MailboxInfo.MailboxGuid);
if (!SharepointAccessManager.Instance.TryGetValue(key, out accessState))
{
flag = true;
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Cache miss, query Sharepoint");
SharepointAccessManager.PermissionCheckerClient permissionCheckerClient = new SharepointAccessManager.PermissionCheckerClient(sessionHashCode, siteMailbox.MailboxInfo.MailboxGuid, sharepointUrl.AbsoluteUri, accessingUserSecurityContext.UserSid, key, accessingUserCredential, this.requestTimeout, this.requestThroughLocalProxy, isTest);
LazyAsyncResult lazyAsyncResult = (LazyAsyncResult)permissionCheckerClient.BeginExecute(new AsyncCallback(SharepointAccessManager.OnCheckComplete), permissionCheckerClient);
int num = (int)this.synchronousWaitTimeout.TotalSeconds * 2;
int num2 = 0;
while (!lazyAsyncResult.IsCompleted || lazyAsyncResult.Result == null)
{
Thread.Sleep(500);
num2++;
if (num2 > num)
{
break;
}
}
object result = lazyAsyncResult.Result;
if (!(result is AccessState))
{
exception = ((lazyAsyncResult.Result is Exception) ? (lazyAsyncResult.Result as Exception) : new TimeoutException("Timed out"));
WebException ex = exception as WebException;
if (ex != null)
{
SharePointException exception2 = new SharePointException(sharepointUrl.AbsoluteUri, ex, false);
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceError <WebExceptionStatus, string, Exception>((long)permissionCheckerClient.SessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Query failed with WebException. Status: {0}, Message: {1}, InnerException: {2}", ex.Status, ex.Message, ex.InnerException);
ProtocolLog.LogError(ProtocolLog.Component.SharepointAccessManager, loggingContext, "Query failed with SharePointException", exception2);
}
else
{
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceError <Type, string, Exception>((long)permissionCheckerClient.SessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Query failed with {0}, Message: {1}, InnerException: {2}", exception.GetType(), exception.Message, exception.InnerException);
ProtocolLog.LogError(ProtocolLog.Component.SharepointAccessManager, loggingContext, string.Format("Query failed with {0}", exception.GetType()), exception);
}
return(false);
}
accessState = (AccessState)result;
}
else if (accessState == AccessState.Pending)
{
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Skip because there is an pending request");
return(true);
}
if (accessState == AccessState.Allowed)
{
if (!accessingUserSecurityContext.AddGroupSids(new SidBinaryAndAttributes[]
{
new SidBinaryAndAttributes(WellKnownSids.SiteMailboxGrantedAccessMembers, 4U)
}))
{
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceError((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Failed to add SiteMailboxGrantedAccessMembers group sid to access token");
return(false);
}
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug <ClientSecurityContext, string, string>((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Access is allowed for user {0}, site mailbox {1}, URL {2}", accessingUserSecurityContext, siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString(), sharepointUrl.AbsoluteUri);
if (flag)
{
ProtocolLog.LogInformation(ProtocolLog.Component.SharepointAccessManager, loggingContext, string.Format("Allow access for site mailbox {0}, URL {1}", siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString(), sharepointUrl));
}
}
else if (flag)
{
ProtocolLog.LogInformation(ProtocolLog.Component.SharepointAccessManager, loggingContext, string.Format("Deny access for site mailbox {0}, URL {1}", siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString(), sharepointUrl));
}
return(true);
}
private void OnInternalQueryComplete(ICancelableAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw new InvalidOperationException("OnInternalQueryComplete: asyncResult cannot be null.");
}
try
{
Exception ex = null;
DownloadResult downloadResult = this.httpClient.EndDownload(asyncResult);
if (!downloadResult.IsSucceeded)
{
ex = downloadResult.Exception;
}
if (downloadResult.ResponseStream == null && ex == null)
{
ex = new SharePointException((this.httpClient.LastKnownRequestedUri != null) ? this.httpClient.LastKnownRequestedUri.AbsoluteUri : string.Empty, new LocalizedString("Response is empty. The user probably doesn't have permission"));
}
if (ex != null)
{
this.executionAsyncResult.InvokeCallback(ex);
}
else
{
downloadResult.ResponseStream.Position = 0L;
long num = 0L;
try
{
using (XmlTextReader xmlTextReader = new XmlTextReader(downloadResult.ResponseStream))
{
xmlTextReader.ReadToFollowing("d:High");
long num2 = xmlTextReader.ReadElementContentAsLong();
long num3 = xmlTextReader.ReadElementContentAsLong();
num = (num2 << 32) + num3;
}
}
catch (XmlException value)
{
this.executionAsyncResult.InvokeCallback(value);
return;
}
catch (DirectoryNotFoundException value2)
{
this.executionAsyncResult.InvokeCallback(value2);
return;
}
catch (WebException value3)
{
this.executionAsyncResult.InvokeCallback(value3);
return;
}
AccessState accessState = ((num & 47L) == 47L) ? AccessState.Allowed : AccessState.Denied;
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug <long>((long)this.SessionHashCode, "PermissionCheckerClient.OnInternalQueryComplete: Permission bits retured by Sharepoint is {0}", num);
this.executionAsyncResult.InvokeCallback(accessState);
}
}
finally
{
this.Cleanup();
}
}
