void sendmsg(zmq::socket_t &socket, DFHackMessaging::DFMessage &msg, string uuid) {
    DFHack::Console &con = DFHack::Core::getInstance().con;

    zmq::message_t zmsguuid(uuid.size());
    memcpy(zmsguuid.data(), uuid.data(), uuid.size());

    // Serialize protobuf message and copy to ZMQ message ready for transfer:
    string dataSerialized;
    msg.SerializePartialToString(&dataSerialized);
    zmq::message_t zmsgdata(dataSerialized.size());
    memcpy(zmsgdata.data(), dataSerialized.data(), dataSerialized.size());

    //con << "SERVER: Sending message to " << uuid << std::endl;
    //msgcount++;
    //con << msgcount << endl;

    try {
        socket.send(zmsguuid, ZMQ_SNDMORE); // Send the uuid identifier so routers knows who to send to.
        socket.send(zmsgdata); // Finally, send the data.
    } catch (std::exception &e) {
        con.print("Error: %s\n", zmq_strerror(errno));
    }
}

void recvMsg(zmq::socket_t &socket) {
    DFHack::Console &con = DFHack::Core::getInstance().con;

    int pollint;
    pollint = zmq::poll(items, 1, 0);

    while(items[0].revents & ZMQ_POLLIN) {
            DFHackMessaging::DFMessage  dfmsg;
            std::string                 uuid;

        while(true) {
            zmq::message_t      zmsg;
            //std::string           zmsgdata(static_cast<char*>(zmsg.data()));
            std::string         zmsgdata;

            socket.recv(&zmsg); // Retrieve message part

            /****************************** Debugging *******************************/
            //con << "----------------------------------------" << std::endl;
            /*con << "           Incoming Message             " << std::endl;
            bool                is_text = true;
            int                 char_nbr;
            unsigned char       byte;
            for (char_nbr = 0; char_nbr < zmsg.size(); char_nbr++) {
                byte = zmsgdata[char_nbr];
                if (byte < 32 || byte > 127)
                    is_text = false;
            }

            con.print("[%03d] ", zmsg.size());

            for (char_nbr = 0; char_nbr < zmsg.size(); char_nbr++) {
                if (is_text)
                    con.print("%c", zmsgdata[char_nbr]);
                else
                    con.print("%02X", (unsigned char) zmsgdata[char_nbr]);
            }
            con.print("\n");*/
            /*************************************************************************/

            // Must be the first message if uuid is empty. Get UUID:
            if(uuid.size() == 0) {
                uuid.assign(static_cast<char*>(zmsg.data()), zmsg.size());
            } else { // Must be the actual message. Parse it.
                /* Here we find out what the message is and perform any actions required. */
                dfmsg.ParseFromArray(zmsg.data(), zmsg.size());
                //dfmsg.set_uuid(uuid); // Rewrite the uuid to the proper value. This should be rewritten at some point.
                /********* Find out what message came in and action it ********************/
                if(dfmsg.has_dftile()) {
                    con << "Action: DFTile" << std::endl;
                }
                if(dfmsg.has_subtozlevel()) {
                    con << "Action: subscribeToMapZLevel" << std::endl;
                    subscribeToMapZLevel(uuid, dfmsg.subtozlevel().zlevel());
                }
            }

            // Multipart detection:
            int64_t more;
            size_t more_size = sizeof(more);
            socket.getsockopt(ZMQ_RCVMORE, &more, &more_size);

            if (!more)
                break;      //  Last message part
        }

        zmq::poll(&items [0], 1, 0);
    }
}

DFhackCExport command_result dfserver (DFHack::Core * c, vector <string> & parameters)
{
    // Prepare our context and socket
    zmq::context_t context(1);
    zmq::socket_t socket (context, ZMQ_ROUTER);
    socket.bind ("tcp://*:5555");

    // Initialize poll set
    items[0].socket = socket;
    items[0].events = ZMQ_POLLIN;

    while (1) {
        recvMsg(socket);
    }
}


