/**
* Function called for each of our connected neighbours. Notify the
* client about the existing neighbour.
*
* @param cls the `struct TransportClient *` to notify
* @param peer identity of the neighbour
* @param address the address
* @param state the current state of the peer
* @param state_timeout the time out for the state
* @param bandwidth_in inbound bandwidth in NBO
* @param bandwidth_out outbound bandwidth in NBO
*/
static void
notify_client_about_neighbour (void *cls,
const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Address *address,
enum GNUNET_TRANSPORT_PeerState state,
struct GNUNET_TIME_Absolute state_timeout,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
{
struct TransportClient *tc = cls;
struct ConnectInfoMessage *cim;
size_t size = sizeof (struct ConnectInfoMessage);
char buf[size] GNUNET_ALIGN;
if (GNUNET_NO == GST_neighbours_test_connected (peer))
return;
GNUNET_assert (size < GNUNET_SERVER_MAX_MESSAGE_SIZE);
cim = (struct ConnectInfoMessage *) buf;
cim->header.size = htons (size);
cim->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
cim->id = *peer;
cim->quota_in = bandwidth_in;
cim->quota_out = bandwidth_out;
unicast (tc, &cim->header, GNUNET_NO);
}
void
write_payload(struct member *memb) {
// allocate & serialize payload
printf("%s sending payload(%d)\n", memb->name, memb->payload->type);
char msg[ALLOC_BUF_SIZE];
serialize_payload(memb->payload, msg, ALLOC_BUF_SIZE);
unicast(memb, msg);
if (memb->payload->type == ROUND) {
++memb->current_round;
}
}
/**
* Send the given message to a particular client
*
* @param client target of the message
* @param msg message to transmit
* @param may_drop #GNUNET_YES if the message can be dropped
*/
void
GST_clients_unicast (struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *msg, int may_drop)
{
struct TransportClient *tc;
tc = lookup_client (client);
if (NULL == tc)
return; /* client got disconnected in the meantime, drop message */
unicast (tc, msg, may_drop);
}
/**
* Broadcast the given message to all of our clients.
*
* @param msg message to broadcast
* @param may_drop #GNUNET_YES if the message can be dropped / is payload
*/
void
GST_clients_broadcast (const struct GNUNET_MessageHeader *msg, int may_drop)
{
struct TransportClient *tc;
for (tc = clients_head; NULL != tc; tc = tc->next)
{
if ((GNUNET_YES == may_drop) && (GNUNET_YES != tc->send_payload))
continue; /* skip, this client does not care about payload */
unicast (tc, msg, may_drop);
}
}
/**
* Initialize a normal client. We got a start message from this
* client, add him to the list of clients for broadcasting of inbound
* messages.
*
* @param cls unused
* @param client the client
* @param message the start message that was sent
*/
static void
clients_handle_start (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
const struct StartMessage *start;
struct TransportClient *tc;
uint32_t options;
tc = lookup_client (client);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
"Client %p sent START\n", tc);
if (tc != NULL)
{
/* got 'start' twice from the same client, not allowed */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
"TransportClient %p ServerClient %p sent multiple START messages\n",
tc, tc->client);
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
start = (const struct StartMessage *) message;
options = ntohl (start->options);
if ((0 != (1 & options)) &&
(0 !=
memcmp (&start->self, &GST_my_identity,
sizeof (struct GNUNET_PeerIdentity))))
{
/* client thinks this is a different peer, reject */
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Rejecting control connection from peer `%s', which is not me!\n"),
GNUNET_i2s (&start->self));
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
tc = setup_client (client);
tc->send_payload = (0 != (2 & options));
unicast (tc, GST_hello_get (), GNUNET_NO);
GST_neighbours_iterate (¬ify_client_about_neighbour, tc);
GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
void ServerPlayer::sendProperty(const char *property_name){
QString value = property(property_name).toString();
unicast(QString(".%1 %2").arg(property_name).arg(value));
}
void ServerPlayer::invoke(const char *method, const QString &arg){
unicast(QString("%1 %2").arg(method).arg(arg));
}
