#include "ncplib_user.h"
#include "nwcrypt.h"

typedef __u8  byte;
typedef __u16 word;
typedef __u32 dword;

#include <sys/ioctl.h>
/* #include <sys/wait.h> */  /* generates a warning here */
extern pid_t wait(int *);
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include "ipxutil.h"

#define ncp_printf printf

static void
assert_server_locked(struct ncp_server *server);

static void
assert_server_not_locked(struct ncp_server *server)
{
	if (server->lock != 0) {
		ncp_printf("ncpfs: server already locked!\n");
	}
}

static void
ncp_lock_server(struct ncp_server *server)
{
	assert_server_not_locked(server);
	server->lock = 1;
}

static void
ncp_unlock_server(struct ncp_server *server)
{
	assert_server_locked(server);
	server->lock = 0;
}

static int
ncp_ioctl_request(struct ncp_server *server, int function) {

	struct ncp_reply_header *reply 
		= (struct ncp_reply_header *)(server->ncp_data);
	struct ncp_ioctl_request request;
	int result;

	assert_server_locked(server);

	if (server->has_subfunction != 0) {
		*(word *)(server->packet) = server->current_size - 2;
	}

	request.function = function;
	request.size     = server->current_size;
	request.data     = server->ncp_data;

	if ((result = ioctl(server->mount_fid, NCP_IOC_NCPREQUEST,
			    &request)) < 0) {
		return result;
	}

	server->ncp_reply_size = result - sizeof(struct ncp_reply_header);

	result = reply->completion_code;

	if ((result != 0)&&(server->silent==0)) {
		ncp_printf("ncp_request_error: %d\n", result);
	}
	return result;	
}

static int
do_ncp_call(struct ncp_server *server, int request_size)
{
	struct ncp_request_header request =
		*((struct ncp_request_header *)(&(server->ncp_data)));

	fd_set rd, wr, ex;
	struct timeval tv;

	int result;
	int retries = 3;

	while (retries > 0) {
		retries -= 1;

		result = sendto(server->ncp_sock, server->ncp_data,
				request_size,
				0, (struct sockaddr *)&(server->addr),
				sizeof(server->addr));

		if (result < 0) {
			return result;
		}

	re_select:
		FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&ex);
		FD_SET(server->ncp_sock, &rd);
		
		tv.tv_sec =  3;
		tv.tv_usec = 0;
		
		if (select(server->ncp_sock+1, &rd, &wr, &ex, &tv) == -1) {
			perror("select");
			return -1;
		}
		
		if (FD_ISSET(server->ncp_sock, &rd)) {
			int len = recv(server->ncp_sock,
				       server->ncp_data, NCP_PACKET_SIZE,
				       0);
			struct ncp_reply_header *r =
				(struct ncp_reply_header *)&(server->ncp_data);

			if (   (len == sizeof(*r))
			    && (r->type == NCP_POSITIVE_ACK)) {
				goto re_select;
			}
			if (   (len          >= sizeof(*r))
			    && (r->type      == NCP_REPLY)
			    && (   (request.type    == NCP_ALLOC_SLOT_REQUEST)
				|| (   (r->sequence  == request.sequence)
				    && (r->conn_low  == request.conn_low)
				    && (r->conn_high == request.conn_high)))) {
				server->reply_size = len;
				break;
			}
		}
	}
	return 0;
}

static int
ncp_user_request(struct ncp_server *server, int function)
{
	struct ncp_request_header *h =
		(struct ncp_request_header *)&(server->ncp_data);
	struct ncp_reply_header *r =
		(struct ncp_reply_header *)&(server->ncp_data);

	int result;

	assert_server_locked(server);

	if (server->has_subfunction != 0) {
		*(__u16 *)(server->packet) = server->current_size - 2;
	}

	h->type = NCP_REQUEST;

	server->sequence += 1;
	h->sequence = server->sequence;
	h->conn_low  = (server->connection) & 0xff; 
	h->conn_high = ((server->connection) & 0xff00) >> 8;
	h->task      = 1;
	h->function  = function;

	if (do_ncp_call(server, server->current_size + sizeof(*h)) != 0) {
		return -1;
	}
	
	server->completion  = r->completion_code;
	server->conn_status = r->connection_state;
	server->ncp_reply_size =
		server->reply_size - sizeof(struct ncp_reply_header);

	result = r->completion_code;

	if ((result != 0) && (server->silent == 0)) {
		ncp_printf("ncp_completion_code: %d\n", result);
	}
	return result;	
}

