bool nabto_fallback_connect_u_event(uint16_t packetLength, nabto_packet_header* hdr) {
nabto_connect* con;
uint8_t* startOfPayloads;
uint8_t* endOfPayloads;
uint8_t* noncePayloadStart;
uint16_t noncePayloadLength;
uint8_t type;
uint8_t flags;
uint8_t* ptr;
bool isReliable;
bool hasKeepAlive;
con = nabto_find_connection(hdr->nsi_sp);
if (con == 0) {
NABTO_LOG_TRACE((PRInsi " No connection found.", MAKE_NSI_PRINTABLE(hdr->nsi_cp, hdr->nsi_sp, 0)));
return false;
}
startOfPayloads = nabtoCommunicationBuffer + hdr->hlen;
endOfPayloads = nabtoCommunicationBuffer + packetLength;
if (!find_payload(startOfPayloads, endOfPayloads, NP_PAYLOAD_TYPE_NONCE, &noncePayloadStart, &noncePayloadLength)) {
NABTO_LOG_ERROR((PRI_tcp_fb "No nonce payload in GW_CONN_U packet.", TCP_FB_ARGS(con)));
return false;
}
if (noncePayloadLength < 2) {
NABTO_LOG_ERROR((PRI_tcp_fb "The payload received is too small to contain both flags and type.", TCP_FB_ARGS(con)));
return false;
}
ptr = noncePayloadStart + NP_PAYLOAD_HDR_BYTELENGTH;
READ_U8(type, ptr); ptr++;
READ_U8(flags, ptr); ptr++;
isReliable = (flags & NP_GW_CONN_U_FLAG_RELIABLE) != 0;
hasKeepAlive = (flags & NP_GW_CONN_U_FLAG_KEEP_ALIVE) != 0;
con->tcpFallbackConnectionState = UTFS_READY_FOR_DATA;
// If the connection is still resolving upgrade it to a fallback connection.
if (isReliable) {
con->fbConAttr |= CON_ATTR_NO_RETRANSMIT;
NABTO_LOG_DEBUG((PRI_tcp_fb "connection needs no retransmition", TCP_FB_ARGS(con)));
}
if (!hasKeepAlive) {
con->fbConAttr |= CON_ATTR_NO_KEEP_ALIVE;
NABTO_LOG_DEBUG((PRI_tcp_fb "connection needs no keep alive", TCP_FB_ARGS(con)));
} else {
NABTO_LOG_DEBUG((PRI_tcp_fb "connection needs keep alive", TCP_FB_ARGS(con)));
}
return true;
}
nabto_connect* nabto_init_connection_real(uint32_t nsi)
{
nabto_connect* con;
con = nabto_find_connection(nsi);
if (con) {
return NULL; //nsi is already present - dont allow another one to be created
}
con = nabto_reserve_connection();
if (!con) {
return NULL; //error - no more connections available
}
con->spnsi = nsi;
return con;
}
bool connect_event(message_event* event, nabto_packet_header* hdr)
{
nabto_endpoint* peer = &event->udpMessage.peer;
bool isLocal = (event->udpMessage.socket == nmc.socketLocal);
NABTO_LOG_TRACE(("U_CONNECT: Searching for hdr->nsi_cp=%" PRIu32 " (should not be found)", hdr->nsi_cp));
if (nabto_find_connection(hdr->nsi_cp) == NULL) {
uint32_t nsi;
uint32_t ec = 0;
nabto_connect* con = nabto_init_connection(hdr, &nsi, &ec, isLocal);
if (con) {
size_t olen;
NABTO_LOG_TRACE(("Couldn't find connection (good!). Created a new connection (nsi=%" PRIu32 ") con->spnsi=%" PRIu32, nsi, con->spnsi));
olen = mk_gsp_connect_rsp(nabtoCommunicationBuffer, hdr->seq, NOTIFY_CONNECT_OK, con->spnsi, hdr->nsi_cp, hdr->nsi_sp, isLocal);
if (olen == 0) {
NABTO_LOG_ERROR(("U_CONNECT out of resources in connect event."));
nabto_release_connection(con); // no resources available
} else {
if (EP_EQUAL(*peer, nmc.context.gsp)) {
send_to_basestation(nabtoCommunicationBuffer, olen, peer);
} else {
nabto_write(event->udpMessage.socket, nabtoCommunicationBuffer, olen, peer->addr, peer->port);
}
con->state = CS_CONNECTING;
if (!con->noRendezvous) {
nabto_rendezvous_start(con);
}
#if NABTO_ENABLE_TCP_FALLBACK
if (con->hasTcpFallbackCapabilities) {
unabto_tcp_fallback_connect(con);
}
#endif
return true;
}
} else if (nsi && ec) {
// build negative answer
size_t olen = mk_gsp_connect_rsp(nabtoCommunicationBuffer, hdr->seq, ec, nsi, hdr->nsi_cp, hdr->nsi_sp, isLocal);
NABTO_LOG_TRACE((PRInsi " Deny connection, result: %" PRIu32, MAKE_NSI_PRINTABLE(0, nsi, 0), ec));
nabto_write(event->udpMessage.socket, nabtoCommunicationBuffer, olen, peer->addr, peer->port);
return true;
} else {
NABTO_LOG_ERROR(("U_CONNECT was a malformed connect event."));
}
}
return false;
}
/// Retrieve the next NSI. @return the NSI
static uint16_t fresh_nsi(void) {
uint16_t i;
static uint16_t nsiStore = 0; ///< the micoro device's very persistant NSI part:)
if (nsiStore == 0) {
// Make a random value in the range [100..1000]
nabto_random((uint8_t*)&nsiStore, sizeof(nsiStore));
nsiStore %= 900;
nsiStore += 100;
}
i = 0;
// Increment the nsi until we find a free NSI.
do {
nsiStore++;
if (nsiStore > 1000) {
nsiStore = 100;
}
i++;
} while((i <= 900) && (nabto_find_connection(nsiStore) != NULL));
return nsiStore;
}
bool rendezvous_event(message_event* event, nabto_packet_header* hdr)
{
uint8_t* end = nabtoCommunicationBuffer + hdr->len;
uint16_t res = hdr->hlen;
uint8_t* ptr;
uint8_t type;
nabto_endpoint epUD;
nabto_connect* con = 0;
nabto_endpoint src;
uint32_t interval = 5000;
src = event->udpMessage.peer;
NABTO_LOG_TRACE((PRInsi " Received from " PRIep " seq=%" PRIu16, MAKE_NSI_PRINTABLE(0, hdr->nsi_sp, 0), MAKE_EP_PRINTABLE(src), hdr->seq));
ptr = nabtoCommunicationBuffer + res;
res = nabto_rd_payload(ptr, end, &type); ptr += SIZE_PAYLOAD_HEADER;
if (res != 6 || type != NP_PAYLOAD_TYPE_EP) {
NABTO_LOG_TRACE(("Can't read first EP"));
return false;
}
READ_U32(epUD.addr, ptr); ptr += 4;
READ_U16(epUD.port, ptr); ptr += 2;
res = nabto_rd_payload(ptr, end, &type); ptr += SIZE_PAYLOAD_HEADER;
if (res == 6 && type == NP_PAYLOAD_TYPE_EP) {
// The second EP is not neccessary since we read the destination ep from the udp packet.
ptr += 6;
res = nabto_rd_payload(ptr, end, &type); ptr += SIZE_PAYLOAD_HEADER;
if (res == 4 && type == NP_PAYLOAD_TYPE_NONCE) {
READ_U32(interval, ptr);
NABTO_LOG_TRACE((PRInsi " Read interval from packet: %" PRIu32, MAKE_NSI_PRINTABLE(0, hdr->nsi_sp, 0), interval));
if (interval == 0) {
NABTO_LOG_WARN(("Interval was 0, setting to 5000"));
interval = 5000;
}
}
}
con = nabto_find_connection(hdr->nsi_sp);
if (!con) {
NABTO_LOG_ERROR(("Connection was not found, nsi: %i", hdr->nsi_sp));
} else {
if (hdr->seq == 0) {
send_rendezvous_socket(event->udpMessage.socket, con, 1, &src, &epUD);
} else if (hdr->seq == 1) {
send_rendezvous_socket(event->udpMessage.socket, con, 2, &src, &epUD);
if (!conclude_connection(con, &src, interval)) {
return false;
}
} else if (hdr->seq == 2) {
if (!conclude_connection(con, &src, interval)) {
return false;
}
} else {
NABTO_LOG_ERROR(("Invalid Sequence Number"));
}
}
return false;
}
nabto_connect* nabto_init_connection(nabto_packet_header* hdr, uint32_t* nsi, uint32_t* ec, bool isLocal)
{
uint8_t type;
uint8_t flags; /* NP_PAYLOAD_IPX_FLAG_* */
nabto_connect* con;
const uint8_t* end = nabtoCommunicationBuffer + hdr->len;
uint8_t* ptr = nabtoCommunicationBuffer + hdr->hlen;
uint16_t res;
uint16_t ipxPayloadLength;
ipxPayloadLength = nabto_rd_payload(ptr, end, &type); ptr += SIZE_PAYLOAD_HEADER;
*nsi = 0;
*ec = 0;
if ((ipxPayloadLength != IPX_PAYLOAD_LENGTH_WITHOUT_NSI) &&
(ipxPayloadLength != IPX_PAYLOAD_LENGTH_WITH_NSI) &&
(ipxPayloadLength != IPX_PAYLOAD_LENGTH_FULL_NSI)) {
NABTO_LOG_TRACE(("Illegal payload size in U_CONNECT request from GSP: %" PRIu16 " %" PRIu8, ipxPayloadLength, type));
return 0;
}
if (type != NP_PAYLOAD_TYPE_IPX) {
NABTO_LOG_TRACE(("Illegal payload type in U_CONNECT request from GSP: %" PRIu16 " %" PRIu8, ipxPayloadLength, type));
return 0;
}
if (ipxPayloadLength == IPX_PAYLOAD_LENGTH_WITH_NSI ||
ipxPayloadLength == IPX_PAYLOAD_LENGTH_FULL_NSI) {
READ_U32(*nsi, ptr + 13);
NABTO_LOG_TRACE(("IPX payload with NSI (SPNSI=%" PRIu32 ")", *nsi));
} else {
*nsi = fresh_nsi();
NABTO_LOG_TRACE(("IPX payload without NSI (fresh NSI=%" PRIu32 ")", *nsi));
}
if (*nsi == 0) {
NABTO_LOG_ERROR(("Trying to create connection with spnsi == 0"));
return 0;
}
if (nabto_find_connection(*nsi)) {
NABTO_LOG_DEBUG((PRInsi " A connection already exists this is probably a retransmission", MAKE_NSI_PRINTABLE(0, *nsi, 0)));
*ec = NOTIFY_CONNECT_OK;
return 0;
}
con = nabto_init_connection_real(*nsi);
if (con == 0) {
if (nabto_find_connection(*nsi)) {
NABTO_LOG_DEBUG((PRInsi " U_CONNECT: A connection resource is already pending new connection", MAKE_NSI_PRINTABLE(0, *nsi, 0)));
} else {
NABTO_LOG_INFO((PRInsi " U_CONNECT: No connection resources free for new connection", MAKE_NSI_PRINTABLE(0, *nsi, 0)));
#if NABTO_ENABLE_DEVICE_BUSY_AS_FATAL
NABTO_LOG_FATAL((PRInsi " U_CONNECT: No free connections configured to be considered fatal", MAKE_NSI_PRINTABLE(0, *nsi, 0)));
#endif
}
*ec = NOTIFY_ERROR_BUSY_MICRO;
return 0;
}
NABTO_LOG_DEBUG((PRInsi " U_CONNECT: Connecting using record %i", MAKE_NSI_PRINTABLE(0, *nsi, 0), nabto_connection_index(con)));
READ_U32(con->cp.privateEndpoint.addr, ptr + 0);
READ_U16(con->cp.privateEndpoint.port, ptr + 4);
READ_U32(con->cp.globalEndpoint.addr, ptr + 6);
READ_U16(con->cp.globalEndpoint.port, ptr + 10);
READ_U8(flags, ptr + 12); /* the final word (4 bytes) has been read already (nsi) */
con->noRendezvous = (flags & NP_PAYLOAD_IPX_FLAG_NO_RENDEZVOUS) ? 1 : 0;
con->cpEqual = EP_EQUAL(con->cp.privateEndpoint, con->cp.globalEndpoint);
con->cpAsync = (flags & NP_PAYLOAD_IPX_FLAG_CP_ASYNC) ? 1 : 0;
con->clientNatType = (flags & NP_PAYLOAD_IPX_NAT_MASK);
con->isLocal = isLocal;
NABTO_LOG_INFO((PRInsi " U_CONNECT: cp.private: " PRIep " cp.global: " PRIep ", noRdv=%" PRIu8 ", cpeq=%" PRIu8 ", asy=%" PRIu8 ", NATType: %" PRIu8 , MAKE_NSI_PRINTABLE(0, *nsi, 0), MAKE_EP_PRINTABLE(con->cp.privateEndpoint), MAKE_EP_PRINTABLE(con->cp.globalEndpoint), con->noRendezvous, con->cpEqual, con->cpAsync, con->clientNatType));
#if NABTO_ENABLE_TCP_FALLBACK
if (ipxPayloadLength == IPX_PAYLOAD_LENGTH_FULL_NSI) {
memcpy(con->consi, ptr+17, 8);
con->nsico = con->consi;
READ_U32(con->cpnsi, ptr+25);
}
#endif
ptr += ipxPayloadLength; //IPX_PAYLOAD_LENGTH_WITHOUT_NSI or IPX_PAYLOAD_LENGTH_WITH_NSI
con->clientId[0] = 0;
res = nabto_rd_payload(ptr, end, &type);
if (type == NP_PAYLOAD_TYPE_CP_ID) {
uint8_t idType;
ptr += SIZE_PAYLOAD_HEADER;
if (res > 0) {
READ_U8(idType, ptr); ++ptr; --res;
if (idType == 1) { // 1 == EMAIL
size_t sz = res;
if (sz >= sizeof(con->clientId)) {
if (sizeof(con->clientId) > 1) {
NABTO_LOG_WARN(("Client ID truncated"));
}
sz = sizeof(con->clientId) - 1;
}
if (sz) {
memcpy(con->clientId, (const void*) ptr, sz);
}
con->clientId[sz] = 0;
}
}
NABTO_LOG_TRACE(("Connection opened from '%s' (to %s)", con->clientId, nmc.nabtoMainSetup.id));
ptr += res;
}
#if NABTO_ENABLE_CONNECTION_ESTABLISHMENT_ACL_CHECK
if (!allow_client_access(con)) {
*ec = NOTIFY_ERROR_CP_ACCESS;
goto init_error;
}
#endif
#if NABTO_ENABLE_TCP_FALLBACK
{
uint8_t* gatewayPtr = ptr;
res = nabto_rd_payload(ptr, end, &type);
if (type == NP_PAYLOAD_TYPE_GW && ipxPayloadLength == IPX_PAYLOAD_LENGTH_FULL_NSI) {
uint8_t* gatewayEndPtr;
size_t idLength;
NABTO_LOG_TRACE(("The connect contains a gateway payload."));
ptr += res + SIZE_PAYLOAD_HEADER;
gatewayPtr += SIZE_PAYLOAD_HEADER;
gatewayEndPtr = ptr;
READ_U32(con->fallbackHost.addr, gatewayPtr); gatewayPtr+=4;
READ_U16(con->fallbackHost.port, gatewayPtr); gatewayPtr+=2;
// skip the nsi
gatewayPtr+=4;
idLength = gatewayEndPtr-gatewayPtr;
if (idLength != 20) {
NABTO_LOG_FATAL(("The id length should be 20 bytes. bytes=%" PRIsize, idLength));
// todo
}
memcpy(con->gatewayId, gatewayPtr, 20);
con->hasTcpFallbackCapabilities = true;
}
}
#endif
#if NABTO_ENABLE_UCRYPTO
if (nmc.context.nonceSize == NONCE_SIZE) {
uint8_t* decryptedDataStart;
uint16_t decryptedDataLength;
if (!unabto_connection_verify_and_decrypt_connect_packet(hdr, &decryptedDataStart, &decryptedDataLength)) {
NABTO_LOG_TRACE(("Failed to read crypto payload in U_CONNECT"));
} else {
unabto_crypto_reinit_d(&con->cryptoctx, nmc.nabtoMainSetup.cryptoSuite, decryptedDataStart, decryptedDataLength);
}
} else
#endif
{
NABTO_LOG_TRACE(("######## U_CONNECT without crypto payload"));
unabto_crypto_reinit_d(&con->cryptoctx, CRYPT_W_NULL_DATA, 0, 0);
}
con->timeOut = CONNECTION_TIMEOUT;
nabtoSetFutureStamp(&con->stamp, 20000); /* give much extra time during initialisation */
if (!verify_connection_encryption(con)) {
goto init_crypto_error;
}
if (con->cpEqual) {
NABTO_LOG_DEBUG((PRInsi " U_CONNECT: addr:" PRIep " rendezvous:%" PRIu8, MAKE_NSI_PRINTABLE(0, *nsi, 0), MAKE_EP_PRINTABLE(con->cp.privateEndpoint), !con->noRendezvous));
} else {
NABTO_LOG_DEBUG((PRInsi " U_CONNECT: private:" PRIep ", global:" PRIep " rendezvous:%" PRIu8, MAKE_NSI_PRINTABLE(0, *nsi, 0), MAKE_EP_PRINTABLE(con->cp.privateEndpoint), MAKE_EP_PRINTABLE(con->cp.globalEndpoint), !con->noRendezvous));
}
NABTO_LOG_INFO(("Connection opened from '%s' (to %s). Encryption code %i", con->clientId, nmc.nabtoMainSetup.id, con->cryptoctx.code));
return con;
init_crypto_error:
*ec = NOTIFY_ERROR_ENCR_MISMATCH;
#if NABTO_ENABLE_CONNECTION_ESTABLISHMENT_ACL_CHECK
init_error:
nabto_release_connection(con);
#endif
return 0;
}