#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include "db.h"

typedef struct {
	char db_pathlen[2];
	char db_datasize[4];
	char db_marks;
} RDBHEAD;

static inline void
db_ntoch16(i, s)
	uint16_t i;
	char *s;
{
	s[0]=i%256;
	s[1]=i/256;
}

static inline uint16_t
db_chton16(s)
	const unsigned char *s;
{
	return (s[1]*256 + s[0]);
}

static inline void
db_ntoch32(i, s)
	uint32_t i;
	char *s;
{
	s[0]=i%256;
	
	i/=256;
	s[1]=i%256;
	
	i/=256;
	s[2]=i%256;
	
	s[3]=i/256;
}

static inline uint32_t
db_chton32(s)
	const unsigned char *s;
{
	return (((s[3]*256 + s[2])*256 + s[1])*256 + s[0]);
}

DB *
db_open(path, flags, mode)
	const char *path;
	int flags;
	mode_t mode;
{
	DB *p;

	if (!(p=(DB *)malloc(sizeof(DB))))
		return (NULL);
	if ((p->db_fd=open(path, flags, mode)) < 0) {
		free(p);
		return (NULL);
	}
	return (p);
}

int
db_close(p)
	DB *p;
{
	if (close(p->db_fd) < 0) {
		free(p);
		return (-1);
	}
	free(p);
	return (0);
}

int
db_put(p, head, data)
	DB *p;
	DBHEAD *head;
	void *data;
{
	RDBHEAD rdbhead;
	uint16_t pathlen=strlen(head->db_path);
	
	db_ntoch16(pathlen, rdbhead.db_pathlen);
	db_ntoch32(head->db_datasize, rdbhead.db_datasize);
	rdbhead.db_marks=head->db_marks;
	
	if (write(p->db_fd, &rdbhead, sizeof(RDBHEAD)) < 0)
		return (-1);
	if (write(p->db_fd, head->db_path, pathlen) < 0)
		return (-1);
	if (write(p->db_fd, data, head->db_datasize) < 0)
		return (-1);
	return (0);
}

int
db_argput(p, path, datasize, marks, data)
	DB *p;
	const char *path;
	int datasize, marks;
	void *data;
{
	RDBHEAD rdbhead;
	uint16_t pathlen=strlen(path);
	
	db_ntoch16(pathlen, rdbhead.db_pathlen);
	db_ntoch32(datasize, rdbhead.db_datasize);
	rdbhead.db_marks=marks;
	
	if (write(p->db_fd, &rdbhead, sizeof(RDBHEAD)) < 0)
		return (-1);
	if (write(p->db_fd, path, pathlen) < 0)
		return (-1);
	if (write(p->db_fd, data, datasize) < 0)
		return (-1);
	return (0);
}

int
db_get(p, head, data)
	DB *p;
	DBHEAD *head;
	void *data;
{
	RDBHEAD rdbhead;
	ssize_t n;
	uint16_t len;

	if ((n=read(p->db_fd, &rdbhead, sizeof(RDBHEAD))) <= 0)
		return ((n==0 ? 0 : -1));		
	head->db_marks=rdbhead.db_marks;
	head->db_datasize=db_chton32(rdbhead.db_datasize);
	len=db_chton16(rdbhead.db_pathlen);
	
	if (read(p->db_fd, head->db_path, len) <= 0)
		return (-1);
	head->db_path[len]=(char)0x0;
	
	if (read(p->db_fd, data, head->db_datasize) <= 0)
		return (-1);

	return (1);
}

int
db_readall(path, func, sp, buff)
	const char *path;
	int (*func)(DBHEAD *, void *, void *);
	void *sp, *buff;
{
	DBHEAD dbhead;
	DB *db;
	int ret;

	if (!(db=db_open(path, O_RDONLY, 0x0)))
		return (-1);

	while ((ret=db_get(db, &dbhead, buff)) > 0) {
		if ((ret=func(&dbhead, buff, sp))!=0) 
			break;
	}
	(void)db_close(db);

	if (ret)
		return (ret);
	return (0);
}