read_write_all: avoid arithmetic on void pointers.

[ccan] / ccan / tdb2 / check.c

diff --git a/ccan/tdb2/check.c b/ccan/tdb2/check.c
index b602d80d64777030aeb08fab853b1df9561561d2..577086689f373f75c1774d9be2fd1175180af950 100644 (file)
--- a/ccan/tdb2/check.c
+++ b/ccan/tdb2/check.c
@@ -72,7 +72,8 @@ static enum TDB_ERROR check_header(struct tdb_context *tdb, tdb_off_t *recovery,
        *features = hdr.features_offered;
        *recovery = hdr.recovery;
        if (*recovery) {
-               if (*recovery < sizeof(hdr) || *recovery > tdb->map_size) {
+               if (*recovery < sizeof(hdr)
+                   || *recovery > tdb->file->map_size) {
                        return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
                                          "tdb_check:"
                                          " invalid recovery offset %zu",
@@ -401,22 +402,26 @@ static enum TDB_ERROR check_hash_tree(struct tdb_context *tdb,
                check:
                        if (check) {
                                TDB_DATA key, data;
-                               key.dsize = rec_key_length(&rec);
-                               data.dsize = rec_data_length(&rec);
-                               key.dptr = (void *)tdb_access_read(tdb,
-                                                  off + sizeof(rec),
-                                                  key.dsize + data.dsize,
-                                                  false);
-                               if (TDB_PTR_IS_ERR(key.dptr)) {
-                                       ecode = TDB_PTR_ERR(key.dptr);
+                               const unsigned char *kptr;
+
+                               kptr = tdb_access_read(tdb,
+                                                      off + sizeof(rec),
+                                                      rec_key_length(&rec)
+                                                      + rec_data_length(&rec),
+                                                      false);
+                               if (TDB_PTR_IS_ERR(kptr)) {
+                                       ecode = TDB_PTR_ERR(kptr);
                                        goto fail;
                                }
-                               data.dptr = key.dptr + key.dsize;
+
+                               key = tdb_mkdata(kptr, rec_key_length(&rec));
+                               data = tdb_mkdata(kptr + key.dsize,
+                                                 rec_data_length(&rec));
                                ecode = check(key, data, private_data);
+                               tdb_access_release(tdb, kptr);
                                if (ecode != TDB_SUCCESS) {
                                        goto fail;
                                }
-                               tdb_access_release(tdb, key.dptr);
                        }
                }
        }
@@ -564,7 +569,7 @@ tdb_off_t dead_space(struct tdb_context *tdb, tdb_off_t off)
        size_t len;
        enum TDB_ERROR ecode;
 
-       for (len = 0; off + len < tdb->map_size; len++) {
+       for (len = 0; off + len < tdb->file->map_size; len++) {
                char c;
                ecode = tdb->methods->tread(tdb, off, &c, 1);
                if (ecode != TDB_SUCCESS) {
@@ -586,7 +591,9 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
        enum TDB_ERROR ecode;
        bool found_recovery = false;
 
-       for (off = sizeof(struct tdb_header); off < tdb->map_size; off += len) {
+       for (off = sizeof(struct tdb_header);
+            off < tdb->file->map_size;
+            off += len) {
                union {
                        struct tdb_used_record u;
                        struct tdb_free_record f;
@@ -624,7 +631,7 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
                                tdb_logerr(tdb, TDB_SUCCESS, TDB_LOG_WARNING,
                                           "Dead space at %zu-%zu (of %zu)",
                                           (size_t)off, (size_t)(off + len),
-                                          (size_t)tdb->map_size);
+                                          (size_t)tdb->file->map_size);
                        }
                } else if (rec.r.magic == TDB_RECOVERY_MAGIC) {
                        ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec.r));
@@ -646,7 +653,7 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
                                                  " length %zu",
                                                  (size_t)rec.r.len);
                        }
-                       if (rec.r.eof > tdb->map_size) {
+                       if (rec.r.eof > tdb->file->map_size) {
                                return tdb_logerr(tdb, TDB_ERR_CORRUPT,
                                                  TDB_LOG_ERROR,
                                                  "tdb_check: invalid old EOF"
@@ -656,7 +663,7 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
                        len = sizeof(rec.r) + rec.r.max_len;
                } else if (frec_magic(&rec.f) == TDB_FREE_MAGIC) {
                        len = sizeof(rec.u) + frec_len(&rec.f);
-                       if (off + len > tdb->map_size) {
+                       if (off + len > tdb->file->map_size) {
                                return tdb_logerr(tdb, TDB_ERR_CORRUPT,
                                                  TDB_LOG_ERROR,
                                                  "tdb_check: free overlength"
@@ -691,7 +698,7 @@ static enum TDB_ERROR check_linear(struct tdb_context *tdb,
                        extra = rec_extra_padding(&rec.u);
 
                        len = sizeof(rec.u) + klen + dlen + extra;
-                       if (off + len > tdb->map_size) {
+                       if (off + len > tdb->file->map_size) {
                                return tdb_logerr(tdb, TDB_ERR_CORRUPT,
                                                  TDB_LOG_ERROR,
                                                  "tdb_check: used overlength"
@@ -762,13 +769,13 @@ enum TDB_ERROR tdb_check_(struct tdb_context *tdb,
 
        ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
        if (ecode != TDB_SUCCESS) {
-               return ecode;
+               return tdb->last_error = ecode;
        }
 
        ecode = tdb_lock_expand(tdb, F_RDLCK);
        if (ecode != TDB_SUCCESS) {
                tdb_allrecord_unlock(tdb, F_RDLCK);
-               return ecode;
+               return tdb->last_error = ecode;
        }
 
        ecode = check_header(tdb, &recovery, &features);
@@ -809,5 +816,5 @@ out:
        tdb_unlock_expand(tdb, F_RDLCK);
        free(fr);
        free(used);
-       return ecode;
+       return tdb->last_error = ecode;
 }