00804078ae0113b4ac15ddb6b2b1b5f49aba19c2
[iotivity.git] / resource / csdk / security / src / srmutility.c
1 //******************************************************************
2 //
3 // Copyright 2015 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 #define _POSIX_C_SOURCE 200112L
21 #include <string.h>
22
23 #include "srmutility.h"
24 #include "srmresourcestrings.h"
25 #include "logger.h"
26 #include "oic_malloc.h"
27 #include "base64.h"
28 #include "ocrandom.h"
29 #include "doxmresource.h"
30
31 #define TAG  "OIC_SRM_UTILITY"
32
33 void ParseQueryIterInit(const unsigned char * query, OicParseQueryIter_t * parseIter)
34 {
35     OIC_LOG(INFO, TAG, "Initializing coap iterator");
36     if ((NULL == query) || (NULL == parseIter))
37     {
38         return;
39     }
40
41     parseIter->attrPos = NULL;
42     parseIter->attrLen = 0;
43     parseIter->valPos = NULL;
44     parseIter->valLen = 0;
45     coap_parse_iterator_init((unsigned char *)query, strlen((char *)query),
46                              (unsigned char *)OIC_SEC_REST_QUERY_SEPARATOR,
47                              (unsigned char *) "", 0, &parseIter->pi);
48 }
49
50 OicParseQueryIter_t * GetNextQuery(OicParseQueryIter_t * parseIter)
51 {
52     OIC_LOG(INFO, TAG, "Getting Next Query");
53     if (NULL == parseIter)
54     {
55         return NULL;
56     }
57
58     unsigned char * qrySeg = NULL;
59     char * delimPos;
60
61     // Get the next query. Querys are separated by OIC_SEC_REST_QUERY_SEPARATOR.
62     qrySeg = coap_parse_next(&parseIter->pi);
63
64     if (qrySeg)
65     {
66         delimPos = strchr((char *)qrySeg, OIC_SEC_REST_QUERY_DELIMETER);
67         if (delimPos)
68         {
69             parseIter->attrPos = parseIter->pi.pos;
70             parseIter->attrLen = (unsigned char *)delimPos - parseIter->pi.pos;
71             parseIter->valPos  = (unsigned char *)delimPos + 1;
72             parseIter->valLen  = &qrySeg[parseIter->pi.segment_length] - parseIter->valPos;
73             return parseIter;
74         }
75     }
76     return NULL;
77 }
78
79 /**
80  * Function to getting string of ownership transfer method
81  *
82  * @prarm oxmType ownership transfer method
83  *
84  * @return string value of ownership transfer method
85  */
86 const char* GetOxmString(OicSecOxm_t oxmType)
87 {
88     switch(oxmType)
89     {
90         case OIC_JUST_WORKS:
91             return OXM_JUST_WORKS;
92         case OIC_RANDOM_DEVICE_PIN:
93             return OXM_RANDOM_DEVICE_PIN;
94         case OIC_MANUFACTURER_CERTIFICATE:
95             return OXM_MANUFACTURER_CERTIFICATE;
96 #ifdef MULTIPLE_OWNER
97         case OIC_PRECONFIG_PIN:
98             return OXM_PRECONF_PIN;
99 #endif //MULTIPLE_OWNER
100         case OIC_MV_JUST_WORKS:
101             return OXM_MV_JUST_WORKS;
102         case OIC_CON_MFG_CERT:
103             return OXM_CON_MFG_CERT;
104         default:
105             return NULL;
106     }
107 }
108
109 OCStackResult ConvertUuidToStr(const OicUuid_t* uuid, char** strUuid)
110 {
111     if(NULL == uuid || NULL == strUuid || NULL != *strUuid)
112     {
113         OIC_LOG(ERROR, TAG, "ConvertUuidToStr : Invalid param");
114         return OC_STACK_INVALID_PARAM;
115     }
116
117     size_t uuidIdx = 0;
118     size_t urnIdx = 0;
119     const size_t urnBufSize = (UUID_LENGTH * 2) + 4 + 1;
120     char* convertedUrn = (char*)OICCalloc(urnBufSize, sizeof(char));
121     VERIFY_NON_NULL(TAG, convertedUrn, ERROR);
122
123     for(uuidIdx=0, urnIdx=0;  uuidIdx < UUID_LENGTH && urnIdx < urnBufSize; uuidIdx++, urnIdx+=2)
124     {
125         // canonical format for UUID has '8-4-4-4-12'
126         if(uuidIdx==4 || uuidIdx==6 || uuidIdx==8 || uuidIdx==10)
127         {
128             snprintf(convertedUrn + urnIdx, 2, "%c", '-');
129             urnIdx++;
130         }
131         snprintf(convertedUrn + urnIdx, 3, "%02x", (uint8_t)(uuid->id[uuidIdx]));
132     }
133     convertedUrn[urnBufSize - 1] = '\0';
134
135     *strUuid = convertedUrn;
136     return OC_STACK_OK;
137
138 exit:
139     return OC_STACK_NO_MEMORY;
140 }
141
142 OCStackResult ConvertStrToUuid(const char* strUuid, OicUuid_t* uuid)
143 {
144     bool result = true;
145     size_t strUuidLen = strlen(strUuid);
146
147     if (0 == strUuidLen)
148     {
149         OIC_LOG(INFO, TAG, "Converting empty UUID string to 00000000-0000-0000-0000-000000000000");
150         memset(uuid->id, 0, sizeof(uuid->id));
151     }
152     else
153     {
154         result = OCConvertStringToUuid(strUuid, uuid->id);
155     }
156
157     if (!result)
158     {
159         OIC_LOG_V(ERROR, TAG, "%s: Invalid parameter '%s'", __func__, strUuid);
160         return OC_STACK_INVALID_PARAM;
161     }
162
163     return OC_STACK_OK;
164 }
165
166 #if defined(__WITH_DTLS__) || defined (__WITH_TLS__)
167 OCStackResult SetDeviceIdSeed(const uint8_t* seed, size_t seedSize)
168 {
169     return SetDoxmDeviceIDSeed(seed, seedSize);
170 }
171 #endif