Getting rid of some more of the otap prefixes

3 files changed, 197 insertions, 198 deletions

diff --git a/libtbd_apply.c b/libtbd_apply.c
index aef8ac3..44b69d0 100644
--- a/libtbd_apply.c
+++ b/libtbd_apply.c
@@ -52,19 +52,19 @@ _otap_apply_identify(FILE* stream)
 {
 	uint8_t cmd;
 	if(fread(&cmd, 1, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
-	if(cmd != OTAP_CMD_IDENTIFY)
-		otap_error(OTAP_ERROR_INVALID_PARAMETER);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
+	if(cmd != TBD_CMD_IDENTIFY)
+		otap_error(TBD_ERROR_INVALID_PARAMETER);
 	uint16_t nlen;
 	if(fread(&nlen, 2, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	if(strlen(TB_DIFF_PROTOCOL_ID) != nlen)
-		otap_error(OTAP_ERROR_INVALID_PARAMETER);
+		otap_error(TBD_ERROR_INVALID_PARAMETER);
 	char nstr[nlen];
 	if(fread(nstr, 1, nlen, stream) != nlen)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	if(strncmp(nstr, TB_DIFF_PROTOCOL_ID, nlen) != 0)
-		otap_error(OTAP_ERROR_INVALID_PARAMETER);
+		otap_error(TBD_ERROR_INVALID_PARAMETER);
 	return 0;
 }
 
@@ -73,33 +73,33 @@ _otap_apply_cmd_dir_create(FILE* stream)
 {
 	uint16_t dlen;
 	if(fread(&dlen, sizeof(uint16_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	char dname[dlen + 1];
 	if(fread(dname, 1, dlen, stream) != dlen)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	dname[dlen] = '\0';
 	printf("cmd_dir_create %s\n", dname);
 	if(strchr(dname, '/') != NULL)
-		otap_error(OTAP_ERROR_INVALID_PARAMETER);
+		otap_error(TBD_ERROR_INVALID_PARAMETER);
 
 	uint32_t mtime;
 	if(fread(&mtime, sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	uint32_t uid;
 	if(fread(&uid, sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	uint32_t gid;
 	if(fread(&gid, sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	uint32_t mode;
 	if(fread(&mode, sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	if(mkdir(dname, (mode_t)mode) != 0)
-		otap_error(OTAP_ERROR_UNABLE_TO_CREATE_DIR);
+		otap_error(TBD_ERROR_UNABLE_TO_CREATE_DIR);
 
 	// Apply metadata.
 	struct utimbuf timebuff = { time(NULL), mtime };
@@ -117,19 +117,19 @@ _otap_apply_cmd_dir_enter(FILE      *stream,
 {
 	uint16_t dlen;
 	if(fread(&dlen, 2, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	char dname[dlen + 1];
 	if(fread(dname, 1, dlen, stream) != dlen)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	dname[dlen] = '\0';
 	printf("cmd_dir_enter %s\n", dname);
 	if((strchr(dname, '/') != NULL) || (strcmp(dname, "..") == 0))
-		otap_error(OTAP_ERROR_UNABLE_TO_CHANGE_DIR);
+		otap_error(TBD_ERROR_UNABLE_TO_CHANGE_DIR);
 	if(depth != NULL)
 		(*depth)++;
 
 	if(chdir(dname) != 0)
-		otap_error(OTAP_ERROR_UNABLE_TO_CHANGE_DIR);
+		otap_error(TBD_ERROR_UNABLE_TO_CHANGE_DIR);
 	return 0;
 }
 
@@ -139,17 +139,17 @@ _otap_apply_cmd_dir_leave(FILE      *stream,
 {
 	uint8_t count;
 	if(fread(&count, 1, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	uintptr_t rcount = count + 1;
 	printf("cmd_dir_leave %"PRIuPTR"\n", rcount);
 
 	if((depth != NULL) && (*depth < rcount))
-		otap_error(OTAP_ERROR_INVALID_PARAMETER);
+		otap_error(TBD_ERROR_INVALID_PARAMETER);
 
 	uintptr_t i;
 	for(i = 0; i < rcount; i++) {
 		if(chdir("..") != 0)
-			otap_error(OTAP_ERROR_UNABLE_TO_CHANGE_DIR);
+			otap_error(TBD_ERROR_UNABLE_TO_CHANGE_DIR);
 	}
 
 	if(depth != NULL)
@@ -162,13 +162,13 @@ _otap_apply_cmd_file_create(FILE* stream)
 {
 	uint16_t flen;
 	if(fread(&flen, 2, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	char fname[flen + 1];
 	if(fread(fname, 1, flen, stream) != flen)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	fname[flen] = '\0';
 	if((strchr(fname, '/') != NULL) || (strcmp(fname, "..") == 0))
-		otap_error(OTAP_ERROR_INVALID_PARAMETER);
+		otap_error(TBD_ERROR_INVALID_PARAMETER);
 
 	uint32_t mtime;
 	uint32_t mode;
@@ -181,19 +181,19 @@ _otap_apply_cmd_file_create(FILE* stream)
 	    fread(&uid, sizeof(uint32_t), 1, stream)   != 1 ||
 	    fread(&gid, sizeof(uint32_t), 1, stream)   != 1 ||
 	    fread(&fsize, 4, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	fprintf(stderr, "cmd_file_create %s:%"PRId32"\n", fname, fsize);
 
 	FILE* fp = fopen(fname, "rb");
 	if(fp != NULL) {
 		fclose(fp);
-		otap_error(OTAP_ERROR_FILE_ALREADY_EXISTS);
+		otap_error(TBD_ERROR_FILE_ALREADY_EXISTS);
 	}
 
 	fp = fopen(fname, "wb");
 	if(fp == NULL)
-		otap_error(OTAP_ERROR_UNABLE_TO_OPEN_FILE_FOR_WRITING);
+		otap_error(TBD_ERROR_UNABLE_TO_OPEN_FILE_FOR_WRITING);
 
 	uintptr_t block = 256;
 	uint8_t fbuff[block];
@@ -201,9 +201,9 @@ _otap_apply_cmd_file_create(FILE* stream)
 		if(fsize < block)
 			block = fsize;
 		if(fread(fbuff, 1, block, stream) != block)
-			otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 		if(fwrite(fbuff, 1, block, fp) != block)
-			otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	}
 	fclose(fp);
 
@@ -230,17 +230,17 @@ _otap_apply_cmd_file_delta(FILE* stream)
 	uint32_t mode;
 	uint16_t flen;
 	if(fread(&flen, 2, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	char fname[flen + 1];
 	if(fread(fname, 1, flen, stream) != flen)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	fname[flen] = '\0';
 
 	fprintf(stderr, "cmd_file_delta %s\n", fname);
 
 	if((strchr(fname, '/') != NULL) ||
 	    (strcmp(fname, "..") == 0))
-		otap_error(OTAP_ERROR_INVALID_PARAMETER);
+		otap_error(TBD_ERROR_INVALID_PARAMETER);
 
 	/* Reading metadata */
 	if(fread(&mdata_mask, sizeof(uint16_t), 1, stream) != 1 ||
@@ -248,26 +248,26 @@ _otap_apply_cmd_file_delta(FILE* stream)
 	    fread(&uid,        sizeof(uint32_t), 1, stream) != 1 ||
 	    fread(&gid,        sizeof(uint32_t), 1, stream) != 1 ||
 	    fread(&mode,       sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	FILE* op = fopen(fname, "rb");
 	if(op == NULL)
-		otap_error(OTAP_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING);
+		otap_error(TBD_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING);
 	if(remove(fname) != 0) {
 		fclose(op);
-		otap_error(OTAP_ERROR_UNABLE_TO_REMOVE_FILE);
+		otap_error(TBD_ERROR_UNABLE_TO_REMOVE_FILE);
 	}
 	FILE* np = fopen(fname, "wb");
 	if(np == NULL) {
 		fclose(op);
-		otap_error(OTAP_ERROR_UNABLE_TO_OPEN_FILE_FOR_WRITING);
+		otap_error(TBD_ERROR_UNABLE_TO_OPEN_FILE_FOR_WRITING);
 	}
 
 	uint32_t dstart, dend;
 	if(fread(&dstart, 4, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	if(fread(&dend, 4, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	uintptr_t block;
 	uint8_t fbuff[256];
@@ -275,34 +275,34 @@ _otap_apply_cmd_file_delta(FILE* stream)
 		if(dstart < block)
 			block = dstart;
 		if(fread(fbuff, 1, block, op) != block)
-			otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 		if(fwrite(fbuff, 1, block, np) != block)
-			otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	}
 
 	uint32_t fsize;
 	if(fread(&fsize, 4, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	for(block = 256; fsize != 0; fsize -= block) {
 		if(fsize < block)
 			block = fsize;
 		if(fread(fbuff, 1, block, stream) != block)
-			otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 		if(fwrite(fbuff, 1, block, np) != block)
-			otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	}
 
 	if(fseek(op, dend, SEEK_SET) != 0) {
 		fclose(np);
 		fclose(op);
-		otap_error(OTAP_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM);
 	}
 
 	for(block = 256; block != 0;) {
 		block = fread(fbuff, 1, block, op);
 		if(fwrite(fbuff, 1, block, np) != block)
-			otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	}
 
 	fclose(np);
@@ -310,14 +310,14 @@ _otap_apply_cmd_file_delta(FILE* stream)
 
 	// Apply metadata.
 	int ret;
-	if(mdata_mask & OTAP_METADATA_MTIME) {
+	if(mdata_mask & TBD_METADATA_MTIME) {
 		struct utimbuf timebuff = { time(NULL), mtime };
 		utime(fname, &timebuff); // Don't care if it succeeds right now.
 	}
-	if(mdata_mask & OTAP_METADATA_UID ||
-	    mdata_mask & OTAP_METADATA_GID)
+	if(mdata_mask & TBD_METADATA_UID ||
+	    mdata_mask & TBD_METADATA_GID)
 		ret = chown(fname, (uid_t)uid, (gid_t)gid);
-	if(mdata_mask | OTAP_METADATA_MODE)
+	if(mdata_mask | TBD_METADATA_MODE)
 		ret = chmod(fname, mode);
 
 	return 0;
@@ -329,14 +329,14 @@ __otap_apply_cmd_entity_delete(const char* name)
 	DIR* dp = opendir(name);
 	if(dp == NULL) {
 		if(remove(name) != 0)
-			otap_error(OTAP_ERROR_UNABLE_TO_REMOVE_FILE);
+			otap_error(TBD_ERROR_UNABLE_TO_REMOVE_FILE);
 
 		return 0;
 	}
 
 	if(chdir(name) != 0) {
 		closedir(dp);
-		otap_error(OTAP_ERROR_UNABLE_TO_CHANGE_DIR);
+		otap_error(TBD_ERROR_UNABLE_TO_CHANGE_DIR);
 	}
 
 	struct dirent* entry;
@@ -350,7 +350,7 @@ __otap_apply_cmd_entity_delete(const char* name)
 			closedir(dp);
 
 			if(chdir("..") != 0)
-				otap_error(OTAP_ERROR_UNABLE_TO_CHANGE_DIR);
+				otap_error(TBD_ERROR_UNABLE_TO_CHANGE_DIR);
 
 			return err;
 		}
@@ -358,9 +358,9 @@ __otap_apply_cmd_entity_delete(const char* name)
 
 	closedir(dp);
 	if(chdir("..") != 0)
-		otap_error(OTAP_ERROR_UNABLE_TO_CHANGE_DIR);
+		otap_error(TBD_ERROR_UNABLE_TO_CHANGE_DIR);
 	if(remove(name) != 0)
-		otap_error(OTAP_ERROR_UNABLE_TO_REMOVE_FILE);
+		otap_error(TBD_ERROR_UNABLE_TO_REMOVE_FILE);
 	return 0;
 }
 
@@ -369,16 +369,16 @@ _otap_apply_cmd_entity_delete(FILE* stream)
 {
 	uint16_t elen;
 	if(fread(&elen, 2, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	char ename[elen + 1];
 	if(fread(ename, 1, elen, stream) != elen)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	ename[elen] = '\0';
 
 	fprintf(stderr, "cmd_entity_delete %s\n", ename);
 
 	if((strchr(ename, '/') != NULL) || (strcmp(ename, "..") == 0))
-		otap_error(OTAP_ERROR_INVALID_PARAMETER);
+		otap_error(TBD_ERROR_INVALID_PARAMETER);
 	return __otap_apply_cmd_entity_delete(ename);
 }
 
@@ -393,30 +393,30 @@ _otap_apply_cmd_symlink_create(FILE *stream)
 	if(fread(&mtime, sizeof(uint32_t), 1, stream) != 1 ||
 	    fread(&uid,   sizeof(uint32_t), 1, stream) != 1 ||
 	    fread(&gid,   sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	/* Reading link file name */
 	if(fread(&len, sizeof(uint16_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	char linkname[len + 1];
 	linkname[len] = '\0';
 	if(fread(linkname, sizeof(char), len, stream) != len)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	/* Reading target path */
 	if(fread(&len, sizeof(uint16_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	char linkpath[len+1];
 	linkpath[len] = '\0';
 
 	if(fread(linkpath, sizeof(char), len, stream) != len)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	fprintf(stderr, "cmd_symlink_create %s -> %s\n", linkname, linkpath);
 
 	if(symlink(linkpath, linkname))
-		return OTAP_ERROR_UNABLE_TO_CREATE_SYMLINK;
+		return TBD_ERROR_UNABLE_TO_CREATE_SYMLINK;
 
 	int ret;
 	struct timeval tv[2];
@@ -427,7 +427,7 @@ _otap_apply_cmd_symlink_create(FILE *stream)
 	lutimes(linkname, tv); // Don't care if it succeeds right now.
 	ret = lchown(linkname, (uid_t)uid, (uid_t)gid);
 
-	return OTAP_ERROR_SUCCESS;
+	return TBD_ERROR_SUCCESS;
 }
 
 static int
@@ -447,14 +447,14 @@ _otap_apply_cmd_special_create(FILE *stream)
 	    fread(&gid, sizeof(uint32_t), 1, stream)   != 1 ||
 	    fread(&dev, sizeof(uint32_t), 1, stream)   != 1) {
 		free(name);
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 	}
 
 	fprintf(stderr, "cmd_special_create %s\n", name);
 
 	if(mknod(name, mode, (dev_t)dev) != 0) {
 		free(name);
-		return OTAP_ERROR_UNABLE_TO_CREATE_SPECIAL_FILE;
+		return TBD_ERROR_UNABLE_TO_CREATE_SPECIAL_FILE;
 	}
 
 	struct utimbuf timebuff = { time(NULL), mtime };
@@ -465,7 +465,7 @@ _otap_apply_cmd_special_create(FILE *stream)
 	ret = chmod(name, mode);
 
 	free(name);
-	return OTAP_ERROR_SUCCESS;
+	return TBD_ERROR_SUCCESS;
 }
 
 static int
@@ -482,26 +482,26 @@ _otap_apply_cmd_dir_delta(FILE *stream)
 	    fread(&uid, sizeof(uint32_t), 1, stream)           != 1 ||
 	    fread(&gid, sizeof(uint32_t), 1, stream)           != 1 ||
 	    fread(&mode, sizeof(uint32_t), 1, stream)          != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	int   ret;
 	char *dname = _otap_apply_fread_string(stream);
 	if(dname == NULL)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	fprintf(stderr, "cmd_dir_delta %s\n", dname);
 
-	if(metadata_mask & OTAP_METADATA_MTIME) {
+	if(metadata_mask & TBD_METADATA_MTIME) {
 		struct utimbuf timebuff = { time(NULL), mtime };
 		utime(dname, &timebuff); // Don't care if it succeeds right now.
 	}
-	if(metadata_mask & OTAP_METADATA_UID || metadata_mask & OTAP_METADATA_GID)
+	if(metadata_mask & TBD_METADATA_UID || metadata_mask & TBD_METADATA_GID)
 		ret = chown(dname, (uid_t)uid, (gid_t)gid);
-	if(metadata_mask | OTAP_METADATA_MODE)
+	if(metadata_mask | TBD_METADATA_MODE)
 		ret = chmod(dname, mode);
 
 	free(dname);
-	return OTAP_ERROR_SUCCESS;
+	return TBD_ERROR_SUCCESS;
 }
 
 static int
@@ -518,33 +518,33 @@ _otap_apply_cmd_file_mdata_update(FILE *stream)
 	    fread(&uid, sizeof(uint32_t), 1, stream)           != 1 ||
 	    fread(&gid, sizeof(uint32_t), 1, stream)           != 1 ||
 	    fread(&mode, sizeof(uint32_t), 1, stream)          != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	int   ret;
 	char *dname = _otap_apply_fread_string(stream);
 	if(dname == NULL)
-		otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 
 	fprintf(stderr, "cmd_metadata_update %s\n", dname);
 
-	if(metadata_mask & OTAP_METADATA_MTIME) {
+	if(metadata_mask & TBD_METADATA_MTIME) {
 		struct utimbuf timebuff = { time(NULL), mtime };
 		utime(dname, &timebuff); // Don't care if it succeeds right now.
 	}
-	if(metadata_mask & OTAP_METADATA_UID || metadata_mask & OTAP_METADATA_GID)
+	if(metadata_mask & TBD_METADATA_UID || metadata_mask & TBD_METADATA_GID)
 		ret = chown(dname, (uid_t)uid, (gid_t)gid);
-	if(metadata_mask | OTAP_METADATA_MODE)
+	if(metadata_mask | TBD_METADATA_MODE)
 		ret = chmod(dname, mode);
 
 	free(dname);
-	return OTAP_ERROR_SUCCESS;
+	return TBD_ERROR_SUCCESS;
 }
 
 int
 otap_apply(FILE* stream)
 {
 	if(stream == NULL)
-		otap_error(OTAP_ERROR_NULL_POINTER);
+		otap_error(TBD_ERROR_NULL_POINTER);
 
 	int err;
 	if((err = _otap_apply_identify(stream)) != 0)
@@ -555,57 +555,57 @@ otap_apply(FILE* stream)
 	while(!flush) {
 		uint8_t cmd;
 		if(fread(&cmd, 1, 1, stream) != 1)
-			otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 		switch(cmd) {
-		case OTAP_CMD_DIR_CREATE:
+		case TBD_CMD_DIR_CREATE:
 			if((err = _otap_apply_cmd_dir_create(stream)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_DIR_ENTER:
+		case TBD_CMD_DIR_ENTER:
 			if((err = _otap_apply_cmd_dir_enter(stream, &depth)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_DIR_LEAVE:
+		case TBD_CMD_DIR_LEAVE:
 			if((err = _otap_apply_cmd_dir_leave(stream, &depth)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_FILE_CREATE:
+		case TBD_CMD_FILE_CREATE:
 			if((err = _otap_apply_cmd_file_create(stream)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_FILE_DELTA:
+		case TBD_CMD_FILE_DELTA:
 			if((err = _otap_apply_cmd_file_delta(stream)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_SYMLINK_CREATE:
+		case TBD_CMD_SYMLINK_CREATE:
 			if((err = _otap_apply_cmd_symlink_create(stream)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_SPECIAL_CREATE:
+		case TBD_CMD_SPECIAL_CREATE:
 			if((err = _otap_apply_cmd_special_create(stream)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_DIR_DELTA:
+		case TBD_CMD_DIR_DELTA:
 			if((err = _otap_apply_cmd_dir_delta(stream)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_FILE_METADATA_UPDATE:
+		case TBD_CMD_FILE_METADATA_UPDATE:
 			if((err = _otap_apply_cmd_file_mdata_update(stream)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_ENTITY_MOVE:
-		case OTAP_CMD_ENTITY_COPY:
-			otap_error(OTAP_ERROR_FEATURE_NOT_IMPLEMENTED); // TODO - Implement.
-		case OTAP_CMD_ENTITY_DELETE:
+		case TBD_CMD_ENTITY_MOVE:
+		case TBD_CMD_ENTITY_COPY:
+			otap_error(TBD_ERROR_FEATURE_NOT_IMPLEMENTED); // TODO - Implement.
+		case TBD_CMD_ENTITY_DELETE:
 			if((err = _otap_apply_cmd_entity_delete(stream)) != 0)
 				return err;
 			break;
-		case OTAP_CMD_UPDATE:
+		case TBD_CMD_UPDATE:
 			flush = true;
 			break;
 		default:
 			fprintf(stderr, "Error: Invalid command 0x%02"PRIx8".\n", cmd);
-			otap_error(OTAP_ERROR_INVALID_PARAMETER);
+			otap_error(TBD_ERROR_INVALID_PARAMETER);
 		}
 	}
 
diff --git a/libtbd_create.c b/libtbd_create.c
index 743d902..5c29ee9 100644
--- a/libtbd_create.c
+++ b/libtbd_create.c
@@ -36,7 +36,7 @@ _otap_create_fwrite_cmd(FILE    *stream,
                         uint8_t  cmd)
 {
 	if(fwrite(&cmd, 1, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
@@ -47,7 +47,7 @@ _otap_create_fwrite_string(FILE       *stream,
 	uint16_t slen = strlen(string);
 	if((fwrite(&slen, 2, 1, stream) != 1)
 	    || (fwrite(string, 1, slen, stream) != slen))
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
@@ -56,7 +56,7 @@ _otap_create_fwrite_mdata_mask(FILE    *stream,
                                uint16_t mask)
 {
 	if(fwrite(&mask, sizeof(uint16_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
@@ -65,7 +65,7 @@ _otap_create_fwrite_mtime(FILE    *stream,
                           uint32_t  mtime)
 {
 	if(fwrite(&mtime, sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
@@ -74,7 +74,7 @@ _otap_create_fwrite_mode(FILE     *stream,
                          uint32_t  mode)
 {
 	if(fwrite(&mode, sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
@@ -83,7 +83,7 @@ _otap_create_fwrite_gid(FILE     *stream,
                         gid_t     gid)
 {
 	if(fwrite(&gid, sizeof(gid_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
@@ -92,7 +92,7 @@ _otap_create_fwrite_uid(FILE     *stream,
                         uid_t     uid)
 {
 	if(fwrite(&uid, sizeof(uid_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
@@ -101,7 +101,7 @@ _otap_create_fwrite_dev(FILE     *stream,
                          uint32_t  dev)
 {
 	if(fwrite(&dev, sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
@@ -110,7 +110,7 @@ _otap_create_cmd_ident(FILE* stream)
 {
 	int err;
 
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_IDENTIFY)) != 0)
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_IDENTIFY)) != 0)
 		return err;
 	if((err = _otap_create_fwrite_string(stream, TB_DIFF_PROTOCOL_ID)) != 0)
 		return err;
@@ -120,7 +120,7 @@ _otap_create_cmd_ident(FILE* stream)
 static int
 _otap_create_cmd_update(FILE *stream)
 {
-	return _otap_create_fwrite_cmd(stream, OTAP_CMD_UPDATE);
+	return _otap_create_fwrite_cmd(stream, TBD_CMD_UPDATE);
 }
 
 static int
@@ -128,7 +128,7 @@ _otap_create_cmd_file_create(FILE       *stream,
                              tbd_stat_t *f)
 {
 	int err;
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_FILE_CREATE)) != 0 ||
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_FILE_CREATE)) != 0 ||
 	   (err = _otap_create_fwrite_string(stream, f->name))  != 0 ||
 	   (err = _otap_create_fwrite_mtime (stream, f->mtime)) != 0 ||
 	   (err = _otap_create_fwrite_mode  (stream, f->mode))  != 0 ||
@@ -138,11 +138,11 @@ _otap_create_cmd_file_create(FILE       *stream,
 
 	uint32_t size = f->size;
 	if(fwrite(&size, sizeof(uint32_t), 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 
 	FILE* fp = tbd_stat_fopen(f, "rb");
 	if(fp == NULL)
-		otap_error(OTAP_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING);
+		otap_error(TBD_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING);
 
 	uint8_t buff[256];
 	uintptr_t b = 256;
@@ -150,7 +150,7 @@ _otap_create_cmd_file_create(FILE       *stream,
 		b = fread(buff, 1, b, fp);
 		if(fwrite(buff, 1, b, stream) != b) {
 			fclose(fp);
-			otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 		}
 	}
 	fclose(fp);
@@ -162,17 +162,17 @@ static uint16_t
 _otap_metadata_mask(tbd_stat_t *a,
                     tbd_stat_t *b)
 {
-	uint16_t metadata_mask = OTAP_METADATA_NONE;
+	uint16_t metadata_mask = TBD_METADATA_NONE;
 
 	/* If nothing changes we issue no command */
 	if(a->mtime != b->mtime)
-		metadata_mask |= OTAP_METADATA_MTIME;
+		metadata_mask |= TBD_METADATA_MTIME;
 	if(a->uid != b->uid)
-		metadata_mask |= OTAP_METADATA_UID;
+		metadata_mask |= TBD_METADATA_UID;
 	if(a->gid != b->gid)
-		metadata_mask |= OTAP_METADATA_GID;
+		metadata_mask |= TBD_METADATA_GID;
 	if(a->mode != b->mode)
-		metadata_mask |= OTAP_METADATA_MODE;
+		metadata_mask |= TBD_METADATA_MODE;
 
 	return metadata_mask;
 }
@@ -185,10 +185,10 @@ _otap_create_cmd_file_metadata_update(FILE        *stream,
 	int err;
 	uint16_t metadata_mask = _otap_metadata_mask(a, b);
 
-	if(metadata_mask == OTAP_METADATA_NONE)
+	if(metadata_mask == TBD_METADATA_NONE)
 		return 0;
 	/* TODO: Optimize protocol by only sending useful metadata */
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_FILE_METADATA_UPDATE)) != 0 ||
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_FILE_METADATA_UPDATE)) != 0 ||
 	   (err = _otap_create_fwrite_mdata_mask (stream, metadata_mask))         != 0 ||
 	   (err = _otap_create_fwrite_mtime      (stream, b->mtime))              != 0 ||
 	   (err = _otap_create_fwrite_uid        (stream, b->uid))                != 0 ||
@@ -206,11 +206,11 @@ _otap_create_cmd_file_delta(FILE        *stream,
 {
 	FILE* fpa = tbd_stat_fopen(a, "rb");
 	if(fpa == NULL)
-		otap_error(OTAP_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING);
+		otap_error(TBD_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING);
 	FILE* fpb = tbd_stat_fopen(b, "rb");
 	if(fpb == NULL) {
 		fclose(fpa);
-		otap_error(OTAP_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING);
+		otap_error(TBD_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING);
 	}
 
 	// Calculate start.
@@ -239,7 +239,7 @@ _otap_create_cmd_file_delta(FILE        *stream,
 	if((fseek(fpa, 0, SEEK_END) != 0) || (fseek(fpb, 0, SEEK_END) != 0)) {
 		fclose(fpa);
 		fclose(fpb);
-		otap_error(OTAP_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM);
 	}
 
 	// Find length.
@@ -249,7 +249,7 @@ _otap_create_cmd_file_delta(FILE        *stream,
 	if((flena < 0) || (flenb < 0)) {
 		fclose(fpa);
 		fclose(fpb);
-		otap_error(OTAP_ERROR_UNABLE_TO_DETECT_STREAM_POSITION);
+		otap_error(TBD_ERROR_UNABLE_TO_DETECT_STREAM_POSITION);
 	}
 
 	// Find end.
@@ -265,14 +265,14 @@ _otap_create_cmd_file_delta(FILE        *stream,
 		    || (fseek(fpb, flenb - (o + blks[1]), SEEK_SET) != 0)) {
 			fclose(fpa);
 			fclose(fpb);
-			otap_error(OTAP_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM);
 		}
 
 		if((fread(buff[0], 1, blks[0], fpa) != blks[0])
 		    || (fread(buff[1], 1, blks[1], fpb) != blks[1])) {
 			fclose(fpa);
 			fclose(fpb);
-			otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 		}
 
 		uintptr_t i, ja, jb;
@@ -307,7 +307,7 @@ _otap_create_cmd_file_delta(FILE        *stream,
 
 	/* TODO: Optimize protocol by only sending useful metadata */
 	int err;
-	if(((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_FILE_DELTA))  != 0) ||
+	if(((err = _otap_create_fwrite_cmd(stream, TBD_CMD_FILE_DELTA))  != 0) ||
 	    ((err = _otap_create_fwrite_string(stream, b->name))           != 0) ||
 	    ((err = _otap_create_fwrite_mdata_mask(stream, metadata_mask)) != 0) ||
 	    ((err = _otap_create_fwrite_mtime (stream, b->mtime))          != 0) ||
@@ -321,22 +321,22 @@ _otap_create_cmd_file_delta(FILE        *stream,
 	    (fwrite(&end,   sizeof(uint32_t), 1, stream) != 1)   ||
 	    (fwrite(&size,  sizeof(uint32_t), 1, stream) != 1)) {
 		fclose(fpb);
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	}
 	if(fseek(fpb, start, SEEK_SET) != 0) {
 		fclose(fpb);
-		otap_error(OTAP_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM);
 	}
 
 	for(o = 0; o < size; o += 256) {
 		uintptr_t csize = ((size - o) > 256 ? 256 : (size - o));
 		if(fread(buff[0], 1, csize, fpb) != csize) {
 			fclose(fpb);
-			otap_error(OTAP_ERROR_UNABLE_TO_READ_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_READ_STREAM);
 		}
 		if(fwrite(buff[0], 1, csize, stream) != csize) {
 			fclose(fpb);
-			otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+			otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 		}
 	}
 
@@ -350,7 +350,7 @@ _otap_create_cmd_dir_create(FILE        *stream,
 {
 	int err;
 
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_DIR_CREATE)) != 0 ||
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_DIR_CREATE)) != 0 ||
 	   (err = _otap_create_fwrite_string(stream, d->name)) != 0 ||
 	   (err = _otap_create_fwrite_mtime(stream, d->mtime)) != 0 ||
 	   (err = _otap_create_fwrite_uid(stream, d->uid))     != 0 ||
@@ -365,7 +365,7 @@ _otap_create_cmd_dir_enter(FILE       *stream,
                            const char *name)
 {
 	int err;
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_DIR_ENTER)) != 0)
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_DIR_ENTER)) != 0)
 		return err;
 	return _otap_create_fwrite_string(stream, name);
 }
@@ -377,7 +377,7 @@ _otap_create_cmd_dir_leave(FILE      *stream,
 	if(count == 0)
 		return 0;
 	int err;
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_DIR_LEAVE)) != 0)
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_DIR_LEAVE)) != 0)
 		return err;
 
 	uint8_t token;
@@ -385,13 +385,13 @@ _otap_create_cmd_dir_leave(FILE      *stream,
 		token = 255;
 		for(; count > 256; count -= 256) {
 			if(fwrite(&token, sizeof (uint8_t), 1, stream) != 1)
-				otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+				otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 		}
 	}
 
 	token = (count - 1);
 	if(fwrite(&token, 1, 1, stream) != 1)
-		otap_error(OTAP_ERROR_UNABLE_TO_WRITE_STREAM);
+		otap_error(TBD_ERROR_UNABLE_TO_WRITE_STREAM);
 	return 0;
 }
 
@@ -400,7 +400,7 @@ _otap_create_cmd_entity_delete(FILE       *stream,
                                const char *name)
 {
 	int err;
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_ENTITY_DELETE)) != 0)
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_ENTITY_DELETE)) != 0)
 		return err;
 	return _otap_create_fwrite_string(stream, name);
 }
@@ -413,10 +413,10 @@ _otap_create_cmd_dir_delta(FILE        *stream,
 	int err;
 	uint16_t metadata_mask = _otap_metadata_mask(a, b);
 
-	if(metadata_mask == OTAP_METADATA_NONE)
+	if(metadata_mask == TBD_METADATA_NONE)
 		return 0;
 
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_DIR_DELTA))    != 0 ||
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_DIR_DELTA))    != 0 ||
 	   (err = _otap_create_fwrite_mdata_mask (stream, metadata_mask)) != 0 ||
 	   (err = _otap_create_fwrite_mtime      (stream, b->mtime))      != 0 ||
 	   (err = _otap_create_fwrite_uid        (stream, b->uid))        != 0 ||
@@ -438,10 +438,10 @@ _otap_create_cmd_symlink_create(FILE        *stream,
 	ssize_t len = readlink(slpath, path, sizeof(path)-1);
 	free(slpath);
 	if(len < 0)
-		return OTAP_ERROR_UNABLE_TO_READ_SYMLINK;
+		return TBD_ERROR_UNABLE_TO_READ_SYMLINK;
 	path[len] = '\0';
 
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_SYMLINK_CREATE)) != 0 ||
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_SYMLINK_CREATE)) != 0 ||
 	   (err = _otap_create_fwrite_mtime (stream, symlink->mtime)) != 0 ||
 	   (err = _otap_create_fwrite_uid   (stream, symlink->uid)) != 0 ||
 	   (err = _otap_create_fwrite_gid   (stream, symlink->gid)) != 0 ||
@@ -470,7 +470,7 @@ _otap_create_cmd_symlink_delta(FILE        *stream,
 	free(spath_b);
 
 	if(len_a < 0 || len_b < 0)
-		return OTAP_ERROR_UNABLE_TO_READ_SYMLINK;
+		return TBD_ERROR_UNABLE_TO_READ_SYMLINK;
 
 	path_a[len_a] = path_b[len_b] = '\0';
 
@@ -494,7 +494,7 @@ _otap_create_cmd_special_create(FILE        *stream,
 {
 	int err;
 
-	if((err = _otap_create_fwrite_cmd(stream, OTAP_CMD_SPECIAL_CREATE)) != 0 ||
+	if((err = _otap_create_fwrite_cmd(stream, TBD_CMD_SPECIAL_CREATE)) != 0 ||
 	   (err = _otap_create_fwrite_string(stream, nod->name))            != 0 ||
 	   (err = _otap_create_fwrite_mtime (stream, nod->mtime))           != 0 ||
 	   (err = _otap_create_fwrite_mode  (stream, nod->mode))             != 0 ||
@@ -509,21 +509,21 @@ _otap_create_cmd_special_delta(FILE        *stream,
                                tbd_stat_t  *a,
                                tbd_stat_t  *b)
 {
-	uint16_t metadata_mask = OTAP_METADATA_NONE;
+	uint16_t metadata_mask = TBD_METADATA_NONE;
 
 	/* If nothing changes we issue no command */
 	if(a->mtime != b->mtime)
-		metadata_mask |= OTAP_METADATA_MTIME;
+		metadata_mask |= TBD_METADATA_MTIME;
 	if(a->uid != b->uid)
-		metadata_mask |= OTAP_METADATA_UID;
+		metadata_mask |= TBD_METADATA_UID;
 	if(a->gid != b->gid)
-		metadata_mask |= OTAP_METADATA_GID;
+		metadata_mask |= TBD_METADATA_GID;
 	if(a->mode != b->mode)
-		metadata_mask |= OTAP_METADATA_MODE;
+		metadata_mask |= TBD_METADATA_MODE;
 	if(a->rdev != b->rdev)
-		metadata_mask |= OTAP_METADATA_RDEV;
+		metadata_mask |= TBD_METADATA_RDEV;
 
-	if(metadata_mask != OTAP_METADATA_NONE)
+	if(metadata_mask != TBD_METADATA_NONE)
 		return 0;
 
 	int err;
@@ -547,7 +547,7 @@ _otap_create_dir(FILE        *stream,
 		tbd_stat_t* f = tbd_stat_entry(d, i);
 
 		if(f == NULL)
-			otap_error(OTAP_ERROR_UNABLE_TO_STAT_FILE);
+			otap_error(TBD_ERROR_UNABLE_TO_STAT_FILE);
 
 		switch(f->type) {
 		case TBD_STAT_TYPE_FILE:
@@ -567,7 +567,7 @@ _otap_create_dir(FILE        *stream,
 			break;
 		default:
 			tbd_stat_free(f);
-			otap_error(OTAP_ERROR_FEATURE_NOT_IMPLEMENTED);
+			otap_error(TBD_ERROR_FEATURE_NOT_IMPLEMENTED);
 			break;
 		}
 		tbd_stat_free(f);
@@ -585,7 +585,7 @@ _otap_create(FILE        *stream,
              bool         top)
 {
 	if((a == NULL) && (b == NULL))
-		otap_error(OTAP_ERROR_NULL_POINTER);
+		otap_error(TBD_ERROR_NULL_POINTER);
 
 	int err;
 	if(((b == NULL) || ((a != NULL) && (a->type != b->type)))) {
@@ -612,7 +612,7 @@ _otap_create(FILE        *stream,
 			fprintf(stderr, "special new %s\n", b->name);
 			return _otap_create_cmd_special_create(stream, b);
 		default:
-			otap_error(OTAP_ERROR_FEATURE_NOT_IMPLEMENTED);
+			otap_error(TBD_ERROR_FEATURE_NOT_IMPLEMENTED);
 			break;
 		}
 	}
@@ -648,7 +648,7 @@ _otap_create(FILE        *stream,
 	for(i = 0; i < b->size; i++) {
 		tbd_stat_t* _b = tbd_stat_entry(b, i);
 		if(_b == NULL)
-			otap_error(OTAP_ERROR_UNABLE_TO_STAT_FILE);
+			otap_error(TBD_ERROR_UNABLE_TO_STAT_FILE);
 		tbd_stat_t* _a = tbd_stat_entry_find(a, _b->name);
 		err = _otap_create(stream, _a, _b, false);
 		tbd_stat_free(_a);
@@ -661,7 +661,7 @@ _otap_create(FILE        *stream,
 	for(i = 0; i < a->size; i++) {
 		tbd_stat_t* _a = tbd_stat_entry(a, i);
 		if(_a == NULL)
-			otap_error(OTAP_ERROR_UNABLE_TO_STAT_FILE);
+			otap_error(TBD_ERROR_UNABLE_TO_STAT_FILE);
 		tbd_stat_t* _b = tbd_stat_entry_find(b, _a->name);
 		fprintf(stderr, "file delete %s\n", _a->name);
 		err = (_b != NULL ? 0 : _otap_create_cmd_entity_delete(stream, _a->name));
@@ -682,7 +682,7 @@ otap_create(FILE        *stream,
             tbd_stat_t *b)
 {
 	if((stream == NULL) || (a == NULL) || (b == NULL))
-		otap_error(OTAP_ERROR_NULL_POINTER);
+		otap_error(TBD_ERROR_NULL_POINTER);
 
 	int err;
 	if((err = _otap_create_cmd_ident(stream)) != 0)
diff --git a/tbdiff.h b/tbdiff.h
index aaa39ae..a3a61fd 100644
--- a/tbdiff.h
+++ b/tbdiff.h
@@ -24,54 +24,54 @@
 #include "libtbd_stat.h"
 
 typedef enum {
-	OTAP_CMD_IDENTIFY             = 0x00,
-	OTAP_CMD_UPDATE               = 0x01,
-	OTAP_CMD_DIR_CREATE           = 0x10,
-	OTAP_CMD_DIR_ENTER            = 0x11,
-	OTAP_CMD_DIR_LEAVE            = 0x12,
-	OTAP_CMD_DIR_DELTA            = 0x13,
-	OTAP_CMD_FILE_CREATE          = 0x20,
-	OTAP_CMD_FILE_DELTA           = 0x21,
-	OTAP_CMD_FILE_METADATA_UPDATE = 0x22,
-	OTAP_CMD_ENTITY_MOVE          = 0x30,
-	OTAP_CMD_ENTITY_COPY          = 0x31,
-	OTAP_CMD_ENTITY_DELETE        = 0x32,
-	OTAP_CMD_SYMLINK_CREATE       = 0x40,
-	OTAP_CMD_SPECIAL_CREATE       = 0x50,
+	TBD_CMD_IDENTIFY             = 0x00,
+	TBD_CMD_UPDATE               = 0x01,
+	TBD_CMD_DIR_CREATE           = 0x10,
+	TBD_CMD_DIR_ENTER            = 0x11,
+	TBD_CMD_DIR_LEAVE            = 0x12,
+	TBD_CMD_DIR_DELTA            = 0x13,
+	TBD_CMD_FILE_CREATE          = 0x20,
+	TBD_CMD_FILE_DELTA           = 0x21,
+	TBD_CMD_FILE_METADATA_UPDATE = 0x22,
+	TBD_CMD_ENTITY_MOVE          = 0x30,
+	TBD_CMD_ENTITY_COPY          = 0x31,
+	TBD_CMD_ENTITY_DELETE        = 0x32,
+	TBD_CMD_SYMLINK_CREATE       = 0x40,
+	TBD_CMD_SPECIAL_CREATE       = 0x50,
 } tbd_cmd_e;
 
 typedef enum {
-	OTAP_METADATA_NONE  = 0x0,
-	OTAP_METADATA_MTIME = 0x1,
-	OTAP_METADATA_MODE  = 0x2,
-	OTAP_METADATA_UID   = 0x4,
-	OTAP_METADATA_GID   = 0x8,
-	OTAP_METADATA_RDEV   = 0x10,
+	TBD_METADATA_NONE  = 0x0,
+	TBD_METADATA_MTIME = 0x1,
+	TBD_METADATA_MODE  = 0x2,
+	TBD_METADATA_UID   = 0x4,
+	TBD_METADATA_GID   = 0x8,
+	TBD_METADATA_RDEV   = 0x10,
 } tbd_metadata_type_e;
 
 typedef enum {
-	OTAP_ERROR_SUCCESS =  0,
-	OTAP_ERROR_FAILURE = -1,
-	OTAP_ERROR_OUT_OF_MEMORY = -2,
-	OTAP_ERROR_NULL_POINTER = -3,
-	OTAP_ERROR_INVALID_PARAMETER = -4,
-	OTAP_ERROR_UNABLE_TO_READ_STREAM  = -5,
-	OTAP_ERROR_UNABLE_TO_WRITE_STREAM = -6,
-	OTAP_ERROR_UNABLE_TO_CREATE_DIR = -7,
-	OTAP_ERROR_UNABLE_TO_CHANGE_DIR = -8,
-	OTAP_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING = -9,
-	OTAP_ERROR_UNABLE_TO_OPEN_FILE_FOR_WRITING = -10,
-	OTAP_ERROR_FILE_ALREADY_EXISTS = -11,
-	OTAP_ERROR_UNABLE_TO_REMOVE_FILE = -12,
-	OTAP_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM = -13,
-	OTAP_ERROR_FEATURE_NOT_IMPLEMENTED = -14,
-	OTAP_ERROR_FILE_DOES_NOT_EXIST = -15,
-	OTAP_ERROR_UNABLE_TO_DETECT_STREAM_POSITION = -16,
-	OTAP_ERROR_UNABLE_TO_STAT_FILE = -17,
-	OTAP_ERROR_UNABLE_TO_READ_SYMLINK = -18,
-	OTAP_ERROR_UNABLE_TO_CREATE_SYMLINK = -19,
-	OTAP_ERROR_UNABLE_TO_READ_SPECIAL_FILE = -20,
-	OTAP_ERROR_UNABLE_TO_CREATE_SPECIAL_FILE = - 21,
+	TBD_ERROR_SUCCESS =  0,
+	TBD_ERROR_FAILURE = -1,
+	TBD_ERROR_OUT_OF_MEMORY = -2,
+	TBD_ERROR_NULL_POINTER = -3,
+	TBD_ERROR_INVALID_PARAMETER = -4,
+	TBD_ERROR_UNABLE_TO_READ_STREAM  = -5,
+	TBD_ERROR_UNABLE_TO_WRITE_STREAM = -6,
+	TBD_ERROR_UNABLE_TO_CREATE_DIR = -7,
+	TBD_ERROR_UNABLE_TO_CHANGE_DIR = -8,
+	TBD_ERROR_UNABLE_TO_OPEN_FILE_FOR_READING = -9,
+	TBD_ERROR_UNABLE_TO_OPEN_FILE_FOR_WRITING = -10,
+	TBD_ERROR_FILE_ALREADY_EXISTS = -11,
+	TBD_ERROR_UNABLE_TO_REMOVE_FILE = -12,
+	TBD_ERROR_UNABLE_TO_SEEK_THROUGH_STREAM = -13,
+	TBD_ERROR_FEATURE_NOT_IMPLEMENTED = -14,
+	TBD_ERROR_FILE_DOES_NOT_EXIST = -15,
+	TBD_ERROR_UNABLE_TO_DETECT_STREAM_POSITION = -16,
+	TBD_ERROR_UNABLE_TO_STAT_FILE = -17,
+	TBD_ERROR_UNABLE_TO_READ_SYMLINK = -18,
+	TBD_ERROR_UNABLE_TO_CREATE_SYMLINK = -19,
+	TBD_ERROR_UNABLE_TO_READ_SPECIAL_FILE = -20,
+	TBD_ERROR_UNABLE_TO_CREATE_SPECIAL_FILE = - 21,
 } tbd_error_e;
 
 #ifdef NDEBUG
@@ -80,7 +80,6 @@ typedef enum {
 #define otap_error(e) { if(e != 0) fprintf(stderr, "OTAP error '%s' in function '%s' at line %d of file '%s'.\n", #e, __FUNCTION__, __LINE__, __FILE__); return e; }
 #endif
 
-extern const char* otap_ident;
 extern int         otap_apply(FILE* stream);
 extern int         otap_create(FILE* stream, tbd_stat_t* a, tbd_stat_t* b);