diff --git a/apps/er-coap-07/er-coap-07-engine.c b/apps/er-coap-07/er-coap-07-engine.c
index d2e4f9b63..875db015e 100644
--- a/apps/er-coap-07/er-coap-07-engine.c
+++ b/apps/er-coap-07/er-coap-07-engine.c
@@ -167,7 +167,7 @@ handle_incoming_data(void)
                     PRINTF("handle_incoming_data(): block_offset >= response->payload_len\n");
 
                     response->code = BAD_OPTION_4_02;
-                    coap_set_payload(response, (uint8_t*)"BlockOutOfScope", 15);
+                    coap_set_payload(response, "BlockOutOfScope", 15); /* a const char str[] and sizeof(str) produces larger code size */
                   }
                   else
                   {
@@ -259,7 +259,7 @@ handle_incoming_data(void)
       }
       /* Reuse input buffer for error message. */
       coap_init_message(message, COAP_TYPE_ACK, coap_error_code, message->tid);
-      coap_set_payload(message, (uint8_t *) coap_error_message, strlen(coap_error_message));
+      coap_set_payload(message, coap_error_message, strlen(coap_error_message));
       coap_send_message(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, uip_appdata, coap_serialize_message(message, uip_appdata));
     }
   } /* if (new data) */
@@ -396,7 +396,7 @@ well_known_core_handler(void* request, void* response, uint8_t *buffer, uint16_t
       PRINTF("well_known_core_handler(): bufpos<=0\n");
 
       coap_set_rest_status(response, BAD_OPTION_4_02);
-      coap_set_payload(response, (uint8_t*)"BlockOutOfScope", 15);
+      coap_set_payload(response, "BlockOutOfScope", 15);
     }
 
     if (resource==NULL) {
diff --git a/apps/er-coap-07/er-coap-07-observing.c b/apps/er-coap-07/er-coap-07-observing.c
index 6c6ed7f1c..5ef27f024 100644
--- a/apps/er-coap-07/er-coap-07-observing.c
+++ b/apps/er-coap-07/er-coap-07-observing.c
@@ -186,27 +186,25 @@ coap_notify_observers(const char *url, int type, uint32_t observe, uint8_t *payl
 void
 coap_observe_handler(resource_t *resource, void *request, void *response)
 {
+  coap_packet_t *const coap_req = (coap_packet_t *) request;
+  coap_packet_t *const coap_res = (coap_packet_t *) response;
+
   static char content[26];
 
-  if (response && ((coap_packet_t *)response)->code<128) /* response without error code */
+  if (coap_res && coap_res->code<128) /* response without error code */
   {
-    if (IS_OPTION((coap_packet_t *)request, COAP_OPTION_OBSERVE))
+    if (IS_OPTION(coap_req, COAP_OPTION_OBSERVE))
     {
-      if (!IS_OPTION((coap_packet_t *)request, COAP_OPTION_TOKEN))
-      {
-        /* Set default token. */
-        coap_set_header_token(request, (uint8_t *)"", 1);
-      }
 
-      if (coap_add_observer(resource->url, &UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, ((coap_packet_t *)request)->token, ((coap_packet_t *)request)->token_len))
+      if (coap_add_observer(resource->url, &UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, coap_req->token, coap_req->token_len))
       {
-        coap_set_header_observe(response, 0);
-        coap_set_payload(response, (uint8_t *)content, snprintf(content, sizeof(content), "Added as observer %u/%u", list_length(observers_list), COAP_MAX_OBSERVERS));
+        coap_set_header_observe(coap_res, 0);
+        coap_set_payload(coap_res, content, snprintf(content, sizeof(content), "Added as observer %u/%u", list_length(observers_list), COAP_MAX_OBSERVERS));
       }
       else
       {
-        ((coap_packet_t *)response)->code = SERVICE_UNAVAILABLE_5_03;
-        coap_set_payload(response, (uint8_t *)"Too many observers", 18);
+        coap_res->code = SERVICE_UNAVAILABLE_5_03;
+        coap_set_payload(coap_res, "TooManyObservers", 16);
       } /* if (added observer) */
     }
     else /* if (observe) */
diff --git a/apps/er-coap-07/er-coap-07-separate.c b/apps/er-coap-07/er-coap-07-separate.c
index f27aed4a7..ef6266dbf 100644
--- a/apps/er-coap-07/er-coap-07-separate.c
+++ b/apps/er-coap-07/er-coap-07-separate.c
@@ -55,15 +55,18 @@
 /*-----------------------------------------------------------------------------------*/
 void coap_separate_handler(resource_t *resource, void *request, void *response)
 {
+  coap_packet_t *const coap_req = (coap_packet_t *) request;
+  coap_packet_t *const coap_res = (coap_packet_t *) response;
+
   PRINTF("Separate response for /%s \n", resource->url);
   /* send separate ACK. */
   coap_packet_t ack[1];
   /* ACK with empty code (0) */
-  coap_init_message(ack, COAP_TYPE_ACK, 0, ((coap_packet_t *)request)->tid);
+  coap_init_message(ack, COAP_TYPE_ACK, 0, coap_req->tid);
   /* Should only overwrite Header which is already parsed to request. */
   coap_send_message(&UIP_IP_BUF->srcipaddr, UIP_UDP_BUF->srcport, (uip_appdata + uip_ext_len), coap_serialize_message(ack, (uip_appdata + uip_ext_len)));
 
   /* Change response to separate response. */
-  ((coap_packet_t *)response)->type = COAP_TYPE_CON;
-  ((coap_packet_t *)response)->tid = coap_get_tid();
+  coap_res->type = COAP_TYPE_CON;
+  coap_res->tid = coap_get_tid();
 }
diff --git a/apps/er-coap-07/er-coap-07.c b/apps/er-coap-07/er-coap-07.c
index b87fb1928..895a6e587 100644
--- a/apps/er-coap-07/er-coap-07.c
+++ b/apps/er-coap-07/er-coap-07.c
@@ -288,234 +288,238 @@ coap_get_tid()
 void
 coap_init_message(void *packet, coap_message_type_t type, uint8_t code, uint16_t tid)
 {
-  /* Important thing */
-  memset(packet, 0, sizeof(coap_packet_t));
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  ((coap_packet_t *)packet)->type = type;
-  ((coap_packet_t *)packet)->code = code;
-  ((coap_packet_t *)packet)->tid = tid;
+  /* Important thing */
+  memset(coap_pkt, 0, sizeof(coap_packet_t));
+
+  coap_pkt->type = type;
+  coap_pkt->code = code;
+  coap_pkt->tid = tid;
 }
 /*-----------------------------------------------------------------------------------*/
 size_t
 coap_serialize_message(void *packet, uint8_t *buffer)
 {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
   /* Initialize */
-  ((coap_packet_t *)packet)->buffer = buffer;
-  ((coap_packet_t *)packet)->version = 1;
-  ((coap_packet_t *)packet)->option_count = 0;
+  coap_pkt->buffer = buffer;
+  coap_pkt->version = 1;
+  coap_pkt->option_count = 0;
 
   /* serialize options */
-  uint8_t *option = ((coap_packet_t *)packet)->buffer + COAP_HEADER_LEN;
+  uint8_t *option = coap_pkt->buffer + COAP_HEADER_LEN;
   int current_number = 0;
 
   PRINTF("-Serializing options-\n");
 
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_CONTENT_TYPE)) {
-    PRINTF("Content-Type [%u]\n", ((coap_packet_t *)packet)->content_type);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_CONTENT_TYPE)) {
+    PRINTF("Content-Type [%u]\n", coap_pkt->content_type);
 
-    option += serialize_int_option(COAP_OPTION_CONTENT_TYPE, current_number, option, ((coap_packet_t *)packet)->content_type);
-    ((coap_packet_t *)packet)->option_count += 1;
+    option += serialize_int_option(COAP_OPTION_CONTENT_TYPE, current_number, option, coap_pkt->content_type);
+    coap_pkt->option_count += 1;
     current_number = COAP_OPTION_CONTENT_TYPE;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE)) {
-    PRINTF("Max-Age [%lu]\n", ((coap_packet_t *)packet)->max_age);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_MAX_AGE)) {
+    PRINTF("Max-Age [%lu]\n", coap_pkt->max_age);
 
-    option += serialize_int_option(COAP_OPTION_MAX_AGE, current_number, option, ((coap_packet_t *)packet)->max_age);
-    ((coap_packet_t *)packet)->option_count += 1;
+    option += serialize_int_option(COAP_OPTION_MAX_AGE, current_number, option, coap_pkt->max_age);
+    coap_pkt->option_count += 1;
     current_number = COAP_OPTION_MAX_AGE;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_PROXY_URI)) {
-    PRINTF("Proxy-Uri [%.*s]\n", ((coap_packet_t *)packet)->proxy_uri_len, ((coap_packet_t *)packet)->proxy_uri);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_PROXY_URI)) {
+    PRINTF("Proxy-Uri [%.*s]\n", coap_pkt->proxy_uri_len, coap_pkt->proxy_uri);
 
-    int length = ((coap_packet_t *)packet)->proxy_uri_len;
+    int length = coap_pkt->proxy_uri_len;
     int j = 0;
     while (length>0)
     {
-        option += serialize_array_option(COAP_OPTION_PROXY_URI, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->proxy_uri + j*270, MIN(270, length), NULL);
-        ((coap_packet_t *)packet)->option_count += 1;
+        option += serialize_array_option(COAP_OPTION_PROXY_URI, current_number, option, (uint8_t *) coap_pkt->proxy_uri + j*270, MIN(270, length), NULL);
+        coap_pkt->option_count += 1;
         current_number = COAP_OPTION_PROXY_URI;
 
         ++j;
         length -= 270;
     }
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG)) {
-    PRINTF("ETag %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->etag_len,
-      ((coap_packet_t *)packet)->etag[0],
-      ((coap_packet_t *)packet)->etag[1],
-      ((coap_packet_t *)packet)->etag[2],
-      ((coap_packet_t *)packet)->etag[3],
-      ((coap_packet_t *)packet)->etag[4],
-      ((coap_packet_t *)packet)->etag[5],
-      ((coap_packet_t *)packet)->etag[6],
-      ((coap_packet_t *)packet)->etag[7]
+  if (IS_OPTION(coap_pkt, COAP_OPTION_ETAG)) {
+    PRINTF("ETag %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", coap_pkt->etag_len,
+      coap_pkt->etag[0],
+      coap_pkt->etag[1],
+      coap_pkt->etag[2],
+      coap_pkt->etag[3],
+      coap_pkt->etag[4],
+      coap_pkt->etag[5],
+      coap_pkt->etag[6],
+      coap_pkt->etag[7]
     ); /*FIXME always prints 8 bytes */
 
-    option += serialize_array_option(COAP_OPTION_ETAG, current_number, option, ((coap_packet_t *)packet)->etag, ((coap_packet_t *)packet)->etag_len, NULL);
-    ((coap_packet_t *)packet)->option_count += 1;
+    option += serialize_array_option(COAP_OPTION_ETAG, current_number, option, coap_pkt->etag, coap_pkt->etag_len, NULL);
+    coap_pkt->option_count += 1;
     current_number = COAP_OPTION_ETAG;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST)) {
-    PRINTF("Uri-Host [%.*s]\n", ((coap_packet_t *)packet)->uri_host_len, ((coap_packet_t *)packet)->uri_host);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_URI_HOST)) {
+    PRINTF("Uri-Host [%.*s]\n", coap_pkt->uri_host_len, coap_pkt->uri_host);
 
-    option += serialize_array_option(COAP_OPTION_URI_HOST, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->uri_host, ((coap_packet_t *)packet)->uri_host_len, NULL);
-    ((coap_packet_t *)packet)->option_count += 1;
+    option += serialize_array_option(COAP_OPTION_URI_HOST, current_number, option, (uint8_t *) coap_pkt->uri_host, coap_pkt->uri_host_len, NULL);
+    coap_pkt->option_count += 1;
     current_number = COAP_OPTION_URI_HOST;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH)) {
-    PRINTF("Location [%.*s]\n", ((coap_packet_t *)packet)->location_path_len, ((coap_packet_t *)packet)->location_path);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_LOCATION_PATH)) {
+    PRINTF("Location [%.*s]\n", coap_pkt->location_path_len, coap_pkt->location_path);
 
     uint8_t split_options = '/';
 
-    option += serialize_array_option(COAP_OPTION_LOCATION_PATH, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->location_path, ((coap_packet_t *)packet)->location_path_len, &split_options);
-    ((coap_packet_t *)packet)->option_count += split_options;
+    option += serialize_array_option(COAP_OPTION_LOCATION_PATH, current_number, option, (uint8_t *) coap_pkt->location_path, coap_pkt->location_path_len, &split_options);
+    coap_pkt->option_count += split_options;
     current_number = COAP_OPTION_LOCATION_PATH;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PORT)) {
-    PRINTF("Uri-Port [%u]\n", ((coap_packet_t *)packet)->uri_port);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_URI_PORT)) {
+    PRINTF("Uri-Port [%u]\n", coap_pkt->uri_port);
 
-    option += serialize_int_option(COAP_OPTION_URI_PORT, current_number, option, ((coap_packet_t *)packet)->uri_port);
-    ((coap_packet_t *)packet)->option_count += 1;
+    option += serialize_int_option(COAP_OPTION_URI_PORT, current_number, option, coap_pkt->uri_port);
+    coap_pkt->option_count += 1;
     current_number = COAP_OPTION_URI_PORT;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_QUERY)) {
-    PRINTF("Location-Query [%.*s]\n", ((coap_packet_t *)packet)->location_query_len, ((coap_packet_t *)packet)->location_query);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_LOCATION_QUERY)) {
+    PRINTF("Location-Query [%.*s]\n", coap_pkt->location_query_len, coap_pkt->location_query);
 
     uint8_t split_options = '&';
 
-    option += serialize_array_option(COAP_OPTION_LOCATION_QUERY, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->location_query, ((coap_packet_t *)packet)->location_query_len, &split_options);
-    ((coap_packet_t *)packet)->option_count += split_options;
+    option += serialize_array_option(COAP_OPTION_LOCATION_QUERY, current_number, option, (uint8_t *) coap_pkt->location_query, coap_pkt->location_query_len, &split_options);
+    coap_pkt->option_count += split_options;
     current_number = COAP_OPTION_LOCATION_QUERY;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH)) {
-    PRINTF("Uri-Path [%.*s]\n", ((coap_packet_t *)packet)->uri_path_len, ((coap_packet_t *)packet)->uri_path);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_URI_PATH)) {
+    PRINTF("Uri-Path [%.*s]\n", coap_pkt->uri_path_len, coap_pkt->uri_path);
 
     uint8_t split_options = '/';
 
-    option += serialize_array_option(COAP_OPTION_URI_PATH, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->uri_path, ((coap_packet_t *)packet)->uri_path_len, &split_options);
-    ((coap_packet_t *)packet)->option_count += split_options;
+    option += serialize_array_option(COAP_OPTION_URI_PATH, current_number, option, (uint8_t *) coap_pkt->uri_path, coap_pkt->uri_path_len, &split_options);
+    coap_pkt->option_count += split_options;
     current_number = COAP_OPTION_URI_PATH;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE)) {
-    PRINTF("Observe [%u]\n", ((coap_packet_t *)packet)->observe);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_OBSERVE)) {
+    PRINTF("Observe [%u]\n", coap_pkt->observe);
 
-    option += serialize_int_option(COAP_OPTION_OBSERVE, current_number, option, ((coap_packet_t *)packet)->observe);
-    ((coap_packet_t *)packet)->option_count += 1;
+    option += serialize_int_option(COAP_OPTION_OBSERVE, current_number, option, coap_pkt->observe);
+    coap_pkt->option_count += 1;
     current_number = COAP_OPTION_OBSERVE;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN)) {
-    PRINTF("Token %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->token_len,
-      ((coap_packet_t *)packet)->token[0],
-      ((coap_packet_t *)packet)->token[1],
-      ((coap_packet_t *)packet)->token[2],
-      ((coap_packet_t *)packet)->token[3],
-      ((coap_packet_t *)packet)->token[4],
-      ((coap_packet_t *)packet)->token[5],
-      ((coap_packet_t *)packet)->token[6],
-      ((coap_packet_t *)packet)->token[7]
+  if (IS_OPTION(coap_pkt, COAP_OPTION_TOKEN)) {
+    PRINTF("Token %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", coap_pkt->token_len,
+      coap_pkt->token[0],
+      coap_pkt->token[1],
+      coap_pkt->token[2],
+      coap_pkt->token[3],
+      coap_pkt->token[4],
+      coap_pkt->token[5],
+      coap_pkt->token[6],
+      coap_pkt->token[7]
     ); /*FIXME always prints 8 bytes */
 
-    option += serialize_array_option(COAP_OPTION_TOKEN, current_number, option, ((coap_packet_t *)packet)->token, ((coap_packet_t *)packet)->token_len, NULL);
-    ((coap_packet_t *)packet)->option_count += 1;
+    option += serialize_array_option(COAP_OPTION_TOKEN, current_number, option, coap_pkt->token, coap_pkt->token_len, NULL);
+    coap_pkt->option_count += 1;
     current_number = COAP_OPTION_TOKEN;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ACCEPT)) {
+  if (IS_OPTION(coap_pkt, COAP_OPTION_ACCEPT)) {
     int i;
-    for (i=0; i<((coap_packet_t *)packet)->accept_num; ++i)
+    for (i=0; i<coap_pkt->accept_num; ++i)
     {
-      PRINTF("Accept [%u]\n", ((coap_packet_t *)packet)->accept[i]);
+      PRINTF("Accept [%u]\n", coap_pkt->accept[i]);
 
-      option += serialize_int_option(COAP_OPTION_ACCEPT, current_number, option, (uint32_t)((coap_packet_t *)packet)->accept[i]);
-      ((coap_packet_t *)packet)->option_count += 1;
+      option += serialize_int_option(COAP_OPTION_ACCEPT, current_number, option, (uint32_t)coap_pkt->accept[i]);
+      coap_pkt->option_count += 1;
       current_number = COAP_OPTION_ACCEPT;
     }
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_MATCH)) {
+  if (IS_OPTION(coap_pkt, COAP_OPTION_IF_MATCH)) {
     PRINTF("If-Match [FIXME]\n");
 
-    option += serialize_array_option(COAP_OPTION_IF_MATCH, current_number, option, ((coap_packet_t *)packet)->if_match, ((coap_packet_t *)packet)->if_match_len, NULL);
-    ((coap_packet_t *)packet)->option_count += 1;
+    option += serialize_array_option(COAP_OPTION_IF_MATCH, current_number, option, coap_pkt->if_match, coap_pkt->if_match_len, NULL);
+    coap_pkt->option_count += 1;
     current_number = COAP_OPTION_IF_MATCH;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) {
-    PRINTF("Uri-Query [%.*s]\n", ((coap_packet_t *)packet)->uri_query_len, ((coap_packet_t *)packet)->uri_query);
+  if (IS_OPTION(coap_pkt, COAP_OPTION_URI_QUERY)) {
+    PRINTF("Uri-Query [%.*s]\n", coap_pkt->uri_query_len, coap_pkt->uri_query);
 
     uint8_t split_options = '&';
 
-    option += serialize_array_option(COAP_OPTION_URI_QUERY, current_number, option, (uint8_t *) ((coap_packet_t *)packet)->uri_query, ((coap_packet_t *)packet)->uri_query_len, &split_options);
-    ((coap_packet_t *)packet)->option_count += split_options + (COAP_OPTION_URI_QUERY-current_number)/COAP_OPTION_FENCE_POST;
+    option += serialize_array_option(COAP_OPTION_URI_QUERY, current_number, option, (uint8_t *) coap_pkt->uri_query, coap_pkt->uri_query_len, &split_options);
+    coap_pkt->option_count += split_options + (COAP_OPTION_URI_QUERY-current_number)/COAP_OPTION_FENCE_POST;
     current_number = COAP_OPTION_URI_QUERY;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK2))
+  if (IS_OPTION(coap_pkt, COAP_OPTION_BLOCK2))
   {
-    PRINTF("Block2 [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block2_num, ((coap_packet_t *)packet)->block2_more ? "+" : "", ((coap_packet_t *)packet)->block2_size);
+    PRINTF("Block2 [%lu%s (%u B/blk)]\n", coap_pkt->block2_num, coap_pkt->block2_more ? "+" : "", coap_pkt->block2_size);
 
-    uint32_t block = ((coap_packet_t *)packet)->block2_num << 4;
-    if (((coap_packet_t *)packet)->block2_more) block |= 0x8;
-    block |= 0xF & log_2(((coap_packet_t *)packet)->block2_size/16);
+    uint32_t block = coap_pkt->block2_num << 4;
+    if (coap_pkt->block2_more) block |= 0x8;
+    block |= 0xF & log_2(coap_pkt->block2_size/16);
 
     PRINTF("Block2 encoded: 0x%lX\n", block);
 
     option += serialize_int_option(COAP_OPTION_BLOCK2, current_number, option, block);
 
-    ((coap_packet_t *)packet)->option_count += 1 + (COAP_OPTION_BLOCK2-current_number)/COAP_OPTION_FENCE_POST;
+    coap_pkt->option_count += 1 + (COAP_OPTION_BLOCK2-current_number)/COAP_OPTION_FENCE_POST;
     current_number = COAP_OPTION_BLOCK2;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK1))
+  if (IS_OPTION(coap_pkt, COAP_OPTION_BLOCK1))
   {
-    PRINTF("Block1 [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block1_num, ((coap_packet_t *)packet)->block1_more ? "+" : "", ((coap_packet_t *)packet)->block1_size);
+    PRINTF("Block1 [%lu%s (%u B/blk)]\n", coap_pkt->block1_num, coap_pkt->block1_more ? "+" : "", coap_pkt->block1_size);
 
-    uint32_t block = ((coap_packet_t *)packet)->block1_num << 4;
-    if (((coap_packet_t *)packet)->block1_more) block |= 0x8;
-    block |= 0xF & log_2(((coap_packet_t *)packet)->block1_size/16);
+    uint32_t block = coap_pkt->block1_num << 4;
+    if (coap_pkt->block1_more) block |= 0x8;
+    block |= 0xF & log_2(coap_pkt->block1_size/16);
 
     PRINTF("Block1 encoded: 0x%lX\n", block);
 
     option += serialize_int_option(COAP_OPTION_BLOCK1, current_number, option, block);
 
-    ((coap_packet_t *)packet)->option_count += 1 + (COAP_OPTION_BLOCK1-current_number)/COAP_OPTION_FENCE_POST;
+    coap_pkt->option_count += 1 + (COAP_OPTION_BLOCK1-current_number)/COAP_OPTION_FENCE_POST;
     current_number = COAP_OPTION_BLOCK1;
   }
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_NONE_MATCH)) {
+  if (IS_OPTION(coap_pkt, COAP_OPTION_IF_NONE_MATCH)) {
     PRINTF("If-None-Match\n");
 
     option += serialize_int_option(COAP_OPTION_IF_NONE_MATCH, current_number, option, 0);
 
-    ((coap_packet_t *)packet)->option_count += 1 + (COAP_OPTION_IF_NONE_MATCH-current_number)/COAP_OPTION_FENCE_POST;
+    coap_pkt->option_count += 1 + (COAP_OPTION_IF_NONE_MATCH-current_number)/COAP_OPTION_FENCE_POST;
     current_number = COAP_OPTION_IF_NONE_MATCH;
   }
 
   /* pack payload */
-  if ((option - ((coap_packet_t *)packet)->buffer)<=COAP_MAX_HEADER_SIZE)
+  if ((option - coap_pkt->buffer)<=COAP_MAX_HEADER_SIZE)
   {
-    memmove(option, ((coap_packet_t *)packet)->payload, ((coap_packet_t *)packet)->payload_len);
+    memmove(option, coap_pkt->payload, coap_pkt->payload_len);
   }
   else
   {
     /* An error occured. Caller must check for !=0. */
-    ((coap_packet_t *)packet)->buffer = NULL;
+    coap_pkt->buffer = NULL;
     coap_error_message = "Serialized header exceeds COAP_MAX_HEADER_SIZE";
     return 0;
   }
 
   /* set header fields */
-  ((coap_packet_t *)packet)->buffer[0]  = 0x00;
-  ((coap_packet_t *)packet)->buffer[0] |= COAP_HEADER_VERSION_MASK & (((coap_packet_t *)packet)->version)<<COAP_HEADER_VERSION_POSITION;
-  ((coap_packet_t *)packet)->buffer[0] |= COAP_HEADER_TYPE_MASK & (((coap_packet_t *)packet)->type)<<COAP_HEADER_TYPE_POSITION;
-  ((coap_packet_t *)packet)->buffer[0] |= COAP_HEADER_OPTION_COUNT_MASK & (((coap_packet_t *)packet)->option_count)<<COAP_HEADER_OPTION_COUNT_POSITION;
-  ((coap_packet_t *)packet)->buffer[1] = ((coap_packet_t *)packet)->code;
-  ((coap_packet_t *)packet)->buffer[2] = 0xFF & (((coap_packet_t *)packet)->tid)>>8;
-  ((coap_packet_t *)packet)->buffer[3] = 0xFF & ((coap_packet_t *)packet)->tid;
+  coap_pkt->buffer[0]  = 0x00;
+  coap_pkt->buffer[0] |= COAP_HEADER_VERSION_MASK & (coap_pkt->version)<<COAP_HEADER_VERSION_POSITION;
+  coap_pkt->buffer[0] |= COAP_HEADER_TYPE_MASK & (coap_pkt->type)<<COAP_HEADER_TYPE_POSITION;
+  coap_pkt->buffer[0] |= COAP_HEADER_OPTION_COUNT_MASK & (coap_pkt->option_count)<<COAP_HEADER_OPTION_COUNT_POSITION;
+  coap_pkt->buffer[1] = coap_pkt->code;
+  coap_pkt->buffer[2] = 0xFF & (coap_pkt->tid)>>8;
+  coap_pkt->buffer[3] = 0xFF & coap_pkt->tid;
 
-  PRINTF("-Done %u options, header len %u, payload len %u-\n", ((coap_packet_t *)packet)->option_count, option - buffer, ((coap_packet_t *)packet)->payload_len);
+  PRINTF("-Done %u options, header len %u, payload len %u-\n", coap_pkt->option_count, option - buffer, coap_pkt->payload_len);
 
-  return (option - buffer) + ((coap_packet_t *)packet)->payload_len; /* packet length */
+  return (option - buffer) + coap_pkt->payload_len; /* packet length */
 }
 /*-----------------------------------------------------------------------------------*/
 void
 coap_send_message(uip_ipaddr_t *addr, uint16_t port, uint8_t *data, uint16_t length)
 {
-  /*configure connection to reply to client*/
+  /* Configure connection to reply to client */
   uip_ipaddr_copy(&udp_conn->ripaddr, addr);
   udp_conn->rport = port;
 
@@ -530,38 +534,40 @@ coap_send_message(uip_ipaddr_t *addr, uint16_t port, uint8_t *data, uint16_t len
 coap_status_t
 coap_parse_message(void *packet, uint8_t *data, uint16_t data_len)
 {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
   /* Initialize packet */
-  memset(packet, 0, sizeof(coap_packet_t));
+  memset(coap_pkt, 0, sizeof(coap_packet_t));
 
   /* pointer to packet bytes */
-  ((coap_packet_t *)packet)->buffer = data;
+  coap_pkt->buffer = data;
 
   /* parse header fields */
-  ((coap_packet_t *)packet)->version = (COAP_HEADER_VERSION_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_VERSION_POSITION;
-  ((coap_packet_t *)packet)->type = (COAP_HEADER_TYPE_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_TYPE_POSITION;
-  ((coap_packet_t *)packet)->option_count = (COAP_HEADER_OPTION_COUNT_MASK & ((coap_packet_t *)packet)->buffer[0])>>COAP_HEADER_OPTION_COUNT_POSITION;
-  ((coap_packet_t *)packet)->code = ((coap_packet_t *)packet)->buffer[1];
-  ((coap_packet_t *)packet)->tid = ((coap_packet_t *)packet)->buffer[2]<<8 | ((coap_packet_t *)packet)->buffer[3];
+  coap_pkt->version = (COAP_HEADER_VERSION_MASK & coap_pkt->buffer[0])>>COAP_HEADER_VERSION_POSITION;
+  coap_pkt->type = (COAP_HEADER_TYPE_MASK & coap_pkt->buffer[0])>>COAP_HEADER_TYPE_POSITION;
+  coap_pkt->option_count = (COAP_HEADER_OPTION_COUNT_MASK & coap_pkt->buffer[0])>>COAP_HEADER_OPTION_COUNT_POSITION;
+  coap_pkt->code = coap_pkt->buffer[1];
+  coap_pkt->tid = coap_pkt->buffer[2]<<8 | coap_pkt->buffer[3];
 
-  if (((coap_packet_t *)packet)->version != 1)
+  if (coap_pkt->version != 1)
   {
     coap_error_message = "CoAP version must be 1";
     return BAD_REQUEST_4_00;
   }
 
   /* parse options */
-  ((coap_packet_t *)packet)->options = 0x0000;
+  coap_pkt->options = 0x0000;
   uint8_t *current_option = data + COAP_HEADER_LEN;
 
-  if (((coap_packet_t *)packet)->option_count)
+  if (coap_pkt->option_count)
   {
     uint8_t option_index = 0;
 
     uint8_t current_number = 0;
     size_t option_len = 0;
 
-    PRINTF("-Parsing %u options-\n", ((coap_packet_t *)packet)->option_count);
-    for (option_index=0; option_index < ((coap_packet_t *)packet)->option_count; ++option_index) {
+    PRINTF("-Parsing %u options-\n", coap_pkt->option_count);
+    for (option_index=0; option_index < coap_pkt->option_count; ++option_index) {
 
       current_number += current_option[0]>>4;
 
@@ -575,103 +581,103 @@ coap_parse_message(void *packet, uint8_t *data, uint16_t data_len)
         current_option += 2;
       }
 
-      SET_OPTION((coap_packet_t *)packet, current_number);
+      SET_OPTION(coap_pkt, current_number);
 
       switch (current_number) {
         case COAP_OPTION_CONTENT_TYPE:
-          ((coap_packet_t *)packet)->content_type = parse_int_option(current_option, option_len);
-          PRINTF("Content-Type [%u]\n", ((coap_packet_t *)packet)->content_type);
+          coap_pkt->content_type = parse_int_option(current_option, option_len);
+          PRINTF("Content-Type [%u]\n", coap_pkt->content_type);
           break;
         case COAP_OPTION_MAX_AGE:
-          ((coap_packet_t *)packet)->max_age = parse_int_option(current_option, option_len);
-          PRINTF("Max-Age [%lu]\n", ((coap_packet_t *)packet)->max_age);
+          coap_pkt->max_age = parse_int_option(current_option, option_len);
+          PRINTF("Max-Age [%lu]\n", coap_pkt->max_age);
           break;
         case COAP_OPTION_PROXY_URI:
           /*FIXME check for own end-point */
-          ((coap_packet_t *)packet)->proxy_uri = (char *) current_option;
-          ((coap_packet_t *)packet)->proxy_uri_len = option_len;
+          coap_pkt->proxy_uri = (char *) current_option;
+          coap_pkt->proxy_uri_len = option_len;
           /*TODO length > 270 not implemented (actually not required) */
-          PRINTF("Proxy-Uri NOT IMPLEMENTED [%.*s]\n", ((coap_packet_t *)packet)->proxy_uri_len, ((coap_packet_t *)packet)->proxy_uri);
+          PRINTF("Proxy-Uri NOT IMPLEMENTED [%.*s]\n", coap_pkt->proxy_uri_len, coap_pkt->proxy_uri);
           coap_error_message = "This is a constrained server (Contiki)";
           return PROXYING_NOT_SUPPORTED_5_05;
           break;
         case COAP_OPTION_ETAG:
-          ((coap_packet_t *)packet)->etag_len = MIN(COAP_ETAG_LEN, option_len);
-          memcpy(((coap_packet_t *)packet)->etag, current_option, ((coap_packet_t *)packet)->etag_len);
-          PRINTF("ETag %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->etag_len,
-            ((coap_packet_t *)packet)->etag[0],
-            ((coap_packet_t *)packet)->etag[1],
-            ((coap_packet_t *)packet)->etag[2],
-            ((coap_packet_t *)packet)->etag[3],
-            ((coap_packet_t *)packet)->etag[4],
-            ((coap_packet_t *)packet)->etag[5],
-            ((coap_packet_t *)packet)->etag[6],
-            ((coap_packet_t *)packet)->etag[7]
+          coap_pkt->etag_len = MIN(COAP_ETAG_LEN, option_len);
+          memcpy(coap_pkt->etag, current_option, coap_pkt->etag_len);
+          PRINTF("ETag %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", coap_pkt->etag_len,
+            coap_pkt->etag[0],
+            coap_pkt->etag[1],
+            coap_pkt->etag[2],
+            coap_pkt->etag[3],
+            coap_pkt->etag[4],
+            coap_pkt->etag[5],
+            coap_pkt->etag[6],
+            coap_pkt->etag[7]
           ); /*FIXME always prints 8 bytes */
           break;
         case COAP_OPTION_URI_HOST:
-          ((coap_packet_t *)packet)->uri_host = (char *) current_option;
-          ((coap_packet_t *)packet)->uri_host_len = option_len;
-          PRINTF("Uri-Host [%.*s]\n", ((coap_packet_t *)packet)->uri_host_len, ((coap_packet_t *)packet)->uri_host);
+          coap_pkt->uri_host = (char *) current_option;
+          coap_pkt->uri_host_len = option_len;
+          PRINTF("Uri-Host [%.*s]\n", coap_pkt->uri_host_len, coap_pkt->uri_host);
           break;
         case COAP_OPTION_LOCATION_PATH:
           /* coap_merge_multi_option() operates in-place on the IPBUF, but final packet field should be const string -> cast to string */
-          coap_merge_multi_option( (char **) &(((coap_packet_t *)packet)->location_path), &(((coap_packet_t *)packet)->location_path_len), current_option, option_len, '/');
-          PRINTF("Location-Path [%.*s]\n", ((coap_packet_t *)packet)->location_path_len, ((coap_packet_t *)packet)->location_path);
+          coap_merge_multi_option( (char **) &(coap_pkt->location_path), &(coap_pkt->location_path_len), current_option, option_len, '/');
+          PRINTF("Location-Path [%.*s]\n", coap_pkt->location_path_len, coap_pkt->location_path);
           break;
         case COAP_OPTION_URI_PORT:
-          ((coap_packet_t *)packet)->uri_port = parse_int_option(current_option, option_len);
-          PRINTF("Uri-Port [%u]\n", ((coap_packet_t *)packet)->uri_port);
+          coap_pkt->uri_port = parse_int_option(current_option, option_len);
+          PRINTF("Uri-Port [%u]\n", coap_pkt->uri_port);
           break;
         case COAP_OPTION_LOCATION_QUERY:
           /* coap_merge_multi_option() operates in-place on the IPBUF, but final packet field should be const string -> cast to string */
-          coap_merge_multi_option( (char **) &(((coap_packet_t *)packet)->location_query), &(((coap_packet_t *)packet)->location_query_len), current_option, option_len, '&');
-          PRINTF("Location-Query [%.*s]\n", ((coap_packet_t *)packet)->location_query_len, ((coap_packet_t *)packet)->location_query);
+          coap_merge_multi_option( (char **) &(coap_pkt->location_query), &(coap_pkt->location_query_len), current_option, option_len, '&');
+          PRINTF("Location-Query [%.*s]\n", coap_pkt->location_query_len, coap_pkt->location_query);
           break;
         case COAP_OPTION_URI_PATH:
           /* coap_merge_multi_option() operates in-place on the IPBUF, but final packet field should be const string -> cast to string */
-          coap_merge_multi_option( (char **) &(((coap_packet_t *)packet)->uri_path), &(((coap_packet_t *)packet)->uri_path_len), current_option, option_len, '/');
-          PRINTF("Uri-Path [%.*s]\n", ((coap_packet_t *)packet)->uri_path_len, ((coap_packet_t *)packet)->uri_path);
+          coap_merge_multi_option( (char **) &(coap_pkt->uri_path), &(coap_pkt->uri_path_len), current_option, option_len, '/');
+          PRINTF("Uri-Path [%.*s]\n", coap_pkt->uri_path_len, coap_pkt->uri_path);
           break;
         case COAP_OPTION_OBSERVE:
-          ((coap_packet_t *)packet)->observe = parse_int_option(current_option, option_len);
-          PRINTF("Observe [%u]\n", ((coap_packet_t *)packet)->observe);
+          coap_pkt->observe = parse_int_option(current_option, option_len);
+          PRINTF("Observe [%u]\n", coap_pkt->observe);
           break;
         case COAP_OPTION_TOKEN:
-          ((coap_packet_t *)packet)->token_len = MIN(COAP_TOKEN_LEN, option_len);
-          memcpy(((coap_packet_t *)packet)->token, current_option, ((coap_packet_t *)packet)->token_len);
-          PRINTF("Token %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->token_len,
-            ((coap_packet_t *)packet)->token[0],
-            ((coap_packet_t *)packet)->token[1],
-            ((coap_packet_t *)packet)->token[2],
-            ((coap_packet_t *)packet)->token[3],
-            ((coap_packet_t *)packet)->token[4],
-            ((coap_packet_t *)packet)->token[5],
-            ((coap_packet_t *)packet)->token[6],
-            ((coap_packet_t *)packet)->token[7]
+          coap_pkt->token_len = MIN(COAP_TOKEN_LEN, option_len);
+          memcpy(coap_pkt->token, current_option, coap_pkt->token_len);
+          PRINTF("Token %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", coap_pkt->token_len,
+            coap_pkt->token[0],
+            coap_pkt->token[1],
+            coap_pkt->token[2],
+            coap_pkt->token[3],
+            coap_pkt->token[4],
+            coap_pkt->token[5],
+            coap_pkt->token[6],
+            coap_pkt->token[7]
           ); /*FIXME always prints 8 bytes */
           break;
         case COAP_OPTION_ACCEPT:
-          if (((coap_packet_t *)packet)->accept_num < COAP_MAX_ACCEPT_NUM)
+          if (coap_pkt->accept_num < COAP_MAX_ACCEPT_NUM)
           {
-            ((coap_packet_t *)packet)->accept[((coap_packet_t *)packet)->accept_num] = parse_int_option(current_option, option_len);
-            ((coap_packet_t *)packet)->accept_num += 1;
-            PRINTF("Accept [%u]\n", ((coap_packet_t *)packet)->content_type);
+            coap_pkt->accept[coap_pkt->accept_num] = parse_int_option(current_option, option_len);
+            coap_pkt->accept_num += 1;
+            PRINTF("Accept [%u]\n", coap_pkt->content_type);
           }
           break;
         case COAP_OPTION_IF_MATCH:
           /*FIXME support multiple ETags */
-          ((coap_packet_t *)packet)->if_match_len = MIN(COAP_ETAG_LEN, option_len);
-          memcpy(((coap_packet_t *)packet)->if_match, current_option, ((coap_packet_t *)packet)->if_match_len);
-          PRINTF("If-Match %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", ((coap_packet_t *)packet)->if_match_len,
-            ((coap_packet_t *)packet)->if_match[0],
-            ((coap_packet_t *)packet)->if_match[1],
-            ((coap_packet_t *)packet)->if_match[2],
-            ((coap_packet_t *)packet)->if_match[3],
-            ((coap_packet_t *)packet)->if_match[4],
-            ((coap_packet_t *)packet)->if_match[5],
-            ((coap_packet_t *)packet)->if_match[6],
-            ((coap_packet_t *)packet)->if_match[7]
+          coap_pkt->if_match_len = MIN(COAP_ETAG_LEN, option_len);
+          memcpy(coap_pkt->if_match, current_option, coap_pkt->if_match_len);
+          PRINTF("If-Match %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", coap_pkt->if_match_len,
+            coap_pkt->if_match[0],
+            coap_pkt->if_match[1],
+            coap_pkt->if_match[2],
+            coap_pkt->if_match[3],
+            coap_pkt->if_match[4],
+            coap_pkt->if_match[5],
+            coap_pkt->if_match[6],
+            coap_pkt->if_match[7]
           ); /*FIXME always prints 8 bytes */
           break;
         case COAP_OPTION_FENCE_POST:
@@ -679,16 +685,16 @@ coap_parse_message(void *packet, uint8_t *data, uint16_t data_len)
           break;
         case COAP_OPTION_URI_QUERY:
           /* coap_merge_multi_option() operates in-place on the IPBUF, but final packet field should be const string -> cast to string */
-          coap_merge_multi_option( (char **) &(((coap_packet_t *)packet)->uri_query), &(((coap_packet_t *)packet)->uri_query_len), current_option, option_len, '&');
-          PRINTF("Uri-Query [%.*s]\n", ((coap_packet_t *)packet)->uri_query_len, ((coap_packet_t *)packet)->uri_query);
+          coap_merge_multi_option( (char **) &(coap_pkt->uri_query), &(coap_pkt->uri_query_len), current_option, option_len, '&');
+          PRINTF("Uri-Query [%.*s]\n", coap_pkt->uri_query_len, coap_pkt->uri_query);
           break;
         case COAP_OPTION_BLOCK2:
-          ((coap_packet_t *)packet)->block2_num = parse_int_option(current_option, option_len);
-          ((coap_packet_t *)packet)->block2_more = (((coap_packet_t *)packet)->block2_num & 0x08)>>3;
-          ((coap_packet_t *)packet)->block2_size = 16 << (((coap_packet_t *)packet)->block2_num & 0x07);
-          ((coap_packet_t *)packet)->block2_offset = (((coap_packet_t *)packet)->block2_num & ~0x0000000F)<<(((coap_packet_t *)packet)->block2_num & 0x07);
-          ((coap_packet_t *)packet)->block2_num >>= 4;
-          PRINTF("Block2 [%lu%s (%u B/blk)]\n", ((coap_packet_t *)packet)->block2_num, ((coap_packet_t *)packet)->block2_more ? "+" : "", ((coap_packet_t *)packet)->block2_size);
+          coap_pkt->block2_num = parse_int_option(current_option, option_len);
+          coap_pkt->block2_more = (coap_pkt->block2_num & 0x08)>>3;
+          coap_pkt->block2_size = 16 << (coap_pkt->block2_num & 0x07);
+          coap_pkt->block2_offset = (coap_pkt->block2_num & ~0x0000000F)<<(coap_pkt->block2_num & 0x07);
+          coap_pkt->block2_num >>= 4;
+          PRINTF("Block2 [%lu%s (%u B/blk)]\n", coap_pkt->block2_num, coap_pkt->block2_more ? "+" : "", coap_pkt->block2_size);
           break;
         case COAP_OPTION_BLOCK1:
           PRINTF("Block1 NOT IMPLEMENTED\n");
@@ -697,7 +703,7 @@ coap_parse_message(void *packet, uint8_t *data, uint16_t data_len)
           return NOT_IMPLEMENTED_5_01;
           break;
         case COAP_OPTION_IF_NONE_MATCH:
-          ((coap_packet_t *)packet)->if_none_match = 1;
+          coap_pkt->if_none_match = 1;
           PRINTF("If-None-Match\n");
           break;
         default:
@@ -715,8 +721,17 @@ coap_parse_message(void *packet, uint8_t *data, uint16_t data_len)
     PRINTF("-Done parsing-------\n");
   } /* if (oc) */
 
-  ((coap_packet_t *)packet)->payload = current_option;
-  ((coap_packet_t *)packet)->payload_len = data_len - (((coap_packet_t *)packet)->payload - data);
+  coap_pkt->payload = current_option;
+  coap_pkt->payload_len = data_len - (coap_pkt->payload - data);
+
+  /* also for receiving, the Erbium upper bound is REST_MAX_CHUNK_SIZE */
+  if (coap_pkt->payload_len > REST_MAX_CHUNK_SIZE)
+  {
+    coap_pkt->payload_len = REST_MAX_CHUNK_SIZE;
+  }
+
+  /* Null-terminate payload */
+  coap_pkt->payload[coap_pkt->payload_len] = '\0';
 
   return NO_ERROR;
 }
@@ -726,8 +741,10 @@ coap_parse_message(void *packet, uint8_t *data, uint16_t data_len)
 int
 coap_get_query_variable(void *packet, const char *name, const char **output)
 {
-  if (IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) {
-    return coap_get_variable(((coap_packet_t *)packet)->uri_query, ((coap_packet_t *)packet)->uri_query_len, name, output);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
+  if (IS_OPTION(coap_pkt, COAP_OPTION_URI_QUERY)) {
+    return coap_get_variable(coap_pkt->uri_query, coap_pkt->uri_query_len, name, output);
   }
   return 0;
 }
@@ -735,8 +752,10 @@ coap_get_query_variable(void *packet, const char *name, const char **output)
 int
 coap_get_post_variable(void *packet, const char *name, const char **output)
 {
-  if (((coap_packet_t *)packet)->payload_len) {
-    return coap_get_variable((const char *)((coap_packet_t *)packet)->payload, ((coap_packet_t *)packet)->payload_len, name, output);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
+  if (coap_pkt->payload_len) {
+    return coap_get_variable((const char *)coap_pkt->payload, coap_pkt->payload_len, name, output);
   }
   return 0;
 }
@@ -752,40 +771,48 @@ coap_get_header_content_type(void *packet)
 int
 coap_set_header_content_type(void *packet, unsigned int content_type)
 {
-  ((coap_packet_t *)packet)->content_type = (coap_content_type_t) content_type;
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_CONTENT_TYPE);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
+  coap_pkt->content_type = (coap_content_type_t) content_type;
+  SET_OPTION(coap_pkt, COAP_OPTION_CONTENT_TYPE);
   return 1;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_accept(void *packet, const uint16_t **accept)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ACCEPT)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *accept = ((coap_packet_t *)packet)->accept;
-  return ((coap_packet_t *)packet)->accept_num;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_ACCEPT)) return 0;
+
+  *accept = coap_pkt->accept;
+  return coap_pkt->accept_num;
 }
 
 int
 coap_set_header_accept(void *packet, uint16_t accept)
 {
-  if (((coap_packet_t *)packet)->accept_num < COAP_MAX_ACCEPT_NUM)
-  {
-    ((coap_packet_t *)packet)->accept[((coap_packet_t *)packet)->accept_num] = accept;
-    ((coap_packet_t *)packet)->accept_num += 1;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-    SET_OPTION((coap_packet_t *)packet, COAP_OPTION_ACCEPT);
+  if (coap_pkt->accept_num < COAP_MAX_ACCEPT_NUM)
+  {
+    coap_pkt->accept[coap_pkt->accept_num] = accept;
+    coap_pkt->accept_num += 1;
+
+    SET_OPTION(coap_pkt, COAP_OPTION_ACCEPT);
   }
-  return ((coap_packet_t *)packet)->accept_num;
+  return coap_pkt->accept_num;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_max_age(void *packet, uint32_t *age)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE)) {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_MAX_AGE)) {
     *age = COAP_DEFAULT_MAX_AGE;
   } else {
-    *age = ((coap_packet_t *)packet)->max_age;
+    *age = coap_pkt->max_age;
   }
   return 1;
 }
@@ -793,48 +820,58 @@ coap_get_header_max_age(void *packet, uint32_t *age)
 int
 coap_set_header_max_age(void *packet, uint32_t age)
 {
-  ((coap_packet_t *)packet)->max_age = age;
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_MAX_AGE);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
+  coap_pkt->max_age = age;
+  SET_OPTION(coap_pkt, COAP_OPTION_MAX_AGE);
   return 1;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_etag(void *packet, const uint8_t **etag)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *etag = ((coap_packet_t *)packet)->etag;
-  return ((coap_packet_t *)packet)->etag_len;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_ETAG)) return 0;
+
+  *etag = coap_pkt->etag;
+  return coap_pkt->etag_len;
 }
 
 int
 coap_set_header_etag(void *packet, const uint8_t *etag, size_t etag_len)
 {
-  ((coap_packet_t *)packet)->etag_len = MIN(COAP_ETAG_LEN, etag_len);
-  memcpy(((coap_packet_t *)packet)->etag, etag, ((coap_packet_t *)packet)->etag_len);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_ETAG);
-  return ((coap_packet_t *)packet)->etag_len;
+  coap_pkt->etag_len = MIN(COAP_ETAG_LEN, etag_len);
+  memcpy(coap_pkt->etag, etag, coap_pkt->etag_len);
+
+  SET_OPTION(coap_pkt, COAP_OPTION_ETAG);
+  return coap_pkt->etag_len;
 }
 /*-----------------------------------------------------------------------------------*/
 /*FIXME support multiple ETags */
 int
 coap_get_header_if_match(void *packet, const uint8_t **etag)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_MATCH)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *etag = ((coap_packet_t *)packet)->if_match;
-  return ((coap_packet_t *)packet)->if_match_len;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_IF_MATCH)) return 0;
+
+  *etag = coap_pkt->if_match;
+  return coap_pkt->if_match_len;
 }
 
 int
 coap_set_header_if_match(void *packet, const uint8_t *etag, size_t etag_len)
 {
-  ((coap_packet_t *)packet)->if_match_len = MIN(COAP_ETAG_LEN, etag_len);
-  memcpy(((coap_packet_t *)packet)->if_match, etag, ((coap_packet_t *)packet)->if_match_len);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_IF_MATCH);
-  return ((coap_packet_t *)packet)->if_match_len;
+  coap_pkt->if_match_len = MIN(COAP_ETAG_LEN, etag_len);
+  memcpy(coap_pkt->if_match, etag, coap_pkt->if_match_len);
+
+  SET_OPTION(coap_pkt, COAP_OPTION_IF_MATCH);
+  return coap_pkt->if_match_len;
 }
 /*-----------------------------------------------------------------------------------*/
 int
