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
  30 #define TAG  "OIC_SRM_UTILITY"
  31
  32 void ParseQueryIterInit(const unsigned char * query, OicParseQueryIter_t * parseIter)
  33 {
  34     OIC_LOG(INFO, TAG, "Initializing coap iterator");
  35     if ((NULL == query) || (NULL == parseIter))
  36     {
  37         return;
  38     }
  39
  40     parseIter->attrPos = NULL;
  41     parseIter->attrLen = 0;
  42     parseIter->valPos = NULL;
  43     parseIter->valLen = 0;
  44     coap_parse_iterator_init((unsigned char *)query, strlen((char *)query),
  45                              (unsigned char *)OIC_SEC_REST_QUERY_SEPARATOR,
  46                              (unsigned char *) "", 0, &parseIter->pi);
  47 }
  48
  49 OicParseQueryIter_t * GetNextQuery(OicParseQueryIter_t * parseIter)
  50 {
  51     OIC_LOG(INFO, TAG, "Getting Next Query");
  52     if (NULL == parseIter)
  53     {
  54         return NULL;
  55     }
  56
  57     unsigned char * qrySeg = NULL;
  58     char * delimPos;
  59
  60     // Get the next query. Querys are separated by OIC_SEC_REST_QUERY_SEPARATOR.
  61     qrySeg = coap_parse_next(&parseIter->pi);
  62
  63     if (qrySeg)
  64     {
  65         delimPos = strchr((char *)qrySeg, OIC_SEC_REST_QUERY_DELIMETER);
  66         if (delimPos)
  67         {
  68             parseIter->attrPos = parseIter->pi.pos;
  69             parseIter->attrLen = (unsigned char *)delimPos - parseIter->pi.pos;
  70             parseIter->valPos  = (unsigned char *)delimPos + 1;
  71             parseIter->valLen  = &qrySeg[parseIter->pi.segment_length] - parseIter->valPos;
  72             return parseIter;
  73         }
  74     }
  75     return NULL;
  76 }
  77
  78 /**
  79  * Function to getting string of ownership transfer method
  80  *
  81  * @prarm oxmType ownership transfer method
  82  *
  83  * @return string value of ownership transfer method
  84  */
  85 const char* GetOxmString(OicSecOxm_t oxmType)
  86 {
  87     switch(oxmType)
  88     {
  89         case OIC_JUST_WORKS:
  90             return OXM_JUST_WORKS;
  91         case OIC_RANDOM_DEVICE_PIN:
  92             return OXM_RANDOM_DEVICE_PIN;
  93         case OIC_MANUFACTURER_CERTIFICATE:
  94             return OXM_MANUFACTURER_CERTIFICATE;
  95 #ifdef MULTIPLE_OWNER
  96         case OIC_PRECONFIG_PIN:
  97             return OXM_PRECONF_PIN;
  98 #endif //MULTIPLE_OWNER
  99         case OIC_MV_JUST_WORKS:
 100             return OXM_MV_JUST_WORKS;
 101         case OIC_CON_MFG_CERT:
 102             return OXM_CON_MFG_CERT;
 103         default:
 104             return NULL;
 105     }
 106 }
 107
 108 OCStackResult ConvertUuidToStr(const OicUuid_t* uuid, char** strUuid)
 109 {
 110     if(NULL == uuid || NULL == strUuid || NULL != *strUuid)
 111     {
 112         OIC_LOG(ERROR, TAG, "ConvertUuidToStr : Invalid param");
 113         return OC_STACK_INVALID_PARAM;
 114     }
 115
 116     size_t uuidIdx = 0;
 117     size_t urnIdx = 0;
 118     const size_t urnBufSize = (UUID_LENGTH * 2) + 4 + 1;
 119     char* convertedUrn = (char*)OICCalloc(urnBufSize, sizeof(char));
 120     VERIFY_NON_NULL(TAG, convertedUrn, ERROR);
 121
 122     for(uuidIdx=0, urnIdx=0;  uuidIdx < UUID_LENGTH && urnIdx < urnBufSize; uuidIdx++, urnIdx+=2)
 123     {
 124         // canonical format for UUID has '8-4-4-4-12'
 125         if(uuidIdx==4 || uuidIdx==6 || uuidIdx==8 || uuidIdx==10)
 126         {
 127             snprintf(convertedUrn + urnIdx, 2, "%c", '-');
 128             urnIdx++;
 129         }
 130         snprintf(convertedUrn + urnIdx, 3, "%02x", (uint8_t)(uuid->id[uuidIdx]));
 131     }
 132     convertedUrn[urnBufSize - 1] = '\0';
 133
 134     *strUuid = convertedUrn;
 135     return OC_STACK_OK;
 136
 137 exit:
 138     return OC_STACK_NO_MEMORY;
 139 }
 140
 141 OCStackResult ConvertStrToUuid(const char* strUuid, OicUuid_t* uuid)
 142 {
 143     bool result = OCConvertStringToUuid(strUuid, uuid->id);
 144     return (result) ? OC_STACK_OK : OC_STACK_INVALID_PARAM;
 145 }