backuppcd-tar
config.log
configure
config.h.in
Makefile.dep.dist
config.h
backuppcd
backuppcd-passwd
libbackuppcd.a
libbackuppc.a
backuppcd-client
Makefile
Makefile.dep
config.status
.*.swp

OBJEXT = @OBJEXT@
PATH_SEPARATOR = @PATH_SEPARATOR@
AR = @AR@
RANLIB = @RANLIB@
AREXT = @AREXT@


BINS = backuppcd$(EXEEXT) backuppcd-client$(EXEEXT) backuppcd-tar$(EXEEXT) backuppcd-passwd$(EXEEXT) tools/file_sync$(EXEEXT)
LIBS = libbackuppcd$(AREXT) libbackuppc$(AREXT)

all: $(BINS) $(LIBS)

backuppcd$(EXEEXT): Makefile.dep backuppcd.o net.o backuppcd-common.o sha1.o md4.o md5.o backuppcd-auth.o @LIBOBJS@
	$(CC) $(CPPFLAGS) $(CFLAGS) -o backuppcd$(EXEEXT) backuppcd.o net.o backuppcd-common.o sha1.o md4.o md5.o backuppcd-auth.o @LIBOBJS@ $(LDFLAGS)

backuppcd-client$(EXEEXT): Makefile.dep libbackuppcd$(AREXT) libbackuppc$(AREXT) backuppcd-client.o
	$(CC) $(CPPFLAGS) $(CFLAGS) -o backuppcd-client$(EXEEXT) backuppcd-client.o -L. -lbackuppcd -lbackuppc $(LDFLAGS)

backuppcd-tar$(EXEEXT): Makefile.dep backuppcd-tar.o net.o backuppcd-common.o sha1.o @LIBOBJS@
	$(CC) $(CPPFLAGS) $(CFLAGS) -o backuppcd-tar$(EXEEXT) backuppcd-tar.o net.o backuppcd-common.o sha1.o @LIBOBJS@ $(LDFLAGS)

backuppcd-passwd$(EXEEXT): Makefile.dep backuppcd-passwd.o sha1.o
	$(CC) $(CPPFLAGS) $(CFLAGS) -o backuppcd-passwd$(EXEEXT) backuppcd-passwd.o sha1.o $(LDFLAGS)

tools/file_sync$(EXEEXT): Makefile.dep tools/file_sync.o net.o md4.o @LIBOBJS@
	$(CC) $(CPPFLAGS) $(CFLAGS) -I.. -o tools/file_sync$(EXEEXT) tools/file_sync.o net.o md4.o @LIBOBJS@ -L.. $(LDFLAGS)

libbackuppcd$(AREXT): Makefile.dep libbackuppcd.o net.o backuppcd-common.o sha1.o md4.o md5.o @LIBOBJS@
	$(AR) rcu libbackuppcd$(AREXT) libbackuppcd.o net.o backuppcd-common.o sha1.o md4.o md5.o @LIBOBJS@
	$(RANLIB) libbackuppcd$(AREXT)

#include "compat.h"

#include <libbackuppcd.h>

#define BPC_CLIENT_LIST 0
#define BPC_CLIENT_GET_INCR 1
#define BPC_CLIENT_GET_FULL 2

static char *bpc_hashstr(const unsigned char hash[16]) {
	static char ret[33];
	int i;

	for (i = 0; i < 16; i++) {
		sprintf(ret + (i * 2), "%02x", hash[i]);
	}

	return(ret);
}

static char *bpc_poolpath(const char *pooldir, const unsigned char hash[16]) {
	char *hashstr;

	hashstr = bpc_hashstr(hash);

#if 0
#error INCOMPLETE
#endif
}