@@ -853,114 +890,138 @@ coap_set_header_if_none_match(void *packet)
 int
 coap_get_header_token(void *packet, const uint8_t **token)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *token = ((coap_packet_t *)packet)->token;
-  return ((coap_packet_t *)packet)->token_len;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_TOKEN)) return 0;
+
+  *token = coap_pkt->token;
+  return coap_pkt->token_len;
 }
 
 int
 coap_set_header_token(void *packet, const uint8_t *token, size_t token_len)
 {
-  ((coap_packet_t *)packet)->token_len = MIN(COAP_TOKEN_LEN, token_len);
-  memcpy(((coap_packet_t *)packet)->token, token, ((coap_packet_t *)packet)->token_len);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_TOKEN);
-  return ((coap_packet_t *)packet)->token_len;
+  coap_pkt->token_len = MIN(COAP_TOKEN_LEN, token_len);
+  memcpy(coap_pkt->token, token, coap_pkt->token_len);
+
+  SET_OPTION(coap_pkt, COAP_OPTION_TOKEN);
+  return coap_pkt->token_len;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_proxy_uri(void *packet, const char **uri)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_PROXY_URI)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *uri = ((coap_packet_t *)packet)->proxy_uri;
-  return ((coap_packet_t *)packet)->proxy_uri_len;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_PROXY_URI)) return 0;
+
+  *uri = coap_pkt->proxy_uri;
+  return coap_pkt->proxy_uri_len;
 }
 
 int
 coap_set_header_proxy_uri(void *packet, const char *uri)
 {
-  ((coap_packet_t *)packet)->proxy_uri = uri;
-  ((coap_packet_t *)packet)->proxy_uri_len = strlen(uri);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_PROXY_URI);
-  return ((coap_packet_t *)packet)->proxy_uri_len;
+  coap_pkt->proxy_uri = uri;
+  coap_pkt->proxy_uri_len = strlen(uri);
+
+  SET_OPTION(coap_pkt, COAP_OPTION_PROXY_URI);
+  return coap_pkt->proxy_uri_len;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_uri_host(void *packet, const char **host)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *host = ((coap_packet_t *)packet)->uri_host;
-  return ((coap_packet_t *)packet)->uri_host_len;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_URI_HOST)) return 0;
+
+  *host = coap_pkt->uri_host;
+  return coap_pkt->uri_host_len;
 }
 
 int
 coap_set_header_uri_host(void *packet, const char *host)
 {
-  ((coap_packet_t *)packet)->uri_host = host;
-  ((coap_packet_t *)packet)->uri_host_len = strlen(host);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_HOST);
-  return ((coap_packet_t *)packet)->uri_host_len;
+  coap_pkt->uri_host = host;
+  coap_pkt->uri_host_len = strlen(host);
+
+  SET_OPTION(coap_pkt, COAP_OPTION_URI_HOST);
+  return coap_pkt->uri_host_len;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_uri_path(void *packet, const char **path)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *path = ((coap_packet_t *)packet)->uri_path;
-  return ((coap_packet_t *)packet)->uri_path_len;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_URI_PATH)) return 0;
+
+  *path = coap_pkt->uri_path;
+  return coap_pkt->uri_path_len;
 }
 
 int
 coap_set_header_uri_path(void *packet, const char *path)
 {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
   while (path[0]=='/') ++path;
 
-  ((coap_packet_t *)packet)->uri_path = path;
-  ((coap_packet_t *)packet)->uri_path_len = strlen(path);
+  coap_pkt->uri_path = path;
+  coap_pkt->uri_path_len = strlen(path);
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_PATH);
-  return ((coap_packet_t *)packet)->uri_path_len;
+  SET_OPTION(coap_pkt, COAP_OPTION_URI_PATH);
+  return coap_pkt->uri_path_len;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_uri_query(void *packet, const char **query)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *query = ((coap_packet_t *)packet)->uri_query;
-  return ((coap_packet_t *)packet)->uri_query_len;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_URI_QUERY)) return 0;
+
+  *query = coap_pkt->uri_query;
+  return coap_pkt->uri_query_len;
 }
 
 int
 coap_set_header_uri_query(void *packet, const char *query)
 {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
   while (query[0]=='?') ++query;
 
-  ((coap_packet_t *)packet)->uri_query = query;
-  ((coap_packet_t *)packet)->uri_query_len = strlen(query);
+  coap_pkt->uri_query = query;
+  coap_pkt->uri_query_len = strlen(query);
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_URI_QUERY);
-  return ((coap_packet_t *)packet)->uri_query_len;
+  SET_OPTION(coap_pkt, COAP_OPTION_URI_QUERY);
+  return coap_pkt->uri_query_len;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_location_path(void *packet, const char **path)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *path = ((coap_packet_t *)packet)->location_path;
-  return ((coap_packet_t *)packet)->location_path_len;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_LOCATION_PATH)) return 0;
+
+  *path = coap_pkt->location_path;
+  return coap_pkt->location_path_len;
 }
 
 int
 coap_set_header_location_path(void *packet, const char *path)
 {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
   char *query;
 
   while (path[0]=='/') ++path;
@@ -968,67 +1029,77 @@ coap_set_header_location_path(void *packet, const char *path)
   if ((query = strchr(path, '?')))
   {
     coap_set_header_location_query(packet, query+1);
-    ((coap_packet_t *)packet)->location_path_len = query - path;
+    coap_pkt->location_path_len = query - path;
   }
   else
   {
-    ((coap_packet_t *)packet)->location_path_len = strlen(path);
+    coap_pkt->location_path_len = strlen(path);
   }
 
-  ((coap_packet_t *)packet)->location_path = path;
+  coap_pkt->location_path = path;
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_PATH);
-  return ((coap_packet_t *)packet)->location_path_len;
+  SET_OPTION(coap_pkt, COAP_OPTION_LOCATION_PATH);
+  return coap_pkt->location_path_len;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_location_query(void *packet, const char **query)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_QUERY)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *query = ((coap_packet_t *)packet)->location_query;
-  return ((coap_packet_t *)packet)->location_query_len;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_LOCATION_QUERY)) return 0;
+
+  *query = coap_pkt->location_query;
+  return coap_pkt->location_query_len;
 }
 
 int
 coap_set_header_location_query(void *packet, const char *query)
 {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
   while (query[0]=='?') ++query;
 
-  ((coap_packet_t *)packet)->location_query = query;
-  ((coap_packet_t *)packet)->location_query_len = strlen(query);
+  coap_pkt->location_query = query;
+  coap_pkt->location_query_len = strlen(query);
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_LOCATION_QUERY);
-  return ((coap_packet_t *)packet)->location_query_len;
+  SET_OPTION(coap_pkt, COAP_OPTION_LOCATION_QUERY);
+  return coap_pkt->location_query_len;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_observe(void *packet, uint32_t *observe)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
 
