internal AcceptorI(Instance instance, string adapterName, string host, int port) { _instance = instance; _adapterName = adapterName; _logger = instance.communicator().getLogger(); _backlog = instance.communicator().getProperties().getPropertyAsIntWithDefault("Ice.TCP.Backlog", 511); // // .NET requires that a certificate be supplied. // X509Certificate2Collection certs = instance.certs(); if(certs.Count == 0) { Ice.SecurityException ex = new Ice.SecurityException(); ex.reason = "IceSSL: certificate required for server endpoint"; throw ex; } try { _addr = IceInternal.Network.getAddressForServer(host, port, _instance.protocolSupport()); _fd = IceInternal.Network.createSocket(false, _addr.AddressFamily); IceInternal.Network.setBlock(_fd, false); IceInternal.Network.setTcpBufSize(_fd, _instance.communicator().getProperties(), _logger); if(IceInternal.AssemblyUtil.platform_ != IceInternal.AssemblyUtil.Platform.Windows) { // // Enable SO_REUSEADDR on Unix platforms to allow // re-using the socket even if it's in the TIME_WAIT // state. On Windows, this doesn't appear to be // necessary and enabling SO_REUSEADDR would actually // not be a good thing since it allows a second // process to bind to an address even it's already // bound by another process. // // TODO: using SO_EXCLUSIVEADDRUSE on Windows would // probably be better but it's only supported by recent // Windows versions (XP SP2, Windows Server 2003). // IceInternal.Network.setReuseAddress(_fd, true); } if(_instance.networkTraceLevel() >= 2) { string s = "attempting to bind to ssl socket " + IceInternal.Network.addrToString(_addr); _logger.trace(_instance.networkTraceCategory(), s); } _addr = IceInternal.Network.doBind(_fd, _addr); } catch(System.Exception) { _fd = null; throw; } }
internal static void traceSlicing(string kind, string typeId, string slicingCat, Ice.Logger logger) { lock (typeof(TraceUtil)) { if (slicingIds.Add(typeId)) { using (System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture)) { s.Write("unknown " + kind + " type `" + typeId + "'"); logger.trace(slicingCat, s.ToString()); } } } }
internal void deadRemoteLogger(Ice.RemoteLoggerPrx remoteLogger, Ice.Logger logger, Ice.LocalException ex, string operation) { // // No need to convert remoteLogger as we only use its identity // if (removeRemoteLogger(remoteLogger)) { if (_traceLevel > 0) { logger.trace(_traceCategory, "detached `" + remoteLogger.ToString() + "' because " + operation + " raised:\n" + ex.ToString()); } } }
internal static void traceRecv(Ice.InputStream str, Ice.Logger logger, TraceLevels tl) { if (tl.protocol >= 1) { int p = str.pos(); str.pos(0); using (System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture)) { byte type = printMessage(s, str); logger.trace(tl.protocolCat, "received " + getMessageTypeAsString(type) + " " + s.ToString()); } str.pos(p); } }
internal static void trace(string heading, Ice.InputStream str, Ice.Logger logger, TraceLevels tl) { if (tl.protocol >= 1) { int p = str.pos(); str.pos(0); using (System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture)) { s.Write(heading); printMessage(s, str); logger.trace(tl.protocolCat, s.ToString()); } str.pos(p); } }
internal static void traceSend(Ice.OutputStream str, Ice.Logger logger, TraceLevels tl) { if (tl.protocol >= 1) { int p = str.pos(); Ice.InputStream iss = new Ice.InputStream(str.instance(), str.getEncoding(), str.getBuffer(), false); iss.pos(0); using (System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture)) { byte type = printMessage(s, iss); logger.trace(tl.protocolCat, "sending " + getMessageTypeAsString(type) + " " + s.ToString()); } str.pos(p); } }
internal TcpAcceptor(Instance instance, string host, int port) { instance_ = instance; _traceLevels = instance.traceLevels(); _logger = instance.initializationData().logger; _backlog = instance.initializationData().properties.getPropertyAsIntWithDefault("Ice.TCP.Backlog", 511); try { _addr = Network.getAddressForServer(host, port, instance_.protocolSupport()); _fd = Network.createSocket(false, _addr.AddressFamily); Network.setBlock(_fd, false); #if !COMPACT Network.setTcpBufSize(_fd, instance_.initializationData().properties, _logger); #endif if(AssemblyUtil.platform_ != AssemblyUtil.Platform.Windows) { // // Enable SO_REUSEADDR on Unix platforms to allow // re-using the socket even if it's in the TIME_WAIT // state. On Windows, this doesn't appear to be // necessary and enabling SO_REUSEADDR would actually // not be a good thing since it allows a second // process to bind to an address even it's already // bound by another process. // // TODO: using SO_EXCLUSIVEADDRUSE on Windows would // probably be better but it's only supported by recent // Windows versions (XP SP2, Windows Server 2003). // Network.setReuseAddress(_fd, true); } if(_traceLevels.network >= 2) { string s = "attempting to bind to tcp socket " + Network.addrToString(_addr); _logger.trace(_traceLevels.networkCat, s); } _addr = Network.doBind(_fd, _addr); } catch(System.Exception) { _fd = null; throw; } }
internal static void trace(string heading, Ice.OutputStream str, Ice.Logger logger, TraceLevels tl) { if (tl.protocol >= 1) { int p = str.pos(); Ice.InputStream iss = new Ice.InputStream(str.instance(), str.getEncoding(), str.getBuffer(), false); iss.pos(0); using (System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture)) { s.Write(heading); printMessage(s, iss); logger.trace(tl.protocolCat, s.ToString()); } str.pos(p); } }
public int checkRetryAfterException(Ice.LocalException ex, Reference @ref, bool sleep, ref int cnt) { TraceLevels traceLevels = instance_.traceLevels(); Ice.Logger logger = instance_.initializationData().logger; // // We don't retry batch requests because the exception might have caused // the all the requests batched with the connection to be aborted and we // want the application to be notified. // if (@ref.getMode() == Reference.Mode.ModeBatchOneway || @ref.getMode() == Reference.Mode.ModeBatchDatagram) { throw ex; } Ice.ObjectNotExistException one = ex as Ice.ObjectNotExistException; if (one != null) { if (@ref.getRouterInfo() != null && one.operation.Equals("ice_add_proxy")) { // // If we have a router, an ObjectNotExistException with an // operation name "ice_add_proxy" indicates to the client // that the router isn't aware of the proxy (for example, // because it was evicted by the router). In this case, we // must *always* retry, so that the missing proxy is added // to the router. // @ref.getRouterInfo().clearCache(@ref); if (traceLevels.retry >= 1) { string s = "retrying operation call to add proxy to router\n" + ex; logger.trace(traceLevels.retryCat, s); } return(0); // We must always retry, so we don't look at the retry count. } else if (@ref.isIndirect()) { // // We retry ObjectNotExistException if the reference is // indirect. // if (@ref.isWellKnown()) { LocatorInfo li = @ref.getLocatorInfo(); if (li != null) { li.clearCache(@ref); } } } else { // // For all other cases, we don't retry ObjectNotExistException. // throw ex; } } else if (ex is Ice.RequestFailedException) { throw ex; } // // There is no point in retrying an operation that resulted in a // MarshalException. This must have been raised locally (because if // it happened in a server it would result in an UnknownLocalException // instead), which means there was a problem in this process that will // not change if we try again. // // The most likely cause for a MarshalException is exceeding the // maximum message size, which is represented by the subclass // MemoryLimitException. For example, a client can attempt to send a // message that exceeds the maximum memory size, or accumulate enough // batch requests without flushing that the maximum size is reached. // // This latter case is especially problematic, because if we were to // retry a batch request after a MarshalException, we would in fact // silently discard the accumulated requests and allow new batch // requests to accumulate. If the subsequent batched requests do not // exceed the maximum message size, it appears to the client that all // of the batched requests were accepted, when in reality only the // last few are actually sent. // if (ex is Ice.MarshalException) { throw ex; } ++cnt; Debug.Assert(cnt > 0); int interval; if (cnt == (_retryIntervals.Length + 1) && ex is Ice.CloseConnectionException) { // // A close connection exception is always retried at least once, even if the retry // limit is reached. // interval = 0; } else if (cnt > _retryIntervals.Length) { if (traceLevels.retry >= 1) { string s = "cannot retry operation call because retry limit has been exceeded\n" + ex; logger.trace(traceLevels.retryCat, s); } throw ex; } else { interval = _retryIntervals[cnt - 1]; } if (traceLevels.retry >= 1) { string s = "retrying operation call"; if (interval > 0) { s += " in " + interval + "ms"; } s += " because of exception\n" + ex; logger.trace(traceLevels.retryCat, s); } if (sleep && interval > 0) { // // Sleep before retrying. // System.Threading.Thread.Sleep(interval); } return(interval); }
// // Only for use by UdpEndpoint. // internal UdpTransceiver(Instance instance, string host, int port, string mcastInterface, bool connect) { _traceLevels = instance.traceLevels(); _logger = instance.initializationData().logger; _stats = instance.initializationData().stats; _state = connect ? StateNeedConnect : StateNotConnected; _incoming = true; try { _addr = Network.getAddressForServer(host, port, instance.protocolSupport()); _fd = Network.createSocket(true, _addr.AddressFamily); setBufSize(instance); Network.setBlock(_fd, false); if(_traceLevels.network >= 2) { string s = "attempting to bind to udp socket " + Network.addrToString(_addr); _logger.trace(_traceLevels.networkCat, s); } if(Network.isMulticast(_addr)) { Network.setReuseAddress(_fd, true); _mcastAddr = _addr; if(AssemblyUtil.platform_ == AssemblyUtil.Platform.Windows) { // // Windows does not allow binding to the mcast address itself // so we bind to INADDR_ANY (0.0.0.0) instead. As a result, // bi-directional connection won't work because the source // address won't the multicast address and the client will // therefore reject the datagram. // if(_addr.AddressFamily == AddressFamily.InterNetwork) { _addr = new IPEndPoint(IPAddress.Any, port); } else { _addr = new IPEndPoint(IPAddress.IPv6Any, port); } } _addr = Network.doBind(_fd, _addr); if(port == 0) { _mcastAddr.Port = _addr.Port; } Network.setMcastGroup(_fd, _mcastAddr.Address, mcastInterface); } else { if(AssemblyUtil.platform_ != AssemblyUtil.Platform.Windows) { // // Enable SO_REUSEADDR on Unix platforms to allow // re-using the socket even if it's in the TIME_WAIT // state. On Windows, this doesn't appear to be // necessary and enabling SO_REUSEADDR would actually // not be a good thing since it allows a second // process to bind to an address even it's already // bound by another process. // // TODO: using SO_EXCLUSIVEADDRUSE on Windows would // probably be better but it's only supported by recent // Windows versions (XP SP2, Windows Server 2003). // Network.setReuseAddress(_fd, true); } _addr = Network.doBind(_fd, _addr); } if(_traceLevels.network >= 1) { StringBuilder s = new StringBuilder("starting to receive udp packets\n"); s.Append(ToString()); List<string> interfaces = Network.getHostsForEndpointExpand(_addr.Address.ToString(), instance.protocolSupport(), true); if(interfaces.Count != 0) { s.Append("\nlocal interfaces: "); s.Append(String.Join(", ", interfaces.ToArray())); } _logger.trace(_traceLevels.networkCat, s.ToString()); } } catch(Ice.LocalException) { _fd = null; throw; } }
public int checkRetryAfterException(Ice.LocalException ex, Reference @ref, ref int cnt) { TraceLevels traceLevels = _instance.traceLevels(); Ice.Logger logger = _instance.initializationData().logger; if (@ref.getMode() == Reference.Mode.ModeBatchOneway || @ref.getMode() == Reference.Mode.ModeBatchDatagram) { Debug.Assert(false); // batch no longer implemented anyway throw ex; } Ice.ObjectNotExistException one = ex as Ice.ObjectNotExistException; if (one != null) { if (@ref.getRouterInfo() != null && one.operation.Equals("ice_add_proxy")) { // // If we have a router, an ObjectNotExistException with an // operation name "ice_add_proxy" indicates to the client // that the router isn't aware of the proxy (for example, // because it was evicted by the router). In this case, we // must *always* retry, so that the missing proxy is added // to the router. // @ref.getRouterInfo().clearCache(@ref); if (traceLevels.retry >= 1) { string s = "retrying operation call to add proxy to router\n" + ex; logger.trace(traceLevels.retryCat, s); } return(0); // We must always retry, so we don't look at the retry count. } else if (@ref.isIndirect()) { // // We retry ObjectNotExistException if the reference is // indirect. // if (@ref.isWellKnown()) { LocatorInfo li = @ref.getLocatorInfo(); if (li != null) { li.clearCache(@ref); } } } else { // // For all other cases, we don't retry ObjectNotExistException. // throw ex; } } else if (ex is Ice.RequestFailedException) { throw ex; } // // There is no point in retrying an operation that resulted in a // MarshalException. This must have been raised locally (because if // it happened in a server it would result in an UnknownLocalException // instead), which means there was a problem in this process that will // not change if we try again. // if (ex is Ice.MarshalException) { throw ex; } // // Don't retry if the communicator is destroyed, object adapter is deactivated, // or connection is manually closed. // if (ex is Ice.CommunicatorDestroyedException || ex is Ice.ObjectAdapterDeactivatedException || ex is Ice.ConnectionManuallyClosedException) { throw ex; } // // Don't retry invocation timeouts. // if (ex is Ice.InvocationTimeoutException || ex is Ice.InvocationCanceledException) { throw ex; } ++cnt; Debug.Assert(cnt > 0); int interval; if (cnt == (_retryIntervals.Length + 1) && ex is Ice.CloseConnectionException) { // // A close connection exception is always retried at least once, even if the retry // limit is reached. // interval = 0; } else if (cnt > _retryIntervals.Length) { if (traceLevels.retry >= 1) { string s = "cannot retry operation call because retry limit has been exceeded\n" + ex; logger.trace(traceLevels.retryCat, s); } throw ex; } else { interval = _retryIntervals[cnt - 1]; } if (traceLevels.retry >= 1) { string s = "retrying operation call"; if (interval > 0) { s += " in " + interval + "ms"; } s += " because of exception\n" + ex; logger.trace(traceLevels.retryCat, s); } return(interval); }