1 files changed, 147 insertions, 142 deletions

diff --git a/tbdiff/tbdiff-create.c b/tbdiff/tbdiff-create.c
index ec5a8ce..edfb985 100644
--- a/tbdiff/tbdiff-create.c
+++ b/tbdiff/tbdiff-create.c
@@ -1,5 +1,5 @@
 /*
- *    Copyright (C) 2011-2012 Codethink Ltd.
+ *    Copyright (C) 2011-2014 Codethink Ltd.
  *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License Version 2 as
@@ -33,27 +33,29 @@
 #define PATH_BUFFER_LENGTH 4096
 
 static int
-tbd_create_fwrite_cmd(FILE    *stream,
-                      uint8_t  cmd)
+tbd_create_write_cmd(FILE     *stream,
+                     tbd_cmd_t cmd)
 {
-	if(fwrite(&cmd, 1, 1, stream) != 1)
+	if(fwrite(&cmd, sizeof(tbd_cmd_t), 1, stream) != 1)
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
 static int
-tbd_create_fwrite_string(FILE       *stream,
-                         const char *string)
+tbd_create_write_string(FILE       *stream,
+                        const char *string)
 {
 	uint16_t slen = strlen(string);
-	if((tbd_write_uint16_t(slen, stream) != 1)
+	if((tbd_write_uint16(slen, stream) != 1)
 	    || (fwrite(string, 1, slen, stream) != slen))
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
 static int
-tbd_create_fwrite_block(FILE *stream, void const *data, size_t size)
+tbd_create_write_block(FILE       *stream,
+                       void const *data,
+                       size_t      size)
 {
 	if (fwrite(&size, 1, sizeof(size), stream) != sizeof(size)) {
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
@@ -66,55 +68,55 @@ tbd_create_fwrite_block(FILE *stream, void const *data, size_t size)
 }
 
 static int
-tbd_create_fwrite_mdata_mask(FILE    *stream,
-                             uint16_t mask)
+tbd_create_write_mdata_mask(FILE    *stream,
+                            uint16_t mask)
 {
-	if(tbd_write_uint16_t(mask, stream) != 1)
+	if(tbd_write_uint16(mask, stream) != 1)
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
 static int
-tbd_create_fwrite_mtime(FILE    *stream,
-                        time_t  mtime)
+tbd_create_write_mtime(FILE  *stream,
+                       time_t mtime)
 {
-	if(tbd_write_time_t(mtime, stream) != 1)
+	if(tbd_write_time(mtime, stream) != 1)
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
 static int
-tbd_create_fwrite_mode(FILE     *stream,
-                       mode_t  mode)
+tbd_create_write_mode(FILE  *stream,
+                      mode_t mode)
 {
-	if(tbd_write_mode_t(mode, stream) != 1)
+	if(tbd_write_mode(mode, stream) != 1)
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
 static int
-tbd_create_fwrite_gid(FILE     *stream,
-                      gid_t     gid)
+tbd_create_write_gid(FILE *stream,
+                     gid_t gid)
 {
-	if(tbd_write_gid_t(gid, stream) != 1)
+	if(tbd_write_gid(gid, stream) != 1)
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
 static int
-tbd_create_fwrite_uid(FILE     *stream,
-                      uid_t     uid)
+tbd_create_write_uid(FILE *stream,
+                     uid_t uid)
 {
-	if(tbd_write_uid_t(uid, stream) != 1)
+	if(tbd_write_uid(uid, stream) != 1)
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
 static int
-tbd_create_fwrite_dev(FILE     *stream,
-                      uint32_t  dev)
+tbd_create_write_dev(FILE    *stream,
+                     uint32_t dev)
 {
-	if(tbd_write_uint32_t(dev, stream) != 1)
+	if(tbd_write_uint32(dev, stream) != 1)
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
@@ -124,9 +126,9 @@ tbd_create_cmd_ident(FILE *stream)
 {
 	int err;
 
-	if((err = tbd_create_fwrite_cmd(stream, TBD_CMD_IDENTIFY)) != 0)
+	if((err = tbd_create_write_cmd(stream, TBD_CMD_IDENTIFY)) != 0)
 		return err;
-	if((err = tbd_create_fwrite_string(stream, TB_DIFF_PROTOCOL_ID)) != 0)
+	if((err = tbd_create_write_string(stream, TB_DIFF_PROTOCOL_ID)) != 0)
 		return err;
 	return 0;
 }
@@ -134,33 +136,33 @@ tbd_create_cmd_ident(FILE *stream)
 static int
 tbd_create_cmd_update(FILE *stream)
 {
-	return tbd_create_fwrite_cmd(stream, TBD_CMD_UPDATE);
+	return tbd_create_write_cmd(stream, TBD_CMD_UPDATE);
 }
 
 /* callback function to pass to tbx_xattrs_pairs
  * this will write the attribute name, then the data representing that block
  */
 static int