-  *observe = ((coap_packet_t *)packet)->observe;
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_OBSERVE)) return 0;
+
+  *observe = coap_pkt->observe;
   return 1;
 }
 
 int
 coap_set_header_observe(void *packet, uint32_t observe)
 {
-  ((coap_packet_t *)packet)->observe = observe;
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_OBSERVE);
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
+  coap_pkt->observe = observe;
+  SET_OPTION(coap_pkt, COAP_OPTION_OBSERVE);
   return 1;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_block2(void *packet, uint32_t *num, uint8_t *more, uint16_t *size, uint32_t *offset)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK2)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_BLOCK2)) return 0;
 
   /* pointers may be NULL to get only specific block parameters */
-  if (num!=NULL) *num = ((coap_packet_t *)packet)->block2_num;
-  if (more!=NULL) *more = ((coap_packet_t *)packet)->block2_more;
-  if (size!=NULL) *size = ((coap_packet_t *)packet)->block2_size;
-  if (offset!=NULL) *offset = ((coap_packet_t *)packet)->block2_offset;
+  if (num!=NULL) *num = coap_pkt->block2_num;
+  if (more!=NULL) *more = coap_pkt->block2_more;
+  if (size!=NULL) *size = coap_pkt->block2_size;
+  if (offset!=NULL) *offset = coap_pkt->block2_offset;
 
   return 1;
 }