int
install_wdog(struct ncp_server *server)
{
	int parent_pid = getpid();
	int pid;
	int sock = server->wdog_sock;

	fd_set rd, wr, ex;
	struct timeval tv;
	char buf[1024];
	struct sockaddr_ipx sender;
	int sizeofaddr = sizeof(struct sockaddr_ipx);
	int pktsize;


	if ((pid = fork()) < 0) {
		return -1;
	}

	if (pid != 0) {
		/* Parent, should go on as usual */
		server->wdog_pid = pid;
		return 0;
	}

	while (1) {

		FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&ex);
		FD_SET(sock, &rd);

		/* every 120 seconds we look if our parent is
		   still alive */
		tv.tv_sec = 120;
		tv.tv_usec = 0;
		
		if (select(sock+1, &rd, &wr, &ex, &tv) == -1) {
			continue;
		}

		if (getppid() != parent_pid) {
			/* our parent has died, so nothing to do
			   anymore */
			exit(0);
		}

		if (FD_ISSET(sock, &rd)) {
			pktsize = recvfrom(sock, buf, sizeof(buf), 0,
					   (struct sockaddr *)&sender,
					   &sizeofaddr);
			if (pktsize < 0) {
				perror("recvfrom");
				continue;
			}
			if (   (pktsize != 2)
			    || (buf[1] != '?')) {
				continue;
			}
			buf[1] = 'Y';
			pktsize = sendto(sock, buf, 2, 0,
					 (struct sockaddr *)&sender,
					 sizeof(sender));
			if (pktsize < 0) {
				perror("send");
			}
		}
	}
}