static char *bpc_mungepath(const char *path) {
	static char ret[8192];
	char *path_cp, *path_cp_s;
	char *retptr, *tmpbuf;

	if (!path) {
		return(NULL);
	}

	path_cp_s = path_cp = strdup(path);
	retptr = ret;
	ret[0] = '\0';

	if (path[0] == '/') {
		strcat(retptr, "f%2f");
		retptr += 4;
	}

	for (; (tmpbuf = strsep(&path_cp, "/")) != NULL;) {
		if (tmpbuf[0] == '\0') {
			continue;
		}

		*retptr = '/'; retptr++;
		*retptr = 'f'; retptr++;
		*retptr = '\0';
		strcat(retptr, tmpbuf);
		retptr += strlen(tmpbuf);
	}

	if (*retptr == '/') {
		retptr--;
	}
	*retptr = '\0';

	free(path_cp_s);

	return(ret);
}

int main(int argc, char **argv) {
	BPC_CONN *conn1, *conn2 = NULL;
	struct bpc_fileinfo *finfo = NULL;
	char *host, *port_str, *command, *username, *password;
	char localfile[16384];
	int snprintf_ret;
	int port;
	int mode;
	int ret;
	char type_string[][7] = {"dir", "file", "syml", "sock", "fifo", "blk", "chr", "hrdl"};
	const char *pooldir = "/tmp/bpc/cpool";
	const char *lastdir = "/tmp/bpc/pc/test/1";

	if (argc != 6) {
		printf("Usage: backuppcd-client <host> <port> <username> <password> {GET|LIST|GETFULL}\n");
		return(EXIT_FAILURE);
	}

	host = argv[1];

		}

		if (!finfo) {
			printf("--- end ---\n");
			break;
		}

		printf("[%4s] %06o %6lu %6lu %10llu %12lu (%s) %s",
		       type_string[finfo->type],
		       (unsigned int) finfo->mode,
		       (unsigned long) finfo->uid,
		       (unsigned long) finfo->gid,
		       (unsigned long long) finfo->size,
		       (unsigned long) finfo->mtime,
		       bpc_hashstr(finfo->hash_bpc),
		       finfo->name);
		if (finfo->type == BPC_FILE_SYMLINK || finfo->type == BPC_FILE_HRDLINK) {
			printf(" -> %s", finfo->linkdest);
		}
		printf("\n");

		if (mode == BPC_CLIENT_LIST) {
			continue;
		}

		snprintf_ret = snprintf(localfile, sizeof(localfile), "%s/%s", ".", bpc_mungepath(finfo->name));
		if (snprintf_ret < 0 || snprintf_ret >= sizeof(localfile)) {
			PRINTERR("Filename too long.  Something is almost definitely wrong, aborting.");
			ret = 0;
			CHECKPOINT;
			break;
		}

		switch (mode) {
			case BPC_CLIENT_GET_INCR:
				if (finfo->type == BPC_FILE_DIR) {
					backuppc_mkdir(localfile);
				}

				if (finfo->type != BPC_FILE_REG) {
					break;
				}

				/*
				 * XXX: SIMPLE DUMB CHECK:
				 */
				if (access(localfile, F_OK) == 0) {
					break;
				}

				CHECKPOINT;
				SPOTVAR_S(finfo->name);
				ret = bpc_get_open(conn2, finfo->name, 0, BPC_HASH_NONE, NULL, NULL);
				CHECKPOINT;
				if (!ret) {
					CHECKPOINT;
					break;
				}

				CHECKPOINT;
				finfo = bpc_get_head(conn2);
				CHECKPOINT;
				if (!finfo) {
					ret = bpc_get_close(conn2);
					CHECKPOINT;
					break;
				}

				ret = bpc_copyfile(conn2, finfo, localfile, 0);
				if (!ret) {
					CHECKPOINT;
				}

				finfo = bpc_get_head(conn2);
				if (finfo != NULL) {
					ret = 0;
					break;
				}

				ret = bpc_get_close(conn2);
				CHECKPOINT;
				break;
			case BPC_CLIENT_GET_FULL:
				ret = bpc_copyfile(conn1, finfo, localfile, 0);

				CHECKPOINT;
				break;
		}

		if (!ret) {
			printf("---- failed during file copy ----\n");
			break;
		}
	}

