Trying to make a TCP server, client connects and disconnects immediately

[Gan via Digitalmars-d-learn]

I managed to get the client to connect but immediately on the 
server side, this happens:

long length = player.playerSocket.receive(buf);
                if (length == 0) { //No longer connected
                        player.playerSocket.shutdown(SocketShutdown.BOTH);
                        player.playerSocket.close();
                }
The player's socket receives a 0 length which means the 
connection is dead. Why does that happen?

Here's my full server-side networking code:

module server.networkingandio.networkingcontroller;
import server.server;
import server.player.player;

import std.socket;
import std.stdio;
import core.thread;
import std.range;
import std.traits;
import std.typecons;
import std.typetuple;
import std.algorithm;
import std.concurrency;

class NetworkingController
{
        Server server;

        Player[] players;

        TcpSocket socket;

        this(Server s)
        {
                server = s;
                players = new Player[](0);
                writeln("Server active on port 7777");

                socket = new TcpSocket();
                socket.bind(new InternetAddress(7777));
                socket.listen(100);
                socket.blocking = true;

                spawn(&handleNewConnectionsThread, cast(shared)socket);
        }
        void logic() {
                //Check for new sockets
                bool receivedNewSocket = true;
                while (receivedNewSocket) {
                        receivedNewSocket = receiveTimeout(0.msecs,
                                (shared NewConnectionMsg message) {
                                        NewConnectionMsg msg = 
cast(NewConnectionMsg)message;
                                        newConnection(msg.socket);
                                },
                                (shared ReceiveDataMsg message) {
					//Convert data to MessageReader, send to server message 
handler
                                }
                        );
                }

                //Check for dead sockets
                for (int i = 0; i < players.length; i++) {
                        Player p = players[i];
                        if (p.playerSocket.isAlive == false) {
                                players = players.remove(i);
                                i--;
                                server.removeConnection(p);
                        }
                }
                //Check for socket messages
        }
        void newConnection(Socket conn) {
                Player p = new Player(conn, this);
                players ~= p;
                server.newConnection(p);
                //Set up listener for player socket
                spawn(&handleReceiveDataThread, cast(shared)p);
        }
}
class NewConnectionMsg {
        Socket socket;
        this(Socket socket) {
                this.socket = socket;
        }
}
class ReceiveDataMsg {
        Player player;
        ubyte[] data;
        this(Player player, ubyte[] data) {
                this.player = player;
                this.data = data;
        }
}

void handleNewConnectionsThread(shared TcpSocket s) {
        Socket socket = cast(Socket)s;
        while(socket.isAlive) {
                Socket playerSocket = socket.accept();
                if (playerSocket !is null && playerSocket.isAlive == true) {
                        playerSocket.blocking = true;
                        ownerTid.send(cast(shared) new 
NewConnectionMsg(playerSocket));
                }
        }
        scope(exit)socket.close();
}

void handleReceiveDataThread(shared Player p) {
        Player player = cast(Player)p;
        while(player.playerSocket.isAlive) {
                ubyte[] buf = new ubyte[](0);
                long length = player.playerSocket.receive(buf);
                if (length == 0) { //No longer connected
                        player.playerSocket.shutdown(SocketShutdown.BOTH);
                        player.playerSocket.close();
                } else {
                        ownerTid.send(cast(shared) new ReceiveDataMsg(player, 
buf));
                }
        }
        scope(exit)player.playerSocket.close();
}