resource.h

Go to the documentation of this file.

/*
 * resource.h -- generic resource handling
 *
 * Copyright (C) 2010,2011,2014,2015 Olaf Bergmann <bergmann@tzi.org>
 *
 * This file is part of the CoAP library libcoap. Please see README for terms
 * of use.
 */
 
#ifndef COAP_RESOURCE_H_
#define COAP_RESOURCE_H_
 
#ifndef COAP_RESOURCE_CHECK_TIME
#define COAP_RESOURCE_CHECK_TIME 2
#endif /* COAP_RESOURCE_CHECK_TIME */
 
#include "uthash.h"
#include "async.h"
#include "block.h"
#include "str.h"
#include "pdu.h"
#include "net.h"
#include "subscribe.h"
 
typedef void (*coap_method_handler_t)
  (coap_context_t  *,
   struct coap_resource_t *,
   coap_session_t *,
   coap_pdu_t *,
   coap_binary_t * /* token */,
   coap_string_t * /* query string */,
   coap_pdu_t * /* response */);
 
#define COAP_ATTR_FLAGS_RELEASE_NAME  0x1
#define COAP_ATTR_FLAGS_RELEASE_VALUE 0x2
 
typedef struct coap_attr_t {
  struct coap_attr_t *next;
  coap_str_const_t *name;
  coap_str_const_t *value;
  int flags;
} coap_attr_t;
 
#define COAP_RESOURCE_FLAGS_RELEASE_URI 0x1
 
#define COAP_RESOURCE_FLAGS_NOTIFY_NON  0x0
 
#define COAP_RESOURCE_FLAGS_NOTIFY_CON  0x2
 
#define COAP_RESOURCE_FLAGS_NOTIFY_NON_ALWAYS  0x4
 
typedef struct coap_resource_t {
  unsigned int dirty:1;          
  unsigned int partiallydirty:1; 
  unsigned int observable:1;     
  unsigned int cacheable:1;      
  unsigned int is_unknown:1;     
  unsigned int is_proxy_uri:1;   
  coap_method_handler_t handler[7];
 
  UT_hash_handle hh;
 
  coap_attr_t *link_attr; 
  coap_subscription_t *subscribers;  
  coap_str_const_t *uri_path;  
  int flags;
 
  unsigned int observe;
 
  coap_context_t *context;
 
  size_t proxy_name_count;
 
  coap_str_const_t ** proxy_name_list;
 
  void *user_data;
 
} coap_resource_t;
 
coap_resource_t *coap_resource_init(coap_str_const_t *uri_path,
                                    int flags);
 
 
coap_resource_t *coap_resource_unknown_init(coap_method_handler_t put_handler);
 
coap_resource_t *coap_resource_proxy_uri_init(coap_method_handler_t handler,
                      size_t host_name_count, const char *host_name_list[]);
 
COAP_STATIC_INLINE void
coap_resource_set_mode(coap_resource_t *resource, int mode) {
  resource->flags = (resource->flags &
    ~(COAP_RESOURCE_FLAGS_NOTIFY_CON|COAP_RESOURCE_FLAGS_NOTIFY_NON)) |
    (mode & (COAP_RESOURCE_FLAGS_NOTIFY_CON|COAP_RESOURCE_FLAGS_NOTIFY_NON));
}
 
COAP_STATIC_INLINE void
coap_resource_set_userdata(coap_resource_t *resource, void *data) {
  resource->user_data = data;
}
 
COAP_STATIC_INLINE void *
coap_resource_get_userdata(coap_resource_t *resource) {
  return resource->user_data;
}
 
void coap_add_resource(coap_context_t *context, coap_resource_t *resource);
 
int coap_delete_resource(coap_context_t *context, coap_resource_t *resource);
 
void coap_delete_all_resources(coap_context_t *context);
 
coap_attr_t *coap_add_attr(coap_resource_t *resource,
                           coap_str_const_t *name,
                           coap_str_const_t *value,
                           int flags);
 
coap_attr_t *coap_find_attr(coap_resource_t *resource,
                            coap_str_const_t *name);
 
void coap_delete_attr(coap_attr_t *attr);
 
typedef unsigned int coap_print_status_t;
 
#define COAP_PRINT_STATUS_MASK  0xF0000000u
#define COAP_PRINT_OUTPUT_LENGTH(v) ((v) & ~COAP_PRINT_STATUS_MASK)
#define COAP_PRINT_STATUS_ERROR 0x80000000u
#define COAP_PRINT_STATUS_TRUNC 0x40000000u
 
coap_print_status_t coap_print_link(const coap_resource_t *resource,
                                    unsigned char *buf,
                                    size_t *len,
                                    size_t *offset);
 
void coap_register_handler(coap_resource_t *resource,
                           coap_request_t method,
                           coap_method_handler_t handler);
 
coap_resource_t *coap_get_resource_from_uri_path(coap_context_t *context,
                                                coap_str_const_t *uri_path);
 
#define RESOURCES_ADD(r, obj) \
  HASH_ADD(hh, (r), uri_path->s[0], (obj)->uri_path->length, (obj))
 
#define RESOURCES_DELETE(r, obj) \
  HASH_DELETE(hh, (r), (obj))
 
#define RESOURCES_ITER(r,tmp)  \
  coap_resource_t *tmp, *rtmp; \
  HASH_ITER(hh, (r), tmp, rtmp)
 
#define RESOURCES_FIND(r, k, res) {                     \
    HASH_FIND(hh, (r), (k)->s, (k)->length, (res)); \
  }
 
coap_subscription_t *coap_add_observer(coap_resource_t *resource,
                                       coap_session_t *session,
                                       const coap_binary_t *token,
                                       coap_string_t *query,
                                       int has_block2,
                                       coap_block_t block2,
                                       uint8_t code);
 
coap_subscription_t *coap_find_observer(coap_resource_t *resource,
                                        coap_session_t *session,
                                        const coap_binary_t *token);
 
void coap_touch_observer(coap_context_t *context,
                         coap_session_t *session,
                         const coap_binary_t *token);
 
int coap_delete_observer(coap_resource_t *resource,
                         coap_session_t *session,
                         const coap_binary_t *token);
 
void coap_delete_observers(coap_context_t *context, coap_session_t *session);
 
COAP_STATIC_INLINE void
coap_resource_set_get_observable(coap_resource_t *resource, int mode) {
  resource->observable = mode ? 1 : 0;
}
 
int
coap_resource_notify_observers(coap_resource_t *resource,
                               const coap_string_t *query);
 
COAP_STATIC_INLINE coap_str_const_t*
coap_resource_get_uri_path(coap_resource_t *resource) {
  if (resource)
    return resource->uri_path;
  return NULL;
}
 
void coap_check_notify(coap_context_t *context);
 
coap_print_status_t coap_print_wellknown(coap_context_t *,
                                         unsigned char *,
                                         size_t *, size_t,
                                         coap_opt_t *);
 
void
coap_handle_failed_notify(coap_context_t *,
                          coap_session_t *,
                          const coap_binary_t *);
 
COAP_DEPRECATED int
coap_resource_set_dirty(coap_resource_t *r,
                        const coap_string_t *query);
 
#endif /* COAP_RESOURCE_H_ */