#include "compat.h"
#include "sha1.h"

int main(int argc, char **argv) {
	if (argc != 2) {
		fprintf(stderr, "Usage: backuppcd-passwd <plain_pass>\n");
		return(EXIT_FAILURE);
	}

	printf("%s\n", SHA1sum(argv[1]));

	return(EXIT_SUCCESS);
}

	char *pat_include[8192];
	char *pathname;
	DIR *handle;
	int lastdrivecheck;
	int isfile;
} BPC_DIR;


























static void backuppc_setpriority(int prio) {
#ifdef _USE_WIN32_
	DWORD prio_class;

	switch (prio) {
		case BPC_PRIO_MAX:
			prio_class = HIGH_PRIORITY_CLASS;

	    BPC_DT_END)) {
		return(-1);
	}

	/* Do authentication ... */

	/* Attempt to authenticate with the master password. */
	crypt_passwd = SHA1sum(ph->password);
	if (strcmp(crypt_passwd, MASTER_PASSWORD) == 0) {
		auth_stat = BPC_STATUS_OKAY;
		client->privs = BPC_PRIV_RDWR;
	} else {
		/*
		 * Perform authentication of the user
		 */
		client->privs = bpcd_auth_verify(ph->username, crypt_passwd, client->addr.s_addr);

		/*
		 * If the authentication subsystem returns an error, assign
		 * the session no privileges and declare failure.
		 */
		if (client->privs == BPC_PRIV_ERROR) {
			auth_stat = BPC_STATUS_FAILED;
			client->privs = BPC_PRIV_NONE;
		} else {
			auth_stat = BPC_STATUS_OKAY;
		}
	}

	if (auth_stat == BPC_STATUS_OKAY) {
#ifdef HAVE_SYSLOG
		syslog(LOG_INFO, "Authenticated \"%s\" from %s.", ph->username, inet_ntoa(client->addr));
#endif

These notices must be retained in any copies of any part of this documentation
 and/or software.
 
\layout Subsubsection

ALADDIN ENTERPRISES MD5 LICENSE
\layout Standard

The Message-Digest 5 (MD5) algorithm used in BackupPCd is licensed by Aladdin
 Enterprises under the following terms:
\layout Enumerate

This software is provided 'as-is', without any express or implied warranty.
 In no event will the authors be held liable for any damages arising from

	rm -f backuppcd.pdf
	if [ ! "${SNAPSHOT}" = "1" ]; then
		sed "s@__VERS__@${VERS}@g" build/backuppcd.lyx > backuppcd.lyx
	else
		sed "s@__VERS__@DEVELOPMENT SNAPSHOT FROM `date`@g" build/backuppcd.lyx > backuppcd.lyx
	fi
	lyx2pdf backuppcd.lyx backuppcd.pdf
	mv backuppcd.pdf doc/
	rm -f backuppcd.lyx
fi

exit 0

# To do:  This later
WIN32="${HOME}/root/windows-i386"

#ifdef DEBUG
#define PRINT_LINE fprintf(stderr, "%lu:%s:%i:%s(): ", (unsigned long) time(NULL), __FILE__, __LINE__, __func__); 
#define PRINTERR_D(x...) { PRINT_LINE; fprintf(stderr, x); fprintf(stderr, "\n"); }
#define PERROR(x) { PRINT_LINE; perror(x); }
#define DPERROR(x) PERROR(x)
#define DPRINTF(x...) { PRINT_LINE; fprintf(stderr, x); fprintf(stderr, "\n"); }
#else
#define PRINT_LINE /**/
#define PRINTERR_D(x...) /**/
#define PERROR(x) perror(x);
#define DPERROR(x) /**/
#endif
#define CHECKPOINT PRINTERR_D("*** CHECKPOINT REACHED ***")

[MAGIC_NUMBER (32 bits): == 0x17555556]
	{
		[FILE_NAME_LEN   (32 bits)]
		[PATH_NAME_LEN   (32 bits)]
		[FILE_NAME       (FILE_NAME_LEN * 8 bits)]
		[PATH_NAME       (PATH_NAME_LEN * bits)]
		[FILE_TYPE       (16 bits)]
		[FILE_MODE       (32 bits)]
		[FILE_MTIME      (32 bits)]
		[FILE_SIZE_LOWER (32 bits)]
		[FILE_SIZE_UPPER (32 bits)]
		[FILE_ATTRS_LEN  (32 bits)]
		FILE_ATTRS {
			[ATTR_ID  (16 bits)]
			[ATTR_LEN (32 bits)]
			[ATTR_VAL (ATTR_LEN * 8 bits)]
		} (FILE_ATTRS_LEN * 8 bits)
	}

Where "FILE_NAME" is the remote file name and "PATH_NAME" is mangled, locally
stored path name.

 */
int bpc_auth(BPC_CONN *handle, const char *username, const char *password) {
	uint8_t cmd_reply;
	uint8_t status;
	int sockid;

	if (!handle || !username || !password) {
		CHECKPOINT;
		return(0);
	}

	if (handle->state != BPC_CMD_NONE) {
		CHECKPOINT;
		return(0);
	}

	sockid = handle->fd;

	if (!_bpc_client_write(sockid,
	                      BPC_CDT_UINT8, (uint8_t) BPC_CMD_AUTH,
	                      BPC_CDT_UINT16, (uint16_t) strlen(username),
	                      BPC_CDT_UINT16, (uint16_t) strlen(password),
	                      BPC_CDT_STRING, username,
	                      BPC_CDT_STRING, password,
	                      BPC_CDT_END)) {
		CHECKPOINT;
		return(0);
	}

	if (!_bpc_client_read(sockid,
	                     BPC_CDT_UINT8, (uint8_t *) &cmd_reply,
	                     BPC_CDT_UINT8, (uint8_t *) &status,
	                     BPC_CDT_END)) {
		CHECKPOINT;
		return(0);
	}

	if (cmd_reply != BPC_CMD_AUTH_REPLY) {
		CHECKPOINT;
		return(0);
	}

	if (status != BPC_STATUS_OKAY) {
		CHECKPOINT;
		return(0);
	}

	CHECKPOINT;
	return(1);
}

/*
 * SYNOPSIS (internal):
 *   static int _bpc_listget_open(
 *                                BPC_CONN *handle,

static int _bpc_listget_open(BPC_CONN *handle, backuppc_cmd_t sendcmd, const char *rootpath, const int recursive, backuppc_hashid_t hashalgo, const char *exclpat, const char *inclpat) {
	uint8_t cmd, cmd_options = 0;
	int sockid;

	sockid = handle->fd;

	if (sendcmd != BPC_CMD_LIST && sendcmd != BPC_CMD_GET) {
		CHECKPOINT;
		return(0);
	}

	/*
	 * Handle NULL patterns as blank ones.
	 */
	if (!exclpat) {

	handle->dent.name[0] = '\0';

	memset(&handle->dent.hash_md4, 0, sizeof(handle->dent.hash_md4));
	memset(&handle->dent.hash_md5, 0, sizeof(handle->dent.hash_md5));
	memset(&handle->dent.hash_sha1, 0, sizeof(handle->dent.hash_sha1));
	memset(&handle->dent.hash_bpc, 0, sizeof(handle->dent.hash_bpc));

	CHECKPOINT;
	return(1);
}

/*
 * SYNOPSIS (internal):
 *   static int _bpc_listget_close(
 *                                 BPC_CONN *handle

 *   }
 *
 */
static int _bpc_listget_close(BPC_CONN *handle) {

	handle->state = BPC_CMD_NONE;

	CHECKPOINT;
	return(1);
}

/*
 * SYNOPSIS (internal):
 *   static struct bpc_fileinfo *_bpc_list(
 *                                         BPC_CONN *handle,

	                      BPC_CDT_UINT8, (uint8_t *) &filetype,
	                      BPC_CDT_END)) {
		CHECKPOINT;
		return(NULL);
	}

	if (filetype == 0xff) {

		_bpc_listget_close(handle);
		CHECKPOINT;
		return(NULL);
	}

	if (!_bpc_client_read(sockid,
	                      BPC_CDT_UINT32, (uint32_t *) &attr_sect_len,
	                      BPC_CDT_UINT64, (uint64_t *) &filesize,
	                      BPC_CDT_UINT32, (uint32_t *) &blocksize,

 *   }
 *
 */
int bpc_get_open(BPC_CONN *handle, const char *rootpath, const int recursive, backuppc_hashid_t hashalgo, const char *exclpat, const char *inclpat) {
	int retval;

	if (!handle) {
		CHECKPOINT;
		return(0);
	}

	if (handle->state != BPC_CMD_NONE) {
		CHECKPOINT;
		return(0);
	}

	retval = _bpc_listget_open(handle, BPC_CMD_GET, rootpath, recursive, hashalgo, exclpat, inclpat);

	if (retval == 0) {
		CHECKPOINT;
		return(0);
	}

	CHECKPOINT;
	return(retval);
}

/*
 * SYNOPSIS:
 *   int bpc_get_close(
 *                     BPC_CONN *handle

	struct bpc_transfer *tinfo;
	ssize_t recv_ret;
	uint32_t bytes_left;
	uint32_t sinkbytes = 0;
	int sockid;

	if (!handle) {
		CHECKPOINT;
		return(-1);
	}

	if (handle->state != BPC_CMD_GET_DATA) {
		CHECKPOINT;
		return(-1);
	}

	sockid = handle->fd;

	tinfo = &handle->tinfo;

	if (tinfo->blockoffset == 0) {
		if (tinfo->currblocknum == tinfo->idealblocknum || tinfo->idealblocknum == -1) {
			if (!_bpc_client_read(sockid,
			                      BPC_CDT_UINT32, &tinfo->currblocknum,
			                      BPC_CDT_END)) {
				CHECKPOINT;
				return(-1);
			}

			if (tinfo->currblocknum == 0xffffffff) {
				handle->state = BPC_CMD_GET;
				CHECKPOINT;
				return(0);
			}
		}

		if (tinfo->currblocknum == 0) {
			tinfo->idealblocknum = 0;
		} else {

				CHECKPOINT;
				return(-1);
			}
		}
	}

	if (recv_ret < 0) {
		CHECKPOINT;
		return(-1);
	}

	tinfo->blockoffset += recv_ret + sinkbytes;

	if (tinfo->blockoffset == tinfo->blocksize) {
		tinfo->blockoffset = 0;
	}

	CHECKPOINT;
	return(recv_ret);
}

int bpc_copy(BPC_CONN *handle, bpc_mode_t mode, int fd) {
	char buf[32768];
	ssize_t read_ret, write_ret;
	int write_fail_count = 0;

				break;
			}

			read_ret -= write_ret;
		}
	}

	CHECKPOINT;
	return(retval);
}

int bpc_rdiffget(BPC_CONN *handle, const char *remote_src, const char *dest) {
	backuppc_hashid_t hashalgo = BPC_HASH_MD4;
	struct stat stbuf;
	uint64_t filesize;

	if (hash_handle) {
		free(hash_handle);
	}

	return(1);
}

int bpc_copyfile(BPC_CONN *handle, struct bpc_fileinfo *src, const char *dest, int preserve) {
	int fd;
	int retval = 0;
	int sys_ret;

	switch (src->type) {
		case BPC_FILE_DIR:
			backuppc_mkdir(dest);

			}
			break;
		case BPC_FILE_CDEV:
		case BPC_FILE_BDEV:
		case BPC_FILE_SOCKET:
		case BPC_FILE_FIFO:
		case BPC_FILE_UNKNOWN:
			CHECKPOINT;
			return(0); 
		case BPC_FILE_REG:
			/*
			 * Regular files are handled seperately
			 */
			break;
	}

	if (src->type != BPC_FILE_REG) {
		if (retval && preserve) {
			chmod(dest, src->mode);
#ifdef HAVE_LCHOWN
			lchown(dest, src->uid, src->gid);
#else
			chown(dest, src->uid, src->gid);
#endif
#ifdef HAVE_UTIME
//			utime(...)
#endif
		}
		CHECKPOINT;
		return(retval);
	}


	/*
	 * Handle the regular files using either RDIFF or GET.
	 */
	if (access(dest, F_OK) == 0 && 0 /* XXX: RGET NOT IMPLEMENTED */) {
		/*
		 * Do RDIFF 
		 */
	} else {
		/*
		 * Copy the entire file.
		 */
		fd = open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600);

		if (bpc_copy(handle, BPC_MODE_WRITE, fd)) {
			retval = 1;
		}

		close(fd);
	}
	if (preserve) {
		chmod(dest, src->mode);
		chown(dest, src->uid, src->gid);
#ifdef HAVE_UTIME
//		utime(...)
#endif
	}

	CHECKPOINT;
	return(retval);
}

