Index: uspace/lib/bithenge/src/blob.c
===================================================================
--- uspace/lib/bithenge/src/blob.c	(revision 44ecf894e75e499c21daf2e1b5fbc588301e35e5)
+++ uspace/lib/bithenge/src/blob.c	(revision b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -49,5 +49,5 @@
  * @return EOK on success or an error code from errno.h.
  */
-int bithenge_init_random_access_blob(bithenge_blob_t *blob,
+errno_t bithenge_init_random_access_blob(bithenge_blob_t *blob,
     const bithenge_random_access_blob_ops_t *ops)
 {
@@ -67,5 +67,5 @@
 }
 
-static int sequential_buffer(bithenge_sequential_blob_t *blob, aoff64_t end)
+static errno_t sequential_buffer(bithenge_sequential_blob_t *blob, aoff64_t end)
 {
 	bool need_realloc = false;
@@ -81,5 +81,5 @@
 	}
 	aoff64_t size = end - blob->data_size;
-	int rc = blob->ops->read(blob, blob->buffer + blob->data_size, &size);
+	errno_t rc = blob->ops->read(blob, blob->buffer + blob->data_size, &size);
 	if (rc != EOK)
 		return rc;
@@ -100,8 +100,8 @@
 }
 
-static int sequential_size(bithenge_blob_t *base, aoff64_t *size)
+static errno_t sequential_size(bithenge_blob_t *base, aoff64_t *size)
 {
 	bithenge_sequential_blob_t *blob = blob_as_sequential(base);
-	int rc;
+	errno_t rc;
 	if (blob->ops->size) {
 		rc = blob->ops->size(blob, size);
@@ -121,5 +121,5 @@
 }
 
-static int sequential_read(bithenge_blob_t *base, aoff64_t offset,
+static errno_t sequential_read(bithenge_blob_t *base, aoff64_t offset,
     char *buffer, aoff64_t *size)
 {
@@ -127,5 +127,5 @@
 	aoff64_t end = offset + *size;
 	if (end > blob->data_size) {
-		int rc = sequential_buffer(blob, end);
+		errno_t rc = sequential_buffer(blob, end);
 		if (rc != EOK)
 			return rc;
@@ -158,5 +158,5 @@
  * @return EOK on success or an error code from errno.h.
  */
-int bithenge_init_sequential_blob(bithenge_sequential_blob_t *blob,
+errno_t bithenge_init_sequential_blob(bithenge_sequential_blob_t *blob,
     const bithenge_sequential_blob_ops_t *ops)
 {
@@ -167,5 +167,5 @@
 	// ops->size is optional
 
-	int rc = bithenge_init_random_access_blob(sequential_as_blob(blob),
+	errno_t rc = bithenge_init_random_access_blob(sequential_as_blob(blob),
 	    &sequential_ops);
 	if (rc != EOK)
@@ -195,5 +195,5 @@
 }
 
-static int memory_size(bithenge_blob_t *base, aoff64_t *size)
+static errno_t memory_size(bithenge_blob_t *base, aoff64_t *size)
 {
 	memory_blob_t *blob = blob_as_memory(base);
@@ -204,5 +204,5 @@
 }
 
-static int memory_read(bithenge_blob_t *base, aoff64_t offset, char *buffer,
+static errno_t memory_read(bithenge_blob_t *base, aoff64_t offset, char *buffer,
     aoff64_t *size)
 {
@@ -240,8 +240,8 @@
  * function fails or the blob is destroyed.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_blob_from_buffer(bithenge_node_t **out, const void *buffer,
+errno_t bithenge_new_blob_from_buffer(bithenge_node_t **out, const void *buffer,
     size_t len, bool needs_free)
 {
-	int rc;
+	errno_t rc;
 	assert(buffer || !len);
 
@@ -278,5 +278,5 @@
  * @param len The length of the data.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_blob_from_data(bithenge_node_t **out, const void *data,
+errno_t bithenge_new_blob_from_data(bithenge_node_t **out, const void *data,
     size_t len)
 {
@@ -309,5 +309,5 @@
 }
 
-static int subblob_size(bithenge_blob_t *base, aoff64_t *size)
+static errno_t subblob_size(bithenge_blob_t *base, aoff64_t *size)
 {
 	subblob_t *blob = blob_as_subblob(base);
@@ -316,5 +316,5 @@
 		return EOK;
 	} else {
-		int rc = bithenge_blob_size(blob->source, size);
+		errno_t rc = bithenge_blob_size(blob->source, size);
 		*size -= blob->offset;
 		return rc;
@@ -322,5 +322,5 @@
 }
 
-static int subblob_read(bithenge_blob_t *base, aoff64_t offset,
+static errno_t subblob_read(bithenge_blob_t *base, aoff64_t offset,
     char *buffer, aoff64_t *size)
 {
@@ -335,5 +335,5 @@
 }
 
-static int subblob_read_bits(bithenge_blob_t *base, aoff64_t offset,
+static errno_t subblob_read_bits(bithenge_blob_t *base, aoff64_t offset,
     char *buffer, aoff64_t *size, bool little_endian)
 {
@@ -368,10 +368,10 @@
 }
 
-static int new_subblob(bithenge_node_t **out, bithenge_blob_t *source,
+static errno_t new_subblob(bithenge_node_t **out, bithenge_blob_t *source,
     aoff64_t offset, aoff64_t size, bool size_matters)
 {
 	assert(out);
 	assert(source);
-	int rc;
+	errno_t rc;
 	subblob_t *blob = 0;
 
@@ -436,5 +436,5 @@
  * @param offset The offset within the input blob at which the new blob will start.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_offset_blob(bithenge_node_t **out, bithenge_blob_t *source,
+errno_t bithenge_new_offset_blob(bithenge_node_t **out, bithenge_blob_t *source,
     aoff64_t offset)
 {
@@ -449,5 +449,5 @@
  * @param size The size of the new blob.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_new_subblob(bithenge_node_t **out, bithenge_blob_t *source,
+errno_t bithenge_new_subblob(bithenge_node_t **out, bithenge_blob_t *source,
     aoff64_t offset, aoff64_t size)
 {
@@ -461,5 +461,5 @@
  * @return EOK on success, or an error code from errno.h.
  */
-int bithenge_blob_equal(bool *out, bithenge_blob_t *a, bithenge_blob_t *b)
+errno_t bithenge_blob_equal(bool *out, bithenge_blob_t *a, bithenge_blob_t *b)
 {
 	assert(a);
@@ -467,5 +467,5 @@
 	assert(b);
 	assert(b->base.blob_ops);
-	int rc;
+	errno_t rc;
 	char buffer_a[4096], buffer_b[4096];
 	aoff64_t offset = 0, size_a = sizeof(buffer_a), size_b = sizeof(buffer_b);
