Merge pull request #629 from gcampbell512/endian-fix

Fix big endian issues writing and reading .LYB files

Author: michalvasko

src/parser_lyb.c

@@ -17,6 +17,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <inttypes.h>
+#include <endian.h>
 
 #include "libyang.h"
 #include "common.h"
@@ -32,7 +33,7 @@ lyb_read(const char *data, uint8_t *buf, size_t count, struct lyb_state *lybs)
 {
     int ret = 0, i, empty_chunk_i;
     size_t to_read;
-    LYB_META meta;
+    uint8_t meta_buf[LYB_META_BYTES];
 
     assert(data && lybs);
 
@@ -76,12 +77,9 @@ lyb_read(const char *data, uint8_t *buf, size_t count, struct lyb_state *lybs)
 
         if (empty_chunk_i > -1) {
             /* read the next chunk meta information */
-            memcpy(&meta, data + ret, LYB_META_BYTES);
-            lybs->written[empty_chunk_i] = 0;
-            lybs->inner_chunks[empty_chunk_i] = 0;
-
-            memcpy(&lybs->written[empty_chunk_i], &meta, LYB_SIZE_BYTES);
-            memcpy(&lybs->inner_chunks[empty_chunk_i], ((uint8_t *)&meta) + LYB_SIZE_BYTES, LYB_INCHUNK_BYTES);
+            memcpy(meta_buf, data + ret, LYB_META_BYTES);
+            lybs->written[empty_chunk_i] = meta_buf[0];
+            lybs->inner_chunks[empty_chunk_i] = meta_buf[1];
 
             /* remember whether there is a following chunk or not */
             lybs->position[empty_chunk_i] = (lybs->written[empty_chunk_i] == LYB_SIZE_MAX ? 1 : 0);
@@ -113,7 +111,9 @@ lyb_read_number(uint64_t *num, size_t bytes, const char *data, struct lyb_state
 static int
 lyb_read_enum(uint64_t *enum_idx, uint32_t count, const char *data, struct lyb_state *lybs)
 {
+    int ret = 0;
     size_t bytes;
+    uint64_t tmp_enum = 0;
 
     if (count < (2 << 8)) {
         bytes = 1;
@@ -125,18 +125,24 @@ lyb_read_enum(uint64_t *enum_idx, uint32_t count, const char *data, struct lyb_s
         bytes = 4;
     }
 
-    return lyb_read_number(enum_idx, bytes, data, lybs);
+    /* The enum is always read into a uint64_t buffer */
+    ret = lyb_read_number(&tmp_enum, bytes, data, lybs);
+    *enum_idx = le64toh(tmp_enum);
+
+    return ret;
 }
 
 static int
 lyb_read_string(const char *data, char **str, int with_length, struct lyb_state *lybs)
 {
     int next_chunk = 0, r, ret = 0;
     size_t len = 0, cur_len;
+    uint8_t len_buf[2];
 
     if (with_length) {
-        ret += (r = lyb_read(data, (uint8_t *)&len, 2, lybs));
+        ret += (r = lyb_read(data, len_buf, 2, lybs));
         LYB_HAVE_READ_GOTO(r, data, error);
+        len = len_buf[0] | (len_buf[1] << 8);
     } else {
         /* read until the end of this subtree */
         len = lybs->written[lybs->used - 1];
@@ -190,7 +196,7 @@ lyb_read_stop_subtree(struct lyb_state *lybs)
 static int
 lyb_read_start_subtree(const char *data, struct lyb_state *lybs)
 {
-    LYB_META meta;
+    uint8_t meta_buf[LYB_META_BYTES];
 
     if (lybs->used == lybs->size) {
         lybs->size += LYB_STATE_STEP;
@@ -200,14 +206,11 @@ lyb_read_start_subtree(const char *data, struct lyb_state *lybs)
         LY_CHECK_ERR_RETURN(!lybs->written || !lybs->position || !lybs->inner_chunks, LOGMEM(NULL), -1);
     }
 
-    memcpy(&meta, data, LYB_META_BYTES);
+    memcpy(meta_buf, data, LYB_META_BYTES);
 
     ++lybs->used;
-    lybs->written[lybs->used - 1] = 0;
-    lybs->inner_chunks[lybs->used - 1] = 0;
-
-    memcpy(&lybs->written[lybs->used - 1], &meta, LYB_SIZE_BYTES);
-    memcpy(&lybs->inner_chunks[lybs->used - 1], ((uint8_t *)&meta) + LYB_SIZE_BYTES, LYB_INCHUNK_BYTES);
+    lybs->written[lybs->used - 1] = meta_buf[0];
+    lybs->inner_chunks[lybs->used - 1] = meta_buf[LYB_SIZE_BYTES];
     lybs->position[lybs->used - 1] = (lybs->written[lybs->used - 1] == LYB_SIZE_MAX ? 1 : 0);
 
     return LYB_META_BYTES;
@@ -219,14 +222,16 @@ lyb_parse_model(struct ly_ctx *ctx, const char *data, const struct lys_module **
     int r, ret = 0;
     char *mod_name = NULL, mod_rev[11];
     uint16_t rev = 0;
+    uint8_t tmp_buf[2];
 
     /* model name */
     ret += (r = lyb_read_string(data, &mod_name, 1, lybs));
     LYB_HAVE_READ_GOTO(r, data, error);
 
     /* revision */
-    ret += (r = lyb_read(data, (uint8_t *)&rev, sizeof rev, lybs));
+    ret += (r = lyb_read(data, tmp_buf, sizeof tmp_buf, lybs));
     LYB_HAVE_READ_GOTO(r, data, error);
+    rev = tmp_buf[0] | (tmp_buf[1] << 8);
 
     if (rev) {
         sprintf(mod_rev, "%04u-%02u-%02u", ((rev & 0xFE00) >> 9) + 2000, (rev & 0x01E0) >> 5, (rev & 0x001F));
@@ -430,15 +435,18 @@ lyb_parse_val_1(struct ly_ctx *ctx, struct lys_type *type, LY_DATA_TYPE value_ty
     case LY_TYPE_INT16:
     case LY_TYPE_UINT16:
         ret = lyb_read_number((uint64_t *)&value->uint16, 2, data, lybs);
+        value->uint16 = le16toh(value->uint16);
         break;
     case LY_TYPE_INT32:
     case LY_TYPE_UINT32:
         ret = lyb_read_number((uint64_t *)&value->uint32, 4, data, lybs);
+        value->uint32 = le32toh(value->uint32);
         break;
     case LY_TYPE_DEC64:
     case LY_TYPE_INT64:
     case LY_TYPE_UINT64:
         ret = lyb_read_number((uint64_t *)&value->uint64, 8, data, lybs);
+        value->uint64 = le64toh(value->uint64);
         break;
     default:
         return -1;
@@ -1101,10 +1109,12 @@ static int
 lyb_parse_data_models(struct ly_ctx *ctx, const char *data, struct lyb_state *lybs)
 {
     int i, r, ret = 0;
+    uint8_t mod_count_buf[2];
 
     /* read model count */
-    ret += (r = lyb_read(data, (uint8_t *)&lybs->mod_count, 2, lybs));
+    ret += (r = lyb_read(data, mod_count_buf, 2, lybs));
     LYB_HAVE_READ_RETURN(r, data, -1);
+    lybs->mod_count = mod_count_buf[0] | (mod_count_buf[1] << 8);
 
     lybs->models = malloc(lybs->mod_count * sizeof *lybs->models);
     LY_CHECK_ERR_RETURN(!lybs->models, LOGMEM(NULL), -1);

src/printer_lyb.c

@@ -18,6 +18,7 @@
 #include <string.h>
 #include <assert.h>
 #include <stdint.h>
+#include <endian.h>
 
 #include "common.h"
 #include "printer.h"
@@ -323,7 +324,7 @@ lyb_write(struct lyout *out, const uint8_t *buf, size_t count, struct lyb_state
 {
     int ret, i, full_chunk_i;
     size_t r, to_write;
-    LYB_META meta;
+    uint8_t meta_buf[LYB_META_BYTES];
 
     assert(out && lybs);
 
@@ -359,10 +360,10 @@ lyb_write(struct lyout *out, const uint8_t *buf, size_t count, struct lyb_state
 
         if (full_chunk_i > -1) {
             /* write the meta information (inner chunk count and chunk size) */
-            memcpy(&meta, &lybs->written[full_chunk_i], LYB_SIZE_BYTES);
-            memcpy(((uint8_t *)&meta) + LYB_SIZE_BYTES, &lybs->inner_chunks[full_chunk_i], LYB_INCHUNK_BYTES);
+            meta_buf[0] = lybs->written[full_chunk_i] & 0xFF;
+            meta_buf[1] = lybs->inner_chunks[full_chunk_i] & 0xFF;
 
-            r = ly_write_skipped(out, lybs->position[full_chunk_i], (char *)&meta, LYB_META_BYTES);
+            r = ly_write_skipped(out, lybs->position[full_chunk_i], (char *)meta_buf, LYB_META_BYTES);
             if (r < LYB_META_BYTES) {
                 return -1;
             }
@@ -397,13 +398,13 @@ static int
 lyb_write_stop_subtree(struct lyout *out, struct lyb_state *lybs)
 {
     int r;
-    LYB_META meta;
+    uint8_t meta_buf[LYB_META_BYTES];
 
     /* write the meta chunk information */
-    memcpy(&meta, &lybs->written[lybs->used - 1], LYB_SIZE_BYTES);
-    memcpy(((uint8_t *)&meta) + LYB_SIZE_BYTES, &lybs->inner_chunks[lybs->used - 1], LYB_INCHUNK_BYTES);
+    meta_buf[0] = lybs->written[lybs->used - 1] & 0xFF;
+    meta_buf[1] = lybs->inner_chunks[lybs->used - 1] & 0xFF;
 
-    r = ly_write_skipped(out, lybs->position[lybs->used - 1], (char *)&meta, LYB_META_BYTES);
+    r = ly_write_skipped(out, lybs->position[lybs->used - 1], (char *)&meta_buf, LYB_META_BYTES);
     if (r < LYB_META_BYTES) {
         return -1;
     }
@@ -448,9 +449,13 @@ lyb_write_number(uint64_t num, size_t bytes, struct lyout *out, struct lyb_state
     size_t i;
     uint8_t byte;
 
+    num = htole64(num);
     for (i = 0; i < bytes; ++i) {
         byte = *(((uint8_t *)&num) + i);
         ret += lyb_write(out, &byte, 1, lybs);
+        if (ret < 0) {
+            break;
+        }
     }
 
     return ret;
@@ -489,7 +494,7 @@ lyb_write_string(const char *str, size_t str_len, int with_length, struct lyout
 
     if (with_length) {
         /* print length on 2 bytes */
-        ret += (r = lyb_write(out, (uint8_t *)&str_len, 2, lybs));
+        ret += (r = lyb_write_number(str_len, 2, out, lybs));
         if (r < 0) {
             return -1;
         }
@@ -534,8 +539,7 @@ lyb_print_model(struct lyout *out, const struct lys_module *mod, struct lyb_stat
 
         revision |= r;
     }
-
-    ret += (r = lyb_write(out, (uint8_t *)&revision, sizeof revision, lybs));
+    ret += (r = lyb_write_number(revision, sizeof revision, out, lybs));
     if (r < 0) {
         return -1;
     }
@@ -625,7 +629,7 @@ lyb_print_data_models(struct lyout *out, const struct lyd_node *root, struct lyb
     }
 
     /* now write module count on 2 bytes */
-    ret += lyb_write(out, (uint8_t *)&mod_count, 2, lybs);
+    ret += lyb_write_number(mod_count, 2, out, lybs);
 
     /* and all the used models */
     for (i = 0; i < mod_count; ++i) {

src/tree_data.c

@@ -7335,6 +7335,7 @@ lyd_lyb_data_length(const char *data)
 {
     const char *ptr;
     uint16_t i, mod_count, str_len;
+    uint8_t tmp_buf[2];
     LYB_META meta;
 
     if (!data) {
@@ -7353,13 +7354,15 @@ lyd_lyb_data_length(const char *data)
     ++ptr;
 
     /* models */
-    memcpy(&mod_count, ptr, 2);
+    memcpy(tmp_buf, ptr, 2);
     ptr += 2;
+    mod_count = tmp_buf[0] | (tmp_buf[1] << 8);
 
     for (i = 0; i < mod_count; ++i) {
         /* model name */
-        memcpy(&str_len, ptr, 2);
+        memcpy(tmp_buf, ptr, 2);
         ptr += 2;
+        str_len = tmp_buf[0] | (tmp_buf[1] << 8);
 
         ptr += str_len;