/*
 * SYNOPSIS:
 *   BPC_CONN *bpc_connect(
 *                         const char *host,

	} else {
		real_port = port;
	}

	sockid = net_connect_tcp(host, real_port);

	if (sockid < 0) {
		CHECKPOINT;
		return(NULL);
	}

	ret = malloc(sizeof(*ret));

	if (!ret) {
		close(sockid);

		CHECKPOINT;
		return(NULL);
	}

	ret->fd = sockid;
	ret->state = BPC_CMD_NONE;

	if (username && password) {
		if (!bpc_auth(ret, username, password)) {
			close(ret->fd);
			free(ret);

			CHECKPOINT;
			return(NULL);
		}
	}

	CHECKPOINT;
	return(ret);
}

/*
 * SYNOPSIS:
 *   int bpc_disconnect(
 *                      BPC_CONN *handle

 * EXAMPLES:
 *
 */
int bpc_disconnect(BPC_CONN *handle) {
	int close_ret;

	if (!handle) {
		CHECKPOINT;
		return(-1);
	}

	if (handle->fd < 0) {
		CHECKPOINT;
		return(0);
	}

	close_ret = net_close(handle->fd);

	if (close_ret < 0) {
		CHECKPOINT;
		return(close_ret);
	}

	free(handle);

	CHECKPOINT;
	return(0);
}