/********************************* CLIENT CODE *********************************/
// MAIN
    // Prepare our context and socket
    zmq::context_t context (1);
    zmq::socket_t socket (context, ZMQ_DEALER);


    // Initialize poll set
    items[0].socket = socket;
    items[0].events = ZMQ_POLLIN;

    cout << "CLIENT: Connecting to DF server..." << std::endl;
    socket.connect("tcp://localhost:5555");

while(1) {
recvMsg(socket);
}


// END MAIN

void sendmsg(zmq::socket_t &socket, DFHackMessaging::DFMessage &msg) {
    string dataSerialized;

    // Serialize protobuf message and copy to ZMQ message ready for transfer:
    msg.SerializePartialToString(&dataSerialized);
    zmq::message_t msgdata(dataSerialized.size());
    memcpy(msgdata.data(), dataSerialized.data(), dataSerialized.size());

    try {
        socket.send(msgdata); // Finally, send the data.
    } catch (std::exception &e) {
        printf ("Error: %s\n", zmq_strerror(errno));
    }
}

void recvMsg(zmq::socket_t &socket) {
    int pollint;
    pollint = zmq::poll(items, 1, 0);

    while(items[0].revents & ZMQ_POLLIN) {
        DFHackMessaging::DFMessage  dfmsg;
        std::string                 uuid;
        zmq::message_t              zmsg;
        std::string                 zmsgdata;

        msgcount++;

        socket.recv(&zmsg); // Retrieve message part

        /****************************** Debugging *******************************/
        //cout << "----------------------------------------" << std::endl;
        //cout << "           Incoming Message             " << std::endl;
        //bool              is_text = true;
        //int                   char_nbr;
        //unsigned char     byte;
        //for (char_nbr = 0; char_nbr < zmsg.size(); char_nbr++) {
        //  byte = zmsgdata[char_nbr];
        //  if (byte < 32 || byte > 127)
        //      is_text = false;
        //}

        //printf("[%03d] ", zmsg.size());

        //for (char_nbr = 0; char_nbr < zmsg.size(); char_nbr++) {
        //  if (is_text)
        //      printf("%c", zmsgdata[char_nbr]);
        //  else
        //      printf("%02X", (unsigned char) zmsgdata[char_nbr]);
        //}
        //printf("\n");
        /*************************************************************************/


        /* Here we find out what the message is and perform any actions required. */
        dfmsg.ParseFromArray(zmsg.data(), zmsg.size());
        //dfmsg.set_uuid(uuid); // Rewrite the uuid to the proper value. This should be rewritten at some point.
        /********* Find out what message came in and action it ********************/
        if(dfmsg.has_dftile()) {
            //cout << "[msg " << msgcount << "] Action: DFTile" << std::endl;
            DFHack::DFCoord tilecoords(dfmsg.dftile().xgcoord(), dfmsg.dftile().ygcoord(), dfmsg.dftile().zgcoord());
            multimap<DFHack::DFCoord, LEO::Cube*>::iterator iter = blockMap.find(tilecoords);
            if(iter == blockMap.end()) {
                if( dfmsg.dftile().shape() != DFHack::TileShape::EMPTY) {
                    //AppLog("Creating a cube...");
                    //Cube *box = new Cube(CREATENOW);
                    //box->SetOcclusionMode(true);
                    //box->Move(tilecoords.y, 0, tilecoords.x);
                    //if( dfmsg.dftile().shape() == DFHack::TileShape::WALL)
                    //  box->SetColor(Vec4(0,0,1,1)); // Blue
                    Cube box = masterCube->Copy();
                    box.SetOcclusionMode(true);
                    box.Move(tilecoords.y, 0, tilecoords.x);
                    if( dfmsg.dftile().shape() == DFHack::TileShape::WALL)
                        box.SetColor(Vec4(0,0,1,1)); // Blue

                    //blockMap.insert( pair<DFHack::DFCoord, LEO::Cube*>(tilecoords, box) );
                }
            }
        }

        zmq::poll(&items [0], 1, 0);
    }
}