@@ -1036,28 +1107,32 @@ coap_get_header_block2(void *packet, uint32_t *num, uint8_t *more, uint16_t *siz
 int
 coap_set_header_block2(void *packet, uint32_t num, uint8_t more, uint16_t size)
 {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
   if (size<16) return 0;
   if (size>2048) return 0;
   if (num>0x0FFFFF) return 0;
 
-  ((coap_packet_t *)packet)->block2_num = num;
-  ((coap_packet_t *)packet)->block2_more = more ? 1 : 0;
-  ((coap_packet_t *)packet)->block2_size = size;
+  coap_pkt->block2_num = num;
+  coap_pkt->block2_more = more ? 1 : 0;
+  coap_pkt->block2_size = size;
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK2);
+  SET_OPTION(coap_pkt, COAP_OPTION_BLOCK2);
   return 1;
 }
 /*-----------------------------------------------------------------------------------*/
 int
 coap_get_header_block1(void *packet, uint32_t *num, uint8_t *more, uint16_t *size, uint32_t *offset)
 {
-  if (!IS_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK1)) return 0;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
+  if (!IS_OPTION(coap_pkt, COAP_OPTION_BLOCK1)) return 0;
 
   /* pointers may be NULL to get only specific block parameters */
-  if (num!=NULL) *num = ((coap_packet_t *)packet)->block1_num;
-  if (more!=NULL) *more = ((coap_packet_t *)packet)->block1_more;
-  if (size!=NULL) *size = ((coap_packet_t *)packet)->block1_size;
-  if (offset!=NULL) *offset = ((coap_packet_t *)packet)->block1_offset;
+  if (num!=NULL) *num = coap_pkt->block1_num;
+  if (more!=NULL) *more = coap_pkt->block1_more;
+  if (size!=NULL) *size = coap_pkt->block1_size;
+  if (offset!=NULL) *offset = coap_pkt->block1_offset;
 
   return 1;
 }
