void unabto_prng_random_seed(uint8_t* buf, size_t bytes) { unsigned long x; FILE *f; f = fopen("/dev/urandom", "rb"); if (f == NULL) f = fopen("/dev/random", "rb"); if (f == NULL) { NABTO_LOG_FATAL(("Could not open random source tried /dev/urandom and /dev/random")); return; } /* disable buffering */ if (setvbuf(f, NULL, _IONBF, 0) != 0) { fclose(f); NABTO_LOG_FATAL(("Could not disable buffering")); return; } x = (unsigned long)fread(buf, 1, bytes, f); fclose(f); if (x < bytes) { NABTO_LOG_FATAL(("Could not get enough random entropy")); return; } }
void tcp_provider_initialize(void) { WORD wVersionRequested; WSADATA wsaData; int err; /* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */ wVersionRequested = MAKEWORD(2, 2); err = WSAStartup(wVersionRequested, &wsaData); if (err != 0) { /* Tell the user that we could not find a usable */ /* Winsock DLL. */ NABTO_LOG_FATAL(("WSAStartup failed with error: %d\n", err)); } /* Confirm that the WinSock DLL supports 2.2.*/ /* Note that if the DLL supports versions greater */ /* than 2.2 in addition to 2.2, it will still return */ /* 2.2 in wVersion since that is the version we */ /* requested. */ if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) { /* Tell the user that we could not find a usable */ /* WinSock DLL. */ NABTO_LOG_FATAL(("Could not find a usable version of Winsock.dll\n")); } }
bool test_if_lo_exists() { bool foundLoopback = false; struct ifaddrs *addrs,*tmp; getifaddrs(&addrs); tmp = addrs; while (tmp) { const char* lo = "lo"; if (tmp->ifa_addr) { if (strncmp(tmp->ifa_name, lo, strlen(lo)) == 0) { if (! (tmp->ifa_flags & (IFF_UP))) { NABTO_LOG_FATAL(("Loopback interface exists but it's not up")); } else if (! (tmp->ifa_flags & (IFF_UP))) { NABTO_LOG_FATAL(("Loopback interface exists but it's not running")); } else { foundLoopback = true; } } } tmp = tmp->ifa_next; } freeifaddrs(addrs); if (!foundLoopback) { NABTO_LOG_FATAL(("No loopback interface found, searched for an interface named lo. This is required if the tunnel should be able to connect to services on localhost.")); } return foundLoopback; }
void tunnel_loop_epoll() { struct epoll_event events[MAX_EPOLL_EVENTS]; int timeout; nabto_stamp_t ne; nabto_stamp_t now; int nfds; if (!unabto_init()) { NABTO_LOG_FATAL(("Failed to initialize unabto")); } if (!init_tunnel_module()) { NABTO_LOG_FATAL(("Cannot initialize tunnel module")); return; } unabto_time_auto_update(false); // time is updated here and after the select since that's the only blocking point. unabto_time_update_stamp(); while (true) { int i; unabto_next_event(&ne); now = nabtoGetStamp(); timeout = nabtoStampDiff2ms(nabtoStampDiff(&ne, &now)); if (timeout < 0) { timeout = 0; } nfds = epoll_wait(unabto_epoll_fd, events, MAX_EPOLL_EVENTS, timeout); unabto_time_update_stamp(); for (i = 0; i < nfds; i++) { unabto_epoll_event_handler* handler = (unabto_epoll_event_handler*)events[i].data.ptr; if (handler->epollEventType == UNABTO_EPOLL_TYPE_UDP) { unabto_network_epoll_read(&events[i]); } #if NABTO_ENABLE_TCP_FALLBACK unabto_tcp_fallback_epoll_event(&events[i]); #endif unabto_tunnel_epoll_event(&events[i]); } unabto_time_event(); } deinit_tunnel_module(); unabto_close(); }
void unabto_tcp_fallback_handle_write(nabto_connect* con) { ssize_t status; int dataToSend; unabto_tcp_fallback_connection* fbConn = &fbConns[nabto_connection_index(con)]; UNABTO_ASSERT(fbConn->sendBufferSent <= fbConn->sendBufferLength); dataToSend = fbConn->sendBufferLength - fbConn->sendBufferSent; status = send(fbConn->socket, fbConn->sendBuffer + fbConn->sendBufferSent, dataToSend, MSG_NOSIGNAL); if (status > 0) { fbConn->sendBufferSent += status; } else if (status < 0) { int err = errno; if ((err == EAGAIN) || err == EWOULDBLOCK) { } else { NABTO_LOG_ERROR((PRI_tcp_fb "Send of tcp packet failed", TCP_FB_ARGS(con))); close_tcp_socket(con); return; } } if (fbConn->sendBufferSent > fbConn->sendBufferLength) { NABTO_LOG_FATAL(("fbConn->sendBufferSent(%" PRIsize ") > fbConn->sendBufferLength(%" PRIsize "), that should not be possible", fbConn->sendBufferSent, fbConn->sendBufferLength)); } if (fbConn->sendBufferSent == fbConn->sendBufferLength) { fbConn->sendBufferLength = 0; } }
/* Release the event handle returned by framework_event_query. * In the ASYNC model we must remove the event handle from the FIFO request * queue. */ void framework_release_handle(naf_handle handle) { queue_entry* entry; if (!handle) { return; } if (queue_empty()) { /* Why do the application try to release a handle on an empty queue? */ NABTO_LOG_FATAL(("SW error: Calling framework_release_handle on an empty queue")); return; } /* Find the entry containing the handle */ entry = queue_find_entry(handle); /* The given handle must belong to the queue */ UNABTO_ASSERT(entry); entry->state = APPREQ_FREE; LOG_APPREQ_WHERE("framework_release_handle", entry); /* Remove top entry from FIFO queue - and remove all consecutive * entries that have expired/finished in the mean time. */ while (!queue_empty()) { if (queue_top()->state != APPREQ_FREE) break; queue_pop(); } LOG_APPREQ_QUEUE(); }
int main(int argc, char** argv) { nabto_main_setup* nms = unabto_init_context(); platform_checks(); #if NABTO_ENABLE_EPOLL unabto_epoll_init(); #endif if (!tunnel_parse_args(argc, argv, nms)) { NABTO_LOG_FATAL(("failed to parse commandline args")); } #if HANDLE_SIGNALS #ifdef WIN32 signal_event = CreateEvent(NULL, FALSE, FALSE, NULL); #endif signal(SIGTERM, handle_signal); signal(SIGINT, handle_signal); #endif #if NABTO_ENABLE_EPOLL if (useSelectBased) { tunnel_loop_select(); } else { tunnel_loop_epoll(); } #else tunnel_loop_select(); #endif return 0; }
int main(int argc, char** argv) { char dnsid[250]; int i, count; pthread_t* nt; int val; struct timespec tv; if (!parse_args(argc, argv)) { help(); exit(1); } sprintf(dnsid, "foo.%s", base_name); count = range_end - range_start; if (count <= 0) { help(); printf("end_range < begin_range\n"); exit(1); } nt = (pthread_t*) calloc(count, sizeof(pthread_t)); if (nt == NULL) { NABTO_LOG_FATAL(("failed to allocate memory for array of threads")); } resolve_dns(dnsid); for (i = 0; i < count; i++) { char* name = (char*) malloc(20 + strlen(base_name)); if (name == NULL) { NABTO_LOG_FATAL(("failed to allocate memory for thread %d (%d.%s)", i, range_start + i, base_name)); } sprintf(name, "%d.%s", range_start + i, base_name); val = pthread_create(nt + i, NULL, main_routine, name); if (val != 0) { NABTO_LOG_FATAL(("failed to create thread %d (%d.%s), val: %d, err: %d", i, range_start + i, base_name, val, errno)); } } while(1) { getchar(); } }
application_event_result application_poll(application_request* request, buffer_read_t* r_b, buffer_write_t* w_b) { application_event_result res = AER_REQ_SYSTEM_ERROR; if (saved_app_req == 0) { NABTO_LOG_FATAL(("No queued request")); } else if (request != saved_app_req) { NABTO_LOG_FATAL(("queued request and parameters doesn't match")); } else { UNABTO_ASSERT(r_b == 0); r_b = &saved_params.r_b; UNABTO_ASSERT(r_b != 0); res = weather_station_application(saved_app_req, r_b, w_b); PGR_LOG_APPREQ_RES(application_poll, (int)res); // hand the saved application request to the caller with the resulting response saved_app_req = 0; } return res; }
static uart_channel* look_up_uart_channel(uint8_t channel) { if (channel >= UART_NUMBER_OF_CHANNELS) { NABTO_LOG_FATAL(("Invalid UART channel specified!")); return NULL; } return &channels[channel]; }
bool unabto_tcp_fallback_module_init() { #if NABTO_ENABLE_DYNAMIC_MEMORY fbConns = (unabto_tcp_fallback_connection*)malloc(sizeof(unabto_tcp_fallback_connection) * NABTO_MEMORY_CONNECTIONS_SIZE); if (fbConns == 0) { NABTO_LOG_FATAL(("Could not allocate memory for fallback connections")); return false; } #endif return true; }
ssize_t nabto_read(nabto_socket_t socket, uint8_t* buffer, size_t length, uint32_t* address, uint16_t* port) { OS_ERR osErr; uint8_t* receiveBuffer; uint16_t receiveBufferLength; RAK_SOCKET_ADDR socketInfo; if(socket > NUMBER_OF_SOCKETS) { NABTO_LOG_FATAL(("Read on invalid socket!")); return 0; } if(sockets[socket].isOpen == false) { NABTO_LOG_ERROR(("Read on closed socket!")); return 0; } while(poll_task_event_queue()); OSSemPend(&sockets[socket].receiverSemaphore, 0, OS_OPT_PEND_NON_BLOCKING, NULL, &osErr); if(osErr != OS_ERR_NONE) { return 0; } NABTO_LOG_TRACE(("nabto_read=%u receiving...", socket)); if (RAK_RecvData(socket, &receiveBuffer, &receiveBufferLength) != RAK_OK) { return 0; } if(receiveBufferLength > length) { NABTO_LOG_TRACE(("nabto_read=%u oversize frame", socket)); RAK_RecvFree(buffer); return 0; } memcpy(buffer, receiveBuffer, receiveBufferLength); RAK_RecvFree(receiveBuffer); RAK_GetSocketInfo(socket, &socketInfo); *address = socketInfo.dest_addr; *port = socketInfo.dest_port; NABTO_LOG_TRACE(("Received UDP packet from " PRI_IP ":%u length=%u", PRI_IP_FORMAT(*address), *port, receiveBufferLength)); return receiveBufferLength; }
/** * 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; }
/** * main using gopt to check command line arguments * -h for help */ int main(int argc, char* argv[]) { // Set nabto to default values nabto_main_setup* nms = unabto_init_context(); // Initialise application if (!application_init()){ NABTO_LOG_FATAL(("Unable to initialise serial connection")); } // Optionally set alternative url to html device driver //nmc.nabtoMainSetup.url = "https://dl.dropbox.com/u/15998645/html_dd_demo.zip"; // Overwrite default values with command line args if (!check_args(argc, argv, nms)) { return 1; } NABTO_LOG_INFO(("Identity: '%s'", nms->id)); NABTO_LOG_INFO(("Program Release %" PRIu32 ".%" PRIu32, RELEASE_MAJOR, RELEASE_MINOR)); NABTO_LOG_INFO(("Buffer size: %d" , nms->bufsize)); // Initialize nabto if (!unabto_init()) { NABTO_LOG_FATAL(("Failed at nabto_main_init")); } // The main loop gives nabto a tick from time to time. // Everything else is taken care of behind the scenes. while (true) { unabto_tick(); nabto_yield(10); } unabto_close(); return 0; }
void nabto_random(uint8_t* buf, size_t len) { static bool isInitialized = false; size_t bytes; if (!isInitialized) { int wprng; int status; register_prng(&fortuna_desc); wprng = find_prng("fortuna"); status = rng_make_prng(128, wprng, &unabto_prng_state, NULL); if (status != CRYPT_OK) { NABTO_LOG_FATAL(("Could not initialize random function")); return; } isInitialized = true; } bytes = fortuna_desc.read(buf, len, &unabto_prng_state); if (bytes != len) { NABTO_LOG_FATAL(("Random function did not give required bytes")); } }
int main(int argc, char** argv) { #if USE_TEST_WEBSERVER #ifdef WIN32 HANDLE testWebserverThread; #else pthread_t testWebserverThread; #endif #endif nabto_main_setup* nms = unabto_init_context(); platform_checks(); #if NABTO_ENABLE_EPOLL unabto_epoll_init(); #endif if (!tunnel_parse_args(argc, argv, nms)) { NABTO_LOG_FATAL(("failed to parse commandline args")); } #if USE_TEST_WEBSERVER if (testWebserver) { #ifdef WIN32 testWebserverThread = CreateThread(NULL, 0, test_webserver, (void*)testWebserverPortStr, NULL, NULL); #else pthread_create(&testWebserverThread, NULL, test_webserver, (void*)testWebserverPortStr); #endif } #endif #if HANDLE_SIGNALS #ifdef WIN32 signal_event = CreateEvent(NULL, FALSE, FALSE, NULL); #endif signal(SIGTERM, handle_signal); signal(SIGINT, handle_signal); #endif #if NABTO_ENABLE_EPOLL if (useSelectBased) { tunnel_loop_select(); } else { tunnel_loop_epoll(); } #else tunnel_loop_select(); #endif return 0; }
bool configuration_store_write(uint16_t offset, const void* data, uint16_t length) { if((offset + length) > sizeof(store)) { NABTO_LOG_FATAL(("Out of bounds write in configuration store.")); return false; } memcpy(&store[offset], data, length); NABTO_LOG_TRACE(("Wrote %u bytes starting at offset %x", (int) length, (int)offset)); return true; }
bool configuration_store_read(uint16_t offset, void* data, uint16_t length) { if((offset + length) > sizeof(store)) { NABTO_LOG_FATAL(("Out of bounds read in configuration store.")); return false; } memcpy(data, &store[offset], length); NABTO_LOG_TRACE(("Read %u bytes starting at offset %x", (int) length, (int)offset)); return true; }
bool configuration_store_set(uint16_t offset, uint8_t value, uint16_t length) { if((offset + length) > sizeof(store)) { NABTO_LOG_FATAL(("Out of bounds write in configuration store.")); return false; } memset(&store[offset], value, length); NABTO_LOG_TRACE(("Set %u bytes to %u starting at offset %x", (int) length, (int)value, (int)offset)); return true; }
// Retrieve the response from a queued request application_event_result application_poll(application_request* request, buffer_read_t* r_b, buffer_write_t* w_b) { application_event_result res; if (saved_app_req == 0) { NABTO_LOG_FATAL(("No queued request")); return AER_REQ_SYSTEM_ERROR; } res = demo_application(request, r_b, w_b); if (res == AER_REQ_RESPONSE_READY) { NABTO_LOG_INFO(("Application poll: Response delivered")); } saved_app_req = 0; return res; }
/** * create a thread which runs the unabto instance. */ unabto_api_status_t unabto_api_platform_start() { if (running) { return UNABTO_API_FAIL; } if (!unabto_init()) { return UNABTO_API_FAIL; } running = true; if (unabto_thread_create(&tick_thread, tick_thread_func, NULL) != 0) { NABTO_LOG_FATAL(("Failed to create tick_thread")); } return UNABTO_API_OK; }
bool unabto_tcp_fallback_handle_write(nabto_connect* con) { ssize_t status; int dataToSend; bool canMaybeSendMoreData = false; unabto_tcp_fallback_connection* fbConn = &fbConns[nabto_connection_index(con)]; UNABTO_ASSERT(fbConn->sendBufferSent <= fbConn->sendBufferLength); dataToSend = fbConn->sendBufferLength - fbConn->sendBufferSent; if (dataToSend == 0) { return false; } NABTO_LOG_TRACE(("data to send %i, sendBufferLength %i, sendBufferSent %i", dataToSend, fbConn->sendBufferLength, fbConn->sendBufferSent)); status = send(fbConn->socket, fbConn->sendBuffer + fbConn->sendBufferSent, dataToSend, MSG_NOSIGNAL); NABTO_LOG_TRACE(("tcp send status: %i", status)); if (status > 0) { fbConn->sendBufferSent += status; canMaybeSendMoreData = true; } else if (status < 0) { int err = errno; if ((err == EAGAIN) || err == EWOULDBLOCK) { canMaybeSendMoreData = false; } else { NABTO_LOG_ERROR((PRI_tcp_fb "Send of tcp packet failed", TCP_FB_ARGS(con))); close_tcp_socket(con); canMaybeSendMoreData = false; return canMaybeSendMoreData; } } if (fbConn->sendBufferSent > fbConn->sendBufferLength) { NABTO_LOG_FATAL(("fbConn->sendBufferSent(%" PRIsize ") > fbConn->sendBufferLength(%" PRIsize "), that should not be possible", fbConn->sendBufferSent, fbConn->sendBufferLength)); } if (fbConn->sendBufferSent == fbConn->sendBufferLength) { fbConn->sendBufferLength = 0; fbConn->sendBufferSent = 0; canMaybeSendMoreData = false; } NABTO_LOG_TRACE(("state after send, sendBufferLength %i, sendBufferSent %i", fbConn->sendBufferLength, fbConn->sendBufferSent)); return canMaybeSendMoreData; }
// move as much data as possible from the UART OS buffer to the UART driver receive buffer. static bool low_level_read_from_uart(uart_channel* uartChannel) { uint8_t buffer[1024]; DWORD count; uint16_t length; count = queue_free(&uartChannel->receiveQueue); if (count == 0) // room for more bytes in the driver receive queue? { return false; // no } if (count > sizeof(buffer)) // limit count { count = sizeof(buffer); } // try to read as many bytes as there is room for in the driver receive queue if (ReadFile(uartChannel->hPort, buffer, count, &count, 0) == false) { return false; // read failed for some reason } // no bytes received? if (count == 0) { return false; // no bytes received } // no bytes received? if (count > 0xffff) { NABTO_LOG_FATAL(("Received an exorbitant amount of data from the UART!")); return false; // something is totally wrong } length = (uint16_t)count; NABTO_LOG_TRACE(("Queued %u bytes in UART driver receive buffer.", length)); queue_enqueue_array(&uartChannel->receiveQueue, buffer, length); return true; }
/** * main using gopt to check command line arguments * -h for help */ int main(int argc, char* argv[]) { // Set nabto to default values nabto_main_setup* nms = unabto_init_context(); // Overwrite default values with command line args if (!check_args(argc, argv, nms)) { return 1; } NABTO_LOG_INFO(("Identity: '%s'", nms->id)); NABTO_LOG_INFO(("Program Release %i.%i", RELEASE_MAJOR, RELEASE_MINOR)); NABTO_LOG_INFO(("Buffer size: %i", nms->bufsize)); // Initialize nabto if (!unabto_init()) { NABTO_LOG_FATAL(("Failed at nabto_main_init")); } nabto_stamp_t attachExpireStamp; // 20 seconds nabtoSetFutureStamp(&attachExpireStamp, 1000*20); // The main loop gives nabto a tick from time to time. // Everything else is taken care of behind the scenes. while (true) { unabto_tick(); nabto_yield(10); if (nabtoIsStampPassed(&attachExpireStamp)) { NABTO_LOG_ERROR(("Attach took too long.")); exit(4); } if (unabto_is_connected_to_gsp()) { NABTO_LOG_INFO(("Successfully attached to the gsp, now exiting.")); exit(0); } } NABTO_LOG_ERROR(("we should not end here")); exit(5); unabto_close(); return 0; }
/* Update the state of the queue entry after calling application. */ application_event_result framework_update_state(queue_entry* entry, application_event_result ret) { if (entry->state != APPREQ_WAITING) { LOG_APPREQ_QUEUE(); NABTO_LOG_FATAL(("SW error: handle should be in 'WAIT' state")); } switch (ret) { case AER_REQ_RESPONSE_READY: entry->state = APPREQ_FREE; break; case AER_REQ_ACCEPTED: entry->state = APPREQ_IN_APP; break; default: //error entry->state = APPREQ_FREE; break; } return ret; }
bool nabto_init_socket(uint32_t localAddr, uint16_t* localPort, nabto_socket_t* socket) { uint8_t i; OS_ERR osErr; NABTO_NOT_USED(localAddr); for(i = 0; i < lengthof(sockets); i++) { if(sockets[i].isOpen == false) { uint16_t port = *localPort; if(port == 0) { port = 30000 + i; } if(RAK_UDPServer(mainTcb, port, i) == RAK_OK) { sockets[i].isOpen = true; OSSemCreate(&sockets[i].receiverSemaphore, NULL, 0, &osErr); if(osErr != OS_ERR_NONE) { NABTO_LOG_FATAL(("Unable to create receiver semaphore %u: %i", i, osErr)); } *localPort = port; *socket = (nabto_socket_t)i; NABTO_LOG_TRACE(("nabto_init_socket %u: port=%u", *socket, *localPort)); return true; } } } return false; }
void wait_event() { int timeout; nabto_stamp_t ne; nabto_stamp_t now; int nfds; int max_read_fd = 0; int max_write_fd = 0; fd_set read_fds; fd_set write_fds; struct timeval timeout_val; unabto_next_event(&ne); now = nabtoGetStamp(); timeout = nabtoStampDiff2ms(nabtoStampDiff(&ne, &now)); if (timeout < 0) timeout = 0; FD_ZERO(&read_fds); FD_ZERO(&write_fds); unabto_network_select_add_to_read_fd_set(&read_fds, &max_read_fd); #if NABTO_ENABLE_TCP_FALLBACK unabto_tcp_fallback_select_add_to_read_fd_set(&read_fds, &max_read_fd); unabto_tcp_fallback_select_add_to_write_fd_set(&write_fds, &max_write_fd); #endif timeout_val.tv_sec = (timeout/1000); timeout_val.tv_usec = ((timeout)%1000)*1000; nfds = select(MAX(max_read_fd+1, max_write_fd+1), &read_fds, &write_fds, NULL, &timeout_val); NABTO_LOG_TRACE(("foobar %i", nfds)); if (nfds < 0) NABTO_LOG_FATAL(("Error in epoll_wait: %d", errno)); unabto_network_select_read_sockets(&read_fds); unabto_time_event(); }
void nabto_close_socket(nabto_socket_t* socket) { NABTO_LOG_FATAL(("Socket shutdown not supported!")); //printf("RAK_ShutDown(%u)=%u", *socket, RAK_ShutDown(*socket)); //sockets[*socket].inUse = false; }
static bool test_parse_args(const char * progname, int argc, char* argv[], nabto_main_setup* nms) { const char *x1[] = { "help", 0 }; const char *x2[] = { "version", 0 }; const char *x3[] = { "config", 0 }; const char *x4[] = { "size", 0 }; const char *x5[] = { "deviceName", 0 }; const char *x6[] = { "use_encryption", 0 }; const char *x7[] = { "encryption_key", 0 }; const char *x8[] = { "localport", 0 }; const char *x11[] = { "nice_exit", 0}; const struct { int k; int f; const char *s; const char*const* l; } opts[] = { { 'h', GOPT_NOARG, "h?", x1 }, { 'V', GOPT_NOARG, "V", x2 }, { 'C', GOPT_NOARG, "C", x3 }, { 'S', GOPT_NOARG, "S", x4 }, { 'd', GOPT_ARG, "d", x5 }, { 's', GOPT_NOARG, "s", x6 }, { 'k', GOPT_ARG, "k", x7 }, { 'p', GOPT_ARG, "p", x8 }, { 'x', GOPT_NOARG, "x", x11 }, { 0,0,0,0 } }; void *options = gopt_sort(&argc, (const char**)argv, opts); if (gopt(options, 'h')) { printf("Usage: %s [options]\n", progname); printf(" -h Print this help.\n"); printf(" -V Print release version.\n"); printf(" -C Print configuration (unabto_config.h).\n"); printf(" -S Print size (in bytes) of structures (memory usage).\n"); exit(0); } if (gopt(options, 'V')) { printf("%s: %d.%d\n", progname, RELEASE_MAJOR, RELEASE_MINOR); exit(0); } if (gopt(options, 'C')) { unabto_printf_unabto_config(stdout, progname); exit(0); } if (gopt(options, 'S')) { unabto_printf_memory_sizes(stdout, progname); exit(0); } if (!gopt_arg(options, 'd', &nms->id)) { NABTO_LOG_FATAL(("Specify a serverId with -d")); } if (gopt(options, 's')) { const char* preSharedKey; if ( gopt_arg( options, 'k', &preSharedKey)) { if (!unabto_read_psk_from_hex(preSharedKey, nms->presharedKey, 16)) { NABTO_LOG_FATAL(("Cannot read presharedkey"); } } #if NABTO_ENABLE_CONNECTIONS nms->cryptoSuite = CRYPT_W_AES_CBC_HMAC_SHA256; #endif }
bool platform_initialize(void* tcb) { OS_ERR osErr; mainTcb = tcb; SYS_Init(); GPIO_SetBit(LED_LINK_PORT, LED_LINK_PIN); GPIO_Open(LED_LINK_PORT, GPIO_PMD_PMD8_OUTPUT, GPIO_PMD_PMD8_MASK); #if NABTO_ENABLE_LOGGING uart_initialize(115200); #endif // Initialize OS tick system OS_CPU_SysTickInit(SYS_GetHCLKFreq() / OS_CFG_TICK_RATE_HZ); OSSemCreate(&loggingSemaphore, NULL, 1, &osErr); if(osErr != OS_ERR_NONE) { NABTO_LOG_FATAL(("Unable to create logging semaphore")); } NABTO_LOG_INFO(("Initializing...")); if (RAK_DriverInit() != RAK_OK) { NABTO_LOG_FATAL(("Platform initialize failed!")); } { char mac[6]; if (RAK_GetMacAddr(mac) != RAK_OK) { NABTO_LOG_FATAL(("RAK_GetMacAddr() failed!")); } NABTO_LOG_INFO(("MAC: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5])); } { RAK_CONNECT param; param.mode = NET_MODE_STA; param.sec_mode = PSK_MODE_SEC; param.ssid = wifiSsid; param.psk = wifiKey; param.conn_handle = wifi_callback; if (RAK_ConnectAP(¶m) != RAK_OK) { NABTO_LOG_FATAL(("Wifi connect error!")); } } while(linkIsUp == false); // wait for callback to set connection status { RAK_IPCONFIG dhcp; if (RAK_IPConfigDHCP(&dhcp) != RAK_OK) { NABTO_LOG_FATAL(("DHCP error!")); } localAddress = dhcp.addr; localMask = dhcp.mask; gateway = dhcp.gw; dnsServer = dhcp.dnsrv1; NABTO_LOG_TRACE(("DHCP: Address=" PRI_IP " mask=" PRI_IP " gateway=" PRI_IP " DNS=" PRI_IP, PRI_IP_FORMAT(localAddress), PRI_IP_FORMAT(localMask), PRI_IP_FORMAT(gateway), PRI_IP_FORMAT(dnsServer))); } memset(sockets, 0, sizeof(sockets)); sendBuffer = RAK_SendMalloc(SEND_BUFFER_SIZE); return true; }