-_write_pair(char const *name, void const *data, size_t size, void *ud)
+tbd_create_cmd_write_xattr_pair(char const *name,
+                                void const *data,
+                                size_t      size,
+                                void       *stream)
 {
-	FILE *stream = ud;
 	int err;
 
-	if ((err = tbd_create_fwrite_string(stream, name)) !=
-	    TBD_ERROR_SUCCESS) {
+	if ((err = tbd_create_write_string(stream, name)) !=
+	    TBD_ERROR_SUCCESS)
 		return err;
-	}
 
-	if ((err = tbd_create_fwrite_block(stream, data, size)) !=
-	    TBD_ERROR_SUCCESS) {
+	if ((err = tbd_create_write_block(stream, data, size)) !=
+	    TBD_ERROR_SUCCESS)
 		return err;
-	}
 
 	return TBD_ERROR_SUCCESS;
 }
 
 static int
-tbd_create_cmd_fwrite_xattrs(FILE *stream, tbd_stat_t *f)
+tbd_create_cmd_write_xattrs(FILE *stream, tbd_stat_t *f)
 {
 	int err = TBD_ERROR_SUCCESS;
 	tbd_xattrs_names_t names;
@@ -186,25 +188,28 @@ tbd_create_cmd_fwrite_xattrs(FILE *stream, tbd_stat_t *f)
 			goto cleanup_names;
 		}
 
