int ISocketsDriver.bind(int socket, IntPtr address, int addressLen)
{
SocketData sd = null;
if (!GetSocketData(socket, out sd))
{
return(ReturnError(SocketError.NotSocket));
}
try
{
SockAddr sa = new SockAddr();
sa.MarshalFromNative(address);
if (sa.sin_port == 80)
{
sa.sin_port++;
}
IPEndPoint ep = new IPEndPoint(sa.sin_addr, sa.sin_port);
sd.Socket.Bind(ep);
}
catch (SocketException se)
{
return(ReturnError(se.SocketErrorCode));
}
catch
{
return(ReturnError(SocketError.SocketError));
}
return((int)SocketError.Success);
}
/// <summary>
/// Executes the request on the base handle.
/// </summary>
public void Connect()
{
var addr = SockAddr.FromIpEndPoint(this.EndPoint);
Libuv.EnsureSuccess(Libuv.uv_tcp_connect(this, this.BaseHandle, ref addr, _UvConnectCallback));
this.EndPoint = null;
}
public void OnPeerDisconnected(UInt32 handle, UInt32 ip, UInt16 port, IntPtr param)
{
if (handle == Handle)
{
SockAddr sockAddr = new SockAddr(ip, port);
/*
* foreach (Peer peer in Peers)
* {
* if (peer.Addr.Equals(sockAddr))
* {
* Peers.Remove(peer);
* return;
* }
* }
*/
Peer peer = Peers.Find((x) => x.Addr.Equals(sockAddr));
if (peer != null)
{
Peers.Remove(peer);
}
OnPropertyChanged("Peers");
}
}
int ISocketsDriver.getpeername(int socket, IntPtr name, ref int namelen)
{
Socket sock = null;
if (!GetSocket(socket, out sock))
{
return(ReturnError(SocketError.NotSocket));
}
int ret = (int)SocketError.Success;
try
{
IPEndPoint ep = sock.RemoteEndPoint as IPEndPoint;
SockAddr addr = new SockAddr();
addr.sin_addr = IPAddressToUint(ep.Address);
addr.sin_family = (short)ep.AddressFamily;
addr.sin_port = (ushort)ep.Port;
addr.MarshalToNative(name);
}
catch (SocketException se)
{
ret = ReturnError(se.SocketErrorCode);
}
return(ret);
}
int ISocketsDriver.connect(int socket, IntPtr address, int addressLen)
{
Socket sock = null;
if (!GetSocket(socket, out sock))
{
return(ReturnError(SocketError.NotSocket));
}
try
{
SockAddr sa = new SockAddr();
sa.MarshalFromNative(address);
sock.BeginConnect(new IPEndPoint(sa.sin_addr, sa.sin_port), new AsyncCallback(EndSockConnect), socket);
}
catch (SocketException se)
{
return(ReturnError(se.SocketErrorCode));
}
catch
{
return(ReturnError(SocketError.SocketError));
}
return(ReturnError(SocketError.WouldBlock));
}
/// <summary>
/// Binds the handle to the specified end point.
/// </summary>
/// <param name="endPoint"></param>
public void Bind(IPEndPoint endPoint)
{
this.EnsureCallingThread();
var addr = SockAddr.FromIpEndPoint(endPoint);
Libuv.EnsureSuccess(Libuv.uv_tcp_bind(this, ref addr, 0));
}
} // END RefreshGeneralTabPage
public ListViewItem FindPeerInPeerListView(SockAddr peerSockAddr)
{
for (Int32 i = 0; i < mPeersListView.Items.Count; i++)
{
SockAddr sockAddr = (SockAddr)mPeersListView.Items[i].Tag;
if (sockAddr == peerSockAddr)
{
return(mPeersListView.Items[i]);
}
}
return(null);
} // END FindPeerInPeerListView
public void OnPeerConnected(UInt32 handle, UInt32 ip, UInt16 port, IntPtr param)
{
if (handle == Handle)
{
SockAddr sockAddr = new SockAddr(ip, port);
if (Peers.Find(x => x.Addr == sockAddr) == null)
{
Peer peer = new Peer(sockAddr);
Peers.Add(peer);
OnPropertyChanged("Peers");
}
}
}
int ISocketsDriver.recvfrom(int socket, IntPtr buf, int len, int flags, IntPtr from, ref int fromlen)
{
SocketData sd = null;
if (!GetSocketData(socket, out sd))
{
return(ReturnError(SocketError.NotSocket));
}
try
{
if (sd.Socket.Poll(0, SelectMode.SelectRead))
{
byte[] data = new byte[len];
int read = 0;
SockAddr fromAddr = new SockAddr();
fromAddr.MarshalFromNative(from);
EndPoint fromEP = new IPEndPoint(fromAddr.sin_addr, fromAddr.sin_port);
read = sd.Socket.ReceiveFrom(data, 0, len, (SocketFlags)flags, ref fromEP);
Marshal.Copy(data, 0, buf, read);
fromAddr.sin_addr = IPAddressToUint(((IPEndPoint)fromEP).Address);
fromAddr.sin_port = (ushort)((IPEndPoint)fromEP).Port;
fromAddr.sin_family = (short)((IPEndPoint)fromEP).AddressFamily;
fromAddr.MarshalToNative(from);
return(read);
}
}
catch (SocketException se)
{
return(ReturnError((SocketError)se.ErrorCode));
}
finally
{
ClearSocketEvent(socket, true);
}
return(ReturnError(SocketError.WouldBlock));
}
int ISocketsDriver.getsockname(int socket, IntPtr name, ref int namelen)
{
Socket sock = null;
if (!GetSocket(socket, out sock))
{
return(ReturnError(SocketError.NotSocket));
}
int ret = (int)SocketError.Success;
try
{
IPEndPoint ep = sock.LocalEndPoint as IPEndPoint;
SockAddr addr = new SockAddr();
if (IPAddress.IsLoopback(ep.Address))
{
addr.sin_addr = IPAddressToUint(ep.Address);
}
else
{
IPHostEntry ipEntry = Dns.GetHostEntry(ep.Address);
for (int i = 0; i < ipEntry.AddressList.Length; i++)
{
if (ipEntry.AddressList[i].AddressFamily == AddressFamily.InterNetwork)
{
addr.sin_addr = IPAddressToUint(ipEntry.AddressList[i]);
}
}
}
addr.sin_family = (short)ep.AddressFamily;
addr.sin_port = (ushort)ep.Port;
addr.MarshalToNative(name);
}
catch (SocketException se)
{
ret = ReturnError(se.SocketErrorCode);
}
return(ret);
}
public void EndPointConversionTest(string ipString, AddressFamily addressFamily, bool isIPv4MappedToIPv6, string mappedIp)
{
var ip = IPAddress.Parse(ipString);
var randomPort = _Random.Next(0, 65536);
var endPoint = new IPEndPoint(ip, randomPort);
var resultEndPoint = SockAddr.FromIpEndPoint(endPoint).ToIpEndPoint();
Assert.Equal(endPoint.AddressFamily, resultEndPoint.AddressFamily);
Assert.Equal(endPoint.Address.ToString(), resultEndPoint.Address.ToString());
Assert.Equal(randomPort, resultEndPoint.Port);
Assert.Equal(ipString, resultEndPoint.Address.ToString());
Assert.Equal(addressFamily, resultEndPoint.AddressFamily);
Assert.Equal(isIPv4MappedToIPv6, resultEndPoint.Address.IsIPv4MappedToIPv6);
if (mappedIp != null)
{
Assert.Equal(mappedIp, resultEndPoint.Address.MapToIPv4().ToString());
}
}
int ISocketsDriver.sendto(int socket, IntPtr buf, int len, int flags, IntPtr to, ref int tolen)
{
SocketData sd = null;
if (!GetSocketData(socket, out sd))
{
return(ReturnError(SocketError.NotSocket));
}
try
{
if (sd.Socket.Poll(0, SelectMode.SelectWrite))
{
byte[] data = new byte[len];
int sent = 0;
Marshal.Copy(buf, data, 0, len);
SockAddr toAddr = new SockAddr();
toAddr.MarshalFromNative(to);
IPEndPoint toEP = new IPEndPoint(toAddr.sin_addr, toAddr.sin_port);
sent = sd.Socket.SendTo(data, 0, len, (SocketFlags)flags, toEP);
ClearSocketEvent(socket, false);
return(sent);
}
}
catch (SocketException se)
{
return(ReturnError((SocketError)se.ErrorCode));
}
return(ReturnError(SocketError.WouldBlock));
}
public Peer(SockAddr addr)
{
this.Addr = addr;
}
public void ArgumentNullExceptionTest()
{
Assert.Throws <ArgumentNullException>(() => SockAddr.FromIpEndPoint(null));
}
private static extern int connecti(int sockf, SockAddr addr, int len);
public static extern int sendto(IntPtr Socket, IntPtr buff, int len, SendDataFlags flags, ref SockAddr To, int tomlen);
public static extern Int32 sendto(IntPtr Socket, IntPtr buffer, Int32 length, SendDataFlags flags, ref SockAddr To, Int32 tomlen);
} // END FindPeerInPeerListView
public void RefreshPeersTab(TorrentHandle torrentId)
{
UInt32 numConnectedPeers = DllInterface.NumberOfConnectedPeers(torrentId);
if (numConnectedPeers == 0)
{
return;
}
// this approach allocates space for the data here, UNMANAGED needs freeing
IntPtr[] ps = new IntPtr[numConnectedPeers];
for (int n = 0; n < numConnectedPeers; n++)
{
ps[n] = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(DllInterface.sPeerInfo)));
}
UInt32 numWritten = DllInterface.GetConnectedPeersInfo(torrentId, ps, numConnectedPeers);
DllInterface.sPeerInfo[] peersInfo = new DllInterface.sPeerInfo[numConnectedPeers];
for (int i = 0; i < numConnectedPeers; i++)
{
peersInfo[i] = (DllInterface.sPeerInfo)Marshal.PtrToStructure(ps[i], typeof(DllInterface.sPeerInfo));
}
/*
* // this approach relies on the called function allocating space for the data
* IntPtr ptrArray = IntPtr.Zero;
* int count = DllInterface.ArrayTest(ref ptrArray);
* DllInterface.sPeerInfo sAddr = (DllInterface.sPeerInfo)Marshal.PtrToStructure(ptrArray, typeof(DllInterface.sPeerInfo));
* for (int i = 0; i < count; i++)
* {
* IntPtr nextPtr = new IntPtr(ptrArray.ToInt32() + i * Marshal.SizeOf(sAddr));
* sAddr = (DllInterface.sPeerInfo)Marshal.PtrToStructure(nextPtr, typeof(DllInterface.sPeerInfo));
*
* Console.WriteLine("{0} {1}", sAddr.addr, sAddr.port);
* }
*/
// remove peers we are no longer connected to
for (Int32 i = 0; i < mPeersListView.Items.Count; i++)
{
SockAddr listId = (SockAddr)mPeersListView.Items[i].Tag;
bool found = false;
for (UInt32 j = 0; j < numConnectedPeers; j++)
{
SockAddr peerId = new SockAddr(peersInfo[j].mIp, peersInfo[j].mPort);
if (listId == peerId)
{
found = true;
break;
}
}
if (!found)
{
mPeersListView.Items.RemoveAt(i);
i = -1;
}
}
for (UInt32 i = 0; i < numConnectedPeers; i++)
{
if (peersInfo[i].mHandshakeRecvd == false)
{
continue;
}
// keep a copy of the ip & port as the id
SockAddr peersSockAddr = new SockAddr(peersInfo[i].mIp, peersInfo[i].mPort);
ListViewItem listViewItem = FindPeerInPeerListView(peersSockAddr);
ListViewItem.ListViewSubItem peerIdItem;
ListViewItem.ListViewSubItem percentageItem;
ListViewItem.ListViewSubItem downSpeedItem;
ListViewItem.ListViewSubItem upSpeedItem;
ListViewItem.ListViewSubItem reqsItem;
ListViewItem.ListViewSubItem flagsItem;
ListViewItem.ListViewSubItem connectionTypeItem;
ListViewItem.ListViewSubItem totalDownloadedItem;
ListViewItem.ListViewSubItem totalUploadedItem;
ListViewItem.ListViewSubItem connectionLengthItem;
if (listViewItem == null)
{
// create the new item and pass the ip string
listViewItem = new System.Windows.Forms.ListViewItem(String.Format("{0}.{1}.{2}.{3} : {4}", peersInfo[i].mIp[0], peersInfo[i].mIp[1], peersInfo[i].mIp[2], peersInfo[i].mIp[3], peersInfo[i].mPort));
// peer id
peerIdItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(peerIdItem);
// % done
percentageItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(percentageItem);
// dl
downSpeedItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(downSpeedItem);
// ul
upSpeedItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(upSpeedItem);
// reqs
reqsItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(reqsItem);
// flags
flagsItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(flagsItem);
// connection type
connectionTypeItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(connectionTypeItem);
// total downloaded
totalDownloadedItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(totalDownloadedItem);
// total uploaded
totalUploadedItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(totalUploadedItem);
// Connection Length
connectionLengthItem = new ListViewItem.ListViewSubItem(listViewItem, "");
listViewItem.SubItems.Add(connectionLengthItem);
listViewItem.Tag = peersSockAddr;
mPeersListView.Items.AddRange(new System.Windows.Forms.ListViewItem[] { listViewItem });
}
else
{
peerIdItem = listViewItem.SubItems[1];
percentageItem = listViewItem.SubItems[2];
downSpeedItem = listViewItem.SubItems[3];
upSpeedItem = listViewItem.SubItems[4];
reqsItem = listViewItem.SubItems[5];
flagsItem = listViewItem.SubItems[6];
connectionTypeItem = listViewItem.SubItems[7];
totalDownloadedItem = listViewItem.SubItems[8];
totalUploadedItem = listViewItem.SubItems[9];
connectionLengthItem = listViewItem.SubItems[10];
}
String strNewValue;
// peer id
System.Text.ASCIIEncoding ae = new System.Text.ASCIIEncoding();
String strPeerId = ae.GetString(peersInfo[i].mPeerId);
if (peerIdItem.Text != strPeerId)
{
peerIdItem.Text = strPeerId;
}
// % done
strNewValue = String.Format("{0:0.0}%", peersInfo[i].mPercentageDone);
if (percentageItem.Text != strNewValue)
{
percentageItem.Text = strNewValue;
}
// dl
float speed = ((float)peersInfo[i].mDlRate / 1024.0f);
strNewValue = String.Format("{0:0.0} kB/s", speed);
if (downSpeedItem.Text != strNewValue)
{
downSpeedItem.Text = strNewValue;
}
// ul
speed = ((float)peersInfo[i].mUlRate / 1024.0f);
strNewValue = String.Format("{0:0.0} kB/s", speed);
if (upSpeedItem.Text != strNewValue)
{
upSpeedItem.Text = strNewValue;
}
// reqs
strNewValue = String.Format("{0} | {1}", peersInfo[i].mOustandingDownloadRequests, peersInfo[i].mOustandingUploadRequests);
if (reqsItem.Text != strNewValue)
{
reqsItem.Text = strNewValue;
}
// Flags
String strFlags = "";
if (peersInfo[i].mAmChoking == 1)
{
strFlags = strFlags + "C";
}
if (peersInfo[i].mIsChokingMe == 1)
{
strFlags = strFlags + "c";
}
if (peersInfo[i].mAmInterested == 1)
{
strFlags = strFlags + "I";
}
if (peersInfo[i].mIsInterestedInMe == 1)
{
strFlags = strFlags + "i";
}
if (flagsItem.Text != strFlags)
{
flagsItem.Text = strFlags;
}
// Connection type
if ((peersInfo[i].mConnectionFlags & (byte)DllInterface.sPeerInfo.ConnectionFlag.INCOMING_CONNECTION) != 0)
{
strNewValue = "Incoming";
}
else
{
strNewValue = "Outgoing";
}
if ((peersInfo[i].mConnectionFlags & (byte)DllInterface.sPeerInfo.ConnectionFlag.ENCRYPTED_CONNECTION) != 0)
{
strNewValue += " Encrypted";
}
else
{
strNewValue += " Unencrypted";
}
if (connectionTypeItem.Text != strNewValue)
{
connectionTypeItem.Text = strNewValue;
}
// total downloaded
strNewValue = FormatBytes(peersInfo[i].mTotalBytesDownloaded);
if (totalDownloadedItem.Text != strNewValue)
{
totalDownloadedItem.Text = strNewValue;
}
// total uploaded
strNewValue = FormatBytes(peersInfo[i].mTotalBytesUploaded);
if (totalUploadedItem.Text != strNewValue)
{
totalUploadedItem.Text = strNewValue;
}
// Connection Length
TimeSpan t = TimeSpan.FromSeconds(peersInfo[i].mConnectionLengthInSeconds);
if (t.Days > 0)
{
strNewValue = string.Format("{0}d {1:D2}h {2:D2}m", t.Days, t.Hours, t.Minutes);
}
else if (t.Hours > 0)
{
strNewValue = string.Format("{0}h {1:D2}m", t.Hours, t.Minutes);
}
else if (t.Minutes > 0)
{
strNewValue = string.Format("{0} minute", t.Minutes);
if (t.Minutes > 1)
{
strNewValue = strNewValue + "s";
}
}
else
{
strNewValue = string.Format("{0} seconds", t.Seconds);
}
if (connectionLengthItem.Text != strNewValue)
{
connectionLengthItem.Text = strNewValue;
}
}
// free the unmanaged memory
for (int n = 0; n < ps.Length; n++)
{
Marshal.FreeHGlobal(ps[n]);
}
} // END RefreshPeersTab
public static void ip6_addr(string ip, int port, out SockAddr addr, out UVException error)
{
Check(uv_ip6_addr(ip, port, out addr), out error);
}
public static void tcp_connect(UVConnectRquest handle, UVTCPHandle socket, ref SockAddr addr, uv_connect_cb cb)
{
handle.Validate();
ThrowIfErrored(uv_tcp_connect(handle, socket, ref addr, cb));
}
public static void tcp_bind(UVTCPHandle handle, ref SockAddr addr, int flags)
{
handle.Validate();
ThrowIfErrored(uv_tcp_bind(handle, ref addr, flags));
}
/*
* This is the winsock hook which intercepts the "sendto" method.
*/
private int SendToHook(IntPtr Socket, IntPtr buff, int len, SendDataFlags flags, ref SockAddr To, int tomlen)
{
int returnCode = 0;
try
{
returnCode = sendto(Socket, buff, len, flags, ref To, tomlen);
if (returnCode == -1)
{
int errCode = Marshal.GetLastWin32Error();
if (errCode == (int)WSA_ERROR.WSAENOTSOCK)
{
// swallow the original eeror and spoof a good return code
this.handler.OnErrorCaptured(this.applicationName, "sendto", this.processName, errCode);
WSASetLastError(0);
returnCode = 0;
}
}
}
catch (Exception exception)
{
this.handler.OnError(this.applicationName, this.processName, exception);
}
return(returnCode);
}
public static void tcp_getpeername(UVTCPHandle handle, out SockAddr addr, ref int namelen)
{
handle.Validate();
ThrowIfErrored(uv_tcp_getpeername(handle, out addr, ref namelen));
}
private Int32 MySendTo(IntPtr Socket, IntPtr buffer, Int32 length, SendDataFlags flags, ref SockAddr To, Int32 tomlen)
{
// this.HookClient.Log("sendto");
return(0);
// return sendto(Socket, buffer, length, flags, ref To, tomlen);
}
public override bool Equals(object o)
{
SockAddr rhs = o as SockAddr;
return(Ip == rhs.Ip && Port == rhs.Port);
}
public static extern int uv_tcp_bind(UVTCPHandle handle, ref SockAddr addr, int flags);
public static extern Int32 recvfrom(IntPtr Socket, IntPtr buffer, Int32 length, SendDataFlags flags, ref SockAddr from, IntPtr fromlen);
public static extern int uv_ip6_addr(string ip, int port, out SockAddr addr);
public Int32 MyRecvFrom(IntPtr Socket, IntPtr buffer, Int32 length, SendDataFlags flags, ref SockAddr from, IntPtr fromlen)
{
// this.HookClient.Log("recvfrom");
return(0);
// return recvfrom(Socket, buffer, length, flags, ref from, IntPtr.Zero);
}
public static extern int uv_tcp_connect(UVConnectRquest connect, UVTCPHandle socket, ref SockAddr addr, uv_connect_cb cb);
public static extern int uv_tcp_getpeername(UVTCPHandle handle, out SockAddr name, ref int namelen);
private static extern int bind(int sockf, SockAddr addr, int len);
