CBOR rebase onto master for merge/review
[iotivity.git] / resource / csdk / stack / samples / linux / SimpleClientServer / ocserverbasicops.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 #include <stdio.h>
22 #include <string.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 #include <signal.h>
26 #include <pthread.h>
27 #include "ocstack.h"
28 #include "logger.h"
29 #include "ocserverbasicops.h"
30 #include "ocpayload.h"
31
32 //string length of "/a/led/" + std::numeric_limits<int>::digits10 + '\0'"
33 // 7 + 9 + 1 = 17
34 const int URI_MAXSIZE = 17;
35
36 volatile sig_atomic_t gQuitFlag = 0;
37
38 static LEDResource LED;
39 // This variable determines instance number of the LED resource.
40 // Used by POST method to create a new instance of LED resource.
41 static int gCurrLedInstance = 0;
42 #define SAMPLE_MAX_NUM_POST_INSTANCE 2
43 static LEDResource gLedInstance[SAMPLE_MAX_NUM_POST_INSTANCE];
44
45 char *gResourceUri= (char *)"/a/led";
46
47 OCRepPayload* getPayload(const char* uri, int64_t power, bool state)
48 {
49     OCRepPayload* payload = OCRepPayloadCreate();
50     if(!payload)
51     {
52         OC_LOG(ERROR, TAG, PCF("Failed to allocate Payload"));
53         return nullptr;
54     }
55
56     OCRepPayloadSetUri(payload, uri);
57     OCRepPayloadSetPropBool(payload, "state", state);
58     OCRepPayloadSetPropInt(payload, "power", power);
59
60     return payload;
61 }
62
63 //This function takes the request as an input and returns the response
64 OCRepPayload* constructResponse (OCEntityHandlerRequest *ehRequest)
65 {
66     if(ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
67     {
68         OC_LOG(ERROR, TAG, PCF("Incoming payload not a representation"));
69         return nullptr;
70     }
71
72     OCRepPayload* input = reinterpret_cast<OCRepPayload*>(ehRequest->payload);
73
74     LEDResource *currLEDResource = &LED;
75
76     if (ehRequest->resource == gLedInstance[0].handle)
77     {
78         currLEDResource = &gLedInstance[0];
79         gResourceUri = (char *) "/a/led/0";
80     }
81     else if (ehRequest->resource == gLedInstance[1].handle)
82     {
83         currLEDResource = &gLedInstance[1];
84         gResourceUri = (char *) "/a/led/1";
85     }
86
87     if(OC_REST_PUT == ehRequest->method)
88     {
89         // Get pointer to query
90         int64_t pow;
91         if(OCRepPayloadGetPropInt(input, "power", &pow))
92         {
93             currLEDResource->power =pow;
94         }
95
96         bool state;
97         if(OCRepPayloadGetPropBool(input, "state", &state))
98         {
99             currLEDResource->state = state;
100         }
101     }
102
103     return getPayload(gResourceUri, currLEDResource->power, currLEDResource->state);
104 }
105
106 OCEntityHandlerResult ProcessGetRequest (OCEntityHandlerRequest *ehRequest,
107         OCRepPayload **payload)
108 {
109     OCEntityHandlerResult ehResult;
110     OCRepPayload *getResp = constructResponse(ehRequest);
111
112     if(getResp)
113     {
114         *payload = getResp;
115         ehResult = OC_EH_OK;
116      }
117     else
118     {
119         ehResult = OC_EH_ERROR;
120     }
121
122     return ehResult;
123 }
124
125 OCEntityHandlerResult ProcessPutRequest (OCEntityHandlerRequest *ehRequest,
126         OCRepPayload **payload)
127 {
128     OCEntityHandlerResult ehResult;
129     OCRepPayload *putResp = constructResponse(ehRequest);
130
131     if(putResp)
132     {
133         *payload = putResp;
134         ehResult = OC_EH_OK;
135     }
136     else
137     {
138         ehResult = OC_EH_ERROR;
139     }
140
141     return ehResult;
142 }
143
144 OCEntityHandlerResult ProcessPostRequest (OCEntityHandlerRequest *ehRequest,
145         OCEntityHandlerResponse *response, OCRepPayload **payload)
146 {
147     OCRepPayload *respPLPost_led = nullptr;
148     OCEntityHandlerResult ehResult = OC_EH_OK;
149
150     /*
151      * The entity handler determines how to process a POST request.
152      * Per the REST paradigm, POST can also be used to update representation of existing
153      * resource or create a new resource.
154      * In the sample below, if the POST is for /a/led then a new instance of the LED
155      * resource is created with default representation (if representation is included in
156      * POST payload it can be used as initial values) as long as the instance is
157      * lesser than max new instance count. Once max instance count is reached, POST on
158      * /a/led updated the representation of /a/led (just like PUT)
159      */
160
161     if (ehRequest->resource == LED.handle)
162     {
163         if (gCurrLedInstance < SAMPLE_MAX_NUM_POST_INSTANCE)
164         {
165             // Create new LED instance
166             char newLedUri[URI_MAXSIZE ];
167             snprintf(newLedUri, URI_MAXSIZE, "/a/led/%d", gCurrLedInstance);
168
169             respPLPost_led = OCRepPayloadCreate();
170             OCRepPayloadSetUri(respPLPost_led, gResourceUri);
171             OCRepPayloadSetPropString(respPLPost_led, "createduri", newLedUri);
172
173             if (0 == createLEDResource (newLedUri, &gLedInstance[gCurrLedInstance], false, 0))
174             {
175                 OC_LOG (INFO, TAG, "Created new LED instance");
176                 gLedInstance[gCurrLedInstance].state = 0;
177                 gLedInstance[gCurrLedInstance].power = 0;
178                 gCurrLedInstance++;
179                 strncpy ((char *)response->resourceUri, newLedUri, MAX_URI_LENGTH);
180                 ehResult = OC_EH_RESOURCE_CREATED;
181             }
182         }
183         else
184         {
185             respPLPost_led = constructResponse(ehRequest);
186         }
187     }
188     else
189     {
190         for (int i = 0; i < SAMPLE_MAX_NUM_POST_INSTANCE; i++)
191         {
192             if (ehRequest->resource == gLedInstance[i].handle)
193             {
194                 if (i == 0)
195                 {
196                     respPLPost_led = constructResponse(ehRequest);
197                     break;
198                 }
199                 else if (i == 1)
200                 {
201                     respPLPost_led = constructResponse(ehRequest);
202                 }
203             }
204         }
205     }
206
207     if ((respPLPost_led != NULL))
208     {
209         *payload = respPLPost_led;
210         ehResult = OC_EH_OK;
211     }
212     else
213     {
214         OC_LOG_V (INFO, TAG, "Payload was NULL");
215         ehResult = OC_EH_ERROR;
216     }
217
218     return ehResult;
219 }
220
221 OCEntityHandlerResult
222 OCEntityHandlerCb (OCEntityHandlerFlag flag,
223         OCEntityHandlerRequest *entityHandlerRequest,void* callbackParam)
224 {
225     OC_LOG_V (INFO, TAG, "Inside entity handler - flags: 0x%x", flag);
226
227     OCEntityHandlerResult ehResult = OC_EH_ERROR;
228     OCEntityHandlerResponse response;
229
230     // Validate pointer
231     if (!entityHandlerRequest)
232     {
233         OC_LOG (ERROR, TAG, "Invalid request pointer");
234         return OC_EH_ERROR;
235     }
236
237     OCRepPayload* payload = nullptr;
238
239     if (flag & OC_REQUEST_FLAG)
240     {
241         OC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
242         if (entityHandlerRequest)
243         {
244             if (OC_REST_GET == entityHandlerRequest->method)
245             {
246                 OC_LOG (INFO, TAG, "Received OC_REST_GET from client");
247                 ehResult = ProcessGetRequest (entityHandlerRequest, &payload);
248             }
249             else if (OC_REST_PUT == entityHandlerRequest->method)
250             {
251                 OC_LOG (INFO, TAG, "Received OC_REST_PUT from client");
252                 ehResult = ProcessPutRequest (entityHandlerRequest, &payload);
253             }
254             else if (OC_REST_POST == entityHandlerRequest->method)
255             {
256                 OC_LOG (INFO, TAG, "Received OC_REST_POST from client");
257                 ehResult = ProcessPostRequest (entityHandlerRequest, &response, &payload);
258             }
259             else
260             {
261                 OC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
262                         entityHandlerRequest->method);
263             }
264
265             if (ehResult == OC_EH_OK && ehResult != OC_EH_FORBIDDEN)
266             {
267                 // Format the response.  Note this requires some info about the request
268                 response.requestHandle = entityHandlerRequest->requestHandle;
269                 response.resourceHandle = entityHandlerRequest->resource;
270                 response.ehResult = ehResult;
271                 response.payload = reinterpret_cast<OCPayload*>(payload);
272                 response.numSendVendorSpecificHeaderOptions = 0;
273                 memset(response.sendVendorSpecificHeaderOptions, 0, sizeof response.sendVendorSpecificHeaderOptions);
274                 memset(response.resourceUri, 0, sizeof(response.resourceUri));
275                 // Indicate that response is NOT in a persistent buffer
276                 response.persistentBufferFlag = 0;
277
278                 // Send the response
279                 if (OCDoResponse(&response) != OC_STACK_OK)
280                 {
281                     OC_LOG(ERROR, TAG, "Error sending response");
282                     ehResult = OC_EH_ERROR;
283                 }
284             }
285         }
286     }
287
288     OCPayloadDestroy(response.payload);
289     return ehResult;
290 }
291
292 /* SIGINT handler: set gQuitFlag to 1 for graceful termination */
293 void handleSigInt(int signum)
294 {
295     if (signum == SIGINT)
296     {
297         gQuitFlag = 1;
298     }
299 }
300
301 int main(int argc, char* argv[])
302 {
303     OC_LOG(DEBUG, TAG, "OCServer is starting...");
304     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
305     {
306         OC_LOG(ERROR, TAG, "OCStack init error");
307         return 0;
308     }
309
310     /*
311      * Declare and create the example resource: LED
312      */
313     createLEDResource(gResourceUri, &LED, false, 0);
314
315     // Break from loop with Ctrl-C
316     OC_LOG(INFO, TAG, "Entering ocserver main loop...");
317     signal(SIGINT, handleSigInt);
318     while (!gQuitFlag)
319     {
320         if (OCProcess() != OC_STACK_OK)
321         {
322             OC_LOG(ERROR, TAG, "OCStack process error");
323             return 0;
324         }
325
326         sleep(2);
327     }
328
329     OC_LOG(INFO, TAG, "Exiting ocserver main loop...");
330
331     if (OCStop() != OC_STACK_OK)
332     {
333         OC_LOG(ERROR, TAG, "OCStack process error");
334     }
335
336     return 0;
337 }
338
339 int createLEDResource (char *uri, LEDResource *ledResource, bool resourceState, int resourcePower)
340 {
341     if (!uri)
342     {
343         OC_LOG(ERROR, TAG, "Resource URI cannot be NULL");
344         return -1;
345     }
346
347     ledResource->state = resourceState;
348     ledResource->power= resourcePower;
349     OCStackResult res = OCCreateResource(&(ledResource->handle),
350             "core.led",
351             OC_RSRVD_INTERFACE_DEFAULT,
352             uri,
353             OCEntityHandlerCb,
354             NULL,
355             OC_DISCOVERABLE|OC_OBSERVABLE);
356     OC_LOG_V(INFO, TAG, "Created LED resource with result: %s", getResult(res));
357
358     return 0;
359 }
360