protected List <TMessage> EndSendMessage <TMessage>(IAsyncResult ar) where TMessage : DnsMessageBase, new() { DnsClientAsyncState <TMessage> state = (DnsClientAsyncState <TMessage>)ar; return(state.Responses); }
private void TcpBeginConnect <TMessage>(DnsClientAsyncState <TMessage> state, IPAddress server) where TMessage : DnsMessageBase, new() { if (state.EndpointInfoIndex == state.EndpointInfos.Count) { state.TcpStream = null; state.TcpClient = null; state.SetCompleted(); return; } try { state.TcpClient = new TcpClient(server.AddressFamily); state.TimedOut = false; state.TimeRemaining = QueryTimeout; IAsyncResult asyncResult = state.TcpClient.BeginConnect(server, _port, TcpConnectCompleted <TMessage>, state); state.Timer = new Timer(TcpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } catch (Exception e) { Trace.TraceError("Error on dns query: " + e); try { state.TcpClient.Close(); state.Timer.Dispose(); } catch { } state.EndpointInfoIndex++; TcpBeginConnect(state); } }
private IAsyncResult BeginSendMessage <TMessage>(TMessage message, List <DnsClientEndpointInfo> endpointInfos, AsyncCallback requestCallback, object state) where TMessage : DnsMessageBase, new() { DnsClientAsyncState <TMessage> asyncResult = new DnsClientAsyncState <TMessage> { Query = message, Responses = new List <TMessage>(), UserCallback = requestCallback, AsyncState = state, EndpointInfoIndex = 0 }; PrepareMessage(message, out asyncResult.QueryLength, out asyncResult.QueryData, out asyncResult.TSigKeySelector, out asyncResult.TSigOriginalMac); asyncResult.EndpointInfos = endpointInfos; if ((asyncResult.QueryLength > MaximumQueryMessageSize) || message.IsTcpUsingRequested) { TcpBeginConnect(asyncResult); } else { UdpBeginSend(asyncResult); } return(asyncResult); }
private void TcpReceiveLengthCompleted <TMessage>(IAsyncResult ar) where TMessage : DnsMessageBase, new() { DnsClientAsyncState <TMessage> state = (DnsClientAsyncState <TMessage>)ar.AsyncState; if (state.Timer != null) { state.Timer.Dispose(); } if (state.TimedOut) { state.EndpointInfoIndex++; TcpBeginConnect(state); } else { try { state.TcpBytesToReceive -= state.TcpStream.EndRead(ar); if (state.TcpBytesToReceive > 0) { IAsyncResult asyncResult = state.TcpStream.BeginRead(state.Buffer, 2 - state.TcpBytesToReceive, state.TcpBytesToReceive, TcpReceiveLengthCompleted <TMessage>, state); state.Timer = new Timer(TcpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } else { int tmp = 0; int responseLength = DnsMessageBase.ParseUShort(state.Buffer, ref tmp); state.Buffer = new byte[responseLength]; state.TcpBytesToReceive = responseLength; IAsyncResult asyncResult = state.TcpStream.BeginRead(state.Buffer, 0, responseLength, TcpReceiveCompleted <TMessage>, state); state.Timer = new Timer(TcpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } } catch (Exception e) { Trace.TraceError("Error on dns query: " + e); try { state.TcpClient.Close(); state.Timer.Dispose(); } catch { } state.EndpointInfoIndex++; TcpBeginConnect(state); } } }
private static void UdpTimedOut <TMessage>(object ar) where TMessage : DnsMessageBase, new() { IAsyncResult asyncResult = (IAsyncResult)ar; if (!asyncResult.IsCompleted) { DnsClientAsyncState <TMessage> state = (DnsClientAsyncState <TMessage>)asyncResult.AsyncState; state.TimedOut = true; state.UdpClient.Close(); } }
private void TcpBeginConnect <TMessage>(DnsClientAsyncState <TMessage> state) where TMessage : DnsMessageBase, new() { if (state.EndpointInfoIndex == state.EndpointInfos.Count) { state.TcpStream = null; state.TcpClient = null; state.SetCompleted(); return; } TcpBeginConnect(state, state.EndpointInfos[state.EndpointInfoIndex].ServerAddress); }
private void TcpConnectCompleted <TMessage>(IAsyncResult ar) where TMessage : DnsMessageBase, new() { DnsClientAsyncState <TMessage> state = (DnsClientAsyncState <TMessage>)ar.AsyncState; if (state.Timer != null) { state.Timer.Dispose(); } if (state.TimedOut) { state.EndpointInfoIndex++; TcpBeginConnect(state); } else { try { state.TcpClient.EndConnect(ar); state.TcpStream = state.TcpClient.GetStream(); int tmp = 0; state.Buffer = new byte[2]; DnsMessageBase.EncodeUShort(state.Buffer, ref tmp, (ushort)state.QueryLength); IAsyncResult asyncResult = state.TcpStream.BeginWrite(state.Buffer, 0, 2, TcpSendLengthCompleted <TMessage>, state); state.Timer = new Timer(TcpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } catch (Exception e) { Trace.TraceError("Error on dns query: " + e); try { state.TcpClient.Close(); state.Timer.Dispose(); } catch { } state.EndpointInfoIndex++; TcpBeginConnect(state); } } }
private void UdpSendCompleted <TMessage>(IAsyncResult ar) where TMessage : DnsMessageBase, new() { DnsClientAsyncState <TMessage> state = (DnsClientAsyncState <TMessage>)ar.AsyncState; if (state.Timer != null) { state.Timer.Dispose(); } if (state.TimedOut) { state.EndpointInfoIndex++; UdpBeginSend(state); } else { try { state.UdpClient.EndSendTo(ar); state.Buffer = new byte[65535]; if (state.EndpointInfos[state.EndpointInfoIndex].IsMulticast) { state.UdpEndpoint = new IPEndPoint(state.UdpClient.AddressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, _port); } IAsyncResult asyncResult = state.UdpClient.BeginReceiveFrom(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, ref state.UdpEndpoint, UdpReceiveCompleted <TMessage>, state); state.Timer = new Timer(UdpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } catch (Exception e) { Trace.TraceError("Error on dns query: " + e); try { state.UdpClient.Close(); state.Timer.Dispose(); } catch { } state.EndpointInfoIndex++; UdpBeginSend(state); } } }
private static void TcpTimedOut <TMessage>(object ar) where TMessage : DnsMessageBase, new() { IAsyncResult asyncResult = (IAsyncResult)ar; if (!asyncResult.IsCompleted) { DnsClientAsyncState <TMessage> state = (DnsClientAsyncState <TMessage>)asyncResult.AsyncState; state.PartialMessage = null; state.TimedOut = true; if (state.TcpStream != null) { state.TcpStream.Close(); } state.TcpClient.Close(); } }
private void TcpSendCompleted <TMessage>(IAsyncResult ar) where TMessage : DnsMessageBase, new() { DnsClientAsyncState <TMessage> state = (DnsClientAsyncState <TMessage>)ar.AsyncState; if (state.Timer != null) { state.Timer.Dispose(); } if (state.TimedOut) { state.EndpointInfoIndex++; TcpBeginConnect(state); } else { try { state.TcpStream.EndWrite(ar); state.TcpBytesToReceive = 2; IAsyncResult asyncResult = state.TcpStream.BeginRead(state.Buffer, 0, 2, TcpReceiveLengthCompleted <TMessage>, state); state.Timer = new Timer(TcpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } catch (Exception e) { Trace.TraceError("Error on dns query: " + e); try { state.TcpClient.Close(); state.Timer.Dispose(); } catch { } state.EndpointInfoIndex++; TcpBeginConnect(state); } } }
private void UdpBeginSend <TMessage>(DnsClientAsyncState <TMessage> state) where TMessage : DnsMessageBase, new() { if (state.EndpointInfoIndex == state.EndpointInfos.Count) { state.UdpClient = null; state.UdpEndpoint = null; state.SetCompleted(); return; } try { DnsClientEndpointInfo endpointInfo = state.EndpointInfos[state.EndpointInfoIndex]; state.UdpEndpoint = new IPEndPoint(endpointInfo.ServerAddress, _port); state.UdpClient = new System.Net.Sockets.Socket(state.UdpEndpoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp); PrepareAndBindUdpSocket(endpointInfo, state.UdpClient); state.TimedOut = false; state.TimeRemaining = QueryTimeout; IAsyncResult asyncResult = state.UdpClient.BeginSendTo(state.QueryData, 0, state.QueryLength, SocketFlags.None, state.UdpEndpoint, UdpSendCompleted <TMessage>, state); state.Timer = new Timer(UdpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } catch (Exception e) { Trace.TraceError("Error on dns query: " + e); try { state.UdpClient.Close(); state.Timer.Dispose(); } catch { } state.EndpointInfoIndex++; UdpBeginSend(state); } }
private void UdpReceiveCompleted <TMessage>(IAsyncResult ar) where TMessage : DnsMessageBase, new() { DnsClientAsyncState <TMessage> state = (DnsClientAsyncState <TMessage>)ar.AsyncState; if (state.Timer != null) { state.Timer.Dispose(); } if (state.TimedOut) { state.EndpointInfoIndex++; UdpBeginSend(state); } else { try { int length = state.UdpClient.EndReceiveFrom(ar, ref state.UdpEndpoint); byte[] responseData = new byte[length]; Buffer.BlockCopy(state.Buffer, 0, responseData, 0, length); TMessage response = DnsMessageBase.Parse <TMessage>(responseData, state.TSigKeySelector, state.TSigOriginalMac); if (AreMultipleResponsesAllowedInParallelMode) { if (ValidateResponse(state.Query, response)) { if (response.IsTcpResendingRequested) { TcpBeginConnect <TMessage>(state.CreateTcpCloneWithoutCallback(), ((IPEndPoint)state.UdpEndpoint).Address); } else { state.Responses.Add(response); } } state.Buffer = new byte[65535]; if (state.EndpointInfos[state.EndpointInfoIndex].IsMulticast) { state.UdpEndpoint = new IPEndPoint(state.UdpClient.AddressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, _port); } IAsyncResult asyncResult = state.UdpClient.BeginReceiveFrom(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, ref state.UdpEndpoint, UdpReceiveCompleted <TMessage>, state); state.Timer = new Timer(UdpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } else { state.UdpClient.Close(); state.UdpClient = null; state.UdpEndpoint = null; if (!ValidateResponse(state.Query, response) || (response.ReturnCode == ReturnCode.ServerFailure)) { state.EndpointInfoIndex++; UdpBeginSend(state); } else { if (response.IsTcpResendingRequested) { TcpBeginConnect <TMessage>(state, ((IPEndPoint)state.UdpEndpoint).Address); } else { state.Responses.Add(response); state.SetCompleted(); } } } } catch (Exception e) { Trace.TraceError("Error on dns query: " + e); try { state.UdpClient.Close(); state.Timer.Dispose(); } catch { } state.EndpointInfoIndex++; UdpBeginSend(state); } } }
private void TcpReceiveCompleted <TMessage>(IAsyncResult ar) where TMessage : DnsMessageBase, new() { DnsClientAsyncState <TMessage> state = (DnsClientAsyncState <TMessage>)ar.AsyncState; if (state.Timer != null) { state.Timer.Dispose(); } if (state.TimedOut) { state.EndpointInfoIndex++; TcpBeginConnect(state); } else { try { state.TcpBytesToReceive -= state.TcpStream.EndRead(ar); if (state.TcpBytesToReceive > 0) { IAsyncResult asyncResult = state.TcpStream.BeginRead(state.Buffer, state.Buffer.Length - state.TcpBytesToReceive, state.TcpBytesToReceive, TcpReceiveCompleted <TMessage>, state); state.Timer = new Timer(TcpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } else { byte[] buffer = state.Buffer; state.Buffer = null; TMessage response = DnsMessageBase.Parse <TMessage>(buffer, state.TSigKeySelector, state.TSigOriginalMac); if (!ValidateResponse(state.Query, response) || (response.ReturnCode == ReturnCode.ServerFailure)) { state.EndpointInfoIndex++; state.PartialMessage = null; state.TcpStream.Close(); state.TcpClient.Close(); state.TcpStream = null; state.TcpClient = null; TcpBeginConnect(state); } else { bool isSubsequentResponseMessage = (state.PartialMessage != null); if (isSubsequentResponseMessage) { state.PartialMessage.AnswerRecords.AddRange(response.AnswerRecords); } else { state.PartialMessage = response; } if (response.IsTcpNextMessageWaiting(isSubsequentResponseMessage)) { state.TcpBytesToReceive = 2; state.Buffer = new byte[2]; IAsyncResult asyncResult = state.TcpStream.BeginRead(state.Buffer, 0, 2, TcpReceiveLengthCompleted <TMessage>, state); state.Timer = new Timer(TcpTimedOut <TMessage>, asyncResult, state.TimeRemaining, Timeout.Infinite); } else { state.TcpStream.Close(); state.TcpClient.Close(); state.TcpStream = null; state.TcpClient = null; state.Responses.Add(state.PartialMessage); state.SetCompleted(); } } } } catch (Exception e) { Trace.TraceError("Error on dns query: " + e); try { state.TcpClient.Close(); state.Timer.Dispose(); } catch { } state.EndpointInfoIndex++; TcpBeginConnect(state); } } }