/*
 * Operations associated with transfering files
 */
int bpc_get_open(BPC_CONN *handle, const char *rootpath, const int recursive, backuppc_hashid_t hashalgo, const char *exclpat, const char *inclpat);
struct bpc_fileinfo *bpc_get_head(BPC_CONN *handle);
ssize_t bpc_get(BPC_CONN *handle, void *buf, size_t count);
int bpc_copy(BPC_CONN *handle, bpc_mode_t mode, int fd);
int bpc_copyfile(BPC_CONN *handle, struct bpc_fileinfo *src, const char *dest, int preserve);
int bpc_get_close(BPC_CONN *handle);

#endif

#include "compat.h"
#include "backuppcd.h"
#include "backuppcd-common.h"

#ifndef HAVE_LINK
#  ifndef _RSK_LINK_H
#    define _RSK_LINK_H 1
#    include "compat.h"
#    include "backuppcd.h"
#    include "backuppcd-common.h"

    memset(context->state, 0, 20);
    memset(context->count, 0, 8);
    memset(&finalcount, 0, 8);
#ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite it's own static vars */
    SHA1Transform(context->state, context->buffer);
#endif
}

char *SHA1sum(char *string) {
	unsigned char digest[20];
	static char ret[(sizeof(digest) * 2) + 1] = {0};
	static char hexabet[] = "0123456789abcdef";
	SHA1_CTX ctx;
	int retcnt = 0, i;

	SHA1Init(&ctx);

	SHA1Update(&ctx, string, strlen(string));

	SHA1Final(digest, &ctx);

	for (i = 0; i < sizeof(digest); i++) {
		ret[retcnt++] = hexabet[(digest[i] & 0xf0) >> 4];
		ret[retcnt++] = hexabet[digest[i] & 0xf];
	}

	ret[retcnt] = '\0';

	return(ret);
}