@@ -1065,26 +1140,30 @@ coap_get_header_block1(void *packet, uint32_t *num, uint8_t *more, uint16_t *siz
 int
 coap_set_header_block1(void *packet, uint32_t num, uint8_t more, uint16_t size)
 {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
   if (size<16) return 0;
   if (size>2048) return 0;
   if (num>0x0FFFFF) return 0;
 
-  ((coap_packet_t *)packet)->block1_num = num;
-  ((coap_packet_t *)packet)->block1_more = more;
-  ((coap_packet_t *)packet)->block1_size = size;
+  coap_pkt->block1_num = num;
+  coap_pkt->block1_more = more;
+  coap_pkt->block1_size = size;
 
-  SET_OPTION((coap_packet_t *)packet, COAP_OPTION_BLOCK1);
+  SET_OPTION(coap_pkt, COAP_OPTION_BLOCK1);
   return 1;
 }
 /*-----------------------------------------------------------------------------------*/
 /*- PAYLOAD -------------------------------------------------------------------------*/
 /*-----------------------------------------------------------------------------------*/
 int
-coap_get_payload(void *packet, const uint8_t **payload)
+coap_get_payload(void *packet, uint8_t **payload)
 {
-  if (((coap_packet_t *)packet)->payload) {
-    *payload = ((coap_packet_t *)packet)->payload;
-    return ((coap_packet_t *)packet)->payload_len;
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
+  if (coap_pkt->payload) {
+    *payload = coap_pkt->payload;
+    return coap_pkt->payload_len;
   } else {
     *payload = NULL;
     return 0;
@@ -1092,13 +1171,15 @@ coap_get_payload(void *packet, const uint8_t **payload)
 }
 
 int
-coap_set_payload(void *packet, uint8_t *payload, size_t length)
+coap_set_payload(void *packet, const void *payload, size_t length)
 {
+  coap_packet_t *const coap_pkt = (coap_packet_t *) packet;
+
   PRINTF("setting payload (%u/%u)\n", length, REST_MAX_CHUNK_SIZE);
 
-  ((coap_packet_t *)packet)->payload = payload;
-  ((coap_packet_t *)packet)->payload_len = MIN(REST_MAX_CHUNK_SIZE, length);
+  coap_pkt->payload = (uint8_t *) payload;
+  coap_pkt->payload_len = MIN(REST_MAX_CHUNK_SIZE, length);
 
-  return ((coap_packet_t *)packet)->payload_len;
+  return coap_pkt->payload_len;
 }
 /*-----------------------------------------------------------------------------------*/
diff --git a/apps/er-coap-07/er-coap-07.h b/apps/er-coap-07/er-coap-07.h
index f7f622404..d7aead6d5 100644
--- a/apps/er-coap-07/er-coap-07.h
+++ b/apps/er-coap-07/er-coap-07.h
@@ -313,7 +313,7 @@ int coap_set_header_block2(void *packet, uint32_t num, uint8_t more, uint16_t si
 int coap_get_header_block1(void *packet, uint32_t *num, uint8_t *more, uint16_t *size, uint32_t *offset);
 int coap_set_header_block1(void *packet, uint32_t num, uint8_t more, uint16_t size);
 
-int coap_get_payload(void *packet, const uint8_t **payload);
-int coap_set_payload(void *packet, uint8_t *payload, size_t length);
+int coap_get_payload(void *packet, uint8_t **payload);
+int coap_set_payload(void *packet, const void *payload, size_t length);
 
 #endif /* COAP_07_H_ */
diff --git a/apps/erbium/erbium.h b/apps/erbium/erbium.h
index 2ab637e3e..f550deeed 100644
--- a/apps/erbium/erbium.h
+++ b/apps/erbium/erbium.h
@@ -184,10 +184,10 @@ struct rest_implementation {
   int (* set_header_location)(void *response, const char *location);
 
   /** Get the payload option of a request. */
-  int (* get_request_payload)(void *request, const uint8_t **payload);
+  int (* get_request_payload)(void *request, uint8_t **payload);
 
   /** Set the payload option of a response. */
-  int (* set_response_payload)(void *response, uint8_t *payload, size_t length);
+  int (* set_response_payload)(void *response, const void *payload, size_t length);
 
   /** Get the query string of a request. */
   int (* get_query)(void *request, const char **value);
diff --git a/examples/er-rest-example/README b/examples/er-rest-example/README
index 3642a1b05..df390ce83 100644
--- a/examples/er-rest-example/README
+++ b/examples/er-rest-example/README
@@ -59,7 +59,7 @@ DETAILS
 The Erbium CoAP currently implements draft 08.
 Central features are commented in rest-server-example.c.
 In general, apps/er-coap-07 supports:
-* All CoAP-07 header options
+* All draft 08 header options
 * CON Retransmissions (note COAP_MAX_OPEN_TRANSACTIONS)
 * Blockwise Transfers (note REST_MAX_CHUNK_SIZE)
 * Separate Responses (see rest_set_pre_handler() and coap_separate_handler())
@@ -73,6 +73,7 @@ The Makefile uses WITH_COAP to configure different implementations for the Erbiu
   The default port for coap-07 is 5683.
 * WITH_COAP=3 uses Erbium CoAP 03 apps/er-coap-03/.
   The default port for coap-03 is 61616.
+  er-coap-03 produces some warnings, as it not fully maintained anymore.
 * WITH_COAP=0 is a stub to link an Erbium HTTP engine that uses the same resource abstraction (REST.x() functions and RESOURCE macros. 
 
 TODOs
diff --git a/examples/er-rest-example/coap-client-example.c b/examples/er-rest-example/coap-client-example.c
index 1bd5f1fac..c67840306 100644
--- a/examples/er-rest-example/coap-client-example.c
+++ b/examples/er-rest-example/coap-client-example.c
@@ -99,7 +99,7 @@ static int uri_switch = 0;
 void
 client_chunk_handler(void *response)
 {
-  const uint8_t *chunk;
+  uint8_t *chunk;
   int len = coap_get_payload(response, &chunk);
   printf("|%.*s", len, (char *)chunk);
 }
@@ -128,16 +128,13 @@ PROCESS_THREAD(coap_client_example, ev, data)
     if (etimer_expired(&et)) {
       printf("--Toggle timer--\n");
 
-#if PLATFORM_HAS_LEDS
       /* prepare request, TID is set by COAP_BLOCKING_REQUEST() */
       coap_init_message(request, COAP_TYPE_CON, COAP_POST, 0 );
       coap_set_header_uri_path(request, service_urls[1]);
-      coap_set_payload(request, (uint8_t *)"Toggle!", 8);
-#else
-      /* prepare request, TID is set by COAP_BLOCKING_REQUEST() */
-      coap_init_message(request, COAP_TYPE_CON, COAP_GET, 0 );
-      coap_set_header_uri_path(request, "hello");
-#endif
+
+      const char msg[] = "Toggle!";
+      coap_set_payload(request, (uint8_t *)msg, sizeof(msg)-1);
+
 
       PRINT6ADDR(&server_ipaddr);
       PRINTF(" : %u\n", UIP_HTONS(REMOTE_PORT));
diff --git a/examples/er-rest-example/rest-server-example.c b/examples/er-rest-example/rest-server-example.c
index a1b334a5c..f36209ba2 100644
--- a/examples/er-rest-example/rest-server-example.c
+++ b/examples/er-rest-example/rest-server-example.c
@@ -158,7 +158,7 @@ mirror_handler(void* request, void* response, uint8_t *buffer, uint16_t preferre
 
   /* The other getters copy the value (or string/array pointer) to the given pointers and return 1 for success or the length of strings/arrays. */
   uint32_t max_age = 0;
-  const char *str = "";
+  const char *str = NULL;
   uint32_t observe = 0;
   const uint8_t *bytes = NULL;
   uint32_t block_num = 0;
@@ -312,7 +312,9 @@ chunks_handler(void* request, void* response, uint8_t *buffer, uint16_t preferre
   {
     REST.set_response_status(response, REST.status.BAD_OPTION);
     /* A block error message should not exceed the minimum block size (16). */
-    REST.set_response_payload(response, (uint8_t*)"BlockOutOfScope", 15);
+
+    const char error_msg[] = "BlockOutOfScope";
+    REST.set_response_payload(response, (uint8_t *)error_msg, sizeof(error_msg)-1);
     return;
   }
 
@@ -359,7 +361,10 @@ void
 polling_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
 {
   REST.set_header_content_type(response, REST.type.TEXT_PLAIN);
-  REST.set_response_payload(response, (uint8_t *)"It's periodic!", 14);
+
+  /* Usually, a CoAP server would response with the current resource representation. */
+  const char msg[] = "It's periodic!";
+  REST.set_response_payload(response, (uint8_t *)msg, sizeof(msg)-1);
 
   /* A post_handler that handles subscriptions will be called for periodic resources by the REST framework. */
 }
@@ -397,7 +402,10 @@ void
 event_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
 {
   REST.set_header_content_type(response, REST.type.TEXT_PLAIN);
-  REST.set_response_payload(response, (uint8_t *)"It's eventful!", 14);
+
+  /* Usually, a CoAP server would response with the current resource representation. */
+  const char msg[] = "It's eventful!";
+  REST.set_response_payload(response, (uint8_t *)msg, sizeof(msg)-1);
 
   /* A post_handler that handles subscriptions/observing will be called for periodic resources by the framework. */
 }
@@ -519,7 +527,8 @@ light_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred
   else
   {
     REST.set_response_status(response, REST.status.UNSUPPORTED_MADIA_TYPE);
-    REST.set_response_payload(response, (uint8_t *)"Supporting content-types text/plain, application/xml, and application/json", 74);
+    const char msg[] = "Supporting content-types text/plain, application/xml, and application/json";
+    REST.set_response_payload(response, (uint8_t *)msg, sizeof(msg)-1);
   }
 }
 #endif /* PLATFORM_HAS_LIGHT */
@@ -552,7 +561,8 @@ battery_handler(void* request, void* response, uint8_t *buffer, uint16_t preferr
   else
   {
     REST.set_response_status(response, REST.status.UNSUPPORTED_MADIA_TYPE);
-    REST.set_response_payload(response, (uint8_t *)"Supporting content-types text/plain and application/json", 56);
+    const char msg[] = "Supporting content-types text/plain and application/json";
+    REST.set_response_payload(response, (uint8_t *)msg, sizeof(msg)-1);
   }
 }
 #endif /* PLATFORM_HAS_BATTERY */