private static void SendPING_Reply(byte[] destinationMac, byte[] destinationIp, byte[] id, byte[] seq)
{
if (EthClick._gatewayMac == null || EthClick._ip == null)
{
return;
}
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Sending Response to Ping request");
}
#endif
Scratch.Overwrite(0, destinationMac);
Scratch.Overwrite(6, EthClick._macAddress);
Scratch.Overwrite(26, EthClick._ip);
Scratch.Overwrite(30, destinationIp);
Scratch.Overwrite(34, Reply);
Scratch.Overwrite(38, id);
Scratch.Overwrite(40, seq);
Scratch.Overwrite(36, new byte[] { 0x00, 0x00 });
Scratch.Overwrite(36, Scratch.InternetChecksum(40, 34));
Scratch.Overwrite(24, new byte[] { 0x00, 0x00 });
Scratch.Overwrite(24, Scratch.InternetChecksum(20, 14));
EthClick.SendFrame(Scratch);
}
private static void SendMDNSNameReply()
{
if (EthClick._ip == null || EthClick._name == string.Empty)
{
return;
}
Prefix.Overwrite(0, new byte[] { 0x01, 0x00, 0x5e, 0x00, 0x00, 0xfb });
Prefix.Overwrite(6, EthClick._macAddress);
Prefix.Overwrite(26, EthClick._ip);
lock (LockObj)
{
Suffix.Overwrite(10, EthClick._ip);
var result = Utility.CombineArrays(Prefix, Utility.CombineArrays(DNS.EncodeDnsName(EthClick._name + ".local"), Suffix));
result.Overwrite(16, ((ushort)(result.Length - 14)).ToBytes());
result.Overwrite(38, ((ushort)(result.Length - 34)).ToBytes());
result.Overwrite(24, new byte[] { 0x00, 0x00 });
result.Overwrite(24, result.InternetChecksum(20, 14));
result.Overwrite(40, new byte[] { 0x00, 0x00 });
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Sending MDNS name message!");
}
#endif
EthClick.SendFrame(result);
}
}
private static void LookupAsync(string dnsName, bool useSecondaryDnsServer = false)
{
if (EthClick._preferredDomainNameServer == null)
{
throw new Exception("Domain Name Server is not set. If you are using DHCP, you must wait until EthClick.PreferredDomainNameServer is populated before you attempt to make a DNS call.");
}
if (EthClick._gatewayMac == null)
{
throw new Exception("DefaultGateway MAC is not set. If you are using DHCP, you must wait until EthClick.GatewayMac is populated before you attempt to make a DNS call.");
}
Scratch.Overwrite(0, EthClick._gatewayMac);
Scratch.Overwrite(6, EthClick._macAddress);
Scratch.Overwrite(30, (useSecondaryDnsServer && EthClick._alternateDomainNameServer != null) ? EthClick._alternateDomainNameServer : EthClick._preferredDomainNameServer);
Scratch.Overwrite(26, EthClick._ip);
lock (LockObj)
{
Scratch.Overwrite(42, Extensions.GetRandomBytes(2));
var result = Utility.CombineArrays(Scratch, Utility.CombineArrays(EncodeDnsName(dnsName), new byte[] { 0x00, 0x01, 0x00, 0x01 }));
result.Overwrite(16, ((ushort)(result.Length - 14)).ToBytes());
result.Overwrite(38, ((ushort)(result.Length - 34)).ToBytes());
result.Overwrite(24, new byte[] { 0x00, 0x00 });
result.Overwrite(24, result.InternetChecksum(20, 14));
result.Overwrite(40, new byte[] { 0x00, 0x00 });
EthClick.SendFrame(result);
}
}
internal static void HandlePacket(byte[] payload)
{
if (payload[34] == Request[0])
{
var destinationMac = Utility.ExtractRangeFromArray(payload, 6, 6);
var destinationIp = Utility.ExtractRangeFromArray(payload, 26, 4);
var id = Utility.ExtractRangeFromArray(payload, 38, 2);
var sequence = Utility.ExtractRangeFromArray(payload, 40, 2);
SendPING_Reply(destinationMac, destinationIp, id, sequence);
EthClick.FirePingReceivedEvent(destinationMac, destinationIp, id, sequence);
}
else if (payload[34] == Reply[0])
{
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Received Ping response.");
}
#endif
}
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Ping received");
}
#endif
}
public static void Main()
{
_eth = new EthClick(Hardware.SocketOne);
_eth.Start(_eth.GenerateUniqueMacAddress("MikroBusNet"), "MikroBusNet");
_eth.Start(_eth.GenerateUniqueMacAddress("MikroBusNet"), "MikroBusNet");
while (true)
{
if (_eth.ConnectedToInternet)
{
Debug.Print("Connected to Internet");
break;
}
Debug.Print("Waiting on Internet connection");
}
EthClick.OnHttpPacketReceived += EthClick_OnHttpPacketReceived;
EthClick.OnConnectionChanged += Adapter_OnConnectionChanged;
EthClick.OnTcpPacketReceived += EthClick_OnTcpReceivedPacketEvent;
EthClick.OnPingReceived += EthClick_OnPingReceived;
_eth.ListenToPort(80); // Listen on Port 80, the default web server port
_serverStartTime = DateTime.Now;
Thread.Sleep(Timeout.Infinite);
}
public static void Main()
{
/* Use this for Static IP and No DHCP */
//_eth.Name = "Quail";
//_eth.MacAddress = _eth.GenerateUniqueMacAddress("Quail");
//_eth.IPAddress = "192.168.1.95".ToBytes();
//_eth.DefaultGateway = "192.168.1.1".ToBytes();
//_eth.PreferredDomainNameServer = "8.8.8.8".ToBytes(); // Google DNS Servers
//_eth.AlternateDomainNameServer = "8.8.8.4".ToBytes(); // Google DNS Servers
//_eth.DHCPDisabled = true;
_eth = new EthClick(Hardware.SocketOne);
_eth.Start(_eth.GenerateUniqueMacAddress("MikroBusNet"), "MikroBusNet");
while (true)
{
if (_eth.ConnectedToInternet)
{
Debug.Print("Connected to Internet");
break;
}
Debug.Print("Waiting on Internet connection");
}
var addressBytes = DNS.Lookup("www.google.com");
Debug.Print("DNS Lookup: www.google.com -> " + addressBytes.ToAddress());
addressBytes = DNS.Lookup("www.mikrobusnet.org");
Debug.Print("DNS Lookup: www.mikrobusnet.org -> " + addressBytes.ToAddress());
}
private static void SendARP_Reply(byte[] destinationMac, byte[] destinationIp)
{
Scratch.Overwrite(0, destinationMac);
Scratch.Overwrite(6, EthClick._macAddress);
Scratch.Overwrite(21, Reply);
Scratch.Overwrite(22, EthClick._macAddress);
Scratch.Overwrite(28, EthClick._ip ?? new byte[] { 0x00, 0x00, 0x00, 0x00 });
Scratch.Overwrite(32, destinationMac);
Scratch.Overwrite(38, destinationIp);
EthClick.SendFrame(Scratch);
}
internal static void SendARP_Gratuitus()
{
Scratch.Overwrite(0, EthClick.BroadcastMac);
Scratch.Overwrite(6, EthClick._macAddress);
Scratch.Overwrite(21, Request);
Scratch.Overwrite(22, EthClick._macAddress);
Scratch.Overwrite(28, EthClick._ip ?? new byte[] { 0x00, 0x00, 0x00, 0x00 });
Scratch.Overwrite(32, EthClick.BlankMac);
Scratch.Overwrite(38, EthClick._ip ?? new byte[] { 0x00, 0x00, 0x00, 0x00 });
EthClick.SendFrame(Scratch);
}
private static void SendNetbiosReply(byte[] nbName, byte[] destinationMac, byte[] destinationIp, byte[] transactionId)
{
Scratch.Overwrite(0, destinationMac);
Scratch.Overwrite(6, EthClick._macAddress);
Scratch.Overwrite(26, EthClick._ip);
Scratch.Overwrite(30, destinationIp);
Scratch.Overwrite(42, transactionId);
Scratch.Overwrite(55, nbName);
Scratch.Overwrite(100, EthClick._ip);
Scratch.Overwrite(24, new byte[] { 0x00, 0x00 });
Scratch.Overwrite(24, Scratch.InternetChecksum(20, 14));
EthClick.SendFrame(Scratch);
}
/// <summary>
/// Sends a UDP message.
/// </summary>
/// <param name="message">The byte encoded message to send.</param>
/// <param name="destinationIp">The byte encoded Destination IPAddress.</param>
/// <param name="destinationPort">The destination Port.</param>
/// <param name="sourcePort">The source Port.</param>
/// <example>Example usage:
/// <code language = "C#">
/// namespace NetworkingExample
/// {
/// public class UdpProgram
/// {
/// private static EthClick _eth;
///
/// public static void Main()
/// {
/// /* Use this for Static IP and No DHCP */
/// //_eth.Name = "Quail";
/// //_eth.MacAddress = _eth.GenerateUniqueMacAddress("Quail");
/// //_eth.IPAddress = "192.168.1.95".ToBytes();
/// //_eth.DefaultGateway = "192.168.1.1".ToBytes();
/// //_eth.PreferredDomainNameServer = "8.8.8.8".ToBytes(); // Google DNS Servers
/// //_eth.AlternateDomainNameServer = "8.8.8.4".ToBytes(); // Google DNS Servers
/// //_eth.DHCPDisabled = true;
///
/// _eth = new EthClick(Hardware.SocketOne);
///
/// _eth.Start(_eth.GenerateUniqueMacAddress("MikroBusNet"), "MikroBusNet");
///
/// while (true)
/// {
/// if (_eth.ConnectedToInternet)
/// {
/// Debug.Print("Connected to Internet");
/// break;
/// }
/// Debug.Print("Waiting on Internet connection");
/// }
///
/// // Listen for UDP messages sent to activated ports
/// EthClick.OnUdpPacketReceived += Adapter_OnUdpPacketReceived;
///
/// // Activate the NTP (date/time) port 123
/// _eth.ListenToPort(123);
///
/// // Create a NTP (date/time) Request Message
/// var msg = new byte[48];
/// msg[0] = 0x1B;
///
/// var ipAddress = "165.193.126.229".ToBytes(); // IPAddress for NIST Time Server in Weehawken, NJ USA see http://tf.nist.gov/tf-cgi/servers.cgi
///
/// // Let's get the UTC time from a time server using a UDP Message
/// UDP.SendUdpMessage(msg, ipAddress, 123, 123);
///
/// Thread.Sleep(Timeout.Infinite);
/// }
///
/// private static void Adapter_OnUdpPacketReceived(Packet packet)
/// {
/// if (packet.Socket.RemotePort == 123)
/// {
/// var transitTime = Utility.ExtractRangeFromArray(packet.Content, 40, 8);
/// Debug.Print("Current UTC Date/Time is " + transitTime.ToDateTime());
/// }
/// }
/// }
///
/// public static class Extensions
/// {
/// /// <summary>
/// /// Convert an 8-byte array from NTP format to .NET DateTime.
/// /// </summary>
/// <![CDATA[///>]]>param name="ntpTime">NTP format 8-byte array containing date and time<![CDATA[<]]>/param>
/// /// <returns>A Standard .NET DateTime</returns>
/// public static DateTime ToDateTime(this byte[] ntpTime)
/// {
/// Microsoft.SPOT.Debug.Assert(ntpTime.Length == 8, "The passed array is too short to be a valid NTP DateTime.");
///
/// ulong intpart = 0;
/// ulong fractpart = 0;
///
/// for (int i = 0; i <![CDATA[<]]>= 3; i++)
/// intpart = (intpart <![CDATA[<<]]> 8) | ntpTime[i];
///
/// for (int i = 4; i <![CDATA[<]]>= 7; i++)
/// fractpart = (fractpart <![CDATA[<<]]> 8) | ntpTime[i];
///
/// ulong milliseconds = (intpart*1000 + (fractpart*1000)/0x100000000L);
///
/// var timeSince1900 = TimeSpan.FromTicks((long) milliseconds*TimeSpan.TicksPerMillisecond);
/// return new DateTime(1900, 1, 1).Add(timeSince1900);
/// }
/// }
/// }
/// </code>
/// <code language = "VB">
/// ' None provided as VS 2012 does not support bit-shifting with VB.Net which is necessary for this example.
/// </code>
/// </example>
///
public static void SendUdpMessage(byte[] message, byte[] destinationIp, ushort destinationPort, ushort sourcePort)
{
Scratch.Overwrite(0, EthClick._gatewayMac);
Scratch.Overwrite(6, EthClick._macAddress);
Scratch.Overwrite(30, destinationIp);
Scratch.Overwrite(26, EthClick._ip);
Scratch.Overwrite(34, sourcePort.ToBytes());
Scratch.Overwrite(36, destinationPort.ToBytes());
Scratch.Overwrite(38, ((ushort)(message.Length + 8)).ToBytes());
Scratch.Overwrite(16, ((ushort)((Scratch.Length + message.Length) - 14)).ToBytes());
Scratch.Overwrite(24, new byte[] { 0x00, 0x00 });
Scratch.Overwrite(24, Scratch.InternetChecksum(20, 14));
Scratch.Overwrite(40, new byte[] { 0x00, 0x00 });
EthClick.SendFrame(Utility.CombineArrays(Scratch, message));
}
/// <summary>
/// Send a PING Request to the specified IP Address.
/// </summary>
/// <param name="ipAddress">The byte encoded IPAddress.</param>
public static void SendPingRequest(byte[] ipAddress)
{
if (EthClick._gatewayMac == null || EthClick._ip == null)
{
return;
}
Scratch.Overwrite(0, EthClick._gatewayMac);
Scratch.Overwrite(6, EthClick._macAddress);
Scratch.Overwrite(26, EthClick._ip);
Scratch.Overwrite(30, EthClick._ip);
Scratch.Overwrite(34, Request);
Scratch.Overwrite(24, new byte[] { 0x00, 0x00 }); // clear header checksum, so that calculation excludes the checksum itself
Scratch.Overwrite(24, Scratch.InternetChecksum(20, 14)); // header checksum
EthClick.SendFrame(Scratch);
}
internal static void SendARP_Probe(byte[] ipAddressToQuery)
{
if (ipAddressToQuery == null)
{
return;
}
Scratch.Overwrite(0, EthClick.BroadcastMac);
Scratch.Overwrite(6, EthClick._macAddress);
Scratch.Overwrite(21, Request);
Scratch.Overwrite(22, EthClick._macAddress);
Scratch.Overwrite(28, EthClick._ip ?? new byte[] { 0x00, 0x00, 0x00, 0x00 });
Scratch.Overwrite(32, EthClick.BroadcastMac);
Scratch.Overwrite(38, ipAddressToQuery);
EthClick.SendFrame(Scratch);
}
public static void Main()
{
/* Use this for Static IP and No DHCP */
//_eth.Name = "Quail";
//_eth.MacAddress = _eth.GenerateUniqueMacAddress("Quail");
//_eth.IPAddress = "192.168.1.95".ToBytes();
//_eth.DefaultGateway = "192.168.1.1".ToBytes();
//_eth.PreferredDomainNameServer = "8.8.8.8".ToBytes(); // Google DNS Servers
//_eth.AlternateDomainNameServer = "8.8.8.4".ToBytes(); // Google DNS Servers
//_eth.DHCPDisabled = true;
_eth = new EthClick(Hardware.SocketOne);
_eth.Start(_eth.GenerateUniqueMacAddress("MikroBusNet"), "MikroBusNet");
while (true)
{
if (_eth.ConnectedToInternet)
{
Debug.Print("Connected to Internet");
Thread.Sleep(500);
break;
}
Debug.Print("Waiting on Internet connection");
}
// Listen for UDP messages sent to activated ports
EthClick.OnUdpPacketReceived += Adapter_OnUdpPacketReceived;
// Activate the NTP (date/time) port 123
_eth.ListenToPort(123);
// Create a NTP (date/time) Request Message
var msg = new byte[48];
msg[0] = 0x1B;
var ipAddress = "165.193.126.229".ToBytes(); // IPAddress for NIST Time Server in Weehawken, NJ USA see http://tf.nist.gov/tf-cgi/servers.cgi
// Let's get the UTC time from a time server using a UDP Message
UDP.SendUdpMessage(msg, ipAddress, 123, 123);
Thread.Sleep(Timeout.Infinite);
}
internal static void HandlePacket(byte[] payload)
{
var sourceIp = Utility.ExtractRangeFromArray(payload, 26, 4);
var sourcePort = Utility.ExtractRangeFromArray(payload, 34, 2);
var destinationPort = Utility.ExtractRangeFromArray(payload, 36, 2);
var socket = new Connection
{
RemoteIp = sourceIp,
RemotePort = sourcePort.ToShort(),
LocalPort = destinationPort.ToShort()
};
var udpDataLength = (ushort)((new[] { payload[38], payload[39] }).ToShort() - 8);
if (udpDataLength > 0)
{
EthClick.FireUdpPacketEvent(Utility.ExtractRangeFromArray(payload, 42, udpDataLength), socket);
}
}
private static void SendLLMNRNameReply(string name, byte[] tranId, byte[] destinationMac, byte[] destinationIp, byte[] destinationPort)
{
if (EthClick._ip == null || EthClick._name == string.Empty)
{
return;
}
lock (LockObj)
{
Prefix.Overwrite(0, destinationMac);
Prefix.Overwrite(6, EthClick._macAddress);
Prefix.Overwrite(26, EthClick._ip);
Prefix.Overwrite(30, destinationIp);
Prefix.Overwrite(36, destinationPort);
Prefix.Overwrite(42, tranId);
var suffix = new byte[name.Length * 2 + 22];
byte[] byteName = Utility.CombineArrays(DNS.EncodeDnsName(name), new byte[] { 0x00, 0x01, 0x00, 0x01 });
suffix.Overwrite(0, Utility.CombineArrays(byteName, byteName));
suffix.Overwrite(suffix.Length - 7, new byte[] { 0x1e });
suffix.Overwrite(suffix.Length - 5, new byte[] { 0x04 });
suffix.Overwrite(suffix.Length - 4, EthClick._ip);
byte[] result = Utility.CombineArrays(Prefix, suffix);
result.Overwrite(16, ((ushort)(result.Length - 14)).ToBytes());
result.Overwrite(38, ((ushort)(result.Length - 34)).ToBytes());
result.Overwrite(24, new byte[] { 0x00, 0x00 });
result.Overwrite(24, result.InternetChecksum(20, 14));
result.Overwrite(40, new byte[] { 0x00, 0x00 });
EthClick.SendFrame(result);
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("LLMNR Response sent");
}
#endif
}
}
internal void SendAsync(byte[] buffer, int offset, short size)
{
if (EthClick._gatewayMac == null || EthClick._ip == null || size <= 0 || IsClosing)
{
return;
}
if (!_isOpen)
{
Open();
}
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Sending TCP Data Segment");
}
#endif
_scratch.Overwrite(0 + 2, RemoteMac);
_scratch.Overwrite(6 + 2, EthClick._macAddress);
_scratch.Overwrite(26 + 2, EthClick._ip);
_scratch.Overwrite(30 + 2, RemoteIp);
_scratch.Overwrite(34 + 2, LocalPort.ToBytes());
_scratch.Overwrite(36 + 2, RemotePort.ToBytes());
_scratch.Overwrite(38 + 2, AckNumber.ToBytes());
_scratch.Overwrite(42 + 2, SeqNumber.ToBytes());
_scratch.Overwrite(48 + 2, new byte[] { 0x04, 0x00 });
_scratch[47 + 2] = 0x10;
_scratch.Overwrite(50 + 2, new byte[] { 0x00, 0x00 });
_scratch.Overwrite(24 + 2, new byte[] { 0x00, 0x00 });
buffer = Utility.CombineArrays(_scratch, 0, _scratch.Length, buffer, offset, size);
buffer.Overwrite(16 + 2, ((ushort)((buffer.Length - 2) - 14)).ToBytes());
buffer.Overwrite(50 + 2, buffer.InternetChecksum(20 + size, 34 + 2, EthClick._ip, RemoteIp));
buffer.Overwrite(24 + 2, buffer.InternetChecksum(20, 14 + 2));
AckNumber += (uint)size;
EthClick.SendFrame(buffer, 2);
}
internal static void HandlePacket(byte[] payload)
{
// ReSharper disable InconsistentNaming
bool SYN = (payload[47] & (1 << 1)) != 0;
var ACK = (payload[47] & (1 << 4)) != 0;
bool FIN = (payload[47] & (1 << 0)) != 0;
bool PSH = (payload[47] & (1 << 3)) != 0;
bool RST = (payload[47] & (1 << 2)) != 0;
// ReSharper restore InconsistentNaming
byte[] sourceIp = Utility.ExtractRangeFromArray(payload, 26, 4);
byte[] sourcePort = Utility.ExtractRangeFromArray(payload, 34, 2);
byte[] localPort = Utility.ExtractRangeFromArray(payload, 36, 2);
ulong connectionId = GenerateConnectionId(payload);
Connection con;
uint packetSeqNumber = Utility.ExtractRangeFromArray(payload, 38, 4).ToInt();
if (SYN && !ACK)
{
var connection = _connections[connectionId] as Connection;
if (connection != null && (_connections.Contains(connectionId) && connection.IsOpen))
{
_connections.Remove(connectionId);
}
var keys = new ulong[_connections.Count];
_connections.Keys.CopyTo(keys, 0);
foreach (ulong key in keys)
{
con = _connections[key] as Connection;
var connection1 = _connections[key] as Connection;
if (connection1 != null &&
Utility.GetMachineTime().Subtract(connection1.LastActivity).Seconds > ConnectionIdleLimit)
{
con.IsClosing = true;
con.SeqNumber++;
con.SendAck(false, true);
_connections.Remove(key);
}
}
if (!_connections.Contains(connectionId))
{
_connections.Add(connectionId, new Connection());
}
con = _connections[connectionId] as Connection;
if (con != null)
{
con.RemoteIp = sourceIp;
con.RemotePort = sourcePort.ToShort();
con.RemoteMac = Utility.ExtractRangeFromArray(payload, 6, 6);
con.LocalPort = localPort.ToShort();
con.SeqNumber = packetSeqNumber + 1;
con.StartSeqNumber = packetSeqNumber;
con.AckNumber = 2380;
con.WindowSize = 1024;
con.ReadyForRequest = true;
con.SendAck(true);
con.AckNumber++;
con.IsOpen = true;
}
}
else if (_connections.Contains(connectionId) && (ACK || FIN || PSH || RST))
{
con = _connections[connectionId] as Connection;
ushort totalLength = Utility.ExtractRangeFromArray(payload, 16, 2).ToShort();
var ipHeaderLength = (ushort)((payload[14] & 0x0f) * 4);
var tcpHeaderLength = (ushort)((payload[26 + ipHeaderLength] >> 4) * 4);
if (totalLength + 14 > payload.Length)
{
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Bad packet size detected? " + totalLength + "/" + payload.Length);
}
#endif
return;
}
if (con != null)
{
con.SeqNumber += (uint)(totalLength - (tcpHeaderLength + ipHeaderLength));
con.WindowSize -= (ushort)(totalLength - (tcpHeaderLength + ipHeaderLength));
if (PSH)
{
con.SendAck();
}
else if (SYN)
{
con.SeqNumber = packetSeqNumber + 1;
con.StartSeqNumber = packetSeqNumber;
con.AckNumber++;
con.SendAck();
con.IsOpen = true;
return;
}
else if ((FIN || RST) && ACK)
{
con.IsClosing = true;
con.SeqNumber++;
con.SendAck();
_connections.Remove(connectionId);
return;
}
else if (FIN)
{
con.IsClosing = true;
con.SeqNumber++;
con.SendAck(false, true);
return;
}
else if (RST)
{
con.IsClosing = true;
con.SeqNumber++;
return;
}
else if (con.IsClosing)
{
_connections.Remove(connectionId);
return;
}
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Check for data");
}
#endif
if ((totalLength - (tcpHeaderLength + ipHeaderLength)) > 0)
{
byte[] segment = Utility.ExtractRangeFromArray(payload, (14 + ipHeaderLength + tcpHeaderLength),
(totalLength - (tcpHeaderLength + ipHeaderLength)));
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("We got some data, PSN: " + packetSeqNumber + ", SSN: " + con.StartSeqNumber +
", header delimiter: " + segment.Locate(HttpRequest.HeaderDelimiter));
}
#endif
EthClick.FireTcpPacketEvent(segment, packetSeqNumber - con.StartSeqNumber, con);
con.FireOnConnectionPacketReceived(new Packet(PacketType.TCP)
{
SequenceNumber = packetSeqNumber - con.StartSeqNumber,
Content = segment,
Socket = con
});
if (segment.Length < 10 ||
!(segment[0] == 0x47 && segment[1] == 0x45 && segment[2] == 0x54) &&
!(segment[0] == 0x50 && segment[1] == 0x4F && segment[2] == 0x53 && segment[3] == 0x54))
{
return; // if it is not a get, then we won't handle it through the HTTP Request Handler
}
if (con.ReadyForRequest)
{
byte[] lrc = Utility.ExtractRangeFromArray(payload, (30 + ipHeaderLength), 2);
if (con.LastRequestChecksum.BytesEqual(lrc))
{
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Retransmission of Request Ignored!");
}
#endif
}
else
{
con.LastRequestChecksum = lrc;
con.ReadyForRequest = false;
EthClick.FireHttpPacketEvent(segment, con);
}
}
}
}
}
else if ((FIN || RST) && ACK)
{
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Handling RST for a connection that no longer exists!!!!!!!!!");
}
#endif
con = new Connection
{
RemoteIp = sourceIp,
RemotePort = sourcePort.ToShort(),
RemoteMac = Utility.ExtractRangeFromArray(payload, 6, 6),
LocalPort = localPort.ToShort(),
SeqNumber = Utility.ExtractRangeFromArray(payload, 38, 4).ToInt(),
AckNumber = Utility.ExtractRangeFromArray(payload, 42, 4).ToInt(),
IsClosing = true
};
con.SendAck();
}
}
internal void SendAck(bool synchronize = false, bool finish = false, bool ack = true)
{
if (EthClick._gatewayMac == null || EthClick._ip == null)
{
return;
}
AckBase.Overwrite(0, RemoteMac);
AckBase.Overwrite(6, EthClick._macAddress);
AckBase.Overwrite(26, EthClick._ip);
AckBase.Overwrite(30, RemoteIp);
AckBase.Overwrite(34, LocalPort.ToBytes());
AckBase.Overwrite(36, RemotePort.ToBytes());
AckBase.Overwrite(38, AckNumber.ToBytes());
AckBase.Overwrite(42, SeqNumber.ToBytes());
AckBase.Overwrite(48, WindowSize.ToBytes());
if (synchronize)
{
AckBase.Overwrite(54, new byte[] { 0x02, 0x04, 0x05, 0xb4 });
AckBase.Overwrite(16, new byte[] { 0x00, 0x2c });
AckBase.Overwrite(46, new byte[] { 0x60 });
}
else
{
AckBase.Overwrite(54, new byte[] { 0x00, 0x00, 0x00, 0x00 });
AckBase.Overwrite(16, new byte[] { 0x00, 0x28 });
AckBase.Overwrite(46, new byte[] { 0x50 });
}
if (synchronize && ack)
{
AckBase[47] = 0x12;
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Sending TCP SYN + ACK");
}
#endif
}
else if (finish && ack)
{
AckBase[47] = 0x11;
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Sending TCP FIN + ACK");
}
#endif
}
else if (synchronize)
{
AckBase[47] = 0x02;
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Sending TCP SYN");
}
#endif
}
else if (finish)
{
AckBase[47] = 0x01;
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Sending TCP FIN");
}
#endif
}
else
{
AckBase[47] = 0x10;
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Sending TCP ACK");
}
#endif
}
AckBase.Overwrite(50, new byte[] { 0x00, 0x00 });
AckBase.Overwrite(50, AckBase.InternetChecksum(synchronize ? 24 : 20, 34, EthClick._ip, RemoteIp));
AckBase.Overwrite(24, new byte[] { 0x00, 0x00 });
AckBase.Overwrite(24, AckBase.InternetChecksum(20, 14));
EthClick.SendFrame(AckBase);
}
internal static void SendMessage(byte[] packetType)
{
lock (MagicCookie)
{
Scratch.Overwrite(0, EthClick.BroadcastMac);
Scratch.Overwrite(6, EthClick._macAddress);
Scratch.Overwrite(30, EthClick.BroadcastIpAddress);
Scratch.Overwrite(54, EthClick.BlankIpAddress);
Scratch.Overwrite(70, EthClick._macAddress);
Scratch.Overwrite(284, packetType);
var options = new byte[13 + (EthClick._name == string.Empty ? 0 : EthClick._name.Length + 2)];
options.Overwrite(0, EthClick._macAddress);
_transactionId = _transactionId ?? Extensions.GetRandomBytes(4);
if (packetType == Discover)
{
_pendingIpAddress = null;
options.Overwrite(6, new byte[] { 0x33, 0x04, 0x00, 0x76, 0xa7, 0x00 });
}
else if (packetType == Request && _pendingIpAddress != null && EthClick._defaultGateway != null)
{
options.Overwrite(6, new byte[] { 0x32, 0x04 });
options.Overwrite(8, _pendingIpAddress);
options.Overwrite(12, new byte[] { 0x36, 0x04 });
options.Overwrite(14, EthClick._defaultGateway);
if (EthClick._gatewayMac != null && EthClick._defaultGateway != null && EthClick._ip != null)
{
Scratch.Overwrite(54, EthClick._ip);
}
}
else
{
#if TINYCLR_TRACE
if (EthClick._verboseDebugging)
{
System.Diagnostics.Debug.WriteLine("Odd DHCP situation... should we be concerned?");
}
#endif
return;
}
if (EthClick._name != string.Empty)
{
options.Overwrite(options.Length - (EthClick._name.Length + 3), new byte[] { 0x0c });
options.Overwrite(options.Length - (EthClick._name.Length + 2), DNS.EncodeDnsName(EthClick._name));
}
options.Overwrite(options.Length - 1, new byte[] { 0xFF });
Scratch.Overwrite(46, _transactionId);
var result = Utility.CombineArrays(Scratch, options);
result.Overwrite(16, ((ushort)(result.Length - 14)).ToBytes());
result.Overwrite(38, ((ushort)(result.Length - 34)).ToBytes());
result.Overwrite(24, new byte[] { 0x00, 0x00 });
result.Overwrite(24, result.InternetChecksum(20, 14));
result.Overwrite(40, new byte[] { 0x00, 0x00 });
EthClick.SendFrame(result);
}
}
public static void Main()
{
/* Use this for Static IP and No DHCP */
//_eth.Name = "Quail";
//_eth.MacAddress = _eth.GenerateUniqueMacAddress("Quail");
//_eth.IPAddress = "192.168.1.95".ToBytes();
//_eth.DefaultGateway = "192.168.1.1".ToBytes();
//_eth.PreferredDomainNameServer = "8.8.8.8".ToBytes(); // Google DNS Servers
//_eth.AlternateDomainNameServer = "8.8.8.4".ToBytes(); // Google DNS Servers
//_eth.DHCPDisabled = true;
_eth = new EthClick(Hardware.SocketOne);
_eth.Start(_eth.GenerateUniqueMacAddress("MikroBusNet"), "MikroBusNet");
while (true)
{
if (_eth.ConnectedToInternet)
{
Debug.Print("Connected to Internet");
break;
}
Debug.Print("Waiting on Internet connection");
}
var r = new HttpRequest("http://services.odata.org/V2/(S(fhsma0h0orzoqo55jjrw1wyq))/OData/OData.svc/");
r.Headers.Add("Accept", "*/*");
var response = r.Send();
if (response != null)
{
Debug.Print("Response: " + response.Message);
}
else
{
Debug.Print("No response");
}
/* Alternate example using a different service */
//const int minVal = 0;
//const int maxVal = 100;
//string apiUrl = @"http://www.random.org/integers/?num=1"
// + "&min=" + minVal + "&max=" + maxVal
// + "&col=1&base=10&format=plain&rnd=new";
//var request = new HttpRequest(apiUrl);
//request.Headers.Add("Accept", "*/*");
//HttpResponse response = request.Send();
if (response != null)
{
Debug.Print("Random number: " + response.Message.Trim());
}
else
{
Debug.Print("No response");
}
Thread.Sleep(Timeout.Infinite);
}
