/// <summary>
/// Gets information about the remote host.
/// Automatically creates and initializes a new instance of the HostInformation class when
/// it is necessary.
/// </summary>
public HostInformation this[string uri]
{
get
{
lock (this.SyncRoot)
{
HostInformation hostInformation = this.Get(uri);
if (hostInformation == null)
{
hostInformation = new HostInformation(uri, this.ITransportContext);
this.UpdateHost(uri, hostInformation);
// set a reasonable start up lifetime property value
int expiration = GenuineUtility.ConvertToMilliseconds(this.ITransportContext.IParameterProvider[GenuineParameter.ConnectTimeout]);
hostInformation.Renew(expiration, true);
// LOG:
BinaryLogWriter binaryLogWriter = GenuineLoggingServices.BinaryLogWriter;
if (binaryLogWriter != null && binaryLogWriter[LogCategory.HostInformation] > 0)
{
binaryLogWriter.WriteEvent(LogCategory.HostInformation, "KnownHosts.this[string]",
LogMessageType.HostInformationCreated, null, null, hostInformation,
null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, -1, 0, 0, 0, null, null, null, null,
"The HostInformation has been created for the remote host: {0}.", uri);
}
}
return(hostInformation);
}
}
}
/// <summary>
/// Releases expired streams.
/// </summary>
public void TimerCallback()
{
int now = GenuineUtility.TickCount;
int releaseAfter = GenuineUtility.ConvertToMilliseconds(this.ITransportContext.IParameterProvider[GenuineParameter.UdpAssembleTimeSpan]);
lock (this._streams.SyncRoot)
{
// gather expired stream
ArrayList itemsDeleted = new ArrayList();
foreach (DictionaryEntry entry in this._streams)
{
StreamAssembled streamAssembled = (StreamAssembled)entry.Value;
if (GenuineUtility.IsTimeoutExpired(streamAssembled.Started + releaseAfter, now) &&
!streamAssembled.IsProcessed)
{
itemsDeleted.Add(entry.Key);
streamAssembled.Close();
}
}
// and remove them
foreach (object key in itemsDeleted)
{
this._streams.Remove(key);
}
}
}
/// <summary>
/// Constructs an instance of the UdpConnectionManager class.
/// </summary>
/// <param name="iTransportContext">The transport context.</param>
public UdpConnectionManager(ITransportContext iTransportContext) : base(iTransportContext)
{
this.Local = new HostInformation("_gudp://" + iTransportContext.HostIdentifier, iTransportContext);
this._sendBuffer = new byte[(int)iTransportContext.IParameterProvider[GenuineParameter.UdpPacketSize]];
TimerProvider.Attach(this);
this._closeInvocationConnectionAfterInactivity = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.CloseInvocationConnectionAfterInactivity]);
}
/// <summary>
/// Constructs an instance of the SharedMemoryConnectionManager class.
/// </summary>
/// <param name="iTransportContext">The transport context.</param>
public SharedMemoryConnectionManager(ITransportContext iTransportContext) : base(iTransportContext)
{
this._sendTimeoutSpan = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.SMSendTimeout]);
this.Local = new HostInformation("_gshmem://" + iTransportContext.HostIdentifier, iTransportContext);
TimerProvider.Attach(this);
}
/// <summary>
/// Closes expired connections and sends ping via inactive connections.
/// </summary>
public void TimerCallback()
{
int now = GenuineUtility.TickCount;
int forcePingAfter = GenuineUtility.ConvertToMilliseconds(this.ITransportContext.IParameterProvider[GenuineParameter.PersistentConnectionSendPingAfterInactivity]);
lock (this._persistent.SyncRoot)
{
// by all connections
foreach (DictionaryEntry dictionaryEntry in this._persistent)
{
SharedMemoryConnection sharedMemoryConnection = (SharedMemoryConnection)dictionaryEntry.Value;
if (GenuineUtility.IsTimeoutExpired(sharedMemoryConnection.LastTimeAMessageWasSent + forcePingAfter, now))
{
GenuineThreadPool.QueueUserWorkItem(new WaitCallback(this.SendPing), sharedMemoryConnection, false);
}
}
}
}
/// <summary>
/// Constructs an instance of the SharedMemoryConnection class.
/// </summary>
/// <param name="iTransportContext">The transport context.</param>
/// <param name="name">The name of the shared chunk.</param>
/// <param name="isServer">The role.</param>
/// <param name="setCloseStatusOnExit">Indicates whether it is necessary to set the "closed" status on exit.</param>
internal SharedMemoryConnection(ITransportContext iTransportContext, string name, bool isServer, bool setCloseStatusOnExit)
{
this.ITransportContext = iTransportContext;
this.ShareName = "GenuineChannels_GShMem_" + name;
this.IsServer = isServer;
this._setCloseStatusOnExit = setCloseStatusOnExit;
this._shareSize = (int)iTransportContext.IParameterProvider[GenuineParameter.SMShareSize];
this._pingTimeOut = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.PersistentConnectionSendPingAfterInactivity]);
this._closeAfterInactivity = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.ClosePersistentConnectionAfterInactivity]);
string localSideName = (isServer ? "Server" : "Client");
string remoteSideName = (isServer ? "Client" : "Server");
IParameterProvider parameters = this.ITransportContext.IParameterProvider;
// construct shared object names for the local side
string readCompletedEventName = GenuineSharedMemoryChannel.ConstructSharedObjectName(
this.ShareName + localSideName + "ReadCompleted", parameters);
string writeCompletedEventName = GenuineSharedMemoryChannel.ConstructSharedObjectName(
this.ShareName + localSideName + "WriteCompleted", parameters);
// construct shared object names for the remote side
string remoteReadCompletedEventName = GenuineSharedMemoryChannel.ConstructSharedObjectName(
this.ShareName + remoteSideName + "ReadCompleted", parameters);
string remoteWriteCompletedEventName = GenuineSharedMemoryChannel.ConstructSharedObjectName(
this.ShareName + remoteSideName + "WriteCompleted", parameters);
if (isServer)
{
if (this._shareSize < MIN_SHARE_SIZE || this._shareSize > MAX_SHARE_SIZE)
{
throw GenuineExceptions.Get_Channel_InvalidParameter("SMShareSize");
}
this.LowLevel_CreateSharedMemory();
this._closed = 0;
this._writtenShareSize = this._shareSize;
this._receiveOffset = 5;
this._sendOffset = (this._shareSize - 5) / 2;
this._receiveSpaceSize = this._sendOffset - 5 - 8;
this._sendSpaceSize = this._shareSize - this._sendOffset - 8;
this._namedEventReadCompleted = NamedEvent.CreateNamedEvent(readCompletedEventName, false, true);
this._namedEventWriteCompleted = NamedEvent.CreateNamedEvent(writeCompletedEventName, false, true);
this._namedEventRemoteReadCompleted = NamedEvent.CreateNamedEvent(remoteReadCompletedEventName, false, true);
this._namedEventRemoteWriteCompleted = NamedEvent.CreateNamedEvent(remoteWriteCompletedEventName, false, true);
}
else
{
this.OpenSharedMemory();
if (this._closed != 0)
{
throw GenuineExceptions.Get_Connect_CanNotConnectToRemoteHost(name, "Remote host has already closed the connection.");
}
this._shareSize = this._writtenShareSize;
if (this._shareSize < MIN_SHARE_SIZE || this._shareSize > MAX_SHARE_SIZE)
{
throw GenuineExceptions.Get_Channel_InvalidParameter("SMShareSize");
}
this._receiveOffset = (this._shareSize - 5) / 2;
this._sendOffset = 5;
this._receiveSpaceSize = this._shareSize - this._receiveOffset - 8;
this._sendSpaceSize = this._receiveOffset - 5 - 8;
this._namedEventReadCompleted = NamedEvent.OpenNamedEvent(readCompletedEventName);
this._namedEventWriteCompleted = NamedEvent.OpenNamedEvent(writeCompletedEventName);
this._namedEventRemoteReadCompleted = NamedEvent.OpenNamedEvent(remoteReadCompletedEventName);
this._namedEventRemoteWriteCompleted = NamedEvent.OpenNamedEvent(remoteWriteCompletedEventName);
}
this._sendBuffer = new byte[this._sendSpaceSize];
}
/// <summary>
/// Constructs an instance of the HttpInvocationConnection class.
/// </summary>
/// <param name="iTransportContext">The transport context.</param>
/// <param name="remote">The remote host.</param>
public HttpInvocationConnection(ITransportContext iTransportContext, HostInformation remote)
{
this.HostId = iTransportContext.BinaryHostIdentifier;
this.HostIdAsString = iTransportContext.HostIdentifier;
this._asyncCallback_onRequestCompleted = new AsyncCallback(this.OnRequestCompleted);
this.ITransportContext = iTransportContext;
this.Remote = remote;
// this.OnEndSending = new AsyncCallback(this.Callback_OnEndSending);
// this.OnEndReceiving = new AsyncCallback(this.Callback_OnEndReceiving);
// cache all setting's values
this._userAgent = this.ITransportContext.IParameterProvider[GenuineParameter.HttpWebUserAgent] as string;
if (this._userAgent == null)
{
this._userAgent = @"Mozilla/4.0+ (compatible; MSIE 6.0; Windows " + Environment.OSVersion.Version +
"; Genuine HTTP Client Channel; MS .NET CLR " + Environment.Version.ToString() + ")";
}
this._userAgent = Regex.Replace(this._userAgent, "\r|\n", " ", RegexOptions.None);
this._useUnsafeConnectionSharing = (bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpUnsafeConnectionSharing];
this._allowWriteStreamBuffering = (bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpAllowWriteStreamBuffering];
this._keepalive = (bool)iTransportContext.IParameterProvider[GenuineParameter.HttpKeepAlive];
this._credentials = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthCredential] as ICredentials;
string userName = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthUserName] as string;
string password = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthPassword] as string;
string domain = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthDomain] as string;
this._hostRenewingSpan = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.ClosePersistentConnectionAfterInactivity]) + GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.MaxTimeSpanToReconnect]);
if (this._credentials != null || (userName != null && userName != string.Empty &&
password != null && password != string.Empty))
{
this._useWebAuthentication = true;
// and setup credentials
if (this._credentials == null)
{
if ((bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpUseDefaultCredentials])
{
this._credentials = CredentialCache.DefaultCredentials;
}
else
{
if (domain == null)
{
this._credentials = new NetworkCredential(userName, password);
}
else
{
this._credentials = new NetworkCredential(userName, password, domain);
}
}
}
}
if ((bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpUseGlobalProxy])
{
#if (FRM20)
this._iWebProxy = WebRequest.DefaultWebProxy;
#else
this._iWebProxy = GlobalProxySelection.Select;
#endif
}
else
{
if (!(this.ITransportContext.IParameterProvider[GenuineParameter.HttpProxyUri] is string))
{
#if (FRM20)
this._iWebProxy = null;
#else
this._iWebProxy = GlobalProxySelection.GetEmptyWebProxy();
#endif
}
else
{
this._iWebProxy = new WebProxy((string)this.ITransportContext.IParameterProvider[GenuineParameter.HttpProxyUri], (bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpBypassOnLocal]);
}
}
this._httpAsynchronousRequestTimeout = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.HttpAsynchronousRequestTimeout]);
}