Пример #1
0
coap_status_t handle_observe_request(lwm2m_context_t * contextP,
                                     lwm2m_uri_t * uriP,
                                     uint8_t * fromAddr,
                                     size_t fromAddrLen,
                                     coap_packet_t * message,
                                     coap_packet_t * response)
{
    lwm2m_observed_t * observedP;
    lwm2m_watcher_t * watcherP;
    lwm2m_server_t * serverP;

    LOG("handle_observe_request()\r\n");

    if (!LWM2M_URI_IS_SET_INSTANCE(uriP) && LWM2M_URI_IS_SET_RESOURCE(uriP)) return COAP_400_BAD_REQUEST;
    if (message->token_len == 0) return COAP_400_BAD_REQUEST;

    serverP = prv_findServer(contextP, fromAddr, fromAddrLen);
    if (serverP == NULL || serverP->status != STATE_REGISTERED) return COAP_401_UNAUTHORIZED;

    observedP = prv_findObserved(contextP, uriP);
    if (observedP == NULL)
    {
        observedP = (lwm2m_observed_t *)lwm2m_malloc(sizeof(lwm2m_observed_t));
        if (observedP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
        memset(observedP, 0, sizeof(lwm2m_observed_t));
        memcpy(&(observedP->uri), uriP, sizeof(lwm2m_uri_t));
        observedP->next = contextP->observedList;
        contextP->observedList = observedP;
    }

    watcherP = prv_findWatcher(observedP, serverP);
    if (watcherP == NULL)
    {
        watcherP = (lwm2m_watcher_t *)lwm2m_malloc(sizeof(lwm2m_watcher_t));
        if (watcherP == NULL) return COAP_500_INTERNAL_SERVER_ERROR;
        memset(watcherP, 0, sizeof(lwm2m_watcher_t));
        watcherP->server = serverP;
        watcherP->tokenLen = message->token_len;
        memcpy(watcherP->token, message->token, message->token_len);
        watcherP->next = observedP->watcherList;
        observedP->watcherList = watcherP;
    }

    coap_set_header_observe(response, watcherP->counter++);

    return COAP_205_CONTENT;
}
Пример #2
0
coap_status_t handle_dm_request(lwm2m_context_t * contextP,
                                lwm2m_uri_t * uriP,
                                void * fromSessionH,
                                coap_packet_t * message,
                                coap_packet_t * response)
{
    coap_status_t result;
    lwm2m_server_t * serverP = NULL;
    lwm2m_media_type_t format;

#ifdef LWM2M_BOOTSTRAP
    lwm2m_server_t * bsServerP = NULL;
#endif

    format = prv_convertMediaType(message->content_type);

    serverP = prv_findServer(contextP, fromSessionH);
    if (NULL == serverP)
    {
#ifdef LWM2M_BOOTSTRAP
        bsServerP = utils_findBootstrapServer(contextP, fromSessionH);
        if (NULL == bsServerP)
        {
            // No server found
            return COAP_IGNORE;
        }
#else
        return COAP_IGNORE;
#endif
    }

#ifdef LWM2M_BOOTSTRAP
    if (contextP->bsState != BOOTSTRAP_PENDING)
    {
        if (NULL != bsServerP)
        {
            // server initiated bootstrap?
            // currently not implemented.
            return NOT_IMPLEMENTED_5_01;
        }
        if ( serverP->status != STATE_REGISTERED &&
                serverP->status != STATE_REG_UPDATE_PENDING)
        {
            return COAP_IGNORE;
        }
    }
    else
    {
        if (NULL != serverP)
        {
            // Request form management server during bootstrap.
            return UNAUTHORIZED_4_01;
        }
    }
#endif

    switch (message->code)
    {
    case COAP_GET:
        {
            uint8_t * buffer = NULL;
            size_t length = 0;

            result = object_read(contextP, uriP, &format, &buffer, &length);
            if (COAP_205_CONTENT == result)
            {
                if (IS_OPTION(message, COAP_OPTION_OBSERVE))
                {
                    result = handle_observe_request(contextP, uriP, serverP, message, response);
                }
                if (COAP_205_CONTENT == result)
                {
                    coap_set_header_content_type(response, format);
                    coap_set_payload(response, buffer, length);
                    // lwm2m_handle_packet will free buffer
                }
                else
                {
                    lwm2m_free(buffer);
                }
            }
        }
        break;

    case COAP_POST:
        {
#ifdef LWM2M_BOOTSTRAP
            /* no POST during bootstrap */
            if (contextP->bsState == BOOTSTRAP_PENDING) return METHOD_NOT_ALLOWED_4_05;
#endif
            if (!LWM2M_URI_IS_SET_INSTANCE(uriP))
            {
                lwm2m_media_type_t format;

                format = prv_convertMediaType(message->content_type);

                result = object_create(contextP, uriP, format, message->payload, message->payload_len);
                if (result == COAP_201_CREATED)
                {
                    //longest uri is /65535/65535 = 12 + 1 (null) chars
                    char location_path[13] = "";
                    //instanceId expected
                    if ((uriP->flag & LWM2M_URI_FLAG_INSTANCE_ID) == 0)
                    {
                        result = COAP_500_INTERNAL_SERVER_ERROR;
                        break;
                    }

                    if (sprintf(location_path, "/%d/%d", uriP->objectId, uriP->instanceId) < 0)
                    {
                        result = COAP_500_INTERNAL_SERVER_ERROR;
                        break;
                    }
                    coap_set_header_location_path(response, location_path);
                }
            }
            else if (!LWM2M_URI_IS_SET_RESOURCE(uriP))
            {
                if (object_isInstanceNew(contextP, uriP->objectId, uriP->instanceId))
                {
                    result = object_create(contextP, uriP, format, message->payload, message->payload_len);
                }
                else
                {
                    result = object_write(contextP, uriP, format, message->payload, message->payload_len);
                }
            }
            else
            {
                result = object_execute(contextP, uriP, message->payload, message->payload_len);
            }
        }
        break;

    case COAP_PUT:
        {
            if (LWM2M_URI_IS_SET_INSTANCE(uriP))
            {
#ifdef LWM2M_BOOTSTRAP
                if (contextP->bsState == BOOTSTRAP_PENDING && object_isInstanceNew(contextP, uriP->objectId, uriP->instanceId))
                {
                    result = object_create(contextP, uriP, format, message->payload, message->payload_len);
                    if (COAP_201_CREATED == result)
                    {
                        result = COAP_204_CHANGED;
                    }
                }
                else
#endif
                {
                    result = object_write(contextP, uriP, format, message->payload, message->payload_len);
                }
            }
            else
            {
                result = BAD_REQUEST_4_00;
            }
        }
        break;

    case COAP_DELETE:
        {
            if (LWM2M_URI_IS_SET_INSTANCE(uriP) && !LWM2M_URI_IS_SET_RESOURCE(uriP))
            {
                result = object_delete(contextP, uriP);
            }
            else
            {
                result = BAD_REQUEST_4_00;
            }
        }
        break;

    default:
        result = BAD_REQUEST_4_00;
        break;
    }

    return result;
}