int
ncp_connect(struct ncp_server *server)
{
	struct ncp_request_header *h =
		(struct ncp_request_header *)&(server->ncp_data);

	struct sockaddr_ipx addr;
	int len = sizeof(struct sockaddr_ipx);

	int ncp_sock, wdog_sock;
	int ncp_port, wdog_port;

	server->is_connected = NOT_CONNECTED;
	
	ncp_sock  = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
	if (ncp_sock == -1) {
		perror("open ncp socket");
		return -1;
	}

	wdog_sock = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
	if (wdog_sock == -1) {
		perror("open wdog socket");
		close(ncp_sock);
		return -1;
	}

	addr.sipx_family = AF_IPX;
	addr.sipx_network = htonl(0x0);
	ipx_assign_node(addr.sipx_node, IPX_THIS_NODE);
	addr.sipx_port = htons(0x0);
	addr.sipx_type = NCP_PTYPE;

	if (bind(ncp_sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
		perror("bind ncp socket");
		close(ncp_sock); close(wdog_sock);
		return -1;
	}

	if (bind(wdog_sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
		perror("bind wdog socket");
		close(ncp_sock); close(wdog_sock);
		return -1;
	}

	if (   (getsockname(ncp_sock, (struct sockaddr *)&addr, &len) != 0)
	    || (len != sizeof(struct sockaddr_ipx))) {
		perror("getsockname ncp socket");
		close(ncp_sock); close(wdog_sock);
		return -1;
	}
	ncp_port = ntohs(addr.sipx_port);
	
	if (   (getsockname(wdog_sock, (struct sockaddr *)&addr, &len) != 0)
	    || (len != sizeof(struct sockaddr_ipx))) {
		perror("getsockname wdog socket");
		close(wdog_sock); close(wdog_sock);
		return -1;
	}
	wdog_port = ntohs(addr.sipx_port);
	
	if (wdog_port != ncp_port+1) {
		fprintf(stderr, "did not alloc 2 consecutive ports\n");
		close(ncp_sock); close(wdog_sock);
		return -1;
	}

	server->ncp_sock = ncp_sock;
	server->wdog_sock = wdog_sock;

	h->type = NCP_ALLOC_SLOT_REQUEST;

	server->sequence = 0;
	h->sequence = server->sequence;
	h->conn_low  = 0xff;
	h->conn_high = 0xff;
	h->task      = 1;
	h->function  = 0;

	if (do_ncp_call(server, sizeof(*h)) != 0) {
		int saved_errno = errno;
		close(ncp_sock); close(wdog_sock);
		errno = saved_errno;
		return -1;
	}

	install_wdog(server);

	server->sequence = 0;
	server->connection = h->conn_low + (h->conn_high * 256);

	server->is_connected = CONN_SOCKET;

	return 0;
}

static int
ncp_user_disconnect(struct ncp_server *server)
{
	struct ncp_request_header *h
		= (struct ncp_request_header *)(server->ncp_data);
	int result;

	h->type = NCP_DEALLOC_SLOT_REQUEST;
	
	server->sequence += 1;
	h->sequence  = server->sequence;
	h->conn_low  = (server->connection) & 0xff;
	h->conn_high = ((server->connection) & 0xff00) >> 8;
	h->task      = 1;
	h->function  = 0;

	if ((result = do_ncp_call(server, sizeof(*h))) != 0) {
		return result;
	}

	close(server->ncp_sock);
	close(server->wdog_sock);
	kill(server->wdog_pid, SIGTERM);
	wait(NULL);
	return 0;
}
	

int
ncp_disconnect(struct ncp_server *server)
{
	int result = -1;

	switch (server->is_connected) {
	case CONN_MOUNTED:
		result = close(server->mount_fid);
	case CONN_SOCKET:
		result = ncp_user_disconnect(server);
	default:
	}
	if (result >= 0) {
		server->is_connected = NOT_CONNECTED;
	}
	return result;
}


int
ncp_connect_mount(struct ncp_server *server, const char *mount_point)
{
	server->mount_fid = open(mount_point, O_RDONLY, 0);

	if (server->mount_fid == -1) {
		return -1;

	}

	server->is_connected = CONN_MOUNTED;
	return 0;
}	

static int
ncp_request(struct ncp_server *server, int function)
{
	switch (server->is_connected) {
	case CONN_MOUNTED:
		return ncp_ioctl_request(server, function);
	case CONN_SOCKET:
		return ncp_user_request(server, function);
	default:
	}
	return -ENOTCONN;
}

static inline int
min(int a, int b) {
	if (a<b)
		return a;
	else
		return b;
}

static void
assert_server_locked(struct ncp_server *server)
{
	if (server->lock == 0) {
		ncp_printf("ncpfs: server not locked!\n");
	}
}

static void
ncp_add_byte(struct ncp_server *server, byte x)
{
	assert_server_locked(server);
	*(byte *)(&(server->packet[server->current_size])) = x;
	server->current_size += 1;
	return;
}

static void
ncp_add_word(struct ncp_server *server, word x)
{
	assert_server_locked(server);
	*(word *)(&(server->packet[server->current_size])) = x;
	server->current_size += 2;
	return;
}

static void
ncp_add_dword(struct ncp_server *server, dword x)
{
	assert_server_locked(server);
	*(dword *)(&(server->packet[server->current_size])) = x;
	server->current_size += 4;
	return;
}

static void
ncp_add_mem(struct ncp_server *server, const void *source, int size)
{
	assert_server_locked(server);
	memcpy(&(server->packet[server->current_size]), source, size);
	server->current_size += size;
	return;
}

static void
ncp_add_pstring(struct ncp_server *server, const char *s)
{
	int len = strlen(s);
	assert_server_locked(server);
	if (len > 255) {
		ncp_printf("ncpfs: string too long: %s\n", s);
		len = 255;
	}
	ncp_add_byte(server, len);
	ncp_add_mem(server, s, len);
	return;
}

static void
ncp_init_request(struct ncp_server *server)
{
	ncp_lock_server(server);

	server->current_size = 0;
	server->packet =
		&(server->ncp_data[sizeof(struct ncp_request_header)]);
	server->has_subfunction = 0;
}

static void
ncp_init_request_s(struct ncp_server *server, int subfunction)
{
	ncp_init_request(server);
	ncp_add_word(server, 0); /* preliminary size */

	ncp_add_byte(server, subfunction);

	server->has_subfunction = 1;
}

static char *
ncp_reply_data(struct ncp_server *server, int offset)
{
	return &(server->ncp_data[sizeof(struct ncp_reply_header) + offset]);
}

static byte
ncp_reply_byte(struct ncp_server *server, int offset)
{
	return *(byte *)(ncp_reply_data(server, offset));
}

static word
ncp_reply_word(struct ncp_server *server, int offset)
{
	return *(word *)(ncp_reply_data(server, offset));
}

static dword
ncp_reply_dword(struct ncp_server *server, int offset)
{
	return *(dword *)(ncp_reply_data(server, offset));
}

int
ncp_negotiate_buffersize(struct ncp_server *server,
			 int size, int *target) {

	int result;

	ncp_init_request(server);
	ncp_add_word(server, htons(size));
	
	if ((result = ncp_request(server, 33)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	*target =min(ntohs(ncp_reply_word(server, 0)), size);

	ncp_unlock_server(server);
	return 0;
}


/*
 * result is a 8-byte buffer
 */
int
ncp_get_encryption_key(struct ncp_server *server,
		       char *target)
{
	int result;

	ncp_init_request_s(server, 23);

	if ((result = ncp_request(server, 23)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	if (server->ncp_reply_size < 8) {
		ncp_printf("ncp_reply_size %d < 8\n",
		       server->ncp_reply_size);
		ncp_unlock_server(server);
		return result;
	}

	memcpy(target, ncp_reply_data(server, 0), 8);
	ncp_unlock_server(server);
	return 0;
}

int
ncp_get_bindery_object_id(struct ncp_server *server,
			  int object_type, char *object_name,
			  struct ncp_bindery_object *target)
{
	int result;
	ncp_init_request_s(server, 53);
	ncp_add_word(server, htons(object_type));
	ncp_add_pstring(server, object_name);

	if ((result = ncp_request(server, 23)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	if (server->ncp_reply_size < 54) {
		ncp_printf("ncp_reply_size %d < 54\n",
		       server->ncp_reply_size);
		ncp_unlock_server(server);
		return result;
	}

	target->object_id   = ntohl(ncp_reply_dword(server, 0));
	target->object_type = ntohs(ncp_reply_word (server, 4));
	memcpy(target->object_name, ncp_reply_data(server, 6), 48);
	ncp_unlock_server(server);
	return 0;
}

int
ncp_read_property_value(struct ncp_server *server,
			int object_type, char *object_name,
			int segment, char *prop_name,
			struct nw_property *target)
{
	int result;
	ncp_init_request_s(server, 61);
	ncp_add_word(server, htons(object_type));
	ncp_add_pstring(server, object_name);
	ncp_add_byte(server, segment);
	ncp_add_pstring(server, prop_name);

	if ((result = ncp_request(server, 23)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	memcpy(&(target->value), ncp_reply_data(server, 0), 128);
	target->more_flag = ncp_reply_byte(server, 128);
	target->property_flag = ncp_reply_byte(server, 129);
	ncp_unlock_server(server);
	return 0;
}

int
ncp_login_encrypted(struct ncp_server *server,
		    struct ncp_bindery_object *object,
		    unsigned char *key,
		    unsigned char *passwd)
{
	dword tmpID = htonl(object->object_id);
	unsigned char buf[128];
	unsigned char encrypted[8];
	int result;

	shuffle((byte *)&tmpID, passwd, strlen(passwd), buf);
	nw_encrypt(key, buf, encrypted);

	ncp_init_request_s(server, 24);
	ncp_add_mem(server, encrypted, 8);
	ncp_add_word(server, htons(object->object_type));
	ncp_add_pstring(server, object->object_name);

	if ((result = ncp_request(server, 23)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}

int
ncp_login_user(struct ncp_server *server,
	       unsigned char *username,
	       unsigned char *password)
{
	int result;
	unsigned char ncp_key[8];
	struct ncp_bindery_object user;

	if ((result = ncp_get_encryption_key(server, ncp_key)) != 0) {
		return result;
	}

	if ((result = ncp_get_bindery_object_id(server, NCP_BINDERY_USER,
						username, &user)) != 0) {
		return result;
	}

	if ((result = ncp_login_encrypted(server, &user,
					  ncp_key, password)) != 0) {
		return result;
	}
	return 0;
}

	

int
ncp_get_volume_info_with_number(struct ncp_server *server, int n,
				struct ncp_volume_info *target)
{
	int result;
	int len;

	ncp_init_request_s(server, 44);
	ncp_add_byte(server, n);

	if ((result = ncp_request(server, 22)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	target->total_blocks = ncp_reply_dword(server, 0);
	target->free_blocks  = ncp_reply_dword(server, 4);
	target->purgeable_blocks = ncp_reply_dword(server, 8);
	target->not_yet_purgeable_blocks = ncp_reply_dword(server, 12);
	target->total_dir_entries = ncp_reply_dword(server, 16);
	target->available_dir_entries = ncp_reply_dword(server, 20);
	target->sectors_per_block = ncp_reply_byte(server, 28);

	memset(&(target->volume_name), 0, sizeof(target->volume_name));

	len = ncp_reply_byte(server, 29);
	if (len > NCP_VOLNAME_LEN) {
		ncp_printf("ncpfs: volume name too long: %d\n", len);
		ncp_unlock_server(server);
		return -EIO;
	}

	memcpy(&(target->volume_name), ncp_reply_data(server, 30), len);
	ncp_unlock_server(server);
	return 0;
}

int
ncp_get_volume_number(struct ncp_server *server, const char *name, int *target)
{
	int result;

	ncp_init_request_s(server, 5);
	ncp_add_pstring(server, name);

	if ((result = ncp_request(server, 22)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	*target = ncp_reply_byte(server, 0);
	ncp_unlock_server(server);
	return 0;
}


int
ncp_file_search_init(struct ncp_server *server,
		     int dir_handle, const char *path,
		     struct ncp_filesearch_info *target)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, dir_handle);
	ncp_add_pstring(server, path);

	if ((result = ncp_request(server, 62)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	target->volume_number = ncp_reply_byte(server, 0);
	target->directory_id  = ntohs(ncp_reply_word(server, 1));
	target->sequence_no   = ntohs(ncp_reply_word(server, 3));
	target->access_rights = ncp_reply_byte(server, 5);
	ncp_unlock_server(server);
	return 0;
}
	

int
ncp_file_search_continue(struct ncp_server *server,
			 struct ncp_filesearch_info *fsinfo,
			 int attributes, const char *name,
			 struct ncp_file_info *target)
{
	int result;

	ncp_init_request(server);

	ncp_add_byte(server, fsinfo->volume_number);
	ncp_add_word(server, htons(fsinfo->directory_id));
	ncp_add_word(server, htons(fsinfo->sequence_no));

	ncp_add_byte(server, attributes);
	ncp_add_pstring(server, name);

	if ((result = ncp_request(server, 63)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	fsinfo->sequence_no = ntohs(ncp_reply_word(server, 0));

	memset(&(target->file_name), 0, sizeof(target->file_name));
	memcpy(&(target->file_name), ncp_reply_data(server, 4),
	       NCP_MAX_FILENAME);

	target->file_attributes = ncp_reply_byte(server, 18);
	target->file_mode       = ncp_reply_byte(server, 19);
	target->file_length     = ntohl(ncp_reply_dword(server, 20));
	target->creation_date   = ntohs(ncp_reply_word(server, 24));
	target->access_date     = ntohs(ncp_reply_word(server, 26));
	target->update_date     = ntohs(ncp_reply_word(server, 28));
	target->update_time     = ntohs(ncp_reply_word(server, 30));

	ncp_unlock_server(server);
	return 0;
}

int
ncp_get_finfo(struct ncp_server *server,
	      int dir_handle, const char *path, const char *name,
	      struct ncp_file_info *target)
{
	int result;

	struct ncp_filesearch_info fsinfo;

	if ((result = ncp_file_search_init(server, dir_handle, path,
					   &fsinfo)) != 0) {
		return result;
	}

	if ((result = ncp_file_search_continue(server, &fsinfo, 0, name,
					       target)) == 0) {
		return result;
	}

	if ((result = ncp_file_search_init(server, dir_handle, path,
					   &fsinfo)) != 0) {
		return result;
	}

	return ncp_file_search_continue(server, &fsinfo, aDIR, name, target);
}

int
ncp_open_file(struct ncp_server *server,
	      int dir_handle, const char *path,
	      int attr, int access,
	      struct ncp_file_info *target)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, dir_handle);
	ncp_add_byte(server, attr);
	ncp_add_byte(server, access);
	ncp_add_pstring(server, path);

	if ((result = ncp_request(server, 76)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	memcpy(&(target->file_id), ncp_reply_data(server, 0),
	       NCP_FILE_ID_LEN);
	
	memset(&(target->file_name), 0, sizeof(target->file_name));
	memcpy(&(target->file_name), ncp_reply_data(server, 8),
	       NCP_MAX_FILENAME);

	target->file_attributes = ncp_reply_byte(server, 22);
	target->file_mode       = ncp_reply_byte(server, 23);
	target->file_length     = ntohl(ncp_reply_dword(server, 24));
	target->creation_date   = ntohs(ncp_reply_word(server, 28));
	target->access_date     = ntohs(ncp_reply_word(server, 30));
	target->update_date     = ntohs(ncp_reply_word(server, 32));
	target->update_time     = ntohs(ncp_reply_word(server, 34));

	ncp_unlock_server(server);
	return 0;
}

int
ncp_close_file(struct ncp_server *server, const char *file_id)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, 0);
	ncp_add_mem(server, file_id, 6);

	if ((result = ncp_request(server, 66)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}

static int
ncp_do_create(struct ncp_server *server,
	      int dir_handle, const char *path,
	      int attr,
	      struct ncp_file_info *target,
	      int function)
{
	int result;
	
	ncp_init_request(server);
	ncp_add_byte(server, dir_handle);
	ncp_add_byte(server, attr);
	ncp_add_pstring(server, path);

	if ((result = ncp_request(server, function)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	memcpy(&(target->file_id), ncp_reply_data(server, 0),
	       NCP_FILE_ID_LEN);
	
	memset(&(target->file_name), 0, sizeof(target->file_name));
	memcpy(&(target->file_name), ncp_reply_data(server, 8),
	       NCP_MAX_FILENAME);

	target->file_attributes = ncp_reply_byte(server, 22);
	target->file_mode       = ncp_reply_byte(server, 23);
	target->file_length     = ntohl(ncp_reply_dword(server, 24));
	target->creation_date   = ntohs(ncp_reply_word(server, 28));
	target->access_date     = ntohs(ncp_reply_word(server, 30));
	target->update_date     = ntohs(ncp_reply_word(server, 32));
	target->update_time     = ntohs(ncp_reply_word(server, 34));

	ncp_unlock_server(server);
	return 0;
}	

int
ncp_create_newfile(struct ncp_server *server,
		   int dir_handle, const char *path,
		   int attr,
		   struct ncp_file_info *target)
{
	return ncp_do_create(server, dir_handle, path, attr, target, 77);
}

int
ncp_create_file(struct ncp_server *server,
		int dir_handle, const char *path,
		int attr,
		struct ncp_file_info *target)
{
	return ncp_do_create(server, dir_handle, path, attr, target, 67);
}

int
ncp_erase_file(struct ncp_server *server,
	       int dir_handle, const char *path,
	       int attr)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, dir_handle);
	ncp_add_byte(server, attr);
	ncp_add_pstring(server, path);

	if ((result = ncp_request(server, 68)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}
	
int
ncp_rename_file(struct ncp_server *server,
		int old_handle, const char *old_path,
		int attr,
		int new_handle, const char *new_path)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, old_handle);
	ncp_add_byte(server, attr);
	ncp_add_pstring(server, old_path);
	ncp_add_byte(server, new_handle);
	ncp_add_pstring(server, new_path);

	if ((result = ncp_request(server, 69)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}

int
ncp_create_directory(struct ncp_server *server,
		     int dir_handle, const char *path,
		     int inherit_mask)
{
	int result;

	ncp_init_request_s(server, 10);
	ncp_add_byte(server, dir_handle);
	ncp_add_byte(server, inherit_mask);
	ncp_add_pstring(server, path);

	if ((result = ncp_request(server, 22)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}

int
ncp_delete_directory(struct ncp_server *server,
		     int dir_handle, const char *path)
{
	int result;

	ncp_init_request_s(server, 11);
	ncp_add_byte(server, dir_handle);
	ncp_add_byte(server, 0); /* reserved */
	ncp_add_pstring(server, path);

	if ((result = ncp_request(server, 22)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}
	
int
ncp_rename_directory(struct ncp_server *server,
		     int dir_handle,
		     const char *old_path, const char *new_path)
{
	int result;

	ncp_init_request_s(server, 15);
	ncp_add_byte(server, dir_handle);
	ncp_add_pstring(server, old_path);
	ncp_add_pstring(server, new_path);

	if ((result = ncp_request(server, 22)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}


static void
ncp_add_handle_path(struct ncp_server *server,
		    __u8 vol_num,
		    __u32 dir_base, int have_dir_base,
		    char *path)
{
	ncp_add_byte(server, vol_num);
	ncp_add_dword(server, dir_base);
	if (have_dir_base != 0) {
		ncp_add_byte(server, 1); /* dir_base */
	} else {
		ncp_add_byte(server, 0xff); /* no handle */
	}
	if (path != NULL) {
		ncp_add_byte(server, 1); /* 1 component */
		ncp_add_pstring(server, path);
	}
	else
	{
		ncp_add_byte(server, 0);
	}
}

static void
ncp_extract_file_info(void *structure, struct nw_info_struct *target)
{
	__u8 *name_len;
	const int info_struct_size = sizeof(struct nw_info_struct) - 257;

	memcpy(target, structure, info_struct_size);
	name_len = structure + info_struct_size;
	target->nameLen = *name_len;
	strncpy(target->entryName, name_len+1, *name_len);
	target->entryName[*name_len] = '\0';
	return;
}

int
ncp_do_lookup(struct ncp_server *server,
	      struct nw_info_struct *dir,
	      char *path,	/* may only be one component */
	      struct nw_info_struct *target)
{
	__u8  vol_num;
	__u32 dir_base;
	int result;
	char *volname = NULL;

	if (target == NULL) {
		return -EINVAL;
	}
 
	if (dir == NULL) {

		/* Access a volume's root directory */
		ncp_init_request(server);
		ncp_add_byte(server, 22); /* subfunction */
		ncp_add_byte(server, 0); /* dos name space */
		ncp_add_byte(server, 0); /* reserved */
		ncp_add_byte(server, 0); /* reserved */
		ncp_add_byte(server, 0); /* reserved */
		ncp_add_handle_path(server, 0, 0, 0, /* no handle */
				    path);

		if ((result = ncp_request(server, 87)) != 0) {
			ncp_unlock_server(server);
			return result;
		}

		dir_base = ncp_reply_dword(server, 4);
		vol_num  = ncp_reply_byte (server, 8);
		ncp_unlock_server(server);
		volname = path;
		path = NULL;
	}
	else
	{
		vol_num = dir->volNumber;
		dir_base = dir->DosDirNum;
	}

	ncp_init_request(server);
	ncp_add_byte(server, 6); /* subfunction */
	ncp_add_byte(server, 0); /* dos name space */
	ncp_add_byte(server, 0); /* dos name space as dest */
	ncp_add_word(server, 0xff); /* get all */
	ncp_add_dword(server, RIM_ALL);
	ncp_add_handle_path(server, vol_num, dir_base, 1,
			    path);

	if ((result = ncp_request(server, 87)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_extract_file_info(ncp_reply_data(server, 0), target);

	if (volname != NULL) {
		target->nameLen = strlen(volname);
		strcpy(target->entryName, volname);
	}

	ncp_unlock_server(server);
	return 0;
}

int
ncp_modify_file_or_subdir_dos_info(struct ncp_server *server,
				   struct nw_info_struct *file,
				   __u32 info_mask,
				   struct nw_modify_dos_info *info)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, 7); /* subfunction */
	ncp_add_byte(server, 0); /* dos name space */
	ncp_add_byte(server, 0); /* reserved */
	ncp_add_word(server, 0x8006); /* search attribs: all */

	ncp_add_dword(server, info_mask);
	ncp_add_mem(server, info, sizeof(*info));
	ncp_add_handle_path(server, file->volNumber,
			    file->DosDirNum, 1, NULL);

	if ((result = ncp_request(server, 87)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}
	

	
int
ncp_del_file_or_subdir(struct ncp_server *server,
		       struct nw_info_struct *dir, char *name)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, 8); /* subfunction */
	ncp_add_byte(server, 0); /* dos name space */
	ncp_add_byte(server, 0); /* reserved */
	ncp_add_word(server, 0x8006); /* search attribs: all */
	ncp_add_handle_path(server, dir->volNumber,
			    dir->DosDirNum, 1, name);
	
	if ((result = ncp_request(server, 87)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}

static inline void
ConvertToNWfromDWORD ( __u32 sfd , __u8 ret[6] )
{
    __u16 *dest = (__u16 *) ret;
    memcpy(&(dest[1]), &sfd, 4);
    dest[0] = dest[1] + 1;
    return;
}

int
ncp_open_create_file_or_subdir(struct ncp_server *server,
			       struct nw_info_struct *dir, char *name,
			       int open_create_mode,
			       __u32 create_attributes,
			       int desired_acc_rights,
			       struct nw_file_info *target)
{
	int result;

	target->opened = 0;

	ncp_init_request(server);
	ncp_add_byte(server, 1); /* subfunction */
	ncp_add_byte(server, 0); /* dos name space */
	ncp_add_byte(server, open_create_mode);
	ncp_add_word(server, 0x8006);
	ncp_add_dword(server, RIM_ALL);
	ncp_add_dword(server, create_attributes);
	/* The desired acc rights seem to be the inherited rights mask
	   for directories */
	ncp_add_word(server, desired_acc_rights);
	ncp_add_handle_path(server, dir->volNumber,
			    dir->DosDirNum, 1, name);

	if ((result = ncp_request(server, 87)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	target->opened = 1;
	target->server_file_handle = ncp_reply_dword(server, 0);
	target->open_create_action = ncp_reply_byte(server, 4);
	ncp_extract_file_info(ncp_reply_data(server, 5), &(target->i));
	ConvertToNWfromDWORD(target->server_file_handle, target->file_handle);

	ncp_unlock_server(server);
	return 0;
}

int
ncp_initialize_search(struct ncp_server *server,
		      struct nw_info_struct *dir,
		      struct nw_search_sequence *target)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, 2); /* subfunction */
	ncp_add_byte(server, 0); /* dos name space */
	ncp_add_byte(server, 0); /* reserved */
	ncp_add_handle_path(server, dir->volNumber,
			    dir->DosDirNum, 1, NULL);
	
	if ((result = ncp_request(server, 87)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	memcpy(target, ncp_reply_data(server, 0), sizeof(*target));

	ncp_unlock_server(server);
	return 0;
}
	
/* Search for everything */
int
ncp_search_for_file_or_subdir(struct ncp_server *server,
			      struct nw_search_sequence *seq,
			      struct nw_info_struct *target)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, 3); /* subfunction */
	ncp_add_byte(server, 0); /* dos name space */
	ncp_add_byte(server, 0); /* data stream (???) */
	ncp_add_word(server, 0xffff); /* Search attribs */
	ncp_add_dword(server, RIM_ALL);	/* return info mask */
	ncp_add_mem(server, seq, 9);
	ncp_add_byte(server, 2); /* 2 byte pattern */
	ncp_add_byte(server, 0xff); /* following is a wildcard */
	ncp_add_byte(server, '*');
	
	if ((result = ncp_request(server, 87)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	memcpy(seq, ncp_reply_data(server, 0), sizeof(*seq));
	ncp_extract_file_info(ncp_reply_data(server, 10), target);

	ncp_unlock_server(server);
	return 0;
}

int
ncp_ren_or_mov_file_or_subdir(struct ncp_server *server,
			      struct nw_info_struct *old_dir, char *old_name,
			      struct nw_info_struct *new_dir, char *new_name)
{
	int result;

	if (   (old_dir == NULL) || (old_name == NULL)
	    || (new_dir == NULL) || (new_name == NULL))
		return -EINVAL;
	
	ncp_init_request(server);
	ncp_add_byte(server, 4); /* subfunction */
	ncp_add_byte(server, 0); /* dos name space */
	ncp_add_byte(server, 1); /* rename flag */
	ncp_add_word(server, 0x8006); /* search attributes */

	/* source Handle Path */
	ncp_add_byte(server, old_dir->volNumber);
	ncp_add_dword(server, old_dir->DosDirNum);
	ncp_add_byte(server, 1);
	ncp_add_byte(server, 1); /* 1 source component */

	/* dest Handle Path */
	ncp_add_byte(server, new_dir->volNumber);
	ncp_add_dword(server, new_dir->DosDirNum);
	ncp_add_byte(server, 1);
	ncp_add_byte(server, 1); /* 1 destination component */

	/* source path string */
	ncp_add_pstring(server, old_name);
	/* dest path string */
	ncp_add_pstring(server, new_name);

	result = ncp_request(server, 87);
	ncp_unlock_server(server);
	return result;
}
	

/* Create a new job entry */
int
ncp_create_queue_job_and_file(struct ncp_server *server,
			      __u32 queue_id,
			      struct queue_job *job)
{
	int result;

	ncp_init_request_s(server, 121);
	ncp_add_dword(server, htonl(queue_id));
	ncp_add_mem(server, &(job->j), sizeof(job->j));

	if ((result = ncp_request(server, 23)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	memcpy(&(job->j), ncp_reply_data(server, 0), 78);

	ConvertToNWfromDWORD(job->j.JobFileHandle, job->file_handle);

	ncp_unlock_server(server);
	return 0;
}

int
ncp_close_file_and_start_job(struct ncp_server *server,
			     __u32 queue_id,
			     struct queue_job *job)
{
	int result;

	ncp_init_request_s(server, 127);
	ncp_add_dword(server, htonl(queue_id));
	ncp_add_dword(server, job->j.JobNumber);

	if ((result = ncp_request(server, 23)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	ncp_unlock_server(server);
	return 0;
}	

int
ncp_read(struct ncp_server *server, const char *file_id,
	 __u32 offset, __u16 to_read,
	 char *target, int *bytes_read)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, 0);
	ncp_add_mem(server, file_id, 6);
	ncp_add_dword(server, htonl(offset));
	ncp_add_word(server, htons(to_read));

	if ((result = ncp_request(server, 72)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	*bytes_read = ntohs(ncp_reply_word(server, 0));

	memcpy(target, ncp_reply_data(server, 2), *bytes_read);

	ncp_unlock_server(server);
	return 0;
}
	
int
ncp_write(struct ncp_server *server, const char *file_id,
	  __u32 offset, __u16 to_write,
	  const char *source, int *bytes_written)
{
	int result;

	ncp_init_request(server);
	ncp_add_byte(server, 0);
	ncp_add_mem(server, file_id, 6);
	ncp_add_dword(server, htonl(offset));
	ncp_add_word(server, htons(to_write));
	ncp_add_mem(server, source, to_write);

	if ((result = ncp_request(server, 73)) != 0) {
		ncp_unlock_server(server);
		return result;
	}

	*bytes_written = to_write;

	ncp_unlock_server(server);
	return 0;
}