resource/csdk/connectivity/inc/caprotocolmessage.h

   1 /******************************************************************
   2  *
   3  * Copyright 2014 Samsung Electronics 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  * @file
  22  * This file contains common function for handling protocol messages.
  23  */
  24
  25 #ifndef CA_PROTOCOL_MESSAGE_H_
  26 #define CA_PROTOCOL_MESSAGE_H_
  27
  28 #include "cacommon.h"
  29 #include "config.h"
  30 #include "coap.h"
  31
  32 #ifdef __cplusplus
  33 extern "C"
  34 {
  35 #endif
  36
  37 typedef uint32_t code_t;
  38
  39 #define CA_RESPONSE_CLASS(C) (((C) >> 5)*100)
  40 #define CA_RESPONSE_CODE(C) (CA_RESPONSE_CLASS(C) + (C - COAP_RESPONSE_CODE(CA_RESPONSE_CLASS(C))))
  41
  42
  43 // Include files from the arduino platform do not provide these conversions:
  44 #ifdef ARDUINO
  45 #define htons(x) ( ((x)<< 8 & 0xFF00) | ((x)>> 8 & 0x00FF) )
  46 #define ntohs(x) htons(x)
  47 #else
  48 #define HAVE_TIME_H 1
  49 #endif
  50
  51 /**
  52  * generates pdu structure from the given information.
  53  * @param[in]   code                 code of the pdu packet.
  54  * @param[in]   info                 pdu information.
  55  * @param[in]   endpoint             endpoint information.
  56  * @return  generated pdu.
  57  */
  58 coap_pdu_t *CAGeneratePDU(uint32_t code, const CAInfo_t *info, const CAEndpoint_t *endpoint);
  59
  60 /**
  61  * extracts request information from received pdu.
  62  * @param[in]   pdu                   received pdu.
  63  * @param[in]   endpoint              endpoint information.
  64  * @param[out]  outReqInfo            request info structure made from received pdu.
  65  * @return  CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h).
  66  */
  67 CAResult_t CAGetRequestInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
  68                                    CARequestInfo_t *outReqInfo);
  69
  70 /**
  71  * extracts response information from received pdu.
  72  * @param[in]   pdu                   received pdu.
  73  * @param[out]  outResInfo            response info structure made from received pdu.
  74  * @param[in]   endpoint              endpoint information.
  75  * @return  CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h).
  76  */
  77 CAResult_t CAGetResponseInfoFromPDU(const coap_pdu_t *pdu, CAResponseInfo_t *outResInfo,
  78                                     const CAEndpoint_t *endpoint);
  79
  80 /**
  81  * extracts error information from received pdu.
  82  * @param[in]   pdu                   received pdu.
  83  * @param[in]   endpoint              endpoint information.
  84  * @param[out]  errorInfo             error info structure made from received pdu.
  85  * @return  CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h).
  86  */
  87 CAResult_t CAGetErrorInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
  88                                  CAErrorInfo_t *errorInfo);
  89
  90 /**
  91  * creates pdu from the request information.
  92  * @param[in]   code                 request or response code.
  93  * @param[in]   info                 information to create pdu.
  94  * @param[in]   endpoint             endpoint information.
  95  * @param[out]  options              options for the request and response.
  96  * @return  generated pdu.
  97  */
  98 coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info,
  99                               const CAEndpoint_t *endpoint, coap_list_t *options);
 100
 101 /**
 102  * parse the URI and creates the options.
 103  * @param[in]    uriInfo             uri information.
 104  * @param[out]   options             options information.
 105  * @return  CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h).
 106  */
 107 CAResult_t CAParseURI(const char *uriInfo, coap_list_t **options);
 108
 109 /**
 110  * Helper that uses libcoap to parse either the path or the parameters of a URI
 111  * and populate the supplied options list.
 112  *
 113  * @param[in]   str                  the input partial URI string (either path or query).
 114  * @param[in]   length               the length of the supplied partial URI.
 115  * @param[in]   target               the part of the URI to parse (either COAP_OPTION_URI_PATH.
 116  *                                   or COAP_OPTION_URI_QUERY).
 117  * @param[out]  optlist              options information.
 118  * @return  CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h).
 119  */
 120 CAResult_t CAParseUriPartial(const unsigned char *str, size_t length, int target,
 121                              coap_list_t **optlist);
 122
 123 /**
 124  * create option list from header information in the info.
 125  * @param[in]   code                 uri information.
 126  * @param[in]   info                 information of the request/response.
 127  * @param[out]  optlist              options information.
 128  * @return  CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h).
 129  */
 130 CAResult_t CAParseHeadOption(uint32_t code, const CAInfo_t *info, coap_list_t **optlist);
 131
 132 /**
 133  * creates option node from key length and data.
 134  * @param[in]   key                  key for the that needs to be sent.
 135  * @param[in]   length               length of the data that needs to be sent.
 136  * @param[in]   data                 data that needs to be sent.
 137  * @return  created list.
 138  */
 139 coap_list_t *CACreateNewOptionNode(uint16_t key, uint32_t length, const char *data);
 140
 141 /**
 142  * order the inserted options.
 143  * need to replace queue head if new node has to be added before the existing queue head.
 144  * @param[in]   a                    option 1 for insertion.
 145  * @param[in]   b                    option 2 for insertion.
 146  * @return  0 or 1.
 147  */
 148 int CAOrderOpts(void *a, void *b);
 149
 150 /**
 151  * number of options count.
 152  * @param[in]   opt_iter            option iteration for count.
 153  * @return number of options.
 154  */
 155 uint32_t CAGetOptionCount(coap_opt_iterator_t opt_iter);
 156
 157 /**
 158  * gets option data.
 159  * @param[in]   key                  ID of the option
 160  * @param[in]   data                 data that is received.
 161  * @param[in]   length               length of the data.
 162  * @param[out]  option               result of the operation.
 163  * @param[in]   buflen               buffer length of the result.
 164  * @return  option count.
 165  */
 166 uint32_t CAGetOptionData(uint16_t key, const uint8_t *data, uint32_t len,
 167                          uint8_t *option, uint32_t buflen);
 168
 169 /**
 170  * extracts request information from received pdu.
 171  * @param[in]    pdu                  received pdu.
 172  * @param[in]    endpoint             endpoint information.
 173  * @param[out]   outCode              code of the received pdu.
 174  * @param[out]   outInfo              request info structure made from received pdu.
 175  * @return  CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h).
 176  */
 177 CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
 178                             uint32_t *outCode, CAInfo_t *outInfo);
 179
 180 /**
 181  * create pdu from received data.
 182  * @param[in]   data                received data.
 183  * @param[in]   length              length of the data received.
 184  * @param[out]  outCode             code received.
 185  * @param[in]   endpoint            endpoint information.
 186  * @return  coap_pdu_t value.
 187  */
 188 coap_pdu_t *CAParsePDU(const char *data, uint32_t length, uint32_t *outCode,
 189                        const CAEndpoint_t *endpoint);
 190
 191 /**
 192  * get Token from received data(pdu).
 193  * @param[in]    pdu_hdr             header of received pdu.
 194  * @param[out]   outInfo             information with token received.
 195  * @param[in]    endpoint            endpoint information.
 196  * @return  CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h).
 197  */
 198 CAResult_t CAGetTokenFromPDU(const coap_hdr_t *pdu_hdr, CAInfo_t *outInfo,
 199                              const CAEndpoint_t *endpoint);
 200
 201 /**
 202  * generates the token.
 203  * @param[out]   token           generated token.
 204  * @param[in]    tokenLength     length of the token.
 205  * @return  CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h).
 206  */
 207 CAResult_t CAGenerateTokenInternal(CAToken_t *token, uint8_t tokenLength);
 208
 209 /**
 210  * destroys the token.
 211  * @param[in]   token           generated token.
 212  */
 213 void CADestroyTokenInternal(CAToken_t token);
 214
 215 /**
 216  * destroy the ca info structure.
 217  * @param[in]   info            info structure  created from received  packet.
 218  */
 219 void CADestroyInfo(CAInfo_t *info);
 220
 221 /**
 222  * gets message type from PDU binary data.
 223  * @param[in]   pdu                 pdu data.
 224  * @param[in]   size                size of pdu data.
 225  * @return  message type.
 226  */
 227 CAMessageType_t CAGetMessageTypeFromPduBinaryData(const void *pdu, uint32_t size);
 228
 229 /**
 230  * gets message ID PDU binary data.
 231  * @param[in]   pdu                 pdu data.
 232  * @param[in]   size                size of pdu data.
 233  * @return  message ID.
 234  */
 235 uint16_t CAGetMessageIdFromPduBinaryData(const void *pdu, uint32_t size);
 236
 237 /**
 238  * gets code PDU binary data.
 239  * @param[in]   pdu                 pdu data.
 240  * @param[in]   size                size of pdu data.
 241  * @return  code.
 242  */
 243 CAResponseResult_t CAGetCodeFromPduBinaryData(const void *pdu, uint32_t size);
 244
 245 /**
 246  * convert format from CoAP media type encoding to CAPayloadFormat_t.
 247  * @param[in]   format              coap format code.
 248  * @return format.
 249  */
 250 CAPayloadFormat_t CAConvertFormat(uint8_t format);
 251
 252 #ifdef __cplusplus
 253 } /* extern "C" */
 254 #endif
 255
 256 #endif /* CA_PROTOCOL_MESSAGE_H_ */