/**
* Entry point.
* @param argc number of parameters
* @param argv the parameters
* - 1 ip-address
* - 2 serverid | -
* - 3 log
* @return the result
*/
int main(int argc, char* argv[])
{
nabto_main_setup* nms;
nabto_endpoint localEp;
// flush stdout
setvbuf(stdout, NULL, _IONBF, 0);
nms = unabto_init_context();
/**
* Overwrite default values with command line args
*/
if (!check_args(argc, argv, nms)) {
return 1;
}
if (!unabto_init()) {
NABTO_LOG_FATAL(("Failed at nabto_main_init"));
}
localEp.addr=nms->ipAddress;
localEp.port=nms->localPort;
if (nms->ipAddress != INADDR_ANY) NABTO_LOG_INFO(("Own IP address: " PRIep, MAKE_EP_PRINTABLE(localEp)));
else NABTO_LOG_INFO(("Own IP address, local IP is set to INADDR_ANY: " PRIep, MAKE_EP_PRINTABLE(localEp)));
while (true) {
/*
* Here the main application should do it's work
* and then whenever time is left for Nabto (but at least regularly)
* the nabto_main_tick() should be called.
*
* nabto_main_tick()
* - polls the socket for incoming messages
* - administers timers to do its own timer based work
*/
unabto_tick();
#if NABTO_ENABLE_STREAM
nabto_stream_test_tick();
#endif
#if (_POSIX_C_SOURCE >= 199309L)
struct timespec sleepTime;
sleepTime.tv_sec = 0;
sleepTime.tv_nsec = 10*1000000;
nanosleep(&sleepTime, NULL);
#endif
}
unabto_close();
return 0;
}
bool unabto_debug_syslog_config(bool enableSyslog, uint8_t facility, uint32_t ip, uint16_t port, uint32_t expire, const uint8_t* configStr, uint16_t configStrLength)
{
bool ret;
nabto_endpoint ep;
ep.addr = ip; ep.port = port;
NABTO_LOG_INFO(("Enabling syslog " PRIep " %.*s expire %" PRIu32 " enabled %i", MAKE_EP_PRINTABLE(ep), configStrLength, configStr, expire, enableSyslog));
if (enableSyslog) {
ret = unabto_log_system_enable_syslog_pattern((const char*)configStr, configStrLength, ip, port, expire);
} else {
unabto_log_system_disable_syslog();
}
return ret;
}
bool unabto_tcp_fallback_connect(nabto_connect* con) {
unabto_tcp_fallback_connection* fbConn = &fbConns[nabto_connection_index(con)];
int status;
int flags;
fbConn->socket = socket(AF_INET, SOCK_STREAM, 0);
if (fbConn->socket < 0) {
NABTO_LOG_ERROR((PRI_tcp_fb "Could not create socket for tcp fallback.", TCP_FB_ARGS(con)));
return false;
}
flags = 1;
if (setsockopt(fbConn->socket, IPPROTO_TCP, TCP_NODELAY, (char *) &flags, sizeof(int)) != 0) {
NABTO_LOG_ERROR(("Could not set socket option TCP_NODELAY"));
}
#ifndef WIN32
flags = fcntl(fbConn->socket, F_GETFL, 0);
if (flags < 0) {
NABTO_LOG_ERROR((PRI_tcp_fb "fcntl fail", TCP_FB_ARGS(con)));
closesocket(fbConn->socket);
fbConn->socket = INVALID_SOCKET;
con->tcpFallbackConnectionState = UTFS_CLOSED;
return false;
}
if (fcntl(fbConn->socket, F_SETFL, flags | O_NONBLOCK) < 0) {
NABTO_LOG_ERROR((PRI_tcp_fb "fcntl fail", TCP_FB_ARGS(con)));
closesocket(fbConn->socket);
fbConn->socket = INVALID_SOCKET;
con->tcpFallbackConnectionState = UTFS_CLOSED;
return false;
}
flags = 1;
if(setsockopt(fbConn->socket, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags)) < 0) {
NABTO_LOG_ERROR(("could not enable KEEPALIVE"));
}
#ifndef __MACH__
flags = 9;
if(setsockopt(fbConn->socket, SOL_TCP, TCP_KEEPCNT, &flags, sizeof(flags)) < 0) {
NABTO_LOG_ERROR(("could not set TCP_KEEPCNT"));
}
flags = 60;
if(setsockopt(fbConn->socket, SOL_TCP, TCP_KEEPIDLE, &flags, sizeof(flags)) < 0) {
NABTO_LOG_ERROR(("could not set TCP_KEEPIDLE"));
}
flags = 60;
if(setsockopt(fbConn->socket, SOL_TCP, TCP_KEEPINTVL, &flags, sizeof(flags)) < 0) {
NABTO_LOG_ERROR(("could not set TCP KEEPINTVL"));
}
#else
flags = 60;
if(setsockopt(fbConn->socket, IPPROTO_TCP, TCP_KEEPALIVE, &flags, sizeof(flags)) < 0) {
NABTO_LOG_ERROR(("could not set TCP_KEEPCNT"));
}
#endif
#endif
memset(&fbConn->fbHost,0,sizeof(struct sockaddr_in));
fbConn->fbHost.sin_family = AF_INET;
fbConn->fbHost.sin_addr.s_addr = htonl(con->fallbackHost.addr);
fbConn->fbHost.sin_port = htons(con->fallbackHost.port);
NABTO_LOG_INFO((PRI_tcp_fb "Ep. " PRIep, TCP_FB_ARGS(con), MAKE_EP_PRINTABLE(con->fallbackHost)));
status = connect(fbConn->socket, (struct sockaddr*)&fbConn->fbHost, sizeof(struct sockaddr_in));
if (status == 0) {
con->tcpFallbackConnectionState = UTFS_CONNECTED;
} else {
int err = errno;
// err is two on windows.
if (err == EINPROGRESS) {
con->tcpFallbackConnectionState = UTFS_CONNECTING;
} else {
NABTO_LOG_ERROR((PRI_tcp_fb "Could not connect to fallback tcp endpoint. %s", TCP_FB_ARGS(con), strerror(errno)));
closesocket(fbConn->socket);
fbConn->socket = INVALID_SOCKET;
con->tcpFallbackConnectionState = UTFS_CLOSED;
return false;
}
}
#ifdef WIN32
flags = 1;
if (ioctlsocket(fbConn->socket, FIONBIO, &flags) != 0) {
NABTO_LOG_ERROR((PRI_tcp_fb "ioctlsocket fail", TCP_FB_ARGS(con)));
closesocket(fbConn->socket);
fbConn->socket = INVALID_SOCKET;
con->tcpFallbackConnectionState = UTFS_CLOSED;
return false;
}
#endif
return true;
}
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;
}
static void send_rendezvous_socket(nabto_socket_t socket, nabto_connect* con, uint16_t seq, nabto_endpoint* dest, nabto_endpoint *myAddress)
{
uint8_t* ptr;
uint8_t* buf = nabtoCommunicationBuffer;
ptr = insert_header(buf, 0, con->spnsi, U_CONNECT, false, seq, 0, 0);
ptr = insert_payload(ptr, NP_PAYLOAD_TYPE_EP, 0, 6);
WRITE_U32(ptr, dest->addr); ptr += 4;
WRITE_U16(ptr, dest->port); ptr += 2;
if (seq > 0) {
if (!myAddress) {
NABTO_LOG_ERROR(("Send rendezvous called with an invalid address"));
return;
} else {
ptr = insert_payload(ptr, NP_PAYLOAD_TYPE_EP, 0, 6);
WRITE_U32(ptr, myAddress->addr); ptr += 4;
WRITE_U16(ptr, myAddress->port); ptr += 2;
}
}
{
size_t len = ptr - buf;
insert_length(buf, len);
if (seq) {
NABTO_LOG_DEBUG((PRInsi " RENDEZVOUS Send to " PRIep ": seq=%" PRIu16 " " PRIep, MAKE_NSI_PRINTABLE(0, con->spnsi, 0), MAKE_EP_PRINTABLE(*dest), seq, MAKE_EP_PRINTABLE(*myAddress)));
} else {
NABTO_LOG_DEBUG((PRInsi " RENDEZVOUS Send to " PRIep ": seq=0", MAKE_NSI_PRINTABLE(0, con->spnsi, 0), MAKE_EP_PRINTABLE(*dest)));
}
if (dest->addr != 0 && dest->port != 0) {
nabto_write(socket, buf, len, dest->addr, dest->port);
} else {
NABTO_LOG_TRACE(("invalid rendezvous packet thrown away"));
}
}
}
