void GameNetInterface::handleInfoPacket(const Address &remoteAddress, U8 packetType, BitStream *stream)
{
switch(packetType)
{
case Ping:
if(mGame->isServer())
handlePing(mGame, remoteAddress, mSocket, stream, mGame->getClientId());
break;
case PingResponse:
if(!mGame->isServer())
handlePingResponse(mGame, remoteAddress, stream);
break;
case Query:
if(mGame->isServer())
handleQuery(mGame, remoteAddress, mSocket, stream);
break;
case QueryResponse:
if(!mGame->isServer())
handleQueryResponse(mGame, remoteAddress, stream);
break;
default:
TNLAssert(false, "Unknown packetType!");
}
}
/**
* Handle an incoming control message from a switch.
*
* @param context the ducttape context.
* @param message the control message, this should be alligned on the beginning of the content,
* that is to say, after the end of the switch header.
* @param switchHeader the header.
* @param switchIf the interface which leads to the switch.
* @param isFormV8 true if the control message is in the form specified by protocol version 8+
*/
static Iface_DEFUN incomingFromCore(struct Message* msg, struct Iface* coreIf)
{
struct ControlHandler_pvt* ch = Identity_check((struct ControlHandler_pvt*) coreIf);
struct RouteHeader routeHdr;
Message_pop(msg, &routeHdr, RouteHeader_SIZE, NULL);
uint8_t labelStr[20];
uint64_t label = Endian_bigEndianToHost64(routeHdr.sh.label_be);
AddrTools_printPath(labelStr, label);
// happens in benchmark
// Log_debug(ch->log, "ctrl packet from [%s]", labelStr);
if (msg->length < 4 + Control_Header_SIZE) {
Log_info(ch->log, "DROP runt ctrl packet from [%s]", labelStr);
return NULL;
}
Assert_true(routeHdr.flags & RouteHeader_flags_CTRLMSG);
if (Checksum_engine(msg->bytes, msg->length)) {
Log_info(ch->log, "DROP ctrl packet from [%s] with invalid checksum", labelStr);
return NULL;
}
struct Control* ctrl = (struct Control*) msg->bytes;
if (ctrl->header.type_be == Control_ERROR_be) {
return handleError(msg, ch, label, labelStr);
} else if (ctrl->header.type_be == Control_KEYPING_be
|| ctrl->header.type_be == Control_PING_be)
{
return handlePing(msg, ch, label, labelStr, ctrl->header.type_be);
} else if (ctrl->header.type_be == Control_KEYPONG_be
|| ctrl->header.type_be == Control_PONG_be)
{
Log_debug(ch->log, "got switch pong from [%s]", labelStr);
Message_push(msg, &routeHdr, RouteHeader_SIZE, NULL);
return Iface_next(&ch->pub.switchPingerIf, msg);
}
Log_info(ch->log, "DROP control packet of unknown type from [%s], type [%d]",
labelStr, Endian_bigEndianToHost16(ctrl->header.type_be));
return NULL;
}
/**
* Handle an incoming control message from a switch.
*
* @param context the ducttape context.
* @param message the control message, this should be alligned on the beginning of the content,
* that is to say, after the end of the switch header.
* @param switchHeader the header.
* @param switchIf the interface which leads to the switch.
* @param isFormV8 true if the control message is in the form specified by protocol version 8+
*/
static Iface_DEFUN incomingFromCore(struct Message* msg, struct Iface* coreIf)
{
struct ControlHandler_pvt* ch = Identity_check((struct ControlHandler_pvt*) coreIf);
struct SwitchHeader switchHeader;
Message_pop(msg, &switchHeader, SwitchHeader_SIZE, NULL);
uint8_t labelStr[20];
uint64_t label = Endian_bigEndianToHost64(switchHeader.label_be);
AddrTools_printPath(labelStr, label);
Log_debug(ch->log, "ctrl packet from [%s]", labelStr);
if (msg->length < 4 + Control_Header_SIZE) {
Log_info(ch->log, "DROP runt ctrl packet from [%s]", labelStr);
return NULL;
}
Assert_true(Message_pop32(msg, NULL) == 0xffffffff);
if (Checksum_engine(msg->bytes, msg->length)) {
Log_info(ch->log, "DROP ctrl packet from [%s] with invalid checksum", labelStr);
return NULL;
}
struct Control* ctrl = (struct Control*) msg->bytes;
if (ctrl->header.type_be == Control_ERROR_be) {
return handleError(msg, ch, label, labelStr);
} else if (ctrl->header.type_be == Control_KEYPING_be
|| ctrl->header.type_be == Control_PING_be)
{
return handlePing(msg, ch, label, labelStr, ctrl->header.type_be);
} else if (ctrl->header.type_be == Control_KEYPONG_be
|| ctrl->header.type_be == Control_PONG_be)
{
Log_debug(ch->log, "got switch pong from [%s]", labelStr);
// Shift back over the header
Message_shift(msg, 4 + SwitchHeader_SIZE, NULL);
return Iface_next(&ch->pub.switchPingerIf, msg);
}
Log_info(ch->log, "DROP control packet of unknown type from [%s], type [%d]",
labelStr, Endian_bigEndianToHost16(ctrl->header.type_be));
return NULL;
}
/** Handle a command specific to the specification for this device */
void handleSpecificationCommand(byte* payload, unsigned int length) {
ArduinoCustom__Header header;
memset(buffer,0,300);
ArduinoCustom_testData testEvents;
pb_istream_t stream = pb_istream_from_buffer(payload, length);
if (pb_decode_delimited(&stream, ArduinoCustom__Header_fields, &header)) {
baseEvents_log("Decoded header for custom command.");
if (header.command == ArduinoCustom_Command_RGB_LED) {
if (pb_decode_delimited(&stream, ArduinoCustom_RGB_fields, &RGB_LED)) {
baseEvents_log("Command: RGB_LED set(h=%d, s=%d, b=%d)",
RGB_LED.rgbled_h, RGB_LED.rgbled_s, RGB_LED.rgbled_b);
hsb2rgb_led_open(RGB_LED.rgbled_h, RGB_LED.rgbled_s, RGB_LED.rgbled_b);
}
}
else if (header.command == ArduinoCustom_Command_DC_MOTOR) {
ArduinoCustom_DC_MOTOR dc_motor;
if (pb_decode_delimited(&stream, ArduinoCustom__Header_fields, &dc_motor)) {
baseEvents_log("Command: DC_MOTOR set: %d", dc_motor.motor_sw);
dc_motor_set(dc_motor.motor_sw);
}
}
else if (header.command == ArduinoCustom_Command_PING) {
ArduinoCustom_ping ping;
if (pb_decode_delimited(&stream, ArduinoCustom_ping_fields, &ping)) {
handlePing(ping, header.originator);
}
}
else if (header.command == ArduinoCustom_Command_TESTEVENTS) {
if (pb_decode_delimited(&stream, ArduinoCustom_testEvents_fields, &testEvents)) {
handleTestEvents(testEvents, header.originator);
}
}
else if (header.command == ArduinoCustom_Command_SERIALPRINTLN) {
ArduinoCustom_serialPrintln serialPrintln;
if (pb_decode_delimited(&stream, ArduinoCustom_serialPrintln_fields, &serialPrintln)) {
handleSerialPrintln(serialPrintln,header.originator);
}
}
else {
baseEvents_log("Unknown command.");
}
}
}
void ennoCommandMessageHandler(char* topic, char* payload, int length){
ArduinoCustom__Header header;
pb_istream_t stream = pb_istream_from_buffer(payload, length);
if (pb_decode_delimited(&stream, ArduinoCustom__Header_fields, &header)) {
printf("Decoded header for custom command.\n");
if (header.command == ArduinoCustom_Command_PING) {
ArduinoCustom_ping ping;
if (pb_decode_delimited(&stream, ArduinoCustom_ping_fields, &ping)) {
handlePing(ping, header.originator);
}
} else if (header.command == ArduinoCustom_Command_TESTEVENTS) {
ArduinoCustom_testEvents testEvents;
if (pb_decode_delimited(&stream, ArduinoCustom_testEvents_fields, &testEvents)) {
handleTestEvents(testEvents, header.originator);
}
} else if (header.command == ArduinoCustom_Command_SERIALPRINTLN) {
ArduinoCustom_serialPrintln serialPrintln;
if (pb_decode_delimited(&stream, ArduinoCustom_serialPrintln_fields, &serialPrintln)) {
handleSerialPrintln(serialPrintln, header.originator);
}
}
}
}
static Iface_DEFUN incomingMsg(struct Message* msg, struct Pathfinder_pvt* pf)
{
struct Address addr;
struct RouteHeader* hdr = (struct RouteHeader*) msg->bytes;
Message_shift(msg, -(RouteHeader_SIZE + DataHeader_SIZE), NULL);
Bits_memcpy(addr.ip6.bytes, hdr->ip6, 16);
Bits_memcpy(addr.key, hdr->publicKey, 32);
addr.protocolVersion = Endian_bigEndianToHost32(hdr->version_be);
addr.padding = 0;
addr.path = Endian_bigEndianToHost64(hdr->sh.label_be);
//Log_debug(pf->log, "Incoming DHT");
struct DHTMessage dht = {
.address = &addr,
.binMessage = msg,
.allocator = msg->alloc
};
DHTModuleRegistry_handleIncoming(&dht, pf->registry);
struct Message* nodeMsg = Message_new(0, 256, msg->alloc);
Iface_CALL(sendNode, nodeMsg, &addr, 0xfffffff0u, pf);
if (dht.pleaseRespond) {
// what a beautiful hack, see incomingFromDHT
return Iface_next(&pf->pub.eventIf, msg);
}
return NULL;
}
static Iface_DEFUN incomingFromEventIf(struct Message* msg, struct Iface* eventIf)
{
struct Pathfinder_pvt* pf = Identity_containerOf(eventIf, struct Pathfinder_pvt, pub.eventIf);
enum PFChan_Core ev = Message_pop32(msg, NULL);
if (Pathfinder_pvt_state_INITIALIZING == pf->state) {
Assert_true(ev == PFChan_Core_CONNECT);
return connected(pf, msg);
}
// Let the PF send another 128 path changes again because it's basically a new tick.
pf->bestPathChanges = 0;
switch (ev) {
case PFChan_Core_SWITCH_ERR: return switchErr(msg, pf);
case PFChan_Core_SEARCH_REQ: return searchReq(msg, pf);
case PFChan_Core_PEER: return peer(msg, pf);
case PFChan_Core_PEER_GONE: return peerGone(msg, pf);
case PFChan_Core_SESSION: return session(msg, pf);
case PFChan_Core_SESSION_ENDED: return sessionEnded(msg, pf);
case PFChan_Core_DISCOVERED_PATH: return discoveredPath(msg, pf);
case PFChan_Core_MSG: return incomingMsg(msg, pf);
case PFChan_Core_PING: return handlePing(msg, pf);
case PFChan_Core_PONG: return handlePong(msg, pf);
case PFChan_Core_UNSETUP_SESSION:
case PFChan_Core_LINK_STATE:
case PFChan_Core_CTRL_MSG: return NULL;
default:;
}
Assert_failure("unexpected event [%d]", ev);
}
static void sendEvent(struct Pathfinder_pvt* pf, enum PFChan_Pathfinder ev, void* data, int size)
{
struct Allocator* alloc = Allocator_child(pf->alloc);
struct Message* msg = Message_new(0, 512+size, alloc);
Message_push(msg, data, size, NULL);
Message_push32(msg, ev, NULL);
Iface_send(&pf->pub.eventIf, msg);
Allocator_free(alloc);
}
static void init(void* vpf)
{
struct Pathfinder_pvt* pf = Identity_check((struct Pathfinder_pvt*) vpf);
struct PFChan_Pathfinder_Connect conn = {
.superiority_be = Endian_hostToBigEndian32(1),
.version_be = Endian_hostToBigEndian32(Version_CURRENT_PROTOCOL)
};
CString_strncpy(conn.userAgent, "Cjdns internal pathfinder", 64);
sendEvent(pf, PFChan_Pathfinder_CONNECT, &conn, PFChan_Pathfinder_Connect_SIZE);
}
struct Pathfinder* Pathfinder_register(struct Allocator* allocator,
struct Log* log,
struct EventBase* base,
struct Random* rand,
struct Admin* admin)
{
struct Allocator* alloc = Allocator_child(allocator);
struct Pathfinder_pvt* pf = Allocator_calloc(alloc, sizeof(struct Pathfinder_pvt), 1);
Identity_set(pf);
pf->alloc = alloc;
pf->log = log;
pf->base = base;
pf->rand = rand;
pf->admin = admin;
pf->pub.eventIf.send = incomingFromEventIf;
pf->dhtModule.context = pf;
pf->dhtModule.handleOutgoing = incomingFromDHT;
// This needs to be done asynchronously so the pf can be plumbed to the core
Timeout_setTimeout(init, pf, 0, base, alloc);
return &pf->pub;
}