-		if ((err = tbd_create_fwrite_cmd(stream,
+		if ((err = tbd_create_write_cmd(stream,
 						 TBD_CMD_XATTRS_UPDATE)
 		    ) != TBD_ERROR_SUCCESS) {
 			goto cleanup_names;
 		}
 
-		if ((err = tbd_create_fwrite_string(stream, f->name))!=
+		if ((err = tbd_create_write_string(stream, f->name))!=
 		    TBD_ERROR_SUCCESS) {
 			goto cleanup_names;
 		}
 
-		if (tbd_write_uint32_t(count, stream) != 1) {
+		if (tbd_write_uint32(count, stream) != 1) {
 			err = TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 			goto cleanup_names;
 		}
 	}
 
 	/* write the name:data pairs */
-	err = tbd_xattrs_pairs(&names, path, _write_pair, stream);
+	err = tbd_xattrs_pairs(&names,
+	                        path,
+	                        tbd_create_cmd_write_xattr_pair,
+	                        stream);
 
 cleanup_names:
 	tbd_xattrs_names_free(&names);
@@ -218,16 +223,16 @@ tbd_create_cmd_file_create(FILE       *stream,
                            tbd_stat_t *f)
 {
 	int err;
-	if((err = tbd_create_fwrite_cmd(stream, TBD_CMD_FILE_CREATE)) != 0 ||
-	   (err = tbd_create_fwrite_string(stream, f->name))  != 0 ||
-	   (err = tbd_create_fwrite_mtime (stream, f->mtime)) != 0 ||
-	   (err = tbd_create_fwrite_mode  (stream, f->mode))  != 0 ||
-	   (err = tbd_create_fwrite_uid   (stream, f->uid))   != 0 ||
-	   (err = tbd_create_fwrite_gid   (stream, f->gid))   != 0)
+	if((err = tbd_create_write_cmd(stream, TBD_CMD_FILE_CREATE)) != 0 ||
+	   (err = tbd_create_write_string(stream, f->name))          != 0 ||
+	   (err = tbd_create_write_mtime (stream, f->mtime))         != 0 ||
+	   (err = tbd_create_write_mode  (stream, f->mode))          != 0 ||
+	   (err = tbd_create_write_uid   (stream, f->uid))           != 0 ||
+	   (err = tbd_create_write_gid   (stream, f->gid))           != 0)
 		return err;
 
 	uint32_t size = f->size;
-	if(tbd_write_uint32_t(size, stream) != 1)
+	if(tbd_write_uint32(size, stream) != 1)
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 
 	FILE *fp = tbd_stat_fopen(f, "rb");
@@ -245,7 +250,7 @@ tbd_create_cmd_file_create(FILE       *stream,
 	}
 	fclose(fp);
 
-	return tbd_create_cmd_fwrite_xattrs(stream, f);
+	return tbd_create_cmd_write_xattrs(stream, f);
 }
 
 static uint16_t
@@ -268,7 +273,7 @@ tbd_metadata_mask(tbd_stat_t *a,
 }
 
 static int
-tbd_create_cmd_file_metadata_update(FILE        *stream,
+tbd_create_cmd_file_metadata_update(FILE       *stream,
                                     tbd_stat_t *a,
                                     tbd_stat_t *b)
 {
@@ -278,15 +283,15 @@ tbd_create_cmd_file_metadata_update(FILE        *stream,
 	if(metadata_mask == TBD_METADATA_NONE)
 		return 0;
 	/* TODO: Optimize protocol by only sending useful metadata */
-	if((err = tbd_create_fwrite_cmd(stream, TBD_CMD_FILE_METADATA_UPDATE)) != 0 ||
-	   (err = tbd_create_fwrite_mdata_mask (stream, metadata_mask))         != 0 ||
-	   (err = tbd_create_fwrite_mtime      (stream, b->mtime))              != 0 ||
-	   (err = tbd_create_fwrite_uid        (stream, b->uid))                != 0 ||
-	   (err = tbd_create_fwrite_gid        (stream, b->gid))                != 0 ||
-	   (err = tbd_create_fwrite_mode       (stream, b->mode))               != 0)
+	if((err = tbd_create_write_cmd(stream, TBD_CMD_FILE_METADATA_UPDATE)) != 0 ||
+	   (err = tbd_create_write_mdata_mask(stream, metadata_mask))         != 0 ||
+	   (err = tbd_create_write_mtime     (stream, b->mtime))              != 0 ||
+	   (err = tbd_create_write_uid       (stream, b->uid))                != 0 ||
+	   (err = tbd_create_write_gid       (stream, b->gid))                != 0 ||
+	   (err = tbd_create_write_mode      (stream, b->mode))               != 0)
 		return err;
 
-	return tbd_create_fwrite_string(stream, b->name);
+	return tbd_create_write_string(stream, b->name);
 }
 
 static int
@@ -303,7 +308,7 @@ tbd_create_cmd_file_delta(FILE        *stream,
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING);
 	}
 
-	// Calculate start.
+	/* Calculate start. */
 	uintptr_t blks[2] = { 256, 256 };
 	uint8_t   buff[2][256];
 
@@ -332,7 +337,7 @@ tbd_create_cmd_file_delta(FILE        *stream,
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM);
 	}
 
-	// Find length.
+	/* Find length. */
 	long flena = ftell(fpa);
 	long flenb = ftell(fpb);
 
@@ -342,7 +347,7 @@ tbd_create_cmd_file_delta(FILE        *stream,
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_DETECT_STREAM_POSITION);
 	}
 
-	// Find end.
+	/* Find end. */
 	blks[0] = 256;
 	blks[1] = 256;
 	for(o = 0; true; o += blks[1]) {
@@ -377,7 +382,7 @@ tbd_create_cmd_file_delta(FILE        *stream,
 	}
 	fclose(fpa);
 
-	// Ensure that the start and end don't overlap for the new file.
+	/* Ensure that the start and end don't overlap for the new file. */
 	if((flenb - o) < start)
 		o = (flenb - start);
 
@@ -385,32 +390,32 @@ tbd_create_cmd_file_delta(FILE        *stream,
 	if(end < start)
 		end = start;
 
-	uint32_t size = flenb - ((flena - end) + start); //(flenb - (o + start));
+	uint32_t size = flenb - ((flena - end) + start); /* (flenb - (o + start)); */
 
 	/* Data is identical, only alter metadata */
 	if((end == start) && (size == 0)) {
 		tbd_create_cmd_file_metadata_update(stream, a, b);
 		fclose(fpb);
-		return tbd_create_cmd_fwrite_xattrs(stream, b);
+		return tbd_create_cmd_write_xattrs(stream, b);
 	}
 
 	uint16_t metadata_mask = tbd_metadata_mask(a, b);
 
 	/* TODO: Optimize protocol by only sending useful metadata */
 	int err;
-	if(((err = tbd_create_fwrite_cmd(stream, TBD_CMD_FILE_DELTA))  != 0) ||
-	    ((err = tbd_create_fwrite_string(stream, b->name))           != 0) ||
-	    ((err = tbd_create_fwrite_mdata_mask(stream, metadata_mask)) != 0) ||
-	    ((err = tbd_create_fwrite_mtime (stream, b->mtime))          != 0) ||
-	    ((err = tbd_create_fwrite_uid   (stream, b->uid))            != 0) ||
-	    ((err = tbd_create_fwrite_gid   (stream, b->gid))            != 0) ||
-	    ((err = tbd_create_fwrite_mode  (stream, b->mode))           != 0)) {
+	if(((err = tbd_create_write_cmd(stream, TBD_CMD_FILE_DELTA))    != 0) ||
+	    ((err = tbd_create_write_string(stream, b->name))           != 0) ||
+	    ((err = tbd_create_write_mdata_mask(stream, metadata_mask)) != 0) ||
+	    ((err = tbd_create_write_mtime (stream, b->mtime))          != 0) ||
+	    ((err = tbd_create_write_uid   (stream, b->uid))            != 0) ||
+	    ((err = tbd_create_write_gid   (stream, b->gid))            != 0) ||
+	    ((err = tbd_create_write_mode  (stream, b->mode))           != 0)) {
 		fclose(fpb);
 		return err;
 	}
-	if((tbd_write_uint32_t(start, stream) != 1) ||
-	    (tbd_write_uint32_t(end, stream) != 1)   ||
-	    (tbd_write_uint32_t(size, stream) != 1)) {
+	if((tbd_write_uint32(start, stream) != 1) ||
+	    (tbd_write_uint32(end, stream) != 1)   ||
+	    (tbd_write_uint32(size, stream) != 1)) {
 		fclose(fpb);
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	}
@@ -432,23 +437,23 @@ tbd_create_cmd_file_delta(FILE        *stream,
 	}
 
 	fclose(fpb);
-	return tbd_create_cmd_fwrite_xattrs(stream, b);
+	return tbd_create_cmd_write_xattrs(stream, b);
 }
 
 static int
-tbd_create_cmd_dir_create(FILE        *stream,
-                          tbd_stat_t  *d)
+tbd_create_cmd_dir_create(FILE       *stream,
+                          tbd_stat_t *d)
 {
 	int err;
 
-	if((err = tbd_create_fwrite_cmd(stream, TBD_CMD_DIR_CREATE)) != 0 ||
-	   (err = tbd_create_fwrite_string(stream, d->name)) != 0 ||
-	   (err = tbd_create_fwrite_mtime(stream, d->mtime)) != 0 ||
-	   (err = tbd_create_fwrite_uid(stream, d->uid))     != 0 ||
-	   (err = tbd_create_fwrite_gid(stream, d->gid))     != 0)
+	if((err = tbd_create_write_cmd(stream, TBD_CMD_DIR_CREATE)) != 0 ||
+	   (err = tbd_create_write_string(stream, d->name))         != 0 ||
+	   (err = tbd_create_write_mtime(stream, d->mtime))         != 0 ||
+	   (err = tbd_create_write_uid(stream, d->uid))             != 0 ||
+	   (err = tbd_create_write_gid(stream, d->gid))             != 0)
 		return err;
 
-	return tbd_create_fwrite_mode(stream, d->mode);
+	return tbd_create_write_mode(stream, d->mode);
 }
 
 static int
@@ -456,22 +461,22 @@ tbd_create_cmd_dir_enter(FILE       *stream,
                          const char *name)
 {
 	int err;
-	if((err = tbd_create_fwrite_cmd(stream, TBD_CMD_DIR_ENTER)) != 0)
+	if((err = tbd_create_write_cmd(stream, TBD_CMD_DIR_ENTER)) != 0)
 		return err;
-	return tbd_create_fwrite_string(stream, name);
+	return tbd_create_write_string(stream, name);
 }
 
 static int
-tbd_create_cmd_dir_leave(FILE      *stream,
-                         tbd_stat_t  *dir)
+tbd_create_cmd_dir_leave(FILE       *stream,
+                         tbd_stat_t *dir)
 {
 	int err;
-	if ((err = tbd_create_fwrite_cmd(stream, TBD_CMD_DIR_LEAVE)) !=
+	if ((err = tbd_create_write_cmd(stream, TBD_CMD_DIR_LEAVE)) !=
 	    TBD_ERROR_SUCCESS) {
 		return err;
 	}
 
-	return tbd_create_fwrite_mtime(stream, dir->mtime);
+	return tbd_create_write_mtime(stream, dir->mtime);
 }
 
 static int
@@ -479,9 +484,9 @@ tbd_create_cmd_entity_delete(FILE       *stream,
                              const char *name)
 {
 	int err;
-	if((err = tbd_create_fwrite_cmd(stream, TBD_CMD_ENTITY_DELETE)) != 0)
+	if((err = tbd_create_write_cmd(stream, TBD_CMD_ENTITY_DELETE)) != 0)
 		return err;
-	return tbd_create_fwrite_string(stream, name);
+	return tbd_create_write_string(stream, name);
 }
 
 static int
@@ -495,20 +500,20 @@ tbd_create_cmd_dir_delta(FILE        *stream,
 	if(metadata_mask == TBD_METADATA_NONE)
 		return 0;
 
-	if((err = tbd_create_fwrite_cmd(stream, TBD_CMD_DIR_DELTA))    != 0 ||
-	   (err = tbd_create_fwrite_mdata_mask (stream, metadata_mask)) != 0 ||
-	   (err = tbd_create_fwrite_mtime      (stream, b->mtime))      != 0 ||
-	   (err = tbd_create_fwrite_uid        (stream, b->uid))        != 0 ||
-	   (err = tbd_create_fwrite_gid        (stream, b->gid))        != 0 ||
-	   (err = tbd_create_fwrite_mode       (stream, b->mode))       != 0)
+	if((err = tbd_create_write_cmd(stream, TBD_CMD_DIR_DELTA))     != 0 ||
+	   (err = tbd_create_write_mdata_mask (stream, metadata_mask)) != 0 ||
+	   (err = tbd_create_write_mtime      (stream, b->mtime))      != 0 ||
+	   (err = tbd_create_write_uid        (stream, b->uid))        != 0 ||
+	   (err = tbd_create_write_gid        (stream, b->gid))        != 0 ||
+	   (err = tbd_create_write_mode       (stream, b->mode))       != 0)
 		return err;
 
-	return tbd_create_fwrite_string(stream, b->name);
+	return tbd_create_write_string(stream, b->name);
 }
 
 static int
-tbd_create_cmd_symlink_create(FILE        *stream,
-                              tbd_stat_t  *symlink)
+tbd_create_cmd_symlink_create(FILE       *stream,
+                              tbd_stat_t *symlink)
 {
 	int err;
 	char path[PATH_BUFFER_LENGTH];
@@ -520,20 +525,20 @@ tbd_create_cmd_symlink_create(FILE        *stream,
 		return TBD_ERROR(TBD_ERROR_UNABLE_TO_READ_SYMLINK);
 	path[len] = '\0';
 
-	if((err = tbd_create_fwrite_cmd(stream, TBD_CMD_SYMLINK_CREATE)) != 0 ||
-	   (err = tbd_create_fwrite_mtime (stream, symlink->mtime)) != 0 ||
-	   (err = tbd_create_fwrite_uid   (stream, symlink->uid)) != 0 ||
-	   (err = tbd_create_fwrite_gid   (stream, symlink->gid)) != 0 ||
-	   (err = tbd_create_fwrite_string(stream, symlink->name)) != 0)
+	if((err = tbd_create_write_cmd(stream, TBD_CMD_SYMLINK_CREATE)) != 0 ||
+	   (err = tbd_create_write_mtime (stream, symlink->mtime))      != 0 ||
+	   (err = tbd_create_write_uid   (stream, symlink->uid))        != 0 ||
+	   (err = tbd_create_write_gid   (stream, symlink->gid))        != 0 ||
+	   (err = tbd_create_write_string(stream, symlink->name))       != 0)
 		return err;
 
-	return tbd_create_fwrite_string(stream, path);
+	return tbd_create_write_string(stream, path);
 }
 
 static int
-tbd_create_cmd_symlink_delta(FILE        *stream,
-                             tbd_stat_t  *a,
-                             tbd_stat_t  *b)
+tbd_create_cmd_symlink_delta(FILE       *stream,
+                             tbd_stat_t *a,
+                             tbd_stat_t *b)
 {
 	int err;
 	char path_a[PATH_BUFFER_LENGTH];
@@ -569,25 +574,25 @@ tbd_create_cmd_symlink_delta(FILE        *stream,
 }
 
 static int
-tbd_create_cmd_special_create(FILE        *stream,
-                              tbd_stat_t  *nod)
+tbd_create_cmd_special_create(FILE       *stream,
+                              tbd_stat_t *nod)
 {
 	int err;
 
-	if((err = tbd_create_fwrite_cmd(stream, TBD_CMD_SPECIAL_CREATE)) != 0 ||
-	   (err = tbd_create_fwrite_string(stream, nod->name))            != 0 ||
-	   (err = tbd_create_fwrite_mtime (stream, nod->mtime))           != 0 ||
-	   (err = tbd_create_fwrite_mode  (stream, nod->mode))             != 0 ||
-	   (err = tbd_create_fwrite_uid   (stream, nod->uid))               != 0 ||
-	   (err = tbd_create_fwrite_gid   (stream, nod->gid))               != 0)
+	if((err = tbd_create_write_cmd(stream, TBD_CMD_SPECIAL_CREATE)) != 0 ||
+	   (err = tbd_create_write_string(stream, nod->name))           != 0 ||
+	   (err = tbd_create_write_mtime (stream, nod->mtime))          != 0 ||
+	   (err = tbd_create_write_mode  (stream, nod->mode))           != 0 ||
+	   (err = tbd_create_write_uid   (stream, nod->uid))            != 0 ||
+	   (err = tbd_create_write_gid   (stream, nod->gid))            != 0)
 		return err;
-	return tbd_create_fwrite_dev(stream, nod->rdev);
+	return tbd_create_write_dev(stream, nod->rdev);
 }
 
 static int
-tbd_create_cmd_special_delta(FILE        *stream,
-                             tbd_stat_t  *a,
-                             tbd_stat_t  *b)
+tbd_create_cmd_special_delta(FILE       *stream,
+                             tbd_stat_t *a,
+                             tbd_stat_t *b)
 {
 	uint16_t metadata_mask = tbd_metadata_mask(a, b);
 	if(a->rdev != b->rdev)
@@ -670,17 +675,17 @@ tbd_create_dir(FILE        *stream,
 }
 
 static int
-tbd_create_impl(FILE        *stream,
-                tbd_stat_t  *a,
-                tbd_stat_t  *b,
-                bool         top)
+tbd_create_impl(FILE       *stream,
+                tbd_stat_t *a,
+                tbd_stat_t *b,
+                bool        top)
 {
 	if((a == NULL) && (b == NULL))
 		return TBD_ERROR(TBD_ERROR_NULL_POINTER);
 
 	int err;
 	if(((b == NULL) || ((a != NULL) && (a->type != b->type)))) {
-		fprintf(stderr, "file delete %s\n", a->name);
+		TBD_DEBUGF("file delete %s\n", a->name);
 		if((err = tbd_create_cmd_entity_delete(stream, a->name)) != 0)
 			return err;
 	}
@@ -688,21 +693,21 @@ tbd_create_impl(FILE        *stream,
 	if((a == NULL) || ((b != NULL) && (a->type != b->type))) {
 		switch(b->type) {
 		case TBD_STAT_TYPE_FILE:
-			fprintf(stderr, "file new %s\n", b->name);
+			TBD_DEBUGF("file new %s\n", b->name);
 			return tbd_create_cmd_file_create(stream, b);
 		case TBD_STAT_TYPE_DIR:
-			fprintf(stderr, "dir new %s\n", b->name);
+			TBD_DEBUGF("dir new %s\n", b->name);
 			return tbd_create_dir(stream, b);
 		case TBD_STAT_TYPE_SYMLINK:
-			fprintf(stderr, "symlink new %s\n", b->name);
+			TBD_DEBUGF("symlink new %s\n", b->name);
 			return tbd_create_cmd_symlink_create(stream, b);
 		case TBD_STAT_TYPE_CHRDEV:
 		case TBD_STAT_TYPE_BLKDEV:
 		case TBD_STAT_TYPE_FIFO:
-			fprintf(stderr, "special new %s\n", b->name);
+			TBD_DEBUGF("special new %s\n", b->name);
 			return tbd_create_cmd_special_create(stream, b);
 		case TBD_STAT_TYPE_SOCKET:
-			fprintf(stderr, "socket new %s\n", b->name);
+			TBD_DEBUGF("socket new %s\n", b->name);
 			return tbd_create_cmd_socket_create(stream, b);
 		default:
 			return TBD_ERROR(TBD_ERROR_FEATURE_NOT_IMPLEMENTED);
@@ -711,22 +716,22 @@ tbd_create_impl(FILE        *stream,
 
 	switch(b->type) {
 	case TBD_STAT_TYPE_FILE:
-		fprintf(stderr, "file delta %s\n", a->name);
+		TBD_DEBUGF("file delta %s\n", a->name);
 		return tbd_create_cmd_file_delta(stream, a, b);
 	case TBD_STAT_TYPE_SYMLINK:
-		fprintf(stderr, "symlink delta %s\n", a->name);
+		TBD_DEBUGF("symlink delta %s\n", a->name);
 		return tbd_create_cmd_symlink_delta(stream, a, b);
 	case TBD_STAT_TYPE_CHRDEV:
 	case TBD_STAT_TYPE_BLKDEV:
 	case TBD_STAT_TYPE_FIFO:
-		fprintf(stderr, "special delta %s\n", a->name);
+		TBD_DEBUGF("special delta %s\n", a->name);
 		return tbd_create_cmd_special_delta(stream, a, b);
 	case TBD_STAT_TYPE_SOCKET:
-		fprintf(stderr, "socket delta %s\n", a->name);
+		TBD_DEBUGF("socket delta %s\n", a->name);
 		return tbd_create_cmd_socket_delta(stream, a, b);
 	case TBD_STAT_TYPE_DIR:
 		if(!top) {
-			fprintf(stderr, "dir delta %s\n", a->name);
+			TBD_DEBUGF("dir delta %s\n", a->name);
 			if ((err = tbd_create_cmd_dir_delta(stream, a, b)) !=
 			    TBD_ERROR_SUCCESS) {
 				return err;
@@ -740,7 +745,7 @@ tbd_create_impl(FILE        *stream,
 	if(!top && ((err = tbd_create_cmd_dir_enter(stream, b->name)) != 0))
 		return err;
 
-	// Handle changes/additions.
+	/* Handle changes/additions. */
 	uintptr_t i;
 	for(i = 0; i < b->size; i++) {
 		tbd_stat_t *_b = tbd_stat_entry(b, i);
@@ -754,10 +759,10 @@ tbd_create_impl(FILE        *stream,
 			return err;
 	}
 
-	// Handle deletions.
+	/* Handle deletions. */
 	for(i = 0; i < a->size; i++) {
 		err = 0;
-		
+
 		tbd_stat_t *_a = tbd_stat_entry(a, i);
 		if(_a == NULL)
 			return TBD_ERROR(TBD_ERROR_UNABLE_TO_STAT_FILE);
@@ -781,9 +786,9 @@ tbd_create_impl(FILE        *stream,
 }
 
 int
-tbd_create(FILE        *stream,
-            tbd_stat_t *a,
-            tbd_stat_t *b)
+tbd_create(FILE       *stream,
+           tbd_stat_t *a,
+           tbd_stat_t *b)
 {
 	int err;
 	if((stream == NULL) || (a == NULL) || (b == NULL))