private static void InitializeSmtpLatencyTracking(LatencyTracker latencyTracker)
{
if (Components.Configuration.ProcessTransportRole == ProcessTransportRole.MailboxSubmission)
{
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionSmtp, latencyTracker);
}
}
private static void EndSmtpLatencyTracking(LatencyTracker latencyTracker)
{
if (Components.Configuration.ProcessTransportRole == ProcessTransportRole.MailboxSubmission)
{
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionSmtp, LatencyComponent.SmtpSend, latencyTracker);
}
}
// Token: 0x0600143B RID: 5179 RVA: 0x0004A334 File Offset: 0x00048534
private static void SendAuthenticationDataToWinRM(HttpContext httpContext, UserToken userToken)
{
WinRMInfo winRMInfo = httpContext.Items["X-RemotePS-WinRMInfo"] as WinRMInfo;
if (ProxySecurityContextModule.NeedSendDataToWinRM(winRMInfo))
{
userToken.UniformCommonAccessToken();
if (winRMInfo != null && "New-PSSession".Equals(winRMInfo.Action, StringComparison.OrdinalIgnoreCase))
{
HttpLogger.SafeAppendGenericInfo("WinRMCAT", userToken.GetReadableCommonAccessToken());
}
LatencyTracker latencyTracker = HttpContext.Current.Items["Logging-HttpRequest-Latency"] as LatencyTracker;
using (WinRMDataSender winRMDataSender = new WinRMDataSender(httpContext, latencyTracker))
{
winRMDataSender.SessionId = winRMInfo.FomattedSessionId;
if (HttpLogger.ActivityScope != null)
{
Guid activityId = HttpLogger.ActivityScope.ActivityId;
winRMDataSender.RequestId = HttpLogger.ActivityScope.ActivityId.ToString();
}
winRMDataSender.UserToken = userToken;
winRMDataSender.Send();
}
}
}
// Token: 0x06000024 RID: 36 RVA: 0x000030E0 File Offset: 0x000012E0
public void HandleEvent(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item)
{
MailboxTransportSubmissionAssistant.IdentifyProbeMessage(mapiEvent);
Thread currentThread = Thread.CurrentThread;
try
{
Interlocked.Increment(ref this.concurrentEvents);
this.SubmissionsInProgress[currentThread] = new SubmissionsInProgress.Entry(ExDateTime.UtcNow, this.databaseInfo.Guid, mapiEvent);
using (new SenderGuidTraceFilter(this.databaseInfo.Guid, mapiEvent.MailboxGuid))
{
bool flag = true;
MailboxTransportSubmissionAssistant.LatencyRecord latencyRecord;
LatencyTracker latencyTracker;
if (MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.TryGetValue(mapiEvent.EventCounter, out latencyRecord))
{
MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.Remove(mapiEvent.EventCounter);
latencyTracker = latencyRecord.LatencyTracker;
LatencyTracker.EndTrackLatency(latencyRecord.LatencyComponent, latencyTracker, true);
flag = false;
}
else
{
latencyTracker = LatencyTracker.CreateInstance(LatencyComponent.MailboxTransportSubmissionService);
LatencyTracker.TrackPreProcessLatency(LatencyComponent.SubmissionAssistant, latencyTracker, mapiEvent.CreateTime);
}
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker);
string text = this.FormatMapiEventInfo(mapiEvent);
this.LogMapiEventIntoCrimsonChannelPeriodically(text);
this.SubmissionsInProgress[Thread.CurrentThread].LatencyTracker = latencyTracker;
if (MailboxTransportSubmissionAssistant.ShouldLogNotifyEvents && (flag || MailboxTransportSubmissionAssistant.ShouldLogTemporaryFailures))
{
LatencyFormatter latencyFormatter = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, mapiEvent.CreateTime, mapiEvent.CreateTime, true, false, false);
MsgTrackMapiSubmitInfo msgTrackInfo = new MsgTrackMapiSubmitInfo(text, null, string.Empty, StoreDriverSubmission.LocalIPAddress, Components.Configuration.LocalServer.TransportServer.Name, string.Empty, string.Empty, MailboxTransportSubmissionAssistant.ItemEntryId(mapiEvent), latencyFormatter.FormatAndUpdatePerfCounters(), null, false, true);
MessageTrackingLog.TrackNotify(msgTrackInfo, false);
}
MSExchangeSubmission.PendingSubmissions.Increment();
new HashSet <string>();
DateTime createTime = mapiEvent.CreateTime;
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePfdPass <int, Guid, long>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "PFD EMS {0} SubmitMail for mailbox {1} at entry {2}", 22427, mapiEvent.MailboxGuid, mapiEvent.EventCounter);
LatencyFormatter latencyFormatter2 = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, createTime, createTime, false, true, false);
bool isPublicFolder = mapiEvent.ExtendedEventFlags.HasFlag(MapiExtendedEventFlags.PublicFolderMailbox);
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker);
ISubmissionProvider submissionProvider = (ISubmissionProvider)Components.StoreDriverSubmission;
MailSubmissionResult mailSubmissionResult = submissionProvider.SubmitMessage(Components.Configuration.LocalServer.TransportServer.ExchangeLegacyDN, mapiEvent.MailboxGuid, this.databaseInfo.Guid, this.databaseInfo.DatabaseName, mapiEvent.EventCounter, mapiEvent.ItemEntryId, mapiEvent.ParentEntryId, Components.Configuration.LocalServer.TransportServer.Fqdn, new IPAddress(StoreDriverSubmission.LocalIPAddress.GetAddressBytes()), mapiEvent.CreateTime, isPublicFolder, (mapiEvent.TenantHint == null) ? null : TenantPartitionHint.FromPersistablePartitionHint(mapiEvent.TenantHint), latencyFormatter2.FormatAndUpdatePerfCounters(), MailboxTransportSubmissionService.QuarantineHandler, MailboxTransportSubmissionService.SubmissionPoisonHandler, latencyTracker);
MailSubmissionResult result = mailSubmissionResult;
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker);
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker);
this.LogAndUpdateCounters(mapiEvent, latencyTracker, createTime, result);
this.HandleEventError(mapiEvent, result, latencyTracker, text);
}
}
finally
{
MSExchangeSubmission.PendingSubmissions.Decrement();
Interlocked.Decrement(ref this.concurrentEvents);
this.SubmissionsInProgress.Remove(currentThread);
}
}
public void Load()
{
if (!this.isInitialized)
{
SubmissionConfiguration.components.Start(new Components.StopServiceHandler(SubmissionConfiguration.OnStopServiceBecauseOfFailure), false, false, true, true);
SubmissionConfiguration.components.Continue();
Components.StoreDriverSubmission.Continue();
LatencyTracker.Start(Components.TransportAppConfig.LatencyTracker, ProcessTransportRole.MailboxSubmission);
SubmissionConfiguration.StartSystemProbe();
this.isInitialized = true;
}
}
public void Load(IMbxDeliveryListener submitHandler)
{
if (!this.isInitialized)
{
DeliveryConfiguration.app.Load();
this.submitHandler = submitHandler;
this.ConstructComponentLoadTree();
DeliveryConfiguration.components.Start(new Components.StopServiceHandler(DeliveryConfiguration.OnStopServiceBecauseOfFailure), false, false, true, true);
DeliveryConfiguration.components.Continue();
MessageTrackingLog.Configure(Components.Configuration.LocalServer.TransportServer);
LatencyTracker.Start(Components.TransportAppConfig.LatencyTracker, ProcessTransportRole.MailboxDelivery);
this.isInitialized = true;
}
}
public WinRMDataSender(HttpContext context, LatencyTracker latencyTracker)
{
WinRMDataSender < > 4__this = this;
CoreLogger.ExecuteAndLog("WinRMDataSender.Ctor", true, null, null, delegate()
{
if (!WinRMDataExchangeHelper.IsExchangeDataUseAuthenticationType() && !WinRMDataExchangeHelper.IsExchangeDataUseNamedPipe())
{
throw new InvalidFlightingException();
}
if (context.User == null || context.User.Identity == null)
{
throw new ArgumentException("context.User and context.User.Identity should not be null.");
}
< > 4__this.httpContext = context;
// Token: 0x06000039 RID: 57 RVA: 0x00003A30 File Offset: 0x00001C30
private void LogAndUpdateCounters(MapiEvent mapiEvent, LatencyTracker latencyTracker, DateTime arrivalTime, MailSubmissionResult result)
{
LatencyFormatter latencyFormatter = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, arrivalTime, arrivalTime, true, false, true);
string text = latencyFormatter.FormatAndUpdatePerfCounters();
this.LogMessageTrackingInfo(result.RemoteHostName, StoreDriverSubmission.LocalIPAddress, Components.Configuration.LocalServer.TransportServer.Name, mapiEvent, result, text);
if (result.ErrorCode == 0U)
{
MailboxTransportSubmissionAssistant.IncrementSuccessfulSubmissionPerfmon();
if (MailboxTransportSubmissionService.StoreDriverTracer.IsMessageAMapiSubmitLAMProbe)
{
MailItemSubmitter.WriteLamNotificationEvent("EventHandled", text, result.MessageId, mapiEvent.MailboxGuid, MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeLamNotificationIdParts);
}
}
}
private void AddComponent(string serverName, string code, ushort latency)
{
if (this.components == null)
{
this.components = new LinkedList <LatencyComponent>();
}
LocalizedString fullName = LatencyTracker.GetFullName(code);
if (LocalizedString.Empty.Equals(fullName))
{
fullName = new LocalizedString(code);
}
LatencyComponent value = new LatencyComponent(serverName, code, fullName, latency, this.componentSequenceNumber++);
this.components.AddLast(value);
}
private void OpenStore()
{
if (this.mapiSubmissionInfo.IsPublicFolder)
{
base.StoreDriverTracer.StoreDriverSubmissionTracer.TracePfdPass <int, string>(base.StoreDriverTracer.MessageProbeActivityId, 0L, "PFD ESD {0} Opening public store on {1}", 29595, this.mapiSubmissionInfo.MailboxServerDN);
try
{
if (base.Context != null)
{
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionStoreOpenSession, base.Context.LatencyTracker);
}
base.Session = StoreProvider.OpenStore(this.mapiSubmissionInfo.GetOrganizationId(), this.mapiSubmissionInfo.MailboxGuid);
return;
}
finally
{
if (base.Context != null)
{
TimeSpan additionalLatency = LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionStoreOpenSession, base.Context.LatencyTracker);
base.Context.AddRpcLatency(additionalLatency, "Open session");
}
}
}
base.StoreDriverTracer.StoreDriverSubmissionTracer.TracePfdPass(base.StoreDriverTracer.MessageProbeActivityId, 0L, "PFD ESD {0} Opening mailbox {1} on {2},{3}", new object[]
{
17307,
this.mapiSubmissionInfo.MailboxGuid,
this.mapiSubmissionInfo.MdbGuid,
this.mapiSubmissionInfo.MailboxFqdn
});
ExDateTime dt = (base.Context == null) ? default(ExDateTime) : ExDateTime.UtcNow;
try
{
base.Session = StoreProvider.OpenStore(this.mapiSubmissionInfo.GetOrganizationId(), "DummyName", this.mapiSubmissionInfo.MailboxFqdn, this.mapiSubmissionInfo.MailboxServerDN, this.mapiSubmissionInfo.MailboxGuid, this.mapiSubmissionInfo.MdbGuid, this.mapiSubmissionInfo.GetSenderLocales(), this.mapiSubmissionInfo.GetAggregatedMailboxGuids());
}
finally
{
if (base.Context != null)
{
TimeSpan additionalLatency2 = ExDateTime.UtcNow - dt;
base.Context.AddRpcLatency(additionalLatency2, "Open session");
}
}
base.SetSessionTimeZone();
}
private void OnEndRequest(object sender, EventArgs e)
{
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[LoggingEndModule::OnEndRequest] Enter");
if (HttpLogger.LoggerNotDisposed)
{
try
{
HttpContext httpContext = HttpContext.Current;
HttpResponse response = httpContext.Response;
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.SubStatus, response.SubStatusCode);
CPUMemoryLogger.Log();
LatencyTracker latencyTracker = HttpContext.Current.Items["Logging-HttpRequest-Latency"] as LatencyTracker;
if (latencyTracker != null)
{
long num = latencyTracker.Stop();
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.TotalTime, num);
latencyTracker.PushLatencyDetailsToLog(null, null, delegate(string funcName, string totalLatency)
{
HttpLogger.SafeAppendColumn(RpsCommonMetadata.GenericLatency, funcName, totalLatency);
});
if (Constants.IsPowerShellWebService)
{
PswsPerfCounter.UpdatePerfCounter(num);
}
else
{
RPSPerfCounter.UpdateAverageRTCounter(num);
}
}
else
{
HttpLogger.SafeAppendColumn(RpsCommonMetadata.GenericLatency, "LatencyMissed", "httpRequestLatencyTracker is null");
}
HttpLogger.SafeAppendGenericInfo("OnEndRequest.End.ContentType", response.ContentType);
}
finally
{
if (HttpLogger.ActivityScope != null)
{
RequestMonitor.Instance.UnRegisterRequest(HttpLogger.ActivityScope.ActivityId);
}
HttpLogger.AsyncCommit(false);
}
}
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[LoggingEndModule::OnEndRequest] Exit");
}
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
base.DisposeMessageItem();
if (base.Session != null)
{
if (base.Context != null)
{
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionStoreDisposeSession, base.Context.LatencyTracker);
}
try
{
base.DisposeStoreSession();
}
finally
{
if (base.Context != null)
{
TimeSpan additionalLatency = LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionStoreDisposeSession, base.Context.LatencyTracker);
base.Context.AddRpcLatency(additionalLatency, "Session dispose");
}
}
}
if (base.Context != null)
{
MapiSubmissionInfo mapiSubmissionInfo = (MapiSubmissionInfo)base.Info;
base.StoreDriverTracer.MapiStoreDriverSubmissionTracer.TracePass(base.StoreDriverTracer.MessageProbeActivityId, 0L, "Event {0}, Mailbox {1}, Mdb {2}, RPC latency {4}", new object[]
{
mapiSubmissionInfo.EventCounter,
mapiSubmissionInfo.MailboxGuid,
mapiSubmissionInfo.MdbGuid,
base.Context.RpcLatency
});
}
}
}
finally
{
base.Dispose(disposing);
}
}
public SmtpMailItemResult Send(IReadOnlyMailItem readOnlyMailItem, bool useLocalHubOnly, TimeSpan waitTimeOut, ISmtpMailItemSenderNotifications notificationHandler)
{
if (readOnlyMailItem == null)
{
throw new ArgumentNullException("readOnlyMailItem");
}
IEnumerable <INextHopServer> enumerable;
if (useLocalHubOnly)
{
string text = SmtpMailItemSender.LocalFQDN;
bool flag = SmtpMailItemSender.IsFrontendAndHubColocatedServer;
if (string.IsNullOrEmpty(text))
{
throw new InvalidOperationException("Email is unable to be sent because the name of the local machine can not be detemined.");
}
enumerable = new List <INextHopServer>();
((List <INextHopServer>)enumerable).Add(new NextHopFqdn(text, flag));
}
else
{
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionHubSelector, readOnlyMailItem.LatencyTracker);
if (!Components.ProxyHubSelectorComponent.ProxyHubSelector.TrySelectHubServers(readOnlyMailItem, out enumerable))
{
throw new InvalidOperationException("Email is unable to be sent because Hub Selector didn't return any HUBs.");
}
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionHubSelector, readOnlyMailItem.LatencyTracker);
}
NextHopSolutionKey key = new NextHopSolutionKey(NextHopType.Empty, "MailboxTransportSubmissionInternalProxy", Guid.Empty);
SmtpMailItemResult smtpMailItemResult;
using (SmtpMailItemNextHopConnection smtpMailItemNextHopConnection = new SmtpMailItemNextHopConnection(key, readOnlyMailItem, notificationHandler))
{
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionSmtpOut, readOnlyMailItem.LatencyTracker);
Components.SmtpOutConnectionHandler.HandleProxyConnection(smtpMailItemNextHopConnection, enumerable, true, null);
smtpMailItemNextHopConnection.AckConnectionEvent.WaitOne(waitTimeOut);
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionSmtpOut, readOnlyMailItem.LatencyTracker);
smtpMailItemResult = smtpMailItemNextHopConnection.SmtpMailItemResult;
}
return(smtpMailItemResult);
}
// Token: 0x060012DD RID: 4829 RVA: 0x0003D4C8 File Offset: 0x0003B6C8
internal static T ExecuteWSManPluginAPI <T>(string funcName, bool throwException, bool trackLatency, T defaultReturnValue, Func <T> func)
{
ExWatson.IsExceptionInteresting isExceptionInteresting = null;
T result;
try
{
AuthZLogger.SafeAppendColumn(RpsCommonMetadata.GenericLatency, funcName, DateTime.UtcNow.ToString());
string funcName2 = funcName;
bool throwException2 = throwException;
LatencyTracker latencyTracker = trackLatency ? AuthZLogHelper.latencyTracker : null;
ExEventLog rbacEventLogger = AuthZLogHelper.RbacEventLogger;
ExEventLog.EventTuple tuple_RemotePSPublicAPIFailed = Microsoft.Exchange.Configuration.ObjectModel.EventLog.TaskEventLogConstants.Tuple_RemotePSPublicAPIFailed;
Trace publicPluginAPITracer = Microsoft.Exchange.Diagnostics.Components.Authorization.ExTraceGlobals.PublicPluginAPITracer;
if (isExceptionInteresting == null)
{
isExceptionInteresting = ((object ex) => AuthZPluginHelper.IsFatalException(ex as Exception));
}
result = Diagnostics.ExecuteAndLog <T>(funcName2, throwException2, latencyTracker, rbacEventLogger, tuple_RemotePSPublicAPIFailed, publicPluginAPITracer, isExceptionInteresting, delegate(Exception ex)
{
AuthZLogHelper.LogException(ex, funcName, throwException);
}, defaultReturnValue, () => AuthZLogHelper.HandleExceptionAndRetry <T>(funcName, func, throwException, defaultReturnValue));
}
catch (Exception ex)
{
string arg = (AuthZLogger.ActivityScope != null) ? AuthZLogger.ActivityScope.ActivityId.ToString() : null;
AuthZLogHelper.EndLogging(true);
Exception ex3;
string str = string.Format("[FailureCategory={0}] ", FailureCategory.AuthZ + "-" + ex3.GetType().Name);
string str2 = string.Format("[AuthZRequestId={0}]", arg);
LocalizedString message = new LocalizedString(str2 + str + ex3.Message);
AuthorizationException ex2 = new AuthorizationException(message, ex3);
throw ex2;
}
return(result);
}
// Token: 0x060000D4 RID: 212 RVA: 0x00005FE8 File Offset: 0x000041E8
private void OnBeginRequest(object sender, EventArgs e)
{
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[LoggingStartModule::OnBeginRequest] Enter");
LatencyTracker latencyTracker = new LatencyTracker(Constants.IsPowerShellWebService ? "Psws.HttpModule" : "Rps.HttpModule", null);
latencyTracker.Start();
HttpContext httpContext = HttpContext.Current;
HttpRequest request = httpContext.Request;
NameValueCollection headers = httpContext.Request.Headers;
httpContext.Items["Logging-HttpRequest-Latency"] = latencyTracker;
HttpLogger.InitializeRequestLogger();
if (HttpLogger.ActivityScope != null)
{
HttpLogger.ActivityScope.UpdateFromMessage(HttpContext.Current.Request);
HttpLogger.ActivityScope.SerializeTo(HttpContext.Current.Response);
}
if (Constants.IsRemotePS && HttpLogger.ActivityScope != null && request.Url.Port == 444)
{
Uri url = request.Url;
NameValueCollection urlProperties = url.GetUrlProperties();
string text = urlProperties["RequestId48CD6591-0506-4D6E-9131-797489A3260F"];
Guid guid;
if (text != null && Guid.TryParse(text, out guid))
{
LoggerHelper.UpdateActivityScopeRequestIdFromUrl(url.ToString());
}
}
HttpLogger.SafeSetLogger(ServiceCommonMetadata.HttpMethod, request.HttpMethod);
WinRMInfo winRMInfoFromHttpHeaders = WinRMInfo.GetWinRMInfoFromHttpHeaders(headers);
if (winRMInfoFromHttpHeaders != null)
{
HttpLogger.SafeSetLogger(RpsHttpMetadata.Action, winRMInfoFromHttpHeaders.Action);
HttpLogger.SafeSetLogger(RpsCommonMetadata.SessionId, winRMInfoFromHttpHeaders.SessionId);
HttpLogger.SafeSetLogger(RpsHttpMetadata.ShellId, winRMInfoFromHttpHeaders.ShellId);
HttpLogger.SafeSetLogger(RpsHttpMetadata.CommandId, winRMInfoFromHttpHeaders.CommandId);
HttpLogger.SafeSetLogger(RpsHttpMetadata.CommandName, winRMInfoFromHttpHeaders.CommandName);
httpContext.Items["X-RemotePS-WinRMInfo"] = winRMInfoFromHttpHeaders;
}
string sourceCafeServer = CafeHelper.GetSourceCafeServer(request);
if (sourceCafeServer != null)
{
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.FrontEndServer, sourceCafeServer);
}
Uri url2 = request.Url;
if (url2.IsAbsoluteUri)
{
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.UrlHost, url2.DnsSafeHost);
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.UrlStem, url2.LocalPath);
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.UrlQuery, url2.Query);
}
else
{
HttpLogger.SafeAppendGenericError("InvalidRelativeUri", url2.ToString(), false);
}
NameValueCollection urlProperties2 = url2.GetUrlProperties();
if (urlProperties2 != null)
{
string text2;
if (!string.IsNullOrWhiteSpace(text2 = urlProperties2["Organization"]))
{
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.ManagedOrganization, text2);
}
else if (!string.IsNullOrWhiteSpace(text2 = urlProperties2["DelegatedOrg"]))
{
HttpLogger.SafeSetLogger(ConfigurationCoreMetadata.ManagedOrganization, "Delegate:" + text2);
}
}
if (HttpLogger.ActivityScope != null)
{
using (new MonitoredScope("RequestMonitor.Register", "RequestMonitor.Register", HttpModuleHelper.HttpPerfMonitors))
{
RequestMonitor.Instance.RegisterRequest(HttpLogger.ActivityScope.ActivityId);
string text3 = headers[WellKnownHeader.WLIDMemberName] ?? headers[WellKnownHeader.LiveIdMemberName];
if (!string.IsNullOrEmpty(text3))
{
SmtpAddress smtpAddress = new SmtpAddress(text3);
RequestMonitor.Instance.Log(HttpLogger.ActivityScope.ActivityId, RequestMonitorMetadata.AuthenticatedUser, text3);
RequestMonitor.Instance.Log(HttpLogger.ActivityScope.ActivityId, RequestMonitorMetadata.Organization, smtpAddress.Domain);
}
RequestMonitor.Instance.Log(HttpLogger.ActivityScope.ActivityId, RequestMonitorMetadata.FrontEndServer, sourceCafeServer);
RequestMonitor.Instance.Log(HttpLogger.ActivityScope.ActivityId, RequestMonitorMetadata.ProtocolAction, HttpLogger.ActivityScope.GetProperty(RpsHttpMetadata.Action));
}
}
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[LoggingStartModule::OnBeginRequest] Exit");
}
// Token: 0x0600002B RID: 43 RVA: 0x000037F4 File Offset: 0x000019F4
private static void BeginTrackLatency(MapiEvent mapiEvent, LatencyTracker latencyTracker, LatencyComponent latencyComponent)
{
MailboxTransportSubmissionAssistant.LatencyRecord value = new MailboxTransportSubmissionAssistant.LatencyRecord(latencyTracker, latencyComponent);
MailboxTransportSubmissionAssistant.eventCounterToLatencyMap[mapiEvent.EventCounter] = value;
LatencyTracker.BeginTrackLatency(latencyComponent, latencyTracker);
}
public MailSubmissionResult SubmitMessage(string serverDN, Guid mailboxGuid, Guid mdbGuid, string databaseName, long eventCounter, byte[] entryId, byte[] parentEntryId, string serverFqdn, IPAddress networkAddressBytes, DateTime originalCreateTime, bool isPublicFolder, TenantPartitionHint tenantHint, string mailboxHopLatency, QuarantineHandler quarantineHandler, SubmissionPoisonHandler submissionPoisonHandler, LatencyTracker latencyTracker)
{
ArgumentValidator.ThrowIfNullOrEmpty("serverDN", serverDN);
ArgumentValidator.ThrowIfEmpty("mailboxGuid", mailboxGuid);
ArgumentValidator.ThrowIfEmpty("mdbGuid", mdbGuid);
ArgumentValidator.ThrowIfNullOrEmpty("databaseName", databaseName);
ArgumentValidator.ThrowIfNull("entryId", entryId);
ArgumentValidator.ThrowIfInvalidValue <int>("entryId", entryId.Length, (int value) => value > 0);
ArgumentValidator.ThrowIfNull("parentEntryId", parentEntryId);
ArgumentValidator.ThrowIfInvalidValue <int>("parentEntryId", parentEntryId.Length, (int value) => value > 0);
ArgumentValidator.ThrowIfNullOrEmpty("serverFqdn", serverFqdn);
ArgumentValidator.ThrowIfNull("networkAddressBytes", networkAddressBytes);
ArgumentValidator.ThrowIfNullOrEmpty("mailboxHopLatency", mailboxHopLatency);
ArgumentValidator.ThrowIfNull("quarantineHandler", quarantineHandler);
ArgumentValidator.ThrowIfNull("submissionPoisonHandler", submissionPoisonHandler);
bool shouldDeprioritize = false;
if (SubmissionConfiguration.Instance.App.SenderRateDeprioritizationEnabled)
{
long num = this.rateTrackerForDeprioritization.IncrementSenderRate(mailboxGuid, originalCreateTime);
if (num > (long)SubmissionConfiguration.Instance.App.SenderRateDeprioritizationThreshold)
{
shouldDeprioritize = true;
}
}
bool shouldThrottle = false;
if (SubmissionConfiguration.Instance.App.SenderRateThrottlingEnabled)
{
long num2 = this.rateTrackerForThrottling.IncrementSenderRate(mailboxGuid, originalCreateTime);
if (num2 > (long)SubmissionConfiguration.Instance.App.SenderRateThrottlingThreshold)
{
shouldThrottle = true;
this.rateTrackerForThrottling.ResetSenderRate(mailboxGuid, originalCreateTime);
}
}
MapiSubmissionInfo submissionInfo = new MapiSubmissionInfo(serverDN, mailboxGuid, entryId, parentEntryId, eventCounter, serverFqdn, networkAddressBytes, mdbGuid, databaseName, originalCreateTime, isPublicFolder, tenantHint, mailboxHopLatency, latencyTracker, shouldDeprioritize, shouldThrottle, this.storeDriverTracer);
return(this.SubmitMessageImpl(submissionInfo, submissionPoisonHandler, quarantineHandler));
}
public MapiSubmissionInfo(string serverDN, Guid mailboxGuid, byte[] entryId, byte[] parentEntryId, long eventCounter, string serverFqdn, IPAddress networkAddress, Guid mdbGuid, string databaseName, DateTime originalCreateTime, bool isPublicFolder, TenantPartitionHint tenantHint, string mailboxHopLatency, LatencyTracker latencyTracker, bool shouldDeprioritize, bool shouldThrottle, IStoreDriverTracer storeDriverTracer) : base(serverDN, serverFqdn, networkAddress, mdbGuid, databaseName, originalCreateTime, tenantHint, mailboxHopLatency, latencyTracker, shouldDeprioritize, shouldThrottle)
{
this.mailboxGuid = mailboxGuid;
this.entryId = entryId;
this.parentEntryId = parentEntryId;
this.eventCounter = eventCounter;
this.isPublicFolder = isPublicFolder;
this.storeDriverTracer = storeDriverTracer;
}
// Token: 0x06000080 RID: 128 RVA: 0x00004400 File Offset: 0x00002600
public WinRMDataReceiver(string connectionUrl, string userName, string authenticationType, LatencyTracker latencyTracker)
{
WinRMDataReceiver < > 4__this = this;
if (!WinRMDataExchangeHelper.IsExchangeDataUseAuthenticationType() && !WinRMDataExchangeHelper.IsExchangeDataUseNamedPipe())
{
throw new InvalidFlightingException();
}
CoreLogger.ExecuteAndLog("WinRMDataReceiver.Ctor", true, latencyTracker, delegate(Exception ex)
{
AuthZLogger.SafeAppendGenericError("WinRMDataReceiver.Ctor", ex.ToString(), false);
}, delegate()
{
< > 4__this.latencyTracker = latencyTracker;
if (WinRMDataExchangeHelper.IsExchangeDataUseAuthenticationType())
{
WinRMDataExchangeHelper.DehydrateAuthenticationType(authenticationType, out < > 4__this.authenticationType, out < > 4__this.serializedData);
}
else
{
// Token: 0x0600003D RID: 61 RVA: 0x00003D68 File Offset: 0x00001F68
private void HandleEventError(MapiEvent mapiEvent, MailSubmissionResult result, LatencyTracker latencyTracker, string eventContext)
{
uint errorCode = result.ErrorCode;
if (errorCode == 22U)
{
MailboxTransportSubmissionAssistant.IncrementSuccessfulPoisonNdrSubmissionPerfmon();
}
else if (errorCode == 23U)
{
MailboxTransportSubmissionAssistant.IncrementPermanentFailedPoisonNdrSubmissionPerfmon();
}
else if (HResult.IsHandled(errorCode))
{
if (HResult.IsNonActionable(errorCode))
{
MailboxTransportSubmissionAssistant.IncrementNonActionableFailedSubmissionPerfmon();
}
else if (!HResult.IsMessageSubmittedOrHasNoRcpts(errorCode))
{
MailboxTransportSubmissionAssistant.IncrementFailedSubmissionPerfmon();
}
}
else if (HResult.IsRetryableAtCurrentHub(errorCode))
{
MailboxTransportSubmissionAssistant.IncrementTemporarySubmissionFailuresPerfmon();
}
MailboxTransportSubmissionAssistant.ComputePercentSubmissionsPerfmon(false);
if (11U == errorCode)
{
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail <string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "Submission for message {0} was throttled, retry happens in 1 minute.", mapiEvent.ItemEntryIdString);
MailboxTransportSubmissionAssistant.BeginTrackLatency(mapiEvent, latencyTracker, LatencyComponent.SubmissionAssistantThrottling);
throw new TransientMailboxException(MailboxTransportSubmissionAssistant.RetryScheduleMessageThrottling);
}
if (errorCode == 1140850696U)
{
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail <uint, string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "Resource is in Quarantined State. Error Code: {0}; Event Context: {1}", errorCode, eventContext);
throw new TransientMailboxException(new RetrySchedule(FinalAction.RetryForever, TimeSpan.MaxValue, new TimeSpan[]
{
result.QuarantineTimeSpan
}));
}
if (24U == errorCode)
{
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail <uint, string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "NDR for Poison Message was not successful. Retry. Error Code: {0}, Event context: {1}.", errorCode, eventContext);
MailboxTransportSubmissionAssistant.IncrementTemporaryPoisonNdrSubmissionFailuresPerfmon();
throw new TransientServerException(MailboxTransportSubmissionAssistant.RetrySchedulePoisonNdr);
}
if (HResult.IsHandled(errorCode))
{
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail <uint, string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "Submission was handled. Error code {0}, event context {1}.", errorCode, eventContext);
return;
}
if (2684354560U == errorCode)
{
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail <string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "Submission for message {0} was throttled at smtp, retry happens in 1 minute.", mapiEvent.ItemEntryIdString);
throw new TransientMailboxException(MailboxTransportSubmissionAssistant.RetryScheduleGeneric);
}
if (HResult.IsRetryableAtCurrentHub(errorCode))
{
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail <uint, string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "Submission was not successful. Retry at current hub error code {0}, event context {1}.", errorCode, eventContext);
if (HResult.IsRetryMailbox(errorCode))
{
throw new TransientMailboxException(MailboxTransportSubmissionAssistant.RetryScheduleGeneric);
}
if (HResult.IsRetryMailboxDatabase(errorCode))
{
throw new TransientDatabaseException(MailboxTransportSubmissionAssistant.RetryScheduleGeneric);
}
if (HResult.IsRetryMailboxServer(errorCode))
{
throw new TransientServerException(MailboxTransportSubmissionAssistant.RetryScheduleGeneric);
}
return;
}
else
{
if (HResult.IsRetryableAtOtherHub(errorCode))
{
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail <uint, string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "Submission was not successful. Retry other hub error code {0}, event context {1}.", errorCode, eventContext);
throw new TransientServerException(MailboxTransportSubmissionAssistant.RetryScheduleGeneric);
}
throw new InvalidOperationException("Internal error. ErrorCode is: " + errorCode);
}
}
internal static T ExecuteAndLog <T>(string funcName, bool missionCritical, LatencyTracker latencyTracker, Action <Exception> onError, T defaultReturnValue, Func <T> func)
{
return(Diagnostics.ExecuteAndLog <T>(funcName, missionCritical, latencyTracker, Constants.CoreEventLogger, TaskEventLogConstants.Tuple_NonCrashingException, ExTraceGlobals.InstrumentationTracer, (object ex) => false, onError, defaultReturnValue, func));
}
internal static void ExecuteAndLog(string funcName, bool missionCritical, LatencyTracker latencyTracker, Action <Exception> onError, Action action)
{
Diagnostics.ExecuteAndLog(funcName, missionCritical, latencyTracker, Constants.CoreEventLogger, TaskEventLogConstants.Tuple_NonCrashingException, ExTraceGlobals.InstrumentationTracer, (object ex) => false, onError, action);
}
protected SubmissionInfo(string serverDN, string serverFqdn, IPAddress networkAddress, Guid mdbGuid, string databaseName, DateTime originalCreateTime, TenantPartitionHint tenantHint, string mailboxHopLatency, LatencyTracker latencyTracker, bool shouldDeprioritize, bool shouldThrottle)
{
this.serverDN = serverDN;
this.serverFqdn = serverFqdn;
this.networkAddress = networkAddress;
this.mdbGuid = mdbGuid;
this.databaseName = databaseName;
this.originalCreateTime = originalCreateTime;
this.tenantHint = tenantHint;
this.mailboxHopLatency = mailboxHopLatency;
this.latencyTracker = latencyTracker;
this.shouldDeprioritize = shouldDeprioritize;
this.shouldThrottle = shouldThrottle;
}
// Token: 0x0600003F RID: 63 RVA: 0x00004116 File Offset: 0x00002316
internal LatencyRecord(LatencyTracker latencyTracker, LatencyComponent latencyComponent)
{
this.latencyTracker = latencyTracker;
this.latencyComponent = latencyComponent;
}
public void FinalizeDeliveryLatencyTracking(LatencyComponent deliveryComponent)
{
LatencyTracker.EndTrackLatency(LatencyComponent.Delivery, deliveryComponent, this.mailItem.LatencyTracker);
}
public void TrackSuccessfulConnectLatency(LatencyComponent connectComponent)
{
LatencyTracker.EndAndBeginTrackLatency(connectComponent, LatencyComponent.Delivery, this.mailItem.LatencyTracker);
}
public void TrackSuccessfulConnectLatency(LatencyComponent connectComponent)
{
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionSmtp, connectComponent, this.LatencyTracker);
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmissionSmtp, this.LatencyTracker);
}
