std.socket tutorials? examples?

[bauss]

On Thursday, 4 October 2018 at 09:54:40 UTC, Chris Katko wrote:
> On Thursday, 4 October 2018 at 08:52:28 UTC, Andrea Fontana 
> wrote:
>> On Thursday, 4 October 2018 at 08:32:13 UTC, Chris Katko wrote:
>>> I've been Google'ing and there's like... nothing out there.
>>>
>>> One of the top results for "std.socket dlang examples"... is 
>>> for TANGO. That's how old it is.
>>
>> Socket paradigm is quite standard across languages.
>>
>> Anyway you can find a couple of example here:
>> https://github.com/dlang/dmd/blob/master/samples/listener.d
>> https://github.com/dlang/dmd/blob/master/samples/htmlget.d
>>
>> Andrea
>
> I was hoping someone would have a walk-through or something. 
> Those examples are 110 lines each!
>
> Usually, with D, there's plenty of useful 
> paradigms/templates/Phobos magic. So if I just port a C/C++/C# 
> socket example over, how am I supposed to know if I'm doing it 
> "the right/proper/best way" in D? That kind of thing.

Not exactly a tutorial or a walkthrough, but I'll try to explain 
basic usage of std.socket using an asynchronous tcp server as 
example.

Usually sockets are pretty low-level though, so not a lot of D 
magic will be present in the example.

First of all D implements classes for the two most common 
protocols UDP and TCP, both called UdpSocket and TcpSocket for 
obvious reasons.

We'll focus on TcpSocket in these examples, but using UdpSocket 
is not much different if you at the very least understand UDP and 
how it works.

The first thing you want to do for the server is creating a new 
instance of the TcpSocket class.

```
auto server = new TcpSocket;
```

Then to make it a non-blocking socket you simply set "blocking" 
to false.

This will call the low-level OS functions that creates 
non-blocking sockets on Windows it would be: ioctlsocket().

https://docs.microsoft.com/en-us/windows/desktop/api/winsock/nf-winsock-ioctlsocket

For Posix it would be fcntl() wih first "F_GETFL" and then 
"F_SETFL" where the flags are updated with "O_NONBLOCK"

http://man7.org/linux/man-pages/man2/fcntl.2.html

```
server.blocking = false;
```

The next thing we do is binding the socket.

In D you can use the "InternetAddress" class to construct a valid 
address for the socket.


```
server.bind(new InternetAddress(ip, port));
```

"ip" and "port" can be changed to the ip and port of your server.

Ex:

```
const ip = "127.0.0.1";
const port = 9988;
```

Once the socket has been bound then we can simply listen for 
connections.

It can be done with the listen function.

```
server.listen(100); // The backlog is set to 100, can be whatever 
you prefer.
```

As you can see so far there has been no real D magic, because 
it's pretty low-level.

Now to actual listen for the connections etc. it'll be a little 
more complex, because we're going to use the "SocketSet" class.

The major difference between something like implementing sockets 
in ex. C++ and D is that in D you don't have to implement your 
socket logic per platform, because phobos already creates that 
logic for you. Of course that's not taking something like boost 
into account which gives same usability in C++.

The next thing is to actually accept the sockets and since we're 
using non-blocking sockets then we don't really need to make a 
separate thread for accepting them, neither do the sockets 
actually need a thread for themselves.

First we need some collection that can hold all current sockets 
accepted (An array will be fine for now.)

```
Socket[] clients;
```

Then we'll create two instances of the "SocketSet" class.

That's because we need a socket set for the server socket and one 
for all the connected sockets.

```
auto serverSet = new SocketSet;
auto clientSet = new SocketSet;
```

A simple infinite while loop will be okay.

```
while (true)
{
     ...
}
```

Now let's dive into our loop, because this is where the "magic" 
of the socket handling actually happens.

At the beginning of the loop we'll want to reset the socket sets.

This can be done using the "reset" function.

This would most definitely be handled differently in a more 
performance critical server, but you'd also use multiple threads 
that each holds a set of sockets etc. we'll not do such things 
for the sake of simplicity.

```
serverSet.reset();
clientSet.reset();
```
First we want to add the server socket to "serverSet".

```
serverSet.add(server);
```

Next we'll loop through our client array and add each socket to 
the client set.

```
if (clients)
{
   foreach (client; clients)
   {
     clientSet.add(client);
   }
}
```

At first we want to check if there are any new sockets connected 
that we can accept.

By calling "Socket.select()" we can get different socket states 
based on a socket set.

```
auto serverResult = Socket.select(serverSet, null, null);
```

If the result from "Socket.select()" is below 1 then there are no 
new sockets to accept.

If the result is 0 then it timed out, if it's -1 then it was 
interrupted.

We want to check for that before we can call "accept()"

```
if (serverResult > 0)
{
   auto client = server.accept();

   ...
}
```

Once we have called "accept()" and received a socket then we can 
add that to our client array.


```
if (client)
{
   clients ~= client;
}
```

The next thing is to simply read data from the sockets.

Again we need to check the set's result using "Socket.select()" 
to make sure there actually are sockets that have data we can 
read from.

```
auto clientResult = Socket.select(clientSet, null, null);

if (clientSet < 1)
{
   continue;
}

```

If the result is above 0 then we have sockets that can be read 
from.

The next thing is simply to read the data they have available.

Now we want to loop through each client and check if they're in 
the set.

They will be removed from the set if they don't have data.

```
foreach (client; clients)
{
   if (!clientSet.isSet(client))
   {
     continue;
   }

   ...
}
```

You simply call the "receive()" function with a buffer and it'll 
fill the buffer with the data currently available.

If the function returns 0 then it has disconnected.

In that case you can remove it from the client array. Normally an 
associative array would be more suitable, because we can give 
each socket an identifier.

Else you can check if the function returned "Socket.ERROR" which 
generally means disconnect in one way or another, but it could be 
more specific.

If the value is above 0 then it'll be the amount of bytes that 
were available in the socket.

```
auto buffer = new ubyte[1024];

auto received = client.receive(buffer);

if (recv == 0 || recv == Socket.ERROR)
{
   continue; // Most likely disconnected ...
}

buffer = buffer[0 .. $]; // Slice the buffer to the actual size 
of the received data.
```

Important: The data received from "receive()" may not be the 
whole buffer when using non-blocking sockets; make sure that you 
have all the data before you start processing it and/or slices it.

Now the next thing to do is simply using the buffer with the data.

Disclaimer: This is not a 100% ideal way of writing socket 
applications, but it should be sufficient enough to get by for a 
start and to at least understand sockets in general.