TEST_F(AddRemoveServerTests, AddServer) {
uint8_t s = lwm2m_add_server(123, LWM2M_SERVER_ADDR, 100, false, NULL, NULL, 0);
ASSERT_EQ(s, COAP_205_CONTENT);
ASSERT_EQ(client_context->state, STATE_INITIAL);
security_instance_t* secInstance = (security_instance_t*)securityObj->instanceList;
server_instance_t* serverInstance = (server_instance_t*)serverObj->instanceList;
ASSERT_EQ(123, secInstance->shortID);
ASSERT_EQ(123, serverInstance->shortServerId);
char uriBuffer[100];
ASSERT_TRUE(lwm2m_get_server_uri(secInstance->instanceId,uriBuffer, sizeof(uriBuffer)));
ASSERT_STREQ(uriBuffer, LWM2M_SERVER_ADDR);
time_t timeout;
uint8_t result = lwm2m_step(client_context, &timeout);
ASSERT_EQ(COAP_NO_ERROR, result);
ASSERT_EQ(STATE_REGISTERING, client_context->state);
lwm2m_server_t * serverListEntry;
serverListEntry = (lwm2m_server_t *)LWM2M_LIST_FIND(client_context->serverList, secInstance->instanceId);
ASSERT_TRUE(serverListEntry);
}
TEST_F(AddRemoveServerTests, RemoveServer) {
uint8_t result;
time_t timeout;
uint8_t s = lwm2m_add_server(123, LWM2M_SERVER_ADDR, 100, false, NULL, NULL, 0);
ASSERT_EQ(s, COAP_205_CONTENT);
security_instance_t* secInstance = (security_instance_t*)securityObj->instanceList;
// Add server to serverlist
result = lwm2m_step(client_context, &timeout);
lwm2m_server_t * serverListEntry;
serverListEntry = (lwm2m_server_t *)LWM2M_LIST_FIND(client_context->serverList, secInstance->instanceId);
ASSERT_TRUE(serverListEntry);
// Now assume registering worked
serverListEntry->status = STATE_REGISTERED;
serverListEntry->location = (char*)lwm2m_malloc(1);
// Unregister now
lwm2m_unregister_server(secInstance->instanceId);
ASSERT_EQ(serverListEntry->status, STATE_DEREG_PENDING);
serverListEntry->status = STATE_DEREGISTERED;
lwm2m_remove_unregistered_servers();
ASSERT_FALSE(securityObj->instanceList);
ASSERT_FALSE(serverObj->instanceList);
ASSERT_TRUE(client_context->serverList);
ASSERT_EQ(client_context->state, STATE_INITIAL);
result = lwm2m_step(client_context, &timeout);
ASSERT_EQ(client_context->state, STATE_BOOTSTRAP_REQUIRED);
ASSERT_FALSE(client_context->serverList);
}
uint8_t network_step_blocking(lwm2m_context_t * lwm2mH, int bound_sockets)
{
struct timeval tv = {2,0};
fd_set readfds = {0};
for (uint8_t c = 0; c < bound_sockets; ++c) {
int sock = lwm2m_network_native_sock(lwm2mH, c);
if (sock == -1)
return COAP_500_INTERNAL_SERVER_ERROR;
FD_SET(sock, &readfds);
}
uint8_t result = lwm2m_step(lwm2mH, &tv.tv_sec);
if (result != 0)
{
fprintf(stderr, "lwm2m_step() failed: 0x%X\r\n", result);
}
/*
* This part wait for an event on the socket until "tv" timed out (set
* with the precedent function)
*/
int select_result = select(FD_SETSIZE, &readfds, NULL, NULL, &tv);
if (select_result < 0 && errno != EINTR)
{
fprintf(stderr, "Error in select(): %d %s\r\n", errno, strerror(errno));
return COAP_500_INTERNAL_SERVER_ERROR;
}
for (uint8_t c = 0; c < bound_sockets; ++c)
{
int sock = lwm2m_network_native_sock(lwm2mH, c);
if (sock == -1)
return COAP_500_INTERNAL_SERVER_ERROR;
if (select_result > 0 && FD_ISSET(sock, &readfds))
{
lwm2m_network_process(lwm2mH);
}
}
return result;
}
int main()
{
int result;
lwm2m_object_t * objArray[4];
printf("Start\n");
ethSetup();
printf("Initializing tinydtls\n");
// fake loading of PSK..
psk_id_length = strlen(PSK_DEFAULT_IDENTITY);
psk_key_length = strlen(PSK_DEFAULT_KEY);
memcpy(psk_id, PSK_DEFAULT_IDENTITY, psk_id_length);
memcpy(psk_key, PSK_DEFAULT_KEY, psk_key_length);
printf("Init\n");
dtls_init();
printf("New context\n");
dtls_context = dtls_new_context(&lwm2mH);
if (dtls_context == NULL) {
printf("error creating the dtls context\n");
}
printf("Setting handlers\n");
dtls_set_handler(dtls_context, &cb);
if (!dtls_context) {
printf("can't create dtls_context\n");
exit(-1);
}
printf("Initialazing Wakaama\n");
// create objects
objArray[0] = get_security_object(123, "coaps://5.39.83.206:5684", false);
securityObjP = objArray[0];
objArray[1] = get_server_object(123, "U", 20, false);
serverObject = objArray[1];
objArray[2] = get_object_device();
objArray[3] = get_object_firmware();
/*
* The liblwm2m library is now initialized with the functions that will be in
* charge of communication
*/
lwm2mH = lwm2m_init(prv_connect_server, prv_buffer_send, NULL);
if (NULL == lwm2mH)
{
fprintf(stderr, "lwm2m_init() failed\r\n");
return -1;
}
// configure the liblwm2m lib
result = lwm2m_configure(lwm2mH, "julien", NULL, 4, objArray);
if (result != 0)
{
printf("lwm2m_configure() failed: 0x%X\n", result);
return -1;
}
// start
result = lwm2m_start(lwm2mH);
if (result != 0)
{
printf("lwm2m_start() failed: 0x%X\n", result);
return -1;
}
// main loop
while (true) {
char buffer[1024];
Endpoint server;
printf("loop...\n");
struct timeval timeout;
timeout.tv_sec = 10;
timeout.tv_usec = 0;
result = lwm2m_step(lwm2mH, &timeout);
if (result != 0)
{
printf("lwm2m_step error %d\n", result);
}
int n = udp.receiveFrom(server, buffer, sizeof(buffer));
printf("Received packet from: %s of size %d\n", server.get_address(), n);
if (n>0) {
// TODO: find connection
connection_t * connP = connList;
while(connP != NULL) {
if (strcmp(connP->host, server.get_address()) == 0)
{
printf("found connection\n");
// is it a secure connection?
if (connP->dtlsSession != NULL) {
printf("dtls session\n");
result = dtls_handle_message(dtls_context, connP->dtlsSession, buffer, n);
printf("dtls handle message %d\n",result);
} else {
printf("nosec session\n");
lwm2m_handle_packet(lwm2mH, (uint8_t*)buffer, n, (void*)connP);
}
break;
}
}
if (connP == NULL) printf("no connection\n");
}
}
}
int main(int argc, char *argv[])
{
int sock;
fd_set readfds;
struct timeval tv;
int result;
lwm2m_context_t * lwm2mH = NULL;
int i;
connection_t * connList = NULL;
int addressFamily = AF_INET6;
int opt;
command_desc_t commands[] =
{
{"list", "List registered clients.", NULL, prv_output_clients, NULL},
{"read", "Read from a client.", " read CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to read such as /3, /3/0/2, /1024/11, /1024/0/1\r\n"
"Result will be displayed asynchronously.", prv_read_client, NULL},
{"disc", "Discover resources of a client.", " disc CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to discover such as /3, /3/0/2, /1024/11, /1024/0/1\r\n"
"Result will be displayed asynchronously.", prv_discover_client, NULL},
{"write", "Write to a client.", " write CLIENT# URI DATA\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to write to such as /3, /3/0/2, /1024/11, /1024/0/1\r\n"
" DATA: data to write\r\n"
"Result will be displayed asynchronously.", prv_write_client, NULL},
{"time", "Write time-related attributes to a client.", " time CLIENT# URI PMIN PMAX\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to write attributes to such as /3, /3/0/2, /1024/11, /1024/0/1\r\n"
" PMIN: Minimum period\r\n"
" PMAX: Maximum period\r\n"
"Result will be displayed asynchronously.", prv_time_client, NULL},
{"attr", "Write value-related attributes to a client.", " attr CLIENT# URI LT GT [STEP]\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to write attributes to such as /3, /3/0/2, /1024/11, /1024/0/1\r\n"
" LT: \"Less than\" value\r\n"
" GT: \"Greater than\" value\r\n"
" STEP: \"Step\" value\r\n"
"Result will be displayed asynchronously.", prv_attr_client, NULL},
{"clear", "Clear attributes of a client.", " clear CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to clear attributes of such as /3, /3/0/2, /1024/11, /1024/0/1\r\n"
"Result will be displayed asynchronously.", prv_clear_client, NULL},
{"exec", "Execute a client resource.", " exec CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri of the resource to execute such as /3/0/2\r\n"
"Result will be displayed asynchronously.", prv_exec_client, NULL},
{"del", "Delete a client Object instance.", " del CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri of the instance to delete such as /1024/11\r\n"
"Result will be displayed asynchronously.", prv_delete_client, NULL},
{"create", "create an Object instance.", " create CLIENT# URI DATA\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to which create the Object Instance such as /1024, /1024/45 \r\n"
" DATA: data to initialize the new Object Instance (0-255 for object 1024) \r\n"
"Result will be displayed asynchronously.", prv_create_client, NULL},
{"observe", "Observe from a client.", " observe CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to observe such as /3, /3/0/2, /1024/11\r\n"
"Result will be displayed asynchronously.", prv_observe_client, NULL},
{"cancel", "Cancel an observe.", " cancel CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri on which to cancel an observe such as /3, /3/0/2, /1024/11\r\n"
"Result will be displayed asynchronously.", prv_cancel_client, NULL},
{"q", "Quit the server.", NULL, prv_quit, NULL},
COMMAND_END_LIST
};
while ((opt = getopt(argc, argv, "4")) != -1)
{
switch (opt)
{
case '4':
addressFamily = AF_INET;
break;
default:
print_usage();
return 0;
}
}
sock = create_socket(LWM2M_STANDARD_PORT_STR, addressFamily);
if (sock < 0)
{
fprintf(stderr, "Error opening socket: %d\r\n", errno);
return -1;
}
lwm2mH = lwm2m_init(NULL);
if (NULL == lwm2mH)
{
fprintf(stderr, "lwm2m_init() failed\r\n");
return -1;
}
signal(SIGINT, handle_sigint);
for (i = 0 ; commands[i].name != NULL ; i++)
{
commands[i].userData = (void *)lwm2mH;
}
fprintf(stdout, "> "); fflush(stdout);
lwm2m_set_monitoring_callback(lwm2mH, prv_monitor_callback, lwm2mH);
while (0 == g_quit)
{
FD_ZERO(&readfds);
FD_SET(sock, &readfds);
FD_SET(STDIN_FILENO, &readfds);
tv.tv_sec = 60;
tv.tv_usec = 0;
result = lwm2m_step(lwm2mH, &(tv.tv_sec));
if (result != 0)
{
fprintf(stderr, "lwm2m_step() failed: 0x%X\r\n", result);
return -1;
}
result = select(FD_SETSIZE, &readfds, 0, 0, &tv);
if ( result < 0 )
{
if (errno != EINTR)
{
fprintf(stderr, "Error in select(): %d\r\n", errno);
}
}
else if (result > 0)
{
uint8_t buffer[MAX_PACKET_SIZE];
int numBytes;
if (FD_ISSET(sock, &readfds))
{
struct sockaddr_storage addr;
socklen_t addrLen;
addrLen = sizeof(addr);
numBytes = recvfrom(sock, buffer, MAX_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrLen);
if (numBytes == -1)
{
fprintf(stderr, "Error in recvfrom(): %d\r\n", errno);
}
else
{
char s[INET6_ADDRSTRLEN];
in_port_t port;
connection_t * connP;
s[0] = 0;
if (AF_INET == addr.ss_family)
{
struct sockaddr_in *saddr = (struct sockaddr_in *)&addr;
inet_ntop(saddr->sin_family, &saddr->sin_addr, s, INET6_ADDRSTRLEN);
port = saddr->sin_port;
}
else if (AF_INET6 == addr.ss_family)
{
struct sockaddr_in6 *saddr = (struct sockaddr_in6 *)&addr;
inet_ntop(saddr->sin6_family, &saddr->sin6_addr, s, INET6_ADDRSTRLEN);
port = saddr->sin6_port;
}
fprintf(stderr, "%d bytes received from [%s]:%hu\r\n", numBytes, s, ntohs(port));
output_buffer(stderr, buffer, numBytes, 0);
connP = connection_find(connList, &addr, addrLen);
if (connP == NULL)
{
connP = connection_new_incoming(connList, sock, (struct sockaddr *)&addr, addrLen);
if (connP != NULL)
{
connList = connP;
}
}
if (connP != NULL)
{
lwm2m_handle_packet(lwm2mH, buffer, numBytes, connP);
}
}
}
else if (FD_ISSET(STDIN_FILENO, &readfds))
{
numBytes = read(STDIN_FILENO, buffer, MAX_PACKET_SIZE - 1);
if (numBytes > 1)
{
buffer[numBytes] = 0;
handle_command(commands, (char*)buffer);
fprintf(stdout, "\r\n");
}
if (g_quit == 0)
{
fprintf(stdout, "> ");
fflush(stdout);
}
else
{
fprintf(stdout, "\r\n");
}
}
}
}
lwm2m_close(lwm2mH);
close(sock);
connection_free(connList);
#ifdef MEMORY_TRACE
if (g_quit == 1)
{
trace_print(0, 1);
}
#endif
return 0;
}
int main(int argc, char *argv[])
{
client_data_t data;
int result;
lwm2m_context_t * lwm2mH = NULL;
int i;
const char * localPort = "56830";
const char * server = NULL;
const char * serverPort = LWM2M_STANDARD_PORT_STR;
char * name = "testlwm2mclient";
int lifetime = 300;
int batterylevelchanging = 0;
time_t reboot_time = 0;
int opt;
bool bootstrapRequested = false;
bool serverPortChanged = false;
#ifdef LWM2M_BOOTSTRAP
lwm2m_client_state_t previousState = STATE_INITIAL;
#endif
char * pskId = NULL;
char * psk = NULL;
uint16_t pskLen = -1;
char * pskBuffer = NULL;
/*
* The function start by setting up the command line interface (which may or not be useful depending on your project)
*
* This is an array of commands describes as { name, description, long description, callback, userdata }.
* The firsts tree are easy to understand, the callback is the function that will be called when this command is typed
* and in the last one will be stored the lwm2m context (allowing access to the server settings and the objects).
*/
command_desc_t commands[] =
{
{"list", "List known servers.", NULL, prv_output_servers, NULL},
{"change", "Change the value of resource.", " change URI [DATA]\r\n"
" URI: uri of the resource such as /3/0, /3/0/2\r\n"
" DATA: (optional) new value\r\n", prv_change, NULL},
{"update", "Trigger a registration update", " update SERVER\r\n"
" SERVER: short server id such as 123\r\n", prv_update, NULL},
#ifdef LWM2M_BOOTSTRAP
{"bootstrap", "Initiate a DI bootstrap process", NULL, prv_initiate_bootstrap, NULL},
{"dispb", "Display current backup of objects/instances/resources\r\n"
"\t(only security and server objects are backupped)", NULL, prv_display_backup, NULL},
#endif
{"ls", "List Objects and Instances", NULL, prv_object_list, NULL},
{"disp", "Display current objects/instances/resources", NULL, prv_display_objects, NULL},
{"dump", "Dump an Object", "dump URI"
"URI: uri of the Object or Instance such as /3/0, /1\r\n", prv_object_dump, NULL},
{"add", "Add support of object 1024", NULL, prv_add, NULL},
{"rm", "Remove support of object 1024", NULL, prv_remove, NULL},
{"quit", "Quit the client gracefully.", NULL, prv_quit, NULL},
{"^C", "Quit the client abruptly (without sending a de-register message).", NULL, NULL, NULL},
COMMAND_END_LIST
};
memset(&data, 0, sizeof(client_data_t));
data.addressFamily = AF_INET6;
opt = 1;
while (opt < argc)
{
if (argv[opt] == NULL
|| argv[opt][0] != '-'
|| argv[opt][2] != 0)
{
print_usage();
return 0;
}
switch (argv[opt][1])
{
case 'b':
bootstrapRequested = true;
if (!serverPortChanged) serverPort = LWM2M_BSSERVER_PORT_STR;
break;
case 'c':
batterylevelchanging = 1;
break;
case 't':
opt++;
if (opt >= argc)
{
print_usage();
return 0;
}
if (1 != sscanf(argv[opt], "%d", &lifetime))
{
print_usage();
return 0;
}
break;
#ifdef WITH_TINYDTLS
case 'i':
opt++;
if (opt >= argc)
{
print_usage();
return 0;
}
pskId = argv[opt];
break;
case 's':
opt++;
if (opt >= argc)
{
print_usage();
return 0;
}
psk = argv[opt];
break;
#endif
case 'n':
opt++;
if (opt >= argc)
{
print_usage();
return 0;
}
name = argv[opt];
break;
case 'l':
opt++;
if (opt >= argc)
{
print_usage();
return 0;
}
localPort = argv[opt];
break;
case 'h':
opt++;
if (opt >= argc)
{
print_usage();
return 0;
}
server = argv[opt];
break;
case 'p':
opt++;
if (opt >= argc)
{
print_usage();
return 0;
}
serverPort = argv[opt];
serverPortChanged = true;
break;
case '4':
data.addressFamily = AF_INET;
break;
default:
print_usage();
return 0;
}
opt += 1;
}
if (!server)
{
server = (AF_INET == data.addressFamily ? DEFAULT_SERVER_IPV4 : DEFAULT_SERVER_IPV6);
}
/*
*This call an internal function that create an IPV6 socket on the port 5683.
*/
fprintf(stderr, "Trying to bind LWM2M Client to port %s\r\n", localPort);
data.sock = create_socket(localPort, data.addressFamily);
if (data.sock < 0)
{
fprintf(stderr, "Failed to open socket: %d %s\r\n", errno, strerror(errno));
return -1;
}
/*
* Now the main function fill an array with each object, this list will be later passed to liblwm2m.
* Those functions are located in their respective object file.
*/
#ifdef WITH_TINYDTLS
if (psk != NULL)
{
pskLen = strlen(psk) / 2;
pskBuffer = malloc(pskLen);
if (NULL == pskBuffer)
{
fprintf(stderr, "Failed to create PSK binary buffer\r\n");
return -1;
}
// Hex string to binary
char *h = psk;
char *b = pskBuffer;
char xlate[] = "0123456789ABCDEF";
for ( ; *h; h += 2, ++b)
{
char *l = strchr(xlate, toupper(*h));
char *r = strchr(xlate, toupper(*(h+1)));
if (!r || !l)
{
fprintf(stderr, "Failed to parse Pre-Shared-Key HEXSTRING\r\n");
return -1;
}
*b = ((l - xlate) << 4) + (r - xlate);
}
}
#endif
char serverUri[50];
int serverId = 123;
sprintf (serverUri, "coap://%s:%s", server, serverPort);
#ifdef LWM2M_BOOTSTRAP
objArray[0] = get_security_object(serverId, serverUri, pskId, pskBuffer, pskLen, bootstrapRequested);
#else
objArray[0] = get_security_object(serverId, serverUri, pskId, pskBuffer, pskLen, false);
#endif
if (NULL == objArray[0])
{
fprintf(stderr, "Failed to create security object\r\n");
return -1;
}
data.securityObjP = objArray[0];
objArray[1] = get_server_object(serverId, "U", lifetime, false);
if (NULL == objArray[1])
{
fprintf(stderr, "Failed to create server object\r\n");
return -1;
}
objArray[2] = get_object_device();
if (NULL == objArray[2])
{
fprintf(stderr, "Failed to create Device object\r\n");
return -1;
}
objArray[3] = get_object_firmware();
if (NULL == objArray[3])
{
fprintf(stderr, "Failed to create Firmware object\r\n");
return -1;
}
objArray[4] = get_object_location();
if (NULL == objArray[4])
{
fprintf(stderr, "Failed to create location object\r\n");
return -1;
}
objArray[5] = get_test_object();
if (NULL == objArray[5])
{
fprintf(stderr, "Failed to create test object\r\n");
return -1;
}
objArray[6] = get_object_conn_m();
if (NULL == objArray[6])
{
fprintf(stderr, "Failed to create connectivity monitoring object\r\n");
return -1;
}
objArray[7] = get_object_conn_s();
if (NULL == objArray[7])
{
fprintf(stderr, "Failed to create connectivity statistics object\r\n");
return -1;
}
int instId = 0;
objArray[8] = acc_ctrl_create_object();
if (NULL == objArray[8])
{
fprintf(stderr, "Failed to create Access Control object\r\n");
return -1;
}
else if (acc_ctrl_obj_add_inst(objArray[8], instId, 3, 0, serverId)==false)
{
fprintf(stderr, "Failed to create Access Control object instance\r\n");
return -1;
}
else if (acc_ctrl_oi_add_ac_val(objArray[8], instId, 0, 0b000000000001111)==false)
{
fprintf(stderr, "Failed to create Access Control ACL default resource\r\n");
return -1;
}
else if (acc_ctrl_oi_add_ac_val(objArray[8], instId, 999, 0b000000000000001)==false)
{
fprintf(stderr, "Failed to create Access Control ACL resource for serverId: 999\r\n");
return -1;
}
/*
* The liblwm2m library is now initialized with the functions that will be in
* charge of communication
*/
lwm2mH = lwm2m_init(&data);
if (NULL == lwm2mH)
{
fprintf(stderr, "lwm2m_init() failed\r\n");
return -1;
}
#ifdef WITH_TINYDTLS
data.lwm2mH = lwm2mH;
#endif
/*
* We configure the liblwm2m library with the name of the client - which shall be unique for each client -
* the number of objects we will be passing through and the objects array
*/
result = lwm2m_configure(lwm2mH, name, NULL, NULL, OBJ_COUNT, objArray);
if (result != 0)
{
fprintf(stderr, "lwm2m_configure() failed: 0x%X\r\n", result);
return -1;
}
signal(SIGINT, handle_sigint);
/**
* Initialize value changed callback.
*/
init_value_change(lwm2mH);
/*
* As you now have your lwm2m context complete you can pass it as an argument to all the command line functions
* precedently viewed (first point)
*/
for (i = 0 ; commands[i].name != NULL ; i++)
{
commands[i].userData = (void *)lwm2mH;
}
fprintf(stdout, "LWM2M Client \"%s\" started on port %s\r\n", name, localPort);
fprintf(stdout, "> "); fflush(stdout);
/*
* We now enter in a while loop that will handle the communications from the server
*/
while (0 == g_quit)
{
struct timeval tv;
fd_set readfds;
if (g_reboot)
{
time_t tv_sec;
tv_sec = lwm2m_gettime();
if (0 == reboot_time)
{
reboot_time = tv_sec + 5;
}
if (reboot_time < tv_sec)
{
/*
* Message should normally be lost with reboot ...
*/
fprintf(stderr, "reboot time expired, rebooting ...");
system_reboot();
}
else
{
tv.tv_sec = reboot_time - tv_sec;
}
}
else if (batterylevelchanging)
{
update_battery_level(lwm2mH);
tv.tv_sec = 5;
}
else
{
tv.tv_sec = 60;
}
tv.tv_usec = 0;
FD_ZERO(&readfds);
FD_SET(data.sock, &readfds);
FD_SET(STDIN_FILENO, &readfds);
/*
* This function does two things:
* - first it does the work needed by liblwm2m (eg. (re)sending some packets).
* - Secondly it adjusts the timeout value (default 60s) depending on the state of the transaction
* (eg. retransmission) and the time between the next operation
*/
result = lwm2m_step(lwm2mH, &(tv.tv_sec));
if (result != 0)
{
fprintf(stderr, "lwm2m_step() failed: 0x%X\r\n", result);
if(previousState == STATE_BOOTSTRAPPING)
{
#ifdef WITH_LOGS
fprintf(stdout, "[BOOTSTRAP] restore security and server objects\r\n");
#endif
prv_connections_free(lwm2mH);
prv_restore_objects(lwm2mH);
lwm2mH->state = STATE_INITIAL;
}
else return -1;
}
#ifdef LWM2M_BOOTSTRAP
update_bootstrap_info(&previousState, lwm2mH);
#endif
/*
* This part will set up an interruption until an event happen on SDTIN or the socket until "tv" timed out (set
* with the precedent function)
*/
result = select(FD_SETSIZE, &readfds, NULL, NULL, &tv);
if (result < 0)
{
if (errno != EINTR)
{
fprintf(stderr, "Error in select(): %d %s\r\n", errno, strerror(errno));
}
}
else if (result > 0)
{
uint8_t buffer[MAX_PACKET_SIZE];
int numBytes;
/*
* If an event happens on the socket
*/
if (FD_ISSET(data.sock, &readfds))
{
struct sockaddr_storage addr;
socklen_t addrLen;
addrLen = sizeof(addr);
/*
* We retrieve the data received
*/
numBytes = recvfrom(data.sock, buffer, MAX_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrLen);
if (0 > numBytes)
{
fprintf(stderr, "Error in recvfrom(): %d %s\r\n", errno, strerror(errno));
}
else if (0 < numBytes)
{
char s[INET6_ADDRSTRLEN];
in_port_t port;
#ifdef WITH_TINYDTLS
dtls_connection_t * connP;
#else
connection_t * connP;
#endif
if (AF_INET == addr.ss_family)
{
struct sockaddr_in *saddr = (struct sockaddr_in *)&addr;
inet_ntop(saddr->sin_family, &saddr->sin_addr, s, INET6_ADDRSTRLEN);
port = saddr->sin_port;
}
else if (AF_INET6 == addr.ss_family)
{
struct sockaddr_in6 *saddr = (struct sockaddr_in6 *)&addr;
inet_ntop(saddr->sin6_family, &saddr->sin6_addr, s, INET6_ADDRSTRLEN);
port = saddr->sin6_port;
}
fprintf(stderr, "%d bytes received from [%s]:%hu\r\n", numBytes, s, ntohs(port));
/*
* Display it in the STDERR
*/
output_buffer(stderr, buffer, numBytes, 0);
connP = connection_find(data.connList, &addr, addrLen);
if (connP != NULL)
{
/*
* Let liblwm2m respond to the query depending on the context
*/
#ifdef WITH_TINYDTLS
int result = connection_handle_packet(connP, buffer, numBytes);
if (0 != result)
{
printf("error handling message %d\n",result);
}
#else
lwm2m_handle_packet(lwm2mH, buffer, numBytes, connP);
#endif
conn_s_updateRxStatistic(objArray[7], numBytes, false);
}
else
{
fprintf(stderr, "received bytes ignored!\r\n");
}
}
}
/*
* If the event happened on the SDTIN
*/
else if (FD_ISSET(STDIN_FILENO, &readfds))
{
numBytes = read(STDIN_FILENO, buffer, MAX_PACKET_SIZE - 1);
if (numBytes > 1)
{
buffer[numBytes] = 0;
/*
* We call the corresponding callback of the typed command passing it the buffer for further arguments
*/
handle_command(commands, (char*)buffer);
}
if (g_quit == 0)
{
fprintf(stdout, "\r\n> ");
fflush(stdout);
}
else
{
fprintf(stdout, "\r\n");
}
}
}
}
/*
* Finally when the loop is left smoothly - asked by user in the command line interface - we unregister our client from it
*/
if (g_quit == 1)
{
#ifdef LWM2M_BOOTSTRAP
close_backup_object();
#endif
lwm2m_close(lwm2mH);
}
close(data.sock);
connection_free(data.connList);
clean_security_object(objArray[0]);
lwm2m_free(objArray[0]);
clean_server_object(objArray[1]);
lwm2m_free(objArray[1]);
free_object_device(objArray[2]);
free_object_firmware(objArray[3]);
free_object_location(objArray[4]);
free_test_object(objArray[5]);
free_object_conn_m(objArray[6]);
free_object_conn_s(objArray[7]);
acl_ctrl_free_object(objArray[8]);
#ifdef MEMORY_TRACE
if (g_quit == 1)
{
trace_print(0, 1);
}
#endif
return 0;
}
int lwm2m_client_cb(void *args)
{
int argc;
char **argv;
int i;
int result;
int opt;
char *name = "testlwm2mclient";
#ifdef WITH_MBEDTLS
unsigned char psk[MBEDTLS_PSK_MAX_LEN];
/* set default tls option */
/*
* if you want to change auth_mode, please change 3rd parameter of tls_opt structure
* - auth_mode can be configured (2: mandatory 1: optional, 0: not verify)
*/
tls_opt option = {MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_DATAGRAM, 0, 1, NULL, };
/* set cipher suite to all*/
option.force_ciphersuites[0] = mbedtls_ssl_get_ciphersuite_id(LWM2M_CIPHERSUIT);
option.force_ciphersuites[1] = 0;
#endif
struct timeval tv = {60, 0};
argc = ((struct pthread_arg *)args)->argc;
argv = ((struct pthread_arg *)args)->argv;
lwm2mH = NULL;
g_quit = 0;
server = DEFAULT_SERVER_IPV4;
serverPort = LWM2M_STANDARD_PORT_STR;
/* Setting up the command line interface. */
command_desc_t commands[] = {
{"list", "List known servers.", NULL, prv_output_servers, NULL},
{
"change", "Change the value of resource.", " change URI [DATA]\r\n"
" URI: uri of the resource such as /3/0, /3/0/2\r\n"
" DATA: (optional) new value\r\n", prv_change, NULL
},
{
"update", "Trigger a registration update", " update SERVER\r\n"
" SERVER: short server id such as 123\r\n", prv_update, NULL
},
{"ls", "List Objects and Instances", NULL, prv_object_list, NULL},
{
"dump", "Dump an Object", "dump URI"
"URI: uri of the Object or Instance such as /3/0, /1\r\n", prv_object_dump, NULL
},
{"add", "Add support of object 1024", NULL, prv_add, NULL},
{"rm", "Remove support of object 1024", NULL, prv_remove, NULL},
{"quit", "Quit the client gracefully.", NULL, prv_quit, NULL},
{"^C", "Quit the client abruptly (without sending a de-register message).", NULL, NULL, NULL},
COMMAND_END_LIST
};
memset(&data, 0, sizeof(client_data_t));
data.addressFamily = AF_INET;
opt = 1;
while (opt < argc) {
if (argv[opt] == NULL
|| argv[opt][0] != '-'
|| argv[opt][2] != 0) {
print_usage();
return 0;
}
switch (argv[opt][1]) {
case 't':
opt++;
if (opt >= argc) {
print_usage();
return 0;
}
if (1 != sscanf(argv[opt], "%d", &g_lifetime)) {
print_usage();
return 0;
}
break;
#ifdef WITH_MBEDTLS
case 'i':
opt++;
if (opt >= argc) {
print_usage();
return 0;
}
g_pskId = argv[opt];
break;
case 's':
opt++;
if (opt >= argc) {
print_usage();
return 0;
}
g_pskBuffer = argv[opt];
break;
#endif
case 'h':
opt++;
if (opt >= argc) {
print_usage();
return 0;
}
server = argv[opt];
break;
default:
print_usage();
return 0;
}
opt += 1;
}
/* Parse server URI to distinguish protocol and server address */
g_proto = coap_get_protocol_from_uri(server);
if (g_proto >= COAP_PROTOCOL_MAX) {
printf("Not supported protocol : %d\n", g_proto);
return -1;
}
/* Move pointer to address field */
server += strlen(coap_uri_prefix[g_proto]);
serverPort = coap_get_port_from_proto(g_proto);
if (lwm2m_init_object() < 0) {
}
/* This call an internal function that create an socket. */
printf("Trying to bind LWM2M Client to port %s\n", serverPort);
data.sock = create_socket(g_proto, serverPort, data.addressFamily);
if (data.sock < 0) {
fprintf(stderr, "Failed to open socket: %d %s\r\n", errno, strerror(errno));
return -1;
}
#ifdef WITH_MBEDTLS
if (g_proto == COAP_TCP_TLS || g_proto == COAP_UDP_DTLS) {
/* Set Transport layer (TCP or UDP) */
switch (g_proto) {
case COAP_TCP_TLS:
option.transport = MBEDTLS_SSL_TRANSPORT_STREAM;
break;
case COAP_UDP_DTLS:
option.transport = MBEDTLS_SSL_TRANSPORT_DATAGRAM;
break;
default:
break;
}
data.tls_opt = &option;
/* Set credential information */
tls_cred cred;
memset(&cred, 0, sizeof(tls_cred));
if (g_pskBuffer) {
if (lwm2m_unhexify(psk, g_pskBuffer, &cred.psk_len) == 0) {
if (g_pskId) {
cred.psk_identity = g_pskId;
cred.psk = psk;
}
}
if (cred.psk_identity == NULL && cred.psk == NULL) {
printf("failed to set psk info\n");
goto exit;
}
} else {
printf("Please set psk and psk_id\n");
goto exit;
}
data.tls_context = TLSCtx(&cred);
if (data.tls_context == NULL) {
printf("TLS context initialize failed\n");
goto exit;
}
}
#endif
if ((lwm2mH = lwm2m_init(&data)) == NULL) {
printf("lwm2m_init2() failed\n");
goto exit;
}
lwm2mH->protocol = g_proto;
if ((result = lwm2m_configure(lwm2mH, name, NULL, NULL, OBJ_COUNT, objArray)) != 0) {
printf("lwm2m_configure() failed: 0x%X\n", result);
goto exit;
}
/* Register the command line command */
for (i = 0 ; commands[i].name != NULL ; i++) {
commands[i].userData = (void *)lwm2mH;
}
printf("LWM2M Client \"%s\" started on port %s\n> ", name, serverPort);
/* We now enter in a while loop that will handle the communications from the server */
while (0 == g_quit) {
tv.tv_sec = 60;
tv.tv_usec = 0;
if ((result = lwm2m_step(lwm2mH, &(tv.tv_sec))) != 0) {
printf("lwm2m_step() failed: 0x%X\n", result);
goto exit;
} else {
printf(" -> State: %s\n", g_step[lwm2mH->state]);
}
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(data.sock, &readfds);
FD_SET(STDIN_FILENO, &readfds);
result = select(FD_SETSIZE, &readfds, NULL, NULL, &tv);
if (result < 0) {
if (errno != EINTR) {
fprintf(stderr, "Error in select(): %d %s\r\n", errno, strerror(errno));
}
} else if (result > 0) {
uint8_t buffer[MAX_PACKET_SIZE];
int numBytes;
if (FD_ISSET(data.sock, &readfds)) {
client_data_t *user_data = lwm2mH->userData;
numBytes = connection_read(g_proto, user_data->connP, data.sock, buffer, MAX_PACKET_SIZE, NULL, 0);
if (numBytes > 0) {
output_buffer(stderr, buffer, numBytes, 0);
lwm2m_handle_packet(lwm2mH, buffer, numBytes, user_data->connP);
conn_s_updateRxStatistic(objArray[7], numBytes, false);
} else {
printf("received bytes ignored!\n");
}
/* If the event happened on the SDTIN */
} else if (FD_ISSET(STDIN_FILENO, &readfds)) {
numBytes = read_input_command_line((char *)buffer);
if (numBytes > 1) {
buffer[numBytes] = 0;
handle_command(commands, (char *)buffer);
}
if (g_quit == 0) {
fprintf(stdout, "\r\n> ");
fflush(stdout);
}
}
}
}
exit:
if (g_quit && lwm2mH) {
lwm2m_close(lwm2mH);
sleep(1);
}
#ifdef WITH_MBEDTLS
if (data.tls_context) {
TLSCtx_free(data.tls_context);
}
#endif
if (data.sock >= 0) {
printf("Closing %d\n", data.sock);
shutdown(data.sock, 3);
if ((i = close(data.sock)) != 0) {
printf("Fail to close %d\n", errno);
}
}
if (data.connP) {
connection_free(data.connP);
}
clean_security_object(objArray[0]);
clean_server_object(objArray[1]);
free_object_device(objArray[2]);
free_object_firmware(objArray[3]);
free_object_location(objArray[4]);
free_test_object(objArray[5]);
free_object_conn_m(objArray[6]);
free_object_conn_s(objArray[7]);
acl_ctrl_free_object(objArray[8]);
lwm2m_free(objArray[0]);
lwm2m_free(objArray[1]);
return 0;
}
int main(int argc, char *argv[])
{
fd_set readfds;
struct timeval tv;
int result;
char * port = "5685";
internal_data_t data;
char * filename = "bootstrap_server.ini";
int opt;
FILE * fd;
command_desc_t commands[] =
{
{"boot", "Bootstrap a client (Server Initiated).", " boot URI [NAME]\r\n"
" URI: uri of the client to bootstrap\r\n"
" NAME: endpoint name of the client as in the .ini file (optionnal)\r\n"
"Example: boot coap://[::1]:56830 testlwm2mclient", prv_bootstrap_client, &data},
{"q", "Quit the server.", NULL, prv_quit, NULL},
COMMAND_END_LIST
};
while ((opt = getopt(argc, argv, "f:p:")) != -1)
{
switch (opt)
{
case 'f':
filename = optarg;
break;
case 'p':
port = optarg;
break;
default:
print_usage(filename, port);
return 0;
}
}
memset(&data, 0, sizeof(internal_data_t));
data.sock = create_socket(port);
if (data.sock < 0)
{
fprintf(stderr, "Error opening socket: %d\r\n", errno);
return -1;
}
data.lwm2mH = lwm2m_init(NULL, prv_buffer_send, NULL);
if (NULL == data.lwm2mH)
{
fprintf(stderr, "lwm2m_init() failed\r\n");
return -1;
}
signal(SIGINT, handle_sigint);
fd = fopen(filename, "r");
if (fd == NULL)
{
fprintf(stderr, "Opening file %s failed.\r\n", filename);
return -1;
}
data.bsInfo = bs_get_info(fd);
fclose(fd);
if (data.bsInfo == NULL)
{
fprintf(stderr, "Reading Bootsrap Info from file %s failed.\r\n", filename);
return -1;
}
lwm2m_set_bootstrap_callback(data.lwm2mH, prv_bootstrap_callback, (void *)&data);
fprintf(stdout, "LWM2M Bootstrap Server now listening on port %s.\r\n\n", port);
fprintf(stdout, "> "); fflush(stdout);
while (0 == g_quit)
{
endpoint_t * endP;
FD_ZERO(&readfds);
FD_SET(data.sock, &readfds);
FD_SET(STDIN_FILENO, &readfds);
tv.tv_sec = 60;
tv.tv_usec = 0;
result = lwm2m_step(data.lwm2mH, &(tv.tv_sec));
if (result != 0)
{
fprintf(stderr, "lwm2m_step() failed: 0x%X\r\n", result);
return -1;
}
result = select(FD_SETSIZE, &readfds, 0, 0, &tv);
if ( result < 0 )
{
if (errno != EINTR)
{
fprintf(stderr, "Error in select(): %d\r\n", errno);
}
}
else if (result >= 0)
{
uint8_t buffer[MAX_PACKET_SIZE];
int numBytes;
// Packet received
if (FD_ISSET(data.sock, &readfds))
{
struct sockaddr_storage addr;
socklen_t addrLen;
addrLen = sizeof(addr);
numBytes = recvfrom(data.sock, buffer, MAX_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrLen);
if (numBytes == -1)
{
fprintf(stderr, "Error in recvfrom(): %d\r\n", errno);
}
else
{
char s[INET6_ADDRSTRLEN];
in_port_t port;
connection_t * connP;
s[0] = 0;
if (AF_INET == addr.ss_family)
{
struct sockaddr_in *saddr = (struct sockaddr_in *)&addr;
inet_ntop(saddr->sin_family, &saddr->sin_addr, s, INET6_ADDRSTRLEN);
port = saddr->sin_port;
}
else if (AF_INET6 == addr.ss_family)
{
struct sockaddr_in6 *saddr = (struct sockaddr_in6 *)&addr;
inet_ntop(saddr->sin6_family, &saddr->sin6_addr, s, INET6_ADDRSTRLEN);
port = saddr->sin6_port;
}
fprintf(stderr, "%d bytes received from [%s]:%hu\r\n", numBytes, s, ntohs(port));
output_buffer(stderr, buffer, numBytes, 0);
connP = connection_find(data.connList, &addr, addrLen);
if (connP == NULL)
{
connP = connection_new_incoming(data.connList, data.sock, (struct sockaddr *)&addr, addrLen);
if (connP != NULL)
{
data.connList = connP;
}
}
if (connP != NULL)
{
lwm2m_handle_packet(data.lwm2mH, buffer, numBytes, connP);
}
}
}
// command line input
else if (FD_ISSET(STDIN_FILENO, &readfds))
{
numBytes = read(STDIN_FILENO, buffer, MAX_PACKET_SIZE - 1);
if (numBytes > 1)
{
buffer[numBytes] = 0;
handle_command(commands, (char*)buffer);
}
if (g_quit == 0)
{
fprintf(stdout, "\r\n> ");
fflush(stdout);
}
else
{
fprintf(stdout, "\r\n");
}
}
// Do operations on endpoints
prv_endpoint_clean(&data);
endP = data.endpointList;
while (endP != NULL)
{
switch(endP->status)
{
case CMD_STATUS_OK:
endP->cmdList = endP->cmdList->next;
endP->status = CMD_STATUS_NEW;
// fall through
case CMD_STATUS_NEW:
prv_send_command(&data, endP);
break;
default:
break;
}
endP = endP->next;
}
}
}
lwm2m_close(data.lwm2mH);
bs_free_info(data.bsInfo);
while (data.endpointList != NULL)
{
endpoint_t * endP;
endP = data.endpointList;
data.endpointList = data.endpointList->next;
prv_endpoint_free(endP);
}
close(data.sock);
connection_free(data.connList);
return 0;
}
int main(int argc, char *argv[])
{
int socket;
fd_set readfds;
struct timeval tv;
int result;
lwm2m_context_t * lwm2mH = NULL;
int i;
command_desc_t commands[] =
{
{"list", "List registered clients.", NULL, prv_output_clients, NULL},
{"read", "Read from a client.", " read CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to read such as /3, /3//2, /3/0/2, /1024/11, /1024//1\r\n"
"Result will be displayed asynchronously.", prv_read_client, NULL},
{"write", "Write to a client.", " write CLIENT# URI DATA\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to write to such as /3, /3//2, /3/0/2, /1024/11, /1024//1\r\n"
" DATA: data to write\r\n"
"Result will be displayed asynchronously.", prv_write_client, NULL},
{"exec", "Execute a client resource.", " exec CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri of the resource to execute such as /3/0/2\r\n"
"Result will be displayed asynchronously.", prv_exec_client, NULL},
{"del", "Delete a client Object instance.", " del CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri of the instance to delete such as /1024/11\r\n"
"Result will be displayed asynchronously.", prv_delete_client, NULL},
{"observe", "Observe from a client.", " observe CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri to observe such as /3, /3/0/2, /1024/11\r\n"
"Result will be displayed asynchronously.", prv_observe_client, NULL},
{"cancel", "Cancel an observe.", " cancel CLIENT# URI\r\n"
" CLIENT#: client number as returned by command 'list'\r\n"
" URI: uri on which to cancel an observe such as /3, /3/0/2, /1024/11\r\n"
"Result will be displayed asynchronously.", prv_cancel_client, NULL},
{"quit", "Quit the server.", NULL, prv_quit, NULL},
COMMAND_END_LIST
};
socket = get_socket();
if (socket < 0)
{
fprintf(stderr, "Error opening socket: %d\r\n", errno);
return -1;
}
lwm2mH = lwm2m_init(socket, "testlwm2mserver", 0, NULL, prv_buffer_send);
if (NULL == lwm2mH)
{
fprintf(stderr, "lwm2m_init() failed\r\n");
return -1;
}
signal(SIGINT, handle_sigint);
for (i = 0 ; commands[i].name != NULL ; i++)
{
commands[i].userData = (void *)lwm2mH;
}
fprintf(stdout, "> "); fflush(stdout);
lwm2m_set_monitoring_callback(lwm2mH, prv_monitor_callback, lwm2mH);
while (0 == g_quit)
{
FD_ZERO(&readfds);
FD_SET(socket, &readfds);
FD_SET(STDIN_FILENO, &readfds);
tv.tv_sec = 60;
tv.tv_usec = 0;
result = lwm2m_step(lwm2mH, &tv);
if (result != 0)
{
fprintf(stderr, "lwm2m_step() failed: 0x%X\r\n", result);
return -1;
}
result = select(FD_SETSIZE, &readfds, 0, 0, &tv);
if ( result < 0 )
{
if (errno != EINTR)
{
fprintf(stderr, "Error in select(): %d\r\n", errno);
}
}
else if (result > 0)
{
uint8_t buffer[MAX_PACKET_SIZE];
int numBytes;
if (FD_ISSET(socket, &readfds))
{
struct sockaddr_storage addr;
socklen_t addrLen;
addrLen = sizeof(addr);
numBytes = recvfrom(socket, buffer, MAX_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrLen);
if (numBytes == -1)
{
fprintf(stderr, "Error in recvfrom(): %d\r\n", errno);
}
else
{
char s[INET6_ADDRSTRLEN];
coap_status_t coap_error_code = NO_ERROR;
static coap_packet_t message[1];
fprintf(stderr, "%d bytes received from [%s]:%hu\r\n",
numBytes,
inet_ntop(addr.ss_family,
&(((struct sockaddr_in6*)&addr)->sin6_addr),
s,
INET6_ADDRSTRLEN),
ntohs(((struct sockaddr_in6*)&addr)->sin6_port));
prv_output_buffer(stderr, buffer, numBytes);
lwm2m_handle_packet(lwm2mH, buffer, numBytes, (uint8_t *)&addr, addrLen);
}
}
else if (FD_ISSET(STDIN_FILENO, &readfds))
{
numBytes = read(STDIN_FILENO, buffer, MAX_PACKET_SIZE);
if (numBytes > 1)
{
buffer[numBytes - 1] = 0;
handle_command(commands, buffer);
}
if (g_quit == 0)
{
fprintf(stdout, "\r\n> ");
fflush(stdout);
}
else
{
fprintf(stdout, "\r\n");
}
}
}
}
lwm2m_close(lwm2mH);
close(socket);
return 0;
}
int lwm2mclient_main()
{
client_data_t data;
int result;
lwm2m_context_t * lwm2mH = NULL;
int i;
const char * localPort = "56830";
//const char * server = "beta-devices.zatar.com";
const char * server = "leshan.eclipse.org";
//const char * server = "5.39.83.206";
const char * serverPort = LWM2M_STANDARD_PORT_STR;
char * name = "ZebraBlr";
int lifetime = 300;
int batterylevelchanging = 0;
time_t reboot_time = 0;
int opt;
bool bootstrapRequested = false;
#ifdef LWM2M_BOOTSTRAP
lwm2m_bootstrap_state_t previousBootstrapState = NOT_BOOTSTRAPPED;
#endif
/*
* The function start by setting up the command line interface (which may or not be useful depending on your project)
*
* This is an array of commands describes as { name, description, long description, callback, userdata }.
* The firsts tree are easy to understand, the callback is the function that will be called when this command is typed
* and in the last one will be stored the lwm2m context (allowing access to the server settings and the objects).
*/
command_desc_t commands[] =
{
{"list", "List known servers.", NULL, prv_output_servers, NULL},
{"change", "Change the value of resource.", " change URI [DATA]\r\n"
" URI: uri of the resource such as /3/0, /3/0/2\r\n"
" DATA: (optional) new value\r\n", prv_change, NULL},
{"update", "Trigger a registration update", " update SERVER\r\n"
" SERVER: short server id such as 123\r\n", prv_update, NULL},
#ifdef LWM2M_BOOTSTRAP
{"bootstrap", "Initiate a DI bootstrap process", NULL, prv_initiate_bootstrap, NULL},
{"disp", "Display current objects/instances/resources", NULL, prv_display_objects, NULL},
{"dispb", "Display current backup of objects/instances/resources\r\n"
"\t(only security and server objects are backupped)", NULL, prv_display_backup, NULL},
#endif
{"ls", "List Objects and Instances", NULL, prv_object_list, NULL},
{"dump", "Dump an Object", "dump URI"
"URI: uri of the Object or Instance such as /3/0, /1\r\n", prv_object_dump, NULL},
{"quit", "Quit the client gracefully.", NULL, prv_quit, NULL},
{"^C", "Quit the client abruptly (without sending a de-register message).", NULL, NULL, NULL},
COMMAND_END_LIST
};
memset(&data, 0, sizeof(client_data_t));
/* Zebra change: Reddy
while ((opt = getopt(argc, argv, "bcl:n:p:t:h:")) != -1)
{
switch (opt)
{
case 'b':
bootstrapRequested = true;
break;
case 'c':
batterylevelchanging = 1;
break;
case 't':
sscanf(optarg, "%d", &lifetime);
break;
case 'n':
name = optarg;
break;
case 'l':
localPort = optarg;
break;
case 'h':
server = optarg;
break;
case 'p':
serverPort = optarg;
break;
default:
print_usage();
return 0;
}
}
*/
/*
*This call an internal function that create an IPV6 socket on the port 5683.
*/
fprintf(stderr, "Trying to bind LWM2M Client to port %s\r\n", localPort);
data.sock = create_socket(localPort);
if (data.sock < 0)
{
fprintf(stderr, "Failed to open socket: %d\r\n", errno);
return -1;
}
/*
* Now the main function fill an array with each object, this list will be later passed to liblwm2m.
* Those functions are located in their respective object file.
*/
char serverUri[50];
int serverId = 123;
sprintf (serverUri, "coap://%s:%s", server, serverPort);
fprintf(stderr, " LWM2M serverUri %s\r\n", serverUri);
#ifdef LWM2M_BOOTSTRAP
objArray[0] = get_security_object(serverId, serverUri, bootstrapRequested);
#else
objArray[0] = get_security_object(serverId, serverUri, false);
#endif
if (NULL == objArray[0])
{
fprintf(stderr, "Failed to create security object\r\n");
return -1;
}
data.securityObjP = objArray[0];
objArray[1] = get_server_object(serverId, "U", lifetime, false);
if (NULL == objArray[1])
{
fprintf(stderr, "Failed to create server object\r\n");
return -1;
}
objArray[2] = get_object_device();
if (NULL == objArray[2])
{
fprintf(stderr, "Failed to create Device object\r\n");
return -1;
}
objArray[3] = get_object_firmware();
if (NULL == objArray[3])
{
fprintf(stderr, "Failed to create Firmware object\r\n");
return -1;
}
objArray[4] = get_object_location();
if (NULL == objArray[4])
{
fprintf(stderr, "Failed to create location object\r\n");
return -1;
}
objArray[5] = get_test_object();
if (NULL == objArray[5])
{
fprintf(stderr, "Failed to create test object\r\n");
return -1;
}
objArray[6] = get_object_conn_m();
if (NULL == objArray[6])
{
fprintf(stderr, "Failed to create connectivity monitoring object\r\n");
return -1;
}
objArray[7] = get_object_conn_s();
if (NULL == objArray[7])
{
fprintf(stderr, "Failed to create connectivity statistics object\r\n");
return -1;
}
int instId = 0;
objArray[8] = acc_ctrl_create_object();
if (NULL == objArray[8])
{
fprintf(stderr, "Failed to create Access Control object\r\n");
return -1;
}
else if (acc_ctrl_obj_add_inst(objArray[8], instId, 3, 0, serverId)==false)
{
fprintf(stderr, "Failed to create Access Control object instance\r\n");
return -1;
}
else if (acc_ctrl_oi_add_ac_val(objArray[8], instId, 0, 0b000000000001111)==false)
{
fprintf(stderr, "Failed to create Access Control ACL default resource\r\n");
return -1;
}
else if (acc_ctrl_oi_add_ac_val(objArray[8], instId, 999, 0b000000000000001)==false)
{
fprintf(stderr, "Failed to create Access Control ACL resource for serverId: 999\r\n");
return -1;
}
/*
* The liblwm2m library is now initialized with the functions that will be in
* charge of communication
*/
lwm2mH = lwm2m_init(prv_connect_server, prv_buffer_send, &data);
if (NULL == lwm2mH)
{
fprintf(stderr, "lwm2m_init() failed\r\n");
return -1;
}
#ifdef LWM2M_BOOTSTRAP
/*
* Bootstrap state initialization
*/
if (bootstrapRequested)
{
lwm2mH->bsState = BOOTSTRAP_REQUESTED;
}
else
{
lwm2mH->bsState = NOT_BOOTSTRAPPED;
}
#endif
/*
* We configure the liblwm2m library with the name of the client - which shall be unique for each client -
* the number of objects we will be passing through and the objects array
*/
result = lwm2m_configure(lwm2mH, name, NULL, NULL, OBJ_COUNT, objArray);
if (result != 0)
{
fprintf(stderr, "lwm2m_configure() failed: 0x%X\r\n", result);
return -1;
}
signal(SIGINT, handle_sigint);
/*
* This function start your client to the LWM2M servers
*/
result = lwm2m_start(lwm2mH);
if (result != 0)
{
fprintf(stderr, "lwm2m_start() failed: 0x%X\r\n", result);
return -1;
}
/**
* Initialize value changed callback.
*/
init_value_change(lwm2mH);
/*
* As you now have your lwm2m context complete you can pass it as an argument to all the command line functions
* precedently viewed (first point)
*/
for (i = 0 ; commands[i].name != NULL ; i++)
{
commands[i].userData = (void *)lwm2mH;
}
fprintf(stdout, "LWM2M Client \"%s\" started on port %s\r\n", name, localPort);
fprintf(stdout, "> "); fflush(stdout);
/*
* We now enter in a while loop that will handle the communications from the server
*/
while (0 == g_quit)
{
struct timeval tv;
fd_set readfds;
if (g_reboot)
{
time_t tv_sec;
tv_sec = lwm2m_gettime();
if (0 == reboot_time)
{
reboot_time = tv_sec + 5;
}
if (reboot_time < tv_sec)
{
/*
* Message should normally be lost with reboot ...
*/
fprintf(stderr, "reboot time expired, rebooting ...");
system_reboot();
}
else
{
tv.tv_sec = reboot_time - tv_sec;
}
}
else if (batterylevelchanging)
{
update_battery_level(lwm2mH);
tv.tv_sec = 5;
}
else
{
tv.tv_sec = 60;
}
tv.tv_usec = 0;
FD_ZERO(&readfds);
FD_SET(data.sock, &readfds);
FD_SET(STDIN_FILENO, &readfds);
/*
* This function does two things:
* - first it does the work needed by liblwm2m (eg. (re)sending some packets).
* - Secondly it adjusts the timeout value (default 60s) depending on the state of the transaction
* (eg. retransmission) and the time between the next operation
*/
result = lwm2m_step(lwm2mH, &(tv.tv_sec));
if (result != 0)
{
fprintf(stderr, "lwm2m_step() failed: 0x%X\r\n", result);
return -1;
}
#ifdef LWM2M_BOOTSTRAP
update_bootstrap_info(&previousBootstrapState, lwm2mH);
#endif
/*
* This part will set up an interruption until an event happen on SDTIN or the socket until "tv" timed out (set
* with the precedent function)
*/
//result = select(FD_SETSIZE, &readfds, NULL, NULL, &tv);
if (result < 0)
{
if (errno != EINTR)
{
fprintf(stderr, "Error in select(): %d\r\n", errno);
}
}
else if (result > 0)
{
uint8_t buffer[MAX_PACKET_SIZE];
int numBytes;
/*
* If an event happens on the socket
*/
if (FD_ISSET(data.sock, &readfds))
{
//struct sockaddr_storage addr;
struct sockaddr addr;
uint32 addrLen;
addrLen = sizeof(addr);
/*
* We retrieve the data received
*/
//numBytes = recvfrom(data.sock, buffer, MAX_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrLen);
numBytes = recvfrom(data.sock, buffer, MAX_PACKET_SIZE,0);
if (0 > numBytes)
{
fprintf(stderr, "Error in recvfrom(): %d\r\n", errno);
}
else if (0 < numBytes)
{
char s[INET6_ADDRSTRLEN];
uint16 port;
connection_t * connP;
if (AF_INET == addr.sa_family)
{
struct sockaddr_in *saddr = (struct sockaddr_in *)&addr;
//inet_ntop(saddr->sin_family, &saddr->sin_addr, s, INET6_ADDRSTRLEN);
port = saddr->sin_port;
}
//else if (AF_INET6 == addr.ss_family)
//{
// struct sockaddr_in6 *saddr = (struct sockaddr_in6 *)&addr;
// inet_ntop(saddr->sin6_family, &saddr->sin6_addr, s, INET6_ADDRSTRLEN);
// port = saddr->sin6_port;
// }
//fprintf(stderr, "%d bytes received from [%s]:%hu\r\n", numBytes, s, ntohs(port));
/*
* Display it in the STDERR
*/
output_buffer(stderr, buffer, numBytes, 0);
connP = connection_find(data.connList, &addr, addrLen);
if (connP != NULL)
{
/*
* Let liblwm2m respond to the query depending on the context
*/
lwm2m_handle_packet(lwm2mH, buffer, numBytes, connP);
conn_s_updateRxStatistic(objArray[7], numBytes, false);
}
else
{
fprintf(stderr, "received bytes ignored!\r\n");
}
}
}
/*
* If the event happened on the SDTIN
*/
else if (FD_ISSET(STDIN_FILENO, &readfds))
{
numBytes = read(STDIN_FILENO, buffer, MAX_PACKET_SIZE - 1);
if (numBytes > 1)
{
buffer[numBytes] = 0;
fprintf(stderr, "STDIN %d bytes '%s'\r\n> ", numBytes, buffer);
/*
* We call the corresponding callback of the typed command passing it the buffer for further arguments
*/
handle_command(commands, (char*)buffer);
}
if (g_quit == 0)
{
fprintf(stdout, "\r\n> ");
fflush(stdout);
}
else
{
fprintf(stdout, "\r\n");
}
}
}
}
/*
* Finally when the loop is left smoothly - asked by user in the command line interface - we unregister our client from it
*/
if (g_quit == 1) {
#ifdef LWM2M_BOOTSTRAP
close_backup_object();
#endif
lwm2m_close(lwm2mH);
}
close(data.sock);
connection_free(data.connList);
return 0;
}