int main(int argc, char** argv) {
nabto_main_setup* nms = unabto_init_context();
stream_echo_init();
if (!check_args(argc, argv, nms)) {
return 1;
}
if (!unabto_init()) {
return 1;
}
while(true) {
unabto_tick();
#ifdef WIN32
Sleep(1);
#endif
#if (_POSIX_C_SOURCE >= 199309L)
struct timespec sleepTime;
sleepTime.tv_sec = 0;
sleepTime.tv_nsec = 10*1000000;
nanosleep(&sleepTime, NULL);
#endif
}
unabto_close();
}
/**
* 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;
}
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();
}
/**
* 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;
}
/**
* 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;
}
int main(int argc, char** argv) {
nabto_main_setup* nms = unabto_init_context();
stream_echo_init();
if (!check_args(argc, argv, nms)) {
return 1;
}
if (!unabto_init()) {
return 1;
}
unabto_time_auto_update(false);
while(true) {
unabto_time_update_stamp();
wait_event();
}
unabto_close();
}
/**
* 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 tunnel_loop_epoll() {
struct epoll_event events[MAX_EPOLL_EVENTS];
int timeout;
nabto_stamp_t ne;
nabto_stamp_t now;
int nfds;
int i;
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_epoll_event_handler_udp* udpHandler = (unabto_epoll_event_handler_udp*)handler;
bool status;
do {
status = unabto_read_socket(udpHandler->fd);
} while (status);
}
#if NABTO_ENABLE_TCP_FALLBACK
if (handler->epollEventType == UNABTO_EPOLL_TYPE_TCP_FALLBACK) {
nabto_connect* con = (nabto_connect*)handler;
if (events[i].events & EPOLLIN) {
unabto_tcp_fallback_read_ready(con);
}
if (events[i].events & EPOLLOUT) {
unabto_tcp_fallback_write_ready(con);
}
}
#endif
if (handler->epollEventType == UNABTO_EPOLL_TYPE_TCP_TUNNEL) {
tunnel* tunnelPtr = (tunnel*)handler;
if (tunnelPtr->sock != INVALID_SOCKET) {
tunnel_event(tunnelPtr, TUNNEL_EVENT_SOURCE_TCP_READ);
}
if (tunnelPtr->sock != INVALID_SOCKET) {
tunnel_event(tunnelPtr, TUNNEL_EVENT_SOURCE_TCP_WRITE);
}
}
}
unabto_time_event();
}
deinit_tunnel_module();
unabto_close();
}
void main(void)
{
static nabto_main_setup* nms;
static char versionString[NABTO_DEVICE_VERSION_MAX_SIZE];
static char idString[NABTO_DEVICE_NAME_MAX_SIZE];
#if NABTO_ENABLE_UCRYPTO
static const far rom uint8_t dummySharedSecret[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
static const far rom uint8_t* sharedSecret;
#endif
// <editor-fold desc="Load information from bootloader and application data areas.">
// Clear the global TCP/IP data structure and load it with the boards unique preprogrammed MAC address.
memset((void*) &AppConfig, 0x00, sizeof (AppConfig));
memcpypgm2ram(&AppConfig.MyMACAddr, (const __ROM uint8_t*) bootloaderData.version1.mac, 6);
if(bootloaderData.base.bootloaderDataVersion == 1)
{
strcpypgm2ram(idString, (const far rom char*) bootloaderData.version1.serialNumber);
strcatpgm2ram(idString, ".nabduino.net");
#if NABTO_ENABLE_UCRYPTO
// sharedSecret = applicationData.sharedSecret; // the old pre-bootloader-version-2 way of storing the shared secret - obsolete!
#endif
}
else if(bootloaderData.base.bootloaderDataVersion == 2)
{
hardwareVersion = (uint8_t) bootloaderData.version2.hardwareVersionMajor;
hardwareVersion <<= 8;
hardwareVersion |= (uint8_t) bootloaderData.version2.hardwareVersionMinor;
if(hardwareVersion == 0x0004)
{
hardwareVersionIndex = 0; // first version of the board that was released.
}
else if(hardwareVersion == 0x0102)
{
hardwareVersionIndex = 1; // second version of the board that was released (yes we jumped from 0.4 beta to 1.2).
}
else if(hardwareVersion == 0x0103)
{
hardwareVersionIndex = 2; // third version of the board
}
strcpypgm2ram(idString, (const far rom char*) bootloaderData.version2.deviceId);
strcatpgm2ram(idString, (const far rom char*) bootloaderData.version2.productDomain);
#if NABTO_ENABLE_UCRYPTO
sharedSecret = bootloaderData.version2.sharedSecret;
#endif
}
else
{ // unsupported version so it's probably safe to assume that bootloader data has been wiped - please fill in the appropriate values for your Nabduino board
hardwareVersionIndex = 0; // hardware version 0.4 = 0, v1.2 = 1, v1.3 = 2
AppConfig.MyMACAddr.v[0] = 0xBC; // Nabto owned MAC OUI is BC:A4:E1
AppConfig.MyMACAddr.v[1] = 0xA4;
AppConfig.MyMACAddr.v[2] = 0xE1;
AppConfig.MyMACAddr.v[3] = 0x00;
AppConfig.MyMACAddr.v[4] = 0x00;
AppConfig.MyMACAddr.v[5] = 0x00; // If using more than one Nabduino on the same network make this byte unique for each board
strcpypgm2ram(idString, "XXX"); // replace XXX with the id of the Nabduino board
strcatpgm2ram(idString, ".nabduino.net");
#if NABTO_ENABLE_UCRYPTO
sharedSecret = dummySharedSecret;
#endif
}
// </editor-fold>
// Initialize IOs etc. taking into account the hardware version.
hal_initialize();
// Initialize the platform (timing, TCP/IP stack, DHCP and some PIC18 specific stuff)
platform_initialize();
network_initialize();
nms = unabto_init_context();
nms->id = (const char*) idString;
// build version string: <application SVN version>/<bootloader SVN version>/<hardware major version>.<hardware minor version>
itoa(RELEASE_MINOR, versionString);
strcatpgm2ram(versionString + strlen(versionString), "/");
itoa(bootloaderData.base.buildVersion, versionString + strlen(versionString));
strcatpgm2ram(versionString + strlen(versionString), "/");
itoa(hardwareVersion >> 8, versionString + strlen(versionString));
strcatpgm2ram(versionString + strlen(versionString), ".");
itoa(hardwareVersion & 0xff, versionString + strlen(versionString));
nms->version = (const char*) versionString;
#if NABTO_ENABLE_UCRYPTO
memcpypgm2ram(nms->presharedKey, (const __ROM void*) sharedSecret, 16);
nms->secureAttach = true;
nms->secureData = true;
nms->cryptoSuite = CRYPT_W_AES_CBC_HMAC_SHA256;
#endif
setup((char**) &nms->url);
unabto_init();
while(1)
{
hal_tick();
platform_tick();
network_tick();
unabto_tick();
loop();
}
}