public override uint Send(SNIPacket packet) { long scopeID = SqlClientEventSource.Log.TrySNIScopeEnterEvent("<sc.SNI.SNINpHandle.Send |SNI|SCOPE>"); try { bool releaseLock = false; try { // is the packet is marked out out-of-band (attention packets only) it must be // sent immediately even if a send of recieve operation is already in progress // because out of band packets are used to cancel ongoing operations // so try to take the lock if possible but continue even if it can't be taken if (packet.IsOutOfBand) { Monitor.TryEnter(this, ref releaseLock); } else { Monitor.Enter(this); releaseLock = true; } // this lock ensures that two packets are not being written to the transport at the same time // so that sending a standard and an out-of-band packet are both written atomically no data is // interleaved lock (_sendSync) { try { packet.WriteToStream(_stream); return(TdsEnums.SNI_SUCCESS); } catch (ObjectDisposedException ode) { SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.SNINpHandle.Send |SNI|ERR> ObjectDisposedException message = {0}.", ode.Message); return(ReportErrorAndReleasePacket(packet, ode)); } catch (IOException ioe) { SqlClientEventSource.Log.TrySNITraceEvent("<sc.SNI.SNINpHandle.Send |SNI|ERR> IOException message = {0}.", ioe.Message); return(ReportErrorAndReleasePacket(packet, ioe)); } } } finally { if (releaseLock) { Monitor.Exit(this); } } } finally { SqlClientEventSource.Log.TrySNIScopeLeaveEvent(scopeID); } }
public override uint Send(SNIPacket packet) { long scopeID = SqlClientEventSource.Log.TrySNIScopeEnterEvent(s_className); try { bool releaseLock = false; try { // is the packet is marked out out-of-band (attention packets only) it must be // sent immediately even if a send of receive operation is already in progress // because out of band packets are used to cancel ongoing operations // so try to take the lock if possible but continue even if it can't be taken if (packet.IsOutOfBand) { Monitor.TryEnter(this, ref releaseLock); } else { Monitor.Enter(this); releaseLock = true; } // this lock ensures that two packets are not being written to the transport at the same time // so that sending a standard and an out-of-band packet are both written atomically no data is // interleaved lock (_sendSync) { try { SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.INFO, "Connection Id {0}, Packet writing to stream, dataLeft {1}", args0: _connectionId, args1: packet?.DataLeft); packet.WriteToStream(_stream); return(TdsEnums.SNI_SUCCESS); } catch (ObjectDisposedException ode) { SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.ERR, "Connection Id {0}, ObjectDisposedException occurred: {1}.", args0: _connectionId, args1: ode?.Message); return(ReportErrorAndReleasePacket(packet, ode)); } catch (IOException ioe) { SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.ERR, "Connection Id {0}, IOException occurred: {1}.", args0: _connectionId, args1: ioe?.Message); return(ReportErrorAndReleasePacket(packet, ioe)); } } } finally { if (releaseLock) { Monitor.Exit(this); } } } finally { SqlClientEventSource.Log.TrySNIScopeLeaveEvent(scopeID); } }
/// <summary> /// Send a packet synchronously /// </summary> /// <param name="packet">SNI packet</param> /// <returns>SNI error code</returns> public override uint Send(SNIPacket packet) { bool releaseLock = false; try { // is the packet is marked out out-of-band (attention packets only) it must be // sent immediately even if a send of recieve operation is already in progress // because out of band packets are used to cancel ongoing operations // so try to take the lock if possible but continue even if it can't be taken if (packet.IsOutOfBand) { Monitor.TryEnter(this, ref releaseLock); } else { Monitor.Enter(this); releaseLock = true; } // this lock ensures that two packets are not being written to the transport at the same time // so that sending a standard and an out-of-band packet are both written atomically no data is // interleaved lock (_sendSync) { try { packet.WriteToStream(_stream); SqlClientEventSource.Log.TrySNITraceEvent(nameof(SNITCPHandle), EventType.INFO, "Connection Id {0}, Data sent to stream synchronously", args0: _connectionId); return(TdsEnums.SNI_SUCCESS); } catch (ObjectDisposedException ode) { SqlClientEventSource.Log.TrySNITraceEvent(nameof(SNITCPHandle), EventType.ERR, "Connection Id {0}, ObjectDisposedException occurred: {1}", args0: _connectionId, args1: ode?.Message); return(ReportTcpSNIError(ode)); } catch (SocketException se) { SqlClientEventSource.Log.TrySNITraceEvent(nameof(SNITCPHandle), EventType.ERR, "Connection Id {0}, SocketException occurred: {1}", args0: _connectionId, args1: se?.Message); return(ReportTcpSNIError(se)); } catch (IOException ioe) { SqlClientEventSource.Log.TrySNITraceEvent(nameof(SNITCPHandle), EventType.ERR, "Connection Id {0}, IOException occurred: {1}", args0: _connectionId, args1: ioe?.Message); return(ReportTcpSNIError(ioe)); } } } finally { if (releaseLock) { Monitor.Exit(this); } } }
/// <summary> /// Send a packet synchronously /// </summary> /// <param name="packet">SNI packet</param> /// <returns>SNI error code</returns> public override uint Send(SNIPacket packet) { bool releaseLock = false; try { // is the packet is marked out out-of-band (attention packets only) it must be // sent immediately even if a send of recieve operation is already in progress // because out of band packets are used to cancel ongoing operations // so try to take the lock if possible but continue even if it can't be taken if (packet.IsOutOfBand) { Monitor.TryEnter(this, ref releaseLock); } else { Monitor.Enter(this); releaseLock = true; } // this lock ensures that two packets are not being written to the transport at the same time // so that sending a standard and an out-of-band packet are both written atomically no data is // interleaved lock (_sendSync) { try { packet.WriteToStream(_stream); return(TdsEnums.SNI_SUCCESS); } catch (ObjectDisposedException ode) { return(ReportTcpSNIError(ode)); } catch (SocketException se) { return(ReportTcpSNIError(se)); } catch (IOException ioe) { return(ReportTcpSNIError(ioe)); } } } finally { if (releaseLock) { Monitor.Exit(this); } } }
public override uint Send(SNIPacket packet) { lock (this) { try { packet.WriteToStream(_stream); return(TdsEnums.SNI_SUCCESS); } catch (ObjectDisposedException ode) { return(ReportErrorAndReleasePacket(packet, ode)); } catch (IOException ioe) { return(ReportErrorAndReleasePacket(packet, ioe)); } } }
/// <summary> /// Send a packet synchronously /// </summary> /// <param name="packet">SNI packet</param> /// <returns>SNI error code</returns> public override uint Send(SNIPacket packet) { lock (this) { try { packet.WriteToStream(_stream); return(TdsEnums.SNI_SUCCESS); } catch (ObjectDisposedException ode) { return(ReportTcpSNIError(ode)); } catch (SocketException se) { return(ReportTcpSNIError(se)); } catch (IOException ioe) { return(ReportTcpSNIError(ioe)); } } }