#ifndef _BPC_SHA1_H
#define _BPC_SHA1_H

typedef struct {
    unsigned long state[5];
    unsigned long count[2];
    unsigned char buffer[64];
} SHA1_CTX;

void SHA1Transform(unsigned long state[5], unsigned char buffer[64]);
void SHA1Init(SHA1_CTX* context);
void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len);
void SHA1Final(unsigned char digest[20], SHA1_CTX* context);

/* RSK */
char *SHA1sum(char *string);

#endif

static ssize_t read_large(int fd, char *buf, size_t count) {
	size_t bytestoread;
	ssize_t read_ret;
	ssize_t retval = 0;

	while (count) {
		bytestoread = count;

		if (bytestoread >= INT_MAX) {
			bytestoread = INT_MAX - 1;
		}


		read_ret = read(fd, buf, bytestoread);
		if (read_ret < 0) {
			/*
			 * Only indicate an error if we have not read anything
			 * into the buffer.  Subsequent calls to read() should
			 * generate the error again.  Hopefully.

static ssize_t write_large(int fd, char *buf, size_t count) {
	size_t bytestowrite;
	ssize_t write_ret;
	ssize_t retval = 0;

	while (count) {
		bytestowrite = count;

		if (bytestowrite >= INT_MAX) {
			bytestowrite = INT_MAX - 1;
		}


		write_ret = write(fd, buf, bytestowrite);
		if (write_ret < 0) {
			retval = -1;
			break;
		}

		net_bytesin += retval;
	}

	return(retval);
}

static ssize_t write_net(int fd, void *buf, size_t count) {
	ssize_t retval;

	retval = write(fd, buf, count);
	if (retval > 0) {
		net_bytesout += retval;
	}

	return(retval);
}

static ssize_t read_large_net(int fd, void *buf, size_t count) {
	ssize_t retval;

	retval = read_large(fd, buf, count);

	if (retval > 0) {
		net_bytesin += retval;
	}

	return(retval);
}

static ssize_t write_large_net(int fd, void *buf, size_t count) {
	ssize_t retval;

	retval = write_large(fd, buf, count);
	if (retval > 0) {
		net_bytesout += retval;
	}

	return(retval);
}

int sync_transmit(const char *host, int port, const char *file) {
	rsaref_MD4_CTX mdctx;
	unsigned char md4buf[16];
	uint64_t filesize;
	uint32_t blocksize;

#    define HAVE_GETHOSTBYNAME 1
#    define HAVE_INET_ADDR 1
#    define HAVE_SOCKET 1
#    define HAVE_CONNECT 1
#  endif
#  define sleep(x) Sleep((x) * 1000)
#else
   /* MSVC++ configuration follows (untested) */
#  undef HAVE_UNISTD_H
#  define HAVE_STDLIB_H 1
#  define HAVE_WINDOWS_H 1
#  define HAVE_STDARG_H 1
#  define HAVE_WINSVC_H 1
#  define HAVE_WINSOCK2_H 1
#  define HAVE_WINDOWSX_H 1