Merge RA branch to master
[iotivity.git] / resource / csdk / stack / samples / linux / SimpleClientServer / ocserver.cpp
1 //******************************************************************
2 //
3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
4 //
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
6 //
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 //      http://www.apache.org/licenses/LICENSE-2.0
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
20
21
22 #include <stdio.h>
23 #include <string.h>
24 #include <string>
25 #include <stdlib.h>
26 #include <unistd.h>
27 #include <signal.h>
28 #include <pthread.h>
29 #include <array>
30 #include "ocstack.h"
31 #include "logger.h"
32 #include "ocpayload.h"
33 #include "ocserver.h"
34
35 //string length of "/a/light/" + std::numeric_limits<int>::digits10 + '\0'"
36 // 9 + 9 + 1 = 19
37 const int URI_MAXSIZE = 19;
38
39 static int gObserveNotifyType = 3;
40
41 int gQuitFlag = 0;
42 int gLightUnderObservation = 0;
43
44 static LightResource Light;
45 // This variable determines instance number of the Light resource.
46 // Used by POST method to create a new instance of Light resource.
47 static int gCurrLightInstance = 0;
48
49 static LightResource gLightInstance[SAMPLE_MAX_NUM_POST_INSTANCE];
50
51 Observers interestedObservers[SAMPLE_MAX_NUM_OBSERVATIONS];
52
53 #ifdef WITH_PRESENCE
54 static int stopPresenceCount = 10;
55 #define numPresenceResources (2)
56 #endif
57
58 char *gResourceUri= (char *)"/a/light";
59 const char *dateOfManufacture = "myDateOfManufacture";
60 const char *deviceName = "myDeviceName";
61 const char *deviceUUID = "myDeviceUUID";
62 const char *firmwareVersion = "myFirmwareVersion";
63 const char *manufacturerName = "myName";
64 const char *operatingSystemVersion = "myOS";
65 const char *hardwareVersion = "myHardwareVersion";
66 const char* platformID = "myPlatformID";
67 const char *manufacturerUrl = "myManufacturerUrl";
68 const char *modelNumber = "myModelNumber";
69 const char *platformVersion = "myPlatformVersion";
70 const char *supportUrl = "mySupportUrl";
71 const char *version = "myVersion";
72 const char *systemTime = "2015-05-15T11.04";
73
74 // Entity handler should check for resourceTypeName and ResourceInterface in order to GET
75 // the existence of a known resource
76 const char *resourceTypeName = "core.light";
77 const char *resourceInterface = OC_RSRVD_INTERFACE_DEFAULT;
78
79 OCPlatformInfo platformInfo;
80 OCDeviceInfo deviceInfo;
81
82 OCRepPayload* getPayload(const char* uri, int64_t power, bool state)
83 {
84     OCRepPayload* payload = OCRepPayloadCreate();
85     if(!payload)
86     {
87         OC_LOG(ERROR, TAG, PCF("Failed to allocate Payload"));
88         return nullptr;
89     }
90
91     OCRepPayloadSetUri(payload, uri);
92     OCRepPayloadSetPropBool(payload, "state", state);
93     OCRepPayloadSetPropInt(payload, "power", power);
94
95     return payload;
96 }
97
98 //This function takes the request as an input and returns the response
99 OCRepPayload* constructResponse(OCEntityHandlerRequest *ehRequest)
100 {
101     if(ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
102     {
103         OC_LOG(ERROR, TAG, PCF("Incoming payload not a representation"));
104         return nullptr;
105     }
106
107     OCRepPayload* input = reinterpret_cast<OCRepPayload*>(ehRequest->payload);
108
109     LightResource *currLightResource = &Light;
110
111     if (ehRequest->resource == gLightInstance[0].handle)
112     {
113         currLightResource = &gLightInstance[0];
114         gResourceUri = (char *) "a/light/0";
115     }
116     else if (ehRequest->resource == gLightInstance[1].handle)
117     {
118         currLightResource = &gLightInstance[1];
119         gResourceUri = (char *) "a/light/1";
120     }
121
122     if(OC_REST_PUT == ehRequest->method)
123     {
124         // Get pointer to query
125         int64_t pow;
126         if(OCRepPayloadGetPropInt(input, "power", &pow))
127         {
128             currLightResource->power =pow;
129         }
130
131         bool state;
132         if(OCRepPayloadGetPropBool(input, "state", &state))
133         {
134             currLightResource->state = state;
135         }
136     }
137
138     return getPayload(gResourceUri, currLightResource->power, currLightResource->state);
139 }
140
141 /*
142  * Very simple example of query parsing.
143  * The query may have multiple filters separated by ';'.
144  * It is upto the entity handler to parse the query for the individual filters,
145  * VALIDATE them and respond as it sees fit.
146
147  * This function only returns false if the query is exactly "power<X" and
148  * current power is greater than X. If X cannot be parsed for an int,
149  * true is returned.
150  */
151 bool checkIfQueryForPowerPassed(char * query)
152 {
153     if (query && strncmp(query, "power<", strlen("power<")) == 0)
154     {
155         char * pointerToOperator = strstr(query, "<");
156
157         if (pointerToOperator)
158         {
159             int powerRequested = atoi(pointerToOperator + 1);
160             if (Light.power > powerRequested)
161             {
162                 OC_LOG_V(INFO, TAG, "Current power: %d. Requested: <%d", Light.power
163                             , powerRequested);
164                 return false;
165             }
166         }
167     }
168     return true;
169 }
170
171 /*
172  * Application should validate and process these as desired.
173  */
174 OCEntityHandlerResult ValidateQueryParams (OCEntityHandlerRequest *entityHandlerRequest)
175 {
176     OC_LOG_V(INFO, TAG, PCF("Received query %s"), entityHandlerRequest->query);
177     OC_LOG(INFO, TAG, PCF("Not processing query"));
178     return OC_EH_OK;
179 }
180
181 OCEntityHandlerResult ProcessGetRequest (OCEntityHandlerRequest *ehRequest,
182         OCRepPayload **payload)
183 {
184     OCEntityHandlerResult ehResult;
185     bool queryPassed = checkIfQueryForPowerPassed(ehRequest->query);
186
187     // Empty payload if the query has no match.
188     if (queryPassed)
189     {
190         OCRepPayload *getResp = constructResponse(ehRequest);
191         if(!getResp)
192         {
193             OC_LOG(ERROR, TAG, "constructResponse failed");
194             return OC_EH_ERROR;
195         }
196
197         *payload = getResp;
198         ehResult = OC_EH_OK;
199     }
200     else
201     {
202         ehResult = OC_EH_OK;
203     }
204
205     return ehResult;
206 }
207
208 OCEntityHandlerResult ProcessPutRequest (OCEntityHandlerRequest *ehRequest,
209         OCRepPayload** payload)
210 {
211     OCEntityHandlerResult ehResult;
212     OCRepPayload *putResp = constructResponse(ehRequest);
213
214     if(!putResp)
215     {
216         OC_LOG(ERROR, TAG, "Failed to construct Json response");
217         return OC_EH_ERROR;
218     }
219
220     *payload = putResp;
221     ehResult = OC_EH_OK;
222
223     return ehResult;
224 }
225
226 OCEntityHandlerResult ProcessPostRequest (OCEntityHandlerRequest *ehRequest,
227         OCEntityHandlerResponse *response, OCRepPayload** payload)
228 {
229     OCEntityHandlerResult ehResult = OC_EH_OK;
230     OCRepPayload *respPLPost_light = nullptr;
231
232     /*
233      * The entity handler determines how to process a POST request.
234      * Per the REST paradigm, POST can also be used to update representation of existing
235      * resource or create a new resource.
236      * In the sample below, if the POST is for /a/light then a new instance of the Light
237      * resource is created with default representation (if representation is included in
238      * POST payload it can be used as initial values) as long as the instance is
239      * lesser than max new instance count. Once max instance count is reached, POST on
240      * /a/light updated the representation of /a/light (just like PUT)
241      */
242
243     if (ehRequest->resource == Light.handle)
244     {
245         if (gCurrLightInstance < SAMPLE_MAX_NUM_POST_INSTANCE)
246         {
247             // Create new Light instance
248             char newLightUri[URI_MAXSIZE];
249             snprintf(newLightUri, URI_MAXSIZE, "/a/light/%d", gCurrLightInstance);
250
251             respPLPost_light = OCRepPayloadCreate();
252             OCRepPayloadSetUri(respPLPost_light, gResourceUri);
253             OCRepPayloadSetPropString(respPLPost_light, "createduri", newLightUri);
254
255             if (0 == createLightResource (newLightUri, &gLightInstance[gCurrLightInstance]))
256             {
257                 OC_LOG (INFO, TAG, "Created new Light instance\n");
258                 gLightInstance[gCurrLightInstance].state = 0;
259                 gLightInstance[gCurrLightInstance].power = 0;
260                 gCurrLightInstance++;
261                 strncpy ((char *)response->resourceUri, newLightUri, MAX_URI_LENGTH);
262                 ehResult = OC_EH_RESOURCE_CREATED;
263             }
264         }
265         else
266         {
267             // Update repesentation of /a/light
268             Light.state = true;
269             Light.power = 11;
270             respPLPost_light = constructResponse(ehRequest);
271         }
272     }
273     else
274     {
275         for (int i = 0; i < SAMPLE_MAX_NUM_POST_INSTANCE; i++)
276         {
277             if (ehRequest->resource == gLightInstance[i].handle)
278             {
279                 gLightInstance[i].state = true;
280                 gLightInstance[i].power = 22;
281                 if (i == 0)
282                 {
283                     respPLPost_light = constructResponse(ehRequest);
284                     break;
285                 }
286                 else if (i == 1)
287                 {
288                     respPLPost_light = constructResponse(ehRequest);
289                 }
290             }
291         }
292     }
293
294     if ((respPLPost_light != NULL))
295     {
296         *payload = respPLPost_light;
297     }
298     else
299     {
300         OC_LOG(INFO, TAG, "Payload was NULL");
301         ehResult = OC_EH_ERROR;
302     }
303
304     return ehResult;
305 }
306
307 OCEntityHandlerResult ProcessDeleteRequest (OCEntityHandlerRequest *ehRequest)
308 {
309     if(ehRequest == NULL)
310     {
311         OC_LOG(INFO, TAG, "The ehRequest is NULL");
312         return OC_EH_ERROR;
313     }
314     OCEntityHandlerResult ehResult = OC_EH_OK;
315
316     OC_LOG_V(INFO, TAG, "\n\nExecuting %s for resource %d ", __func__, ehRequest->resource);
317
318     /*
319      * In the sample below, the application will:
320      * 1a. pass the delete request to the c stack
321      * 1b. internally, the c stack figures out what needs to be done and does it accordingly
322      *    (e.g. send observers notification, remove observers...)
323      * 1c. the c stack returns with the result whether the request is fullfilled.
324      * 2. optionally, app removes observers out of its array 'interestedObservers'
325      */
326
327     if ((ehRequest != NULL) && (ehRequest->resource == Light.handle))
328     {
329         //Step 1: Ask stack to do the work.
330         OCStackResult result = OCDeleteResource(ehRequest->resource);
331
332         if (result == OC_STACK_OK)
333         {
334             OC_LOG (INFO, TAG, "\n\nDelete Resource operation succeeded.");
335             ehResult = OC_EH_OK;
336
337             //Step 2: clear observers who wanted to observe this resource at the app level.
338             for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
339             {
340                 if (interestedObservers[i].resourceHandle == ehRequest->resource)
341                 {
342                     interestedObservers[i].valid = false;
343                     interestedObservers[i].observationId = 0;
344                     interestedObservers[i].resourceHandle = NULL;
345                 }
346             }
347         }
348         else if (result == OC_STACK_NO_RESOURCE)
349         {
350             OC_LOG(INFO, TAG, "\n\nThe resource doesn't exist or it might have been deleted.");
351             ehResult = OC_EH_RESOURCE_DELETED;
352         }
353         else
354         {
355             OC_LOG(INFO, TAG, "\n\nEncountered error from OCDeleteResource().");
356             ehResult = OC_EH_ERROR;
357         }
358     }
359     else if (ehRequest->resource != Light.handle)
360     {
361         //Let's this app not supporting DELETE on some resources so
362         //consider the DELETE request is received for a non-support resource.
363         OC_LOG_V(INFO, TAG, "\n\nThe request is received for a non-support resource.");
364         ehResult = OC_EH_FORBIDDEN;
365     }
366
367     return ehResult;
368 }
369
370 OCEntityHandlerResult ProcessNonExistingResourceRequest(OCEntityHandlerRequest * /*ehRequest*/)
371 {
372     OC_LOG_V(INFO, TAG, "\n\nExecuting %s ", __func__);
373
374     return OC_EH_RESOURCE_NOT_FOUND;
375 }
376
377 void ProcessObserveRegister (OCEntityHandlerRequest *ehRequest)
378 {
379     OC_LOG_V (INFO, TAG, "Received observation registration request with observation Id %d",
380             ehRequest->obsInfo.obsId);
381     for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
382     {
383         if (interestedObservers[i].valid == false)
384         {
385             interestedObservers[i].observationId = ehRequest->obsInfo.obsId;
386             interestedObservers[i].valid = true;
387             gLightUnderObservation = 1;
388             break;
389         }
390     }
391 }
392
393 void ProcessObserveDeregister (OCEntityHandlerRequest *ehRequest)
394 {
395     bool clientStillObserving = false;
396
397     OC_LOG_V (INFO, TAG, "Received observation deregistration request for observation Id %d",
398             ehRequest->obsInfo.obsId);
399     for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
400     {
401         if (interestedObservers[i].observationId == ehRequest->obsInfo.obsId)
402         {
403             interestedObservers[i].valid = false;
404         }
405         if (interestedObservers[i].valid == true)
406         {
407             // Even if there is one single client observing we continue notifying entity handler
408             clientStillObserving = true;
409         }
410     }
411     if (clientStillObserving == false)
412         gLightUnderObservation = 0;
413 }
414
415 OCEntityHandlerResult
416 OCDeviceEntityHandlerCb (OCEntityHandlerFlag flag,
417                          OCEntityHandlerRequest *entityHandlerRequest,
418                          char* uri,
419                          void* /*callbackParam*/)
420 {
421     OC_LOG_V (INFO, TAG, "Inside device default entity handler - flags: 0x%x, uri: %s", flag, uri);
422
423     OCEntityHandlerResult ehResult = OC_EH_OK;
424     OCEntityHandlerResponse response;
425
426     // Validate pointer
427     if (!entityHandlerRequest)
428     {
429         OC_LOG (ERROR, TAG, "Invalid request pointer");
430         return OC_EH_ERROR;
431     }
432     // Initialize certain response fields
433     response.numSendVendorSpecificHeaderOptions = 0;
434     memset(response.sendVendorSpecificHeaderOptions, 0,
435             sizeof response.sendVendorSpecificHeaderOptions);
436     memset(response.resourceUri, 0, sizeof response.resourceUri);
437     OCRepPayload* payload = nullptr;
438
439
440     if (flag & OC_REQUEST_FLAG)
441     {
442         OC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
443
444         if (entityHandlerRequest->resource == NULL)
445         {
446             OC_LOG (INFO, TAG, "Received request from client to a non-existing resource");
447             ehResult = ProcessNonExistingResourceRequest(entityHandlerRequest);
448         }
449         else if (OC_REST_GET == entityHandlerRequest->method)
450         {
451             OC_LOG (INFO, TAG, "Received OC_REST_GET from client");
452             ehResult = ProcessGetRequest (entityHandlerRequest, &payload);
453         }
454         else if (OC_REST_PUT == entityHandlerRequest->method)
455         {
456             OC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
457             ehResult = ProcessPutRequest (entityHandlerRequest, &payload);
458         }
459         else if (OC_REST_DELETE == entityHandlerRequest->method)
460         {
461             OC_LOG (INFO, TAG, "Received OC_REST_DELETE from client");
462             ehResult = ProcessDeleteRequest (entityHandlerRequest);
463         }
464         else
465         {
466             OC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
467                       entityHandlerRequest->method);
468             ehResult = OC_EH_ERROR;
469         }
470                // If the result isn't an error or forbidden, send response
471         if (!((ehResult == OC_EH_ERROR) || (ehResult == OC_EH_FORBIDDEN)))
472         {
473             // Format the response.  Note this requires some info about the request
474             response.requestHandle = entityHandlerRequest->requestHandle;
475             response.resourceHandle = entityHandlerRequest->resource;
476             response.ehResult = ehResult;
477             response.payload = reinterpret_cast<OCPayload*>(payload);
478             // Indicate that response is NOT in a persistent buffer
479             response.persistentBufferFlag = 0;
480
481             // Send the response
482             if (OCDoResponse(&response) != OC_STACK_OK)
483             {
484                 OC_LOG(ERROR, TAG, "Error sending response");
485                 ehResult = OC_EH_ERROR;
486             }
487         }
488     }
489     if (flag & OC_OBSERVE_FLAG)
490     {
491         OC_LOG(INFO, TAG, "Flag includes OC_OBSERVE_FLAG");
492         if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
493         {
494             OC_LOG (INFO, TAG, "Received OC_OBSERVE_REGISTER from client");
495         }
496         else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
497         {
498             OC_LOG (INFO, TAG, "Received OC_OBSERVE_DEREGISTER from client");
499         }
500     }
501
502     return ehResult;
503 }
504
505 OCEntityHandlerResult
506 OCNOPEntityHandlerCb (OCEntityHandlerFlag /*flag*/,
507                       OCEntityHandlerRequest * /*entityHandlerRequest*/,
508                       void* /*callbackParam*/)
509 {
510     // This is callback is associated with the 2 presence notification
511     // resources. They are non-operational.
512     return OC_EH_OK;
513 }
514
515 OCEntityHandlerResult
516 OCEntityHandlerCb (OCEntityHandlerFlag flag,
517         OCEntityHandlerRequest *entityHandlerRequest, void* /*callback*/)
518 {
519     OC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
520
521     OCEntityHandlerResult ehResult = OC_EH_OK;
522     OCEntityHandlerResponse response = { 0, 0, OC_EH_ERROR, 0, 0, { },{ 0 }, false };
523
524     // Validate pointer
525     if (!entityHandlerRequest)
526     {
527         OC_LOG (ERROR, TAG, "Invalid request pointer");
528         return OC_EH_ERROR;
529     }
530
531     // Initialize certain response fields
532     response.numSendVendorSpecificHeaderOptions = 0;
533     memset(response.sendVendorSpecificHeaderOptions,
534             0, sizeof response.sendVendorSpecificHeaderOptions);
535     memset(response.resourceUri, 0, sizeof response.resourceUri);
536     OCRepPayload* payload = nullptr;
537
538     if (flag & OC_REQUEST_FLAG)
539     {
540         OC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
541
542         if (OC_REST_GET == entityHandlerRequest->method)
543         {
544             OC_LOG (INFO, TAG, "Received OC_REST_GET from client");
545             ehResult = ProcessGetRequest (entityHandlerRequest, &payload);
546         }
547         else if (OC_REST_PUT == entityHandlerRequest->method)
548         {
549             OC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
550             ehResult = ProcessPutRequest (entityHandlerRequest, &payload);
551         }
552         else if (OC_REST_POST == entityHandlerRequest->method)
553         {
554             OC_LOG (INFO, TAG, "Received OC_REST_POST from client");
555             ehResult = ProcessPostRequest (entityHandlerRequest, &response, &payload);
556         }
557         else if (OC_REST_DELETE == entityHandlerRequest->method)
558         {
559             OC_LOG (INFO, TAG, "Received OC_REST_DELETE from client");
560             ehResult = ProcessDeleteRequest (entityHandlerRequest);
561         }
562         else
563         {
564             OC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
565                       entityHandlerRequest->method);
566             ehResult = OC_EH_ERROR;
567         }
568         // If the result isn't an error or forbidden, send response
569         if (!((ehResult == OC_EH_ERROR) || (ehResult == OC_EH_FORBIDDEN)))
570         {
571             // Format the response.  Note this requires some info about the request
572             response.requestHandle = entityHandlerRequest->requestHandle;
573             response.resourceHandle = entityHandlerRequest->resource;
574             response.ehResult = ehResult;
575             response.payload = reinterpret_cast<OCPayload*>(payload);
576             // Indicate that response is NOT in a persistent buffer
577             response.persistentBufferFlag = 0;
578
579             // Handle vendor specific options
580             if(entityHandlerRequest->rcvdVendorSpecificHeaderOptions &&
581                     entityHandlerRequest->numRcvdVendorSpecificHeaderOptions)
582             {
583                 OC_LOG (INFO, TAG, "Received vendor specific options");
584                 uint8_t i = 0;
585                 OCHeaderOption * rcvdOptions =
586                         entityHandlerRequest->rcvdVendorSpecificHeaderOptions;
587                 for( i = 0; i < entityHandlerRequest->numRcvdVendorSpecificHeaderOptions; i++)
588                 {
589                     if(((OCHeaderOption)rcvdOptions[i]).protocolID == OC_COAP_ID)
590                     {
591                         OC_LOG_V(INFO, TAG, "Received option with OC_COAP_ID and ID %u with",
592                                 ((OCHeaderOption)rcvdOptions[i]).optionID );
593
594                         OC_LOG_BUFFER(INFO, TAG, ((OCHeaderOption)rcvdOptions[i]).optionData,
595                             MAX_HEADER_OPTION_DATA_LENGTH);
596                     }
597                 }
598                 OCHeaderOption * sendOptions = response.sendVendorSpecificHeaderOptions;
599                 uint8_t option2[] = {21,22,23,24,25,26,27,28,29,30};
600                 uint8_t option3[] = {31,32,33,34,35,36,37,38,39,40};
601                 sendOptions[0].protocolID = OC_COAP_ID;
602                 sendOptions[0].optionID = 2248;
603                 memcpy(sendOptions[0].optionData, option2, sizeof(option2));
604                 sendOptions[0].optionLength = 10;
605                 sendOptions[1].protocolID = OC_COAP_ID;
606                 sendOptions[1].optionID = 2600;
607                 memcpy(sendOptions[1].optionData, option3, sizeof(option3));
608                 sendOptions[1].optionLength = 10;
609                 response.numSendVendorSpecificHeaderOptions = 2;
610             }
611
612             // Send the response
613             if (OCDoResponse(&response) != OC_STACK_OK)
614             {
615                 OC_LOG(ERROR, TAG, "Error sending response");
616                 ehResult = OC_EH_ERROR;
617             }
618         }
619     }
620     if (flag & OC_OBSERVE_FLAG)
621     {
622         OC_LOG(INFO, TAG, "Flag includes OC_OBSERVE_FLAG");
623
624         if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
625         {
626             OC_LOG (INFO, TAG, "Received OC_OBSERVE_REGISTER from client");
627             ProcessObserveRegister (entityHandlerRequest);
628         }
629         else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
630         {
631             OC_LOG (INFO, TAG, "Received OC_OBSERVE_DEREGISTER from client");
632             ProcessObserveDeregister (entityHandlerRequest);
633         }
634     }
635
636     OCPayloadDestroy(response.payload);
637     return ehResult;
638 }
639
640 /* SIGINT handler: set gQuitFlag to 1 for graceful termination */
641 void handleSigInt(int signum)
642 {
643     if (signum == SIGINT)
644     {
645         gQuitFlag = 1;
646     }
647 }
648
649 void *ChangeLightRepresentation (void *param)
650 {
651     (void)param;
652     OCStackResult result = OC_STACK_ERROR;
653
654     uint8_t j = 0;
655     uint8_t numNotifies = (SAMPLE_MAX_NUM_OBSERVATIONS)/2;
656     OCObservationId obsNotify[numNotifies];
657
658     while (!gQuitFlag)
659     {
660         sleep(3);
661         Light.power += 5;
662         if (gLightUnderObservation)
663         {
664             OC_LOG_V(INFO, TAG, " =====> Notifying stack of new power level %d\n", Light.power);
665             if (gObserveNotifyType == 1)
666             {
667                 // Notify list of observers. Alternate observers on the list will be notified.
668                 j = 0;
669                 for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; (i=i+2))
670                 {
671                     if (interestedObservers[i].valid == true)
672                     {
673                         obsNotify[j] = interestedObservers[i].observationId;
674                         j++;
675                     }
676                 }
677
678                 OCRepPayload* payload = getPayload(gResourceUri, Light.power, Light.state);
679                 result = OCNotifyListOfObservers (Light.handle, obsNotify, j,
680                         payload, OC_NA_QOS);
681                 OCRepPayloadDestroy(payload);
682             }
683             else if (gObserveNotifyType == 0)
684             {
685                 // Notifying all observers
686                 result = OCNotifyAllObservers (Light.handle, OC_NA_QOS);
687                 if (OC_STACK_NO_OBSERVERS == result)
688                 {
689                     OC_LOG (INFO, TAG,
690                             "=======> No more observers exist, stop sending observations");
691                     gLightUnderObservation = 0;
692                 }
693             }
694             else
695             {
696                 OC_LOG (ERROR, TAG, "Incorrect notification type selected");
697             }
698         }
699 #ifdef WITH_PRESENCE
700         if(stopPresenceCount > 0)
701         {
702             OC_LOG_V(INFO, TAG, "================  Counting down to stop presence %d", stopPresenceCount);
703         }
704         if(!stopPresenceCount--)
705         {
706             OC_LOG(INFO, TAG, "================ stopping presence");
707             OCStopPresence();
708         }
709 #endif
710     }
711     return NULL;
712 }
713
714 #ifdef WITH_PRESENCE
715 void *presenceNotificationGenerator(void *param)
716 {
717     sleep(10);
718     (void)param;
719     OCDoHandle presenceNotificationHandles[numPresenceResources];
720     OCStackResult res = OC_STACK_OK;
721
722     std::array<std::string, numPresenceResources> presenceNotificationResources { {
723         std::string("core.fan"),
724         std::string("core.led") } };
725     std::array<std::string, numPresenceResources> presenceNotificationUris { {
726         std::string("/a/fan"),
727         std::string("/a/led") } };
728
729     for(int i=0; i<numPresenceResources; i++)
730     {
731         if(res == OC_STACK_OK)
732         {
733             sleep(1);
734             res = OCCreateResource(&presenceNotificationHandles[i],
735                     presenceNotificationResources.at(i).c_str(),
736                     OC_RSRVD_INTERFACE_DEFAULT,
737                     presenceNotificationUris.at(i).c_str(),
738                     OCNOPEntityHandlerCb,
739                     NULL,
740                     OC_DISCOVERABLE|OC_OBSERVABLE);
741         }
742         if(res != OC_STACK_OK)
743         {
744             OC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to create resource "
745                     "%s with result %s.", presenceNotificationResources.at(i).c_str(),
746                     getResult(res));
747             break;
748         }
749         OC_LOG_V(INFO, TAG, PCF("Created %s for presence notification"),
750                                 presenceNotificationUris[i].c_str());
751     }
752     sleep(5);
753     for(int i=0; i<numPresenceResources; i++)
754     {
755         if(res == OC_STACK_OK)
756         {
757             res = OCDeleteResource(presenceNotificationHandles[i]);
758         }
759         if(res != OC_STACK_OK)
760         {
761             OC_LOG_V(ERROR, TAG, "\"Presence Notification Generator\" failed to delete "\
762                     "resource %s.", presenceNotificationResources.at(i).c_str());
763             break;
764         }
765         OC_LOG_V(INFO, TAG, PCF("Deleted %s for presence notification"),
766                                 presenceNotificationUris[i].c_str());
767     }
768     return NULL;
769 }
770 #endif
771
772 int createLightResource (char *uri, LightResource *lightResource)
773 {
774     if (!uri)
775     {
776         OC_LOG(ERROR, TAG, "Resource URI cannot be NULL");
777         return -1;
778     }
779
780     lightResource->state = false;
781     lightResource->power= 0;
782     OCStackResult res = OCCreateResource(&(lightResource->handle),
783             "core.light",
784             "oc.mi.def",
785             uri,
786             OCEntityHandlerCb,
787             NULL,
788             OC_DISCOVERABLE|OC_OBSERVABLE);
789     OC_LOG_V(INFO, TAG, "Created Light resource with result: %s", getResult(res));
790
791     return 0;
792 }
793
794 void DeletePlatformInfo()
795 {
796     free (platformInfo.platformID);
797     free (platformInfo.manufacturerName);
798     free (platformInfo.manufacturerUrl);
799     free (platformInfo.modelNumber);
800     free (platformInfo.dateOfManufacture);
801     free (platformInfo.platformVersion);
802     free (platformInfo.operatingSystemVersion);
803     free (platformInfo.hardwareVersion);
804     free (platformInfo.firmwareVersion);
805     free (platformInfo.supportUrl);
806     free (platformInfo.systemTime);
807 }
808
809 void DeleteDeviceInfo()
810 {
811     free (deviceInfo.deviceName);
812 }
813
814 bool DuplicateString(char** targetString, const char* sourceString)
815 {
816     if(!sourceString)
817     {
818         return false;
819     }
820     else
821     {
822         *targetString = (char *) malloc(strlen(sourceString) + 1);
823
824         if(*targetString)
825         {
826             strncpy(*targetString, sourceString, (strlen(sourceString) + 1));
827             return true;
828         }
829     }
830     return false;
831 }
832
833 OCStackResult SetPlatformInfo(const char* platformID, const char *manufacturerName,
834     const char *manufacturerUrl, const char *modelNumber, const char *dateOfManufacture,
835     const char *platformVersion, const char* operatingSystemVersion, const char* hardwareVersion,
836     const char *firmwareVersion, const char* supportUrl, const char* systemTime)
837 {
838
839     bool success = true;
840
841     if(manufacturerName != NULL && (strlen(manufacturerName) > MAX_MANUFACTURER_NAME_LENGTH))
842     {
843         return OC_STACK_INVALID_PARAM;
844     }
845
846     if(manufacturerUrl != NULL && (strlen(manufacturerUrl) > MAX_MANUFACTURER_URL_LENGTH))
847     {
848         return OC_STACK_INVALID_PARAM;
849     }
850
851     if(!DuplicateString(&platformInfo.platformID, platformID))
852     {
853         success = false;
854     }
855
856     if(!DuplicateString(&platformInfo.manufacturerName, manufacturerName))
857     {
858         success = false;
859     }
860
861     if(!DuplicateString(&platformInfo.manufacturerUrl, manufacturerUrl))
862     {
863         success = false;
864     }
865
866     if(!DuplicateString(&platformInfo.modelNumber, modelNumber))
867     {
868         success = false;
869     }
870
871     if(!DuplicateString(&platformInfo.dateOfManufacture, dateOfManufacture))
872     {
873         success = false;
874     }
875
876     if(!DuplicateString(&platformInfo.platformVersion, platformVersion))
877     {
878         success = false;
879     }
880
881     if(!DuplicateString(&platformInfo.operatingSystemVersion, operatingSystemVersion))
882     {
883         success = false;
884     }
885
886     if(!DuplicateString(&platformInfo.hardwareVersion, hardwareVersion))
887     {
888         success = false;
889     }
890
891     if(!DuplicateString(&platformInfo.firmwareVersion, firmwareVersion))
892     {
893         success = false;
894     }
895
896     if(!DuplicateString(&platformInfo.supportUrl, supportUrl))
897     {
898         success = false;
899     }
900
901     if(!DuplicateString(&platformInfo.systemTime, systemTime))
902     {
903         success = false;
904     }
905
906     if(success)
907     {
908         return OC_STACK_OK;
909     }
910
911     DeletePlatformInfo();
912     return OC_STACK_ERROR;
913 }
914
915 OCStackResult SetDeviceInfo(const char* deviceName)
916 {
917     if(!DuplicateString(&deviceInfo.deviceName, deviceName))
918     {
919         return OC_STACK_ERROR;
920     }
921     return OC_STACK_OK;
922 }
923
924 static void PrintUsage()
925 {
926     OC_LOG(INFO, TAG, "Usage : ocserver -o <0|1>");
927     OC_LOG(INFO, TAG, "-o 0 : Notify all observers");
928     OC_LOG(INFO, TAG, "-o 1 : Notify list of observers");
929 }
930
931 #ifdef RA_ADAPTER
932 static void jidbound(char *jid)
933 {
934     OC_LOG_V(INFO, TAG, "\n\n    Bound JID: %s\n\n", jid);
935 }
936 #endif
937
938 int main(int argc, char* argv[])
939 {
940     pthread_t threadId;
941     pthread_t threadId_presence;
942
943 #ifdef RA_ADAPTER
944     char host[] = "localhost";
945     char user[] = "test1";
946     char pass[] = "intel123";
947     char empstr[] = "";
948     OCRAInfo_t rainfo = {.hostname = host, .port = 5222,
949         .xmpp_domain = host, .username = user, .password = pass,
950         .resource = empstr, .user_jid = empstr, .jidbound = jidbound};
951 #endif
952
953     int opt = 0;
954     while ((opt = getopt(argc, argv, "o:s:p:d:u:w:r:j:")) != -1)
955     {
956         switch(opt)
957         {
958             case 'o':
959                 gObserveNotifyType = atoi(optarg);
960                 break;
961 #ifdef RA_ADAPTER
962             case 's':
963                 rainfo.hostname = optarg;
964                 break;
965             case 'p':
966                 rainfo.port = atoi(optarg);
967                 break;
968             case 'd':
969                 rainfo.xmpp_domain = optarg;
970                 break;
971             case 'u':
972                 rainfo.username = optarg;
973                 break;
974             case 'w':
975                 rainfo.password = optarg;
976                 break;
977             case 'j':
978                 rainfo.user_jid = optarg;
979                 break;
980             case 'r':
981                 rainfo.resource = optarg;
982                 break;
983 #endif
984             default:
985                 PrintUsage();
986                 return -1;
987         }
988     }
989
990     if ((gObserveNotifyType != 0) && (gObserveNotifyType != 1))
991     {
992         PrintUsage();
993         return -1;
994     }
995
996 #ifdef RA_ADAPTER
997     OCSetRAInfo(&rainfo);
998 #endif
999
1000     OC_LOG(DEBUG, TAG, "OCServer is starting...");
1001
1002     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
1003     {
1004         OC_LOG(ERROR, TAG, "OCStack init error");
1005         return 0;
1006     }
1007 #ifdef WITH_PRESENCE
1008     if (OCStartPresence(0) != OC_STACK_OK)
1009     {
1010         OC_LOG(ERROR, TAG, "OCStack presence/discovery error");
1011         return 0;
1012     }
1013 #endif
1014
1015     OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandlerCb, NULL);
1016
1017     OCStackResult registrationResult =
1018         SetPlatformInfo(platformID, manufacturerName, manufacturerUrl, modelNumber,
1019             dateOfManufacture, platformVersion,  operatingSystemVersion,  hardwareVersion,
1020             firmwareVersion,  supportUrl, systemTime);
1021
1022     if (registrationResult != OC_STACK_OK)
1023     {
1024         OC_LOG(INFO, TAG, "Platform info setting failed locally!");
1025         exit (EXIT_FAILURE);
1026     }
1027
1028     registrationResult = OCSetPlatformInfo(platformInfo);
1029
1030     if (registrationResult != OC_STACK_OK)
1031     {
1032         OC_LOG(INFO, TAG, "Platform Registration failed!");
1033         exit (EXIT_FAILURE);
1034     }
1035
1036     registrationResult = SetDeviceInfo(deviceName);
1037
1038     if (registrationResult != OC_STACK_OK)
1039     {
1040         OC_LOG(INFO, TAG, "Device info setting failed locally!");
1041         exit (EXIT_FAILURE);
1042     }
1043
1044     registrationResult = OCSetDeviceInfo(deviceInfo);
1045
1046     if (registrationResult != OC_STACK_OK)
1047     {
1048         OC_LOG(INFO, TAG, "Device Registration failed!");
1049         exit (EXIT_FAILURE);
1050     }
1051
1052     /*
1053      * Declare and create the example resource: Light
1054      */
1055     createLightResource(gResourceUri, &Light);
1056
1057     // Initialize observations data structure for the resource
1058     for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; i++)
1059     {
1060         interestedObservers[i].valid = false;
1061     }
1062
1063     /*
1064      * Create a thread for changing the representation of the Light
1065      */
1066     pthread_create (&threadId, NULL, ChangeLightRepresentation, (void *)NULL);
1067
1068     /*
1069      * Create a thread for generating changes that cause presence notifications
1070      * to be sent to clients
1071      */
1072
1073     #ifdef WITH_PRESENCE
1074     pthread_create(&threadId_presence, NULL, presenceNotificationGenerator, (void *)NULL);
1075     #endif
1076
1077     // Break from loop with Ctrl-C
1078     OC_LOG(INFO, TAG, "Entering ocserver main loop...");
1079
1080     DeletePlatformInfo();
1081     DeleteDeviceInfo();
1082
1083     signal(SIGINT, handleSigInt);
1084
1085     while (!gQuitFlag)
1086     {
1087         if (OCProcess() != OC_STACK_OK)
1088         {
1089             OC_LOG(ERROR, TAG, "OCStack process error");
1090             return 0;
1091         }
1092
1093         sleep(2);
1094     }
1095
1096     /*
1097      * Cancel the Light thread and wait for it to terminate
1098      */
1099     pthread_cancel(threadId);
1100     pthread_join(threadId, NULL);
1101     pthread_cancel(threadId_presence);
1102     pthread_join(threadId_presence, NULL);
1103
1104     OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
1105
1106     if (OCStop() != OC_STACK_OK)
1107     {
1108         OC_LOG(ERROR, TAG, "OCStack process error");
1109     }
1110
1111     return 0;
1112 }