Import ncpfs 0.9

Makefile

@@ -2,17 +2,17 @@
 # Makefile for the linux ncp-filesystem routines.
 #
 
-KERNEL = 1.3
+KERNEL = 1.2
 
 INCLUDES =  -I/usr/src/linux/include -Ikernel
 BINDIR = ./bin
+SUBDIRS = kernel-$(KERNEL)/src util ipx-0.75
 
 CFLAGS = -Wall $(INCLUDES)
 CC = gcc
 
 all: kernel
-	make -C util
-	make -C kernel/src ncpfs.o
+	for i in $(SUBDIRS); do make -C $$i; done
 	cp kernel/src/ncpfs.o bin
 
 kernel:
@@ -20,7 +20,7 @@ kernel:
 	ln -s kernel-$(KERNEL) kernel
 
 dep:
-	$(CPP) -M $(INCLUDES) *.c > .depend
+	for i in $(SUBDIRS); do	make -C $$i dep; done
 
 clean:
 	rm -f kernel
@@ -28,10 +28,10 @@ clean:
 	rm -f `find . -type f -name '*~' -print`
 	rm -f `find . -type f -name '.depend' -print`
 	rm -f `find . -type f -name '*.out' -print`
-
+	for i in $(SUBDIRS); do	make -C $$i clean; done
 
 realclean: clean
-	rm -fr bin/* ncpfs.tgz util/mnt
+	rm -fr bin/* ncpfs.tgz
 	make -C util realclean
 
 modules: ncpfs.o

README

@@ -1,6 +1,16 @@
-This is version 0.6 of ncpfs, a free NetWare client for Linux. You
-need at least kernel 1.3.44 for this version. It does NOT work with
-any lower one, especially not with version 1.2.x.
+This is version 0.8 of ncpfs, a free NetWare client filesystem for
+Linux. This one currently works with Kernel 1.2.13. I do not know
+whether it works with any other kernel of the 1.2.x series, I only
+used it with 1.2.13.
+
+Due to problems in the 1.3.x IPX kernel code, ncpfs-0.8 does NOT work
+with any 1.3.x kernel up to 1.3.45, although there is a kernel-1.3
+subdirectory. It compiles fine and seems to work, but any connection
+will block after a very short time. Please be patient. I'm sure this
+will be solved. If you follow the kernel development closely, you
+might want to try ncpfs with a kernel later than 1.3.45, but I can not
+promise anything. To try it with 1.3, simply change the variable
+KERNEL in the Makefile from 1.2 to 1.3 and continue as usual.
 
 To install ncpfs, just type 'make'. After that, you find the
 neccessary kernel module and the mounting tools in ./bin. Type 'insmod

ipx-0.75/Makefile

@@ -0,0 +1,30 @@
+CFLAGS = -O2 -Wall
+BINDIR = ../bin
+UTILS = $(BINDIR)/ipx_configure $(BINDIR)/ipx_interface \
+	$(BINDIR)/ipx_internal_net $(BINDIR)/ipx_route
+
+all: $(UTILS)
+
+$(BINDIR)/ipx_configure: ipx_configure.o
+	$(CC) -o $(BINDIR)/ipx_configure ipx_configure.o
+
+$(BINDIR)/ipx_interface: ipx_interface.o
+	$(CC) -o $(BINDIR)/ipx_interface ipx_interface.o
+
+$(BINDIR)/ipx_internal_net: ipx_internal_net.o
+	$(CC) -o $(BINDIR)/ipx_internal_net ipx_internal_net.o
+
+$(BINDIR)/ipx_route: ipx_route.o
+	$(CC) -o $(BINDIR)/ipx_route ipx_route.o
+
+
+clean:
+	rm -f $(UTILS) *.o rip sap ipxrcv ipxsend
+
+install: $(UTILS)
+	for i in $(UTILS); \
+	do \
+		install --strip $$i /sbin; \
+		install $$i.8 /usr/man/man8; \
+	done
+

ipx-0.75/README

@@ -0,0 +1,65 @@
+This file contains a very short introduction to the IPX implementation
+on Linux.  Feel free to forward comments (especially suggested additions)
+to greg@caldera.com.
+
+The following are important definitions in understanding the descriptions
+in this README file.
+
+IPX Interface - This is the item to which IPX sockets are bound.
+An IPX interface corresponds to an IPX Network Number which corresponds 
+to a physical device and frame type.  A sample IPX Interface would be:
+Network Number: 0x00ABCDEF
+Device: Eth0 
+Frame Type: 802.2.
+The particular interface is selected during binding by using the
+Network Number (see sample code below).
+
+Primary Interface - The interface that is selected by default when
+binding a socket.  This is selected when binding by using
+a network number of 0 (see sample code below).
+
+Internal Network - This is a special kind of IPX interface that does
+not have a physical device or frame type.  It is used to provide
+a route-independent address for service providers.   Internal network
+numbers are optional; however, when one is present it is also the
+Primary Interface.
+
+This tar file contains the following IPX utilities:
+
+ipx_interface.c
+This program is used to create an IPX interface.  
+
+ipx_internal_net.c
+This program is used to create an IPX Internal Network number.  
+
+ipx_route.c
+This program creates an IPX route.
+
+ipx_configure.c
+This program is used to read/write two configuration parameters:
+	AUTO INTERFACE CREATE - IPX should/shouldn't automatically create
+		an IPX interface when it discovers one that has not been
+		registered via ipx_interface above.
+	AUTO PRIMARY SELECT - IPX should/shouldn't automatically select
+		a primary interface when it one an interface exists and
+		none are designated as the primary.  Manual designation
+		is performed via ipx_interface.
+
+By default, these are both turned off.
+				
+The following are sample IPX programs:
+
+ipxrcv.c and ipxsend.c 
+ipxsend will send a single packet to an instance of ipxrcv running on the 
+same machine.  It uses getsockname(2) to determine the address to which to 
+send the packet.  
+rip.c
+rip passively monitors the rip traffic on the attached IPX network.
+sap.c
+sap passively monitors the sap traffic on the attached IPX network.
+
+There are three files in /proc/net that relate to IPX.
+ipx_interface contains the list of IPX interfaces.
+ipx_route contains the list of IPX routes.
+ipx contains the list of IPX sockets in use.
+

ipx-0.75/ipx_interface.c

@@ -0,0 +1,303 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <strings.h>
+#include <netinet/in.h>
+#include <linux/ipx.h>
+#include <linux/if.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+static struct ifreq	id;
+static char	*progname;
+
+void
+usage(void)
+{
+	fprintf(stderr, "Usage: %s add [-p] device frame_type [net_number]\n\
+Usage: %s del device frame_type\n\
+Usage: %s check device frame_type\n", progname, progname, progname);
+	exit(-1);
+}
+
+struct frame_type {
+	char	*ft_name;
+	unsigned char	ft_val;
+}	frame_types[] = {
+	{"802.2",	IPX_FRAME_8022},
+	{"802.3",	IPX_FRAME_8023},
+	{"SNAP",	IPX_FRAME_SNAP},
+	{"EtherII",	IPX_FRAME_ETHERII}
+};
+
+#define NFTYPES	(sizeof(frame_types)/sizeof(struct frame_type))
+
+int
+lookup_frame_type(char *frame)
+{
+	int	j;
+
+	for (j = 0; (j < NFTYPES) && 
+		(strcasecmp(frame_types[j].ft_name, frame)); 
+		j++)
+		;
+
+	if (j != NFTYPES)
+		return j;
+
+	fprintf(stderr, "%s: Frame type must be", progname);
+	for (j = 0; j < NFTYPES; j++) {
+		fprintf(stderr, "%s%s", 
+			(j == NFTYPES-1) ? " or " : " ",
+			frame_types[j].ft_name);
+	}
+	fprintf(stderr, ".\n");
+	return -1;
+}
+
+int
+ipx_add_interface(int argc, char **argv)
+{
+	struct sockaddr_ipx	*sipx = (struct sockaddr_ipx *)&id.ifr_addr;
+	int	s;
+	int	result;
+	unsigned long	netnum;
+	char	errmsg[80];
+	int	i, fti = 0;
+	char	c;
+
+	sipx->sipx_special = IPX_SPECIAL_NONE;
+	sipx->sipx_network = 0L;
+	sipx->sipx_type = IPX_FRAME_NONE;
+	while ((c = getopt(argc, argv, "p")) > 0) {
+		switch (c) {
+		case 'p': sipx->sipx_special = IPX_PRIMARY; break;
+		}
+	}
+
+	if (((i = (argc - optind)) < 2) || (i > 3)) {
+		usage();
+	}
+
+	for (i = optind; i < argc; i++) {
+		switch (i-optind) {
+		case 0:	/* Physical Device - Required */
+			strcpy(id.ifr_name, argv[i]);
+			break;
+		case 1: /* Frame Type - Required */
+			fti = lookup_frame_type(argv[i]);
+			if (fti < 0)
+				exit(-1);
+			sipx->sipx_type = frame_types[fti].ft_val;
+			break;
+
+		case 2: /* Network Number - Optional */
+			netnum = strtoul(argv[i], (char **)NULL, 16);
+			if (netnum == 0xffffffffL) {
+				fprintf(stderr, 
+				"%s: Inappropriate network number %08lX\n", 
+					progname, netnum);
+				exit(-1);
+			}
+			sipx->sipx_network = htonl(netnum);
+			break;
+		}
+	}
+			
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		sprintf(errmsg, "%s: socket", progname);
+		perror(errmsg);
+		exit(-1);
+	}
+
+	i = 0;
+	sipx->sipx_family = AF_IPX;
+	sipx->sipx_action = IPX_CRTITF;
+	do {
+		result = ioctl(s, SIOCSIFADDR, &id);
+		i++;
+	}	while ((i < 5) && (result < 0) && (errno == EAGAIN));
+
+	if (result == 0) exit(0);
+		
+	switch (errno) {
+	case EEXIST:
+		fprintf(stderr, "%s: Primary network already selected.\n",
+			progname);
+		break;
+	case EADDRINUSE:
+		fprintf(stderr, "%s: Network number (%08lX) already in use.\n",
+			progname, htonl(sipx->sipx_network));
+		break;
+	case EPROTONOSUPPORT:
+		fprintf(stderr, "%s: Invalid frame type (%s).\n",
+			progname, frame_types[fti].ft_name);
+		break;
+	case ENODEV:
+		fprintf(stderr, "%s: No such device (%s).\n", progname,
+			id.ifr_name);
+		break;
+	case ENETDOWN:
+		fprintf(stderr, "%s: Requested device (%s) is down.\n", progname,
+			id.ifr_name);
+		break;
+	case EINVAL:
+		fprintf(stderr, "%s: Invalid device (%s).\n", progname,
+			id.ifr_name);
+		break;
+	case EAGAIN:
+		fprintf(stderr, 
+			"%s: Insufficient memory to create interface.\n",
+			progname);
+		break;
+	default:
+		sprintf(errmsg, "%s: ioctl", progname);
+		perror(errmsg);
+		break;
+	}
+	exit(-1);
+}
+
+int
+ipx_del_interface(int argc, char **argv)
+{
+	struct sockaddr_ipx	*sipx = (struct sockaddr_ipx *)&id.ifr_addr;
+	int	s;
+	int	result;
+	char	errmsg[80];
+	int	fti;
+	
+	if (argc != 3) {
+		usage();
+	}
+
+	sipx->sipx_network = 0L;
+	strcpy(id.ifr_name, argv[1]);
+	fti = lookup_frame_type(argv[2]);
+	if (fti < 0)
+		exit(-1);
+	sipx->sipx_type = frame_types[fti].ft_val;
+
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		sprintf(errmsg, "%s: socket", progname);
+		perror(errmsg);
+		exit(-1);
+	}
+	sipx->sipx_action = IPX_DLTITF;
+	sipx->sipx_family = AF_IPX;
+	result = ioctl(s, SIOCSIFADDR, &id);
+	if (result == 0) exit(0);
+
+	switch (errno) {
+	case EPROTONOSUPPORT:
+		fprintf(stderr, "%s: Invalid frame type (%s).\n",
+			progname, frame_types[fti].ft_name);
+		break;
+	case ENODEV:
+		fprintf(stderr, "%s: No such device (%s).\n", progname,
+			id.ifr_name);
+		break;
+	case EINVAL:
+		fprintf(stderr, "%s: No such IPX interface %s %s.\n", progname,
+			id.ifr_name, frame_types[fti].ft_name);
+		break;
+	default:
+		sprintf(errmsg, "%s: ioctl", progname);
+		perror(errmsg);
+		break;
+	}
+	exit(-1);
+}
+
+int
+ipx_check_interface(int argc, char **argv)
+{
+	struct sockaddr_ipx	*sipx = (struct sockaddr_ipx *)&id.ifr_addr;
+	int	s;
+	int	result;
+	char	errmsg[80];
+	int	fti;
+	
+	if (argc != 3) {
+		usage();
+	}
+
+	sipx->sipx_network = 0L;
+	strcpy(id.ifr_name, argv[1]);
+	fti = lookup_frame_type(argv[2]);
+	if (fti < 0)
+		exit(-1);
+	sipx->sipx_type = frame_types[fti].ft_val;
+
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		sprintf(errmsg, "%s: socket", progname);
+		perror(errmsg);
+		exit(-1);
+	}
+	sipx->sipx_family = AF_IPX;
+	result = ioctl(s, SIOCGIFADDR, &id);
+	if (result == 0) {
+		printf(
+	"IPX Address for (%s, %s) is %08lX:%02X%02X%02X%02X%02X%02X.\n",
+			argv[1], frame_types[fti].ft_name,
+			htonl(sipx->sipx_network), sipx->sipx_node[0],
+			sipx->sipx_node[1], sipx->sipx_node[2], 
+			sipx->sipx_node[3], sipx->sipx_node[4], 
+			sipx->sipx_node[5]);
+		exit(0);
+	}
+
+	switch (errno) {
+	case EPROTONOSUPPORT:
+		fprintf(stderr, "%s: Invalid frame type (%s).\n",
+			progname, frame_types[fti].ft_name);
+		break;
+	case ENODEV:
+		fprintf(stderr, "%s: No such device (%s).\n", progname,
+			id.ifr_name);
+		break;
+	case EADDRNOTAVAIL:
+		fprintf(stderr, "%s: No such IPX interface %s %s.\n", progname,
+			id.ifr_name, frame_types[fti].ft_name);
+		break;
+	default:
+		sprintf(errmsg, "%s: ioctl", progname);
+		perror(errmsg);
+		break;
+	}
+	exit(-1);
+}
+
+int
+main(int argc, char **argv)
+{
+	int	i;
+
+	progname = argv[0];
+	if (argc < 2) {
+		usage();
+		exit(-1);
+	}
+
+	if (strncasecmp(argv[1], "add", 3) == 0) {
+		for (i = 1; i < (argc-1); i++) 
+			argv[i] = argv[i+1];
+		ipx_add_interface(argc-1, argv);
+	} else if (strncasecmp(argv[1], "del", 3) == 0) {
+		for (i = 1; i < (argc-1); i++) 
+			argv[i] = argv[i+1];
+		ipx_del_interface(argc-1, argv);
+	} else if (strncasecmp(argv[1], "check", 5) == 0) {
+		for (i = 1; i < (argc-1); i++) 
+			argv[i] = argv[i+1];
+		ipx_check_interface(argc-1, argv);
+	} 
+	usage();
+	return 0;
+}

ipx-0.75/ipx_internal_net.c

@@ -0,0 +1,195 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <errno.h>
+#include <strings.h>
+#include <netinet/in.h>
+#include <linux/ipx.h>
+#include <linux/if.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+static struct ifreq	id;
+static char	*progname;
+
+void
+usage(void)
+{
+	fprintf(stderr, "Usage: %s add net_number(hex) node(hex)\n\
+Usage: %s del\n", progname, progname);
+	exit(-1);
+}
+
+int
+map_char_to_val(char dig)
+{
+	char	digit = tolower(dig);
+	if ((digit >= '0') && (digit <= '9')) {
+		return digit - '0';
+	} else if ((digit >= 'a') && (digit <= 'f')) {
+		return (10 + (digit - 'a'));
+	} else {
+		return 0;
+	}
+}
+
+int
+ipx_add_internal_net(int argc, char **argv)
+{
+	struct sockaddr_ipx	*sipx = (struct sockaddr_ipx *)&id.ifr_addr;
+	int	s;
+	int	result;
+	unsigned long	netnum;
+	char	errmsg[80];
+	int	nodelen;
+	char	*node;
+	char	tmpnode[13];
+	unsigned char	*tout;
+	char	*tin;
+	int	i;
+	
+	if (argc != 3) {
+		usage();
+	}
+
+	netnum = strtoul(argv[1], (char **)NULL, 16);
+	if ((netnum == 0L) || (netnum == 0xffffffffL)) {
+		fprintf(stderr, "%s: Inappropriate network number %08lX\n", 
+			progname, netnum);
+		exit(-1);
+	}
+
+	node = argv[2];
+	nodelen = strlen(node);
+	if (nodelen > 12) {
+		fprintf(stderr, "%s: Node length is too long (> 12).\n", progname);
+		exit(-1);
+	}
+	
+	for (i = 0; (i < nodelen) && isxdigit(node[i]); i++) 
+		;
+
+	if (i < nodelen) {
+		fprintf(stderr, "%s: Invalid value in node, must be hex digits.\n",
+			progname);
+		exit(-1);
+	}
+		
+	strcpy(tmpnode, "000000000000");
+	memcpy(&(tmpnode[12-nodelen]), node, nodelen);
+	for (tin = tmpnode, tout = sipx->sipx_node; *tin != '\0'; tin += 2, tout++)  {
+		*tout = (unsigned char) map_char_to_val(*tin);
+		*tout <<= 4;
+		*tout |= (unsigned char) map_char_to_val(*(tin+1));
+	}
+
+	if ((memcmp(sipx->sipx_node, "\0\0\0\0\0\0\0\0", IPX_NODE_LEN) == 0) ||
+		(memcmp(sipx->sipx_node, "\377\377\377\377\377\377", IPX_NODE_LEN) == 0)){
+		fprintf(stderr, "%s: Node is invalid.\n", progname);
+		exit(-1);
+	}
+
+	sipx->sipx_network = htonl(netnum);
+	sipx->sipx_type = IPX_FRAME_NONE;
+	sipx->sipx_special = IPX_INTERNAL;
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		sprintf(errmsg, "%s: socket", progname);
+		perror(errmsg);
+		exit(-1);
+	}
+
+	sipx->sipx_family = AF_IPX;
+	sipx->sipx_action = IPX_CRTITF;
+	i = 0;
+	do {
+		result = ioctl(s, SIOCSIFADDR, &id);
+		i++;
+	}	while ((i < 5) && (result < 0) && (errno == EAGAIN));
+
+	if (result == 0) exit(0);
+		
+	switch (errno) {
+	case EEXIST:
+		fprintf(stderr, "%s: Primary network already selected.\n",
+			progname);
+		break;
+	case EADDRINUSE:
+		fprintf(stderr, "%s: Network number (%08lX) already in use.\n",
+			progname, htonl(sipx->sipx_network));
+		break;
+	case EAGAIN:
+		fprintf(stderr, 
+			"%s: Insufficient memory to create internal net.\n",
+			progname);
+		break;
+	default:
+		sprintf(errmsg, "%s: ioctl", progname);
+		perror(errmsg);
+		break;
+	}
+	exit(-1);
+}
+
+int
+ipx_del_internal_net(int argc, char **argv)
+{
+	struct sockaddr_ipx	*sipx = (struct sockaddr_ipx *)&id.ifr_addr;
+	int	s;
+	int	result;
+	char	errmsg[80];
+	
+	if (argc != 1) {
+		usage();
+	}
+
+	sipx->sipx_network = 0L;
+	sipx->sipx_special = IPX_INTERNAL;
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		sprintf(errmsg, "%s: socket", progname);
+		perror(errmsg);
+		exit(-1);
+	}
+	sipx->sipx_family = AF_IPX;
+	sipx->sipx_action = IPX_DLTITF;
+	result = ioctl(s, SIOCSIFADDR, &id);
+	if (result == 0) exit(0);
+
+	switch (errno) {
+	case ENOENT:
+		fprintf(stderr, "%s: No internal network configured.\n", progname);
+		break;
+	default:
+		sprintf(errmsg, "%s: ioctl", progname);
+		perror(errmsg);
+		break;
+	}
+	exit(-1);
+}
+
+int
+main(int argc, char **argv)
+{
+	int	i;
+
+	progname = argv[0];
+	if (argc < 2) {
+		usage();
+		exit(-1);
+	}
+
+	if (strncasecmp(argv[1], "add", 3) == 0) {
+		for (i = 1; i < (argc-1); i++) 
+			argv[i] = argv[i+1];
+		ipx_add_internal_net(argc-1, argv);
+	} else if (strncasecmp(argv[1], "del", 3) == 0) {
+		for (i = 1; i < (argc-1); i++) 
+			argv[i] = argv[i+1];
+		ipx_del_internal_net(argc-1, argv);
+	}
+	usage();
+	return 0;
+}
+

ipx-0.75/ipx_route.c

@@ -0,0 +1,215 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <errno.h>
+#include <strings.h>
+#include <netinet/in.h>
+#include <linux/ipx.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <linux/route.h>
+
+static struct rtentry	rd;
+static char	*progname;
+
+int
+map_char_to_val(char dig)
+{
+	char	digit = tolower(dig);
+	if ((digit >= '0') && (digit <= '9')) {
+		return digit - '0';
+	} else if ((digit >= 'a') && (digit <= 'f')) {
+		return (10 + (digit - 'a'));
+	} else {
+		return 0;
+	}
+}
+
+void
+usage(void)
+{
+	fprintf(stderr, 
+	"Usage: %s add network(hex) router_network(hex) router_node(hex)\n\
+Usage: %s del network(hex)\n", progname, progname);
+	exit(-1);
+}
+
+int
+ipx_add_route(int argc, char **argv)
+{
+	/* Router */
+	struct sockaddr_ipx	*sr = (struct sockaddr_ipx *)&rd.rt_gateway;
+	/* Target */
+	struct sockaddr_ipx	*st = (struct sockaddr_ipx *)&rd.rt_dst;
+	int	s;
+	int	result;
+	int	nodelen;
+	int	i;
+	unsigned long	netnum;
+	char	errmsg[80];
+	char	*node;
+	char	*tin;
+	char	tmpnode[13];
+	unsigned char	*tout;
+	
+	if (argc != 4)
+		usage();
+
+	/* Network Number */
+	netnum = strtoul(argv[1], (char **)NULL, 16);
+	if ((netnum == 0xffffffffL) || (netnum == 0L)) {
+		fprintf(stderr, "%s: Inappropriate network number %08lX\n", 
+			progname, netnum);
+		exit(-1);
+	}
+	rd.rt_flags = RTF_GATEWAY;
+	st->sipx_network = htonl(netnum);
+
+	/* Router Network Number */
+	netnum = strtoul(argv[2], (char **)NULL, 16);
+	if ((netnum == 0xffffffffL) || (netnum == 0L)) {
+		fprintf(stderr, "%s: Inappropriate network number %08lX\n", 
+			progname, netnum);
+		exit(-1);
+	}
+	sr->sipx_network = htonl(netnum);
+	
+	/* Router Node */
+	node = argv[3];
+	nodelen = strlen(node);
+	if (nodelen > 12) {
+		fprintf(stderr, "%s: Node length is too long (> 12).\n", 
+			progname);
+		exit(-1);
+	}
+	
+	for (i = 0; (i < nodelen) && isxdigit(node[i]); i++) 
+		;
+
+	if (i < nodelen) {
+		fprintf(stderr, "%s: Invalid value in node, must be hex digits.\n",
+			progname);
+		exit(-1);
+	}
+		
+	strcpy(tmpnode, "000000000000");
+	memcpy(&(tmpnode[12-nodelen]), node, nodelen);
+	for (tin = tmpnode, tout = sr->sipx_node; *tin != '\0'; tin += 2, tout++)  {
+		*tout = (unsigned char) map_char_to_val(*tin);
+		*tout <<= 4;
+		*tout |= (unsigned char) map_char_to_val(*(tin+1));
+	}
+
+	if ((memcmp(sr->sipx_node, "\0\0\0\0\0\0\0\0", IPX_NODE_LEN) == 0) ||
+		(memcmp(sr->sipx_node, "\377\377\377\377\377\377", IPX_NODE_LEN) == 0)){
+		fprintf(stderr, "%s: Node (%s) is invalid.\n", progname, tmpnode);
+		exit(-1);
+	}
+
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		sprintf(errmsg, "%s: socket", progname);
+		perror(errmsg);
+		exit(-1);
+	}
+
+	sr->sipx_family = st->sipx_family = AF_IPX;
+	i = 0;
+	do {
+		result = ioctl(s, SIOCADDRT, &rd);
+		i++;
+	}	while ((i < 5) && (result < 0) && (errno == EAGAIN));
+
+	if (result == 0) exit(0);
+
+	switch (errno) {
+	case ENETUNREACH:
+		fprintf(stderr, "%s: Router network (%08lX) not reachable.\n",
+			progname, htonl(sr->sipx_network));
+		break;
+	default:
+		sprintf(errmsg, "%s: ioctl", progname);
+		perror(errmsg);
+		break;
+	}
+	exit(-1);
+}
+
+int
+ipx_del_route(int argc, char **argv)
+{
+	/* Router */
+	struct sockaddr_ipx	*sr = (struct sockaddr_ipx *)&rd.rt_gateway;
+	/* Target */
+	struct sockaddr_ipx	*st = (struct sockaddr_ipx *)&rd.rt_dst;
+	int	s;
+	int	result;
+	unsigned long	netnum;
+	char	errmsg[80];
+	
+	if (argc != 2) {
+		usage();
+	}
+
+	rd.rt_flags = RTF_GATEWAY;
+	/* Network Number */
+	netnum = strtoul(argv[1], (char **)NULL, 16);
+	if ((netnum == 0xffffffffL) || (netnum == 0L)) {
+		fprintf(stderr, "%s: Inappropriate network number %08lX.\n", 
+			progname, netnum);
+		exit(-1);
+	}
+	st->sipx_network = htonl(netnum);
+
+	st->sipx_family = sr->sipx_family = AF_IPX;
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		sprintf(errmsg, "%s: socket", progname);
+		perror(errmsg);
+		exit(-1);
+	}
+	result = ioctl(s, SIOCDELRT, &rd);
+	if (result == 0) exit(0);
+
+	switch (errno) {
+	case ENOENT:
+		fprintf(stderr, "%s: Route not found for network %08lX.\n",
+			progname, netnum);
+		break;
+	case EPERM:
+		fprintf(stderr, "%s: Network %08lX is directly connected.\n",
+			progname, netnum);
+		break;
+	default:
+		sprintf(errmsg, "%s: ioctl", progname);
+		perror(errmsg);
+		break;
+	}
+	exit(-1);
+}
+
+int
+main(int argc, char **argv)
+{
+	int	i;
+
+	progname = argv[0];
+	if (argc < 2) {
+		usage();
+		exit(-1);
+	}
+
+	if (strncasecmp(argv[1], "add", 3) == 0) {
+		for (i = 1; i < (argc-1); i++) 
+			argv[i] = argv[i+1];
+		ipx_add_route(argc-1, argv);
+	} else if (strncasecmp(argv[1], "del", 3) == 0) {
+		for (i = 1; i < (argc-1); i++) 
+			argv[i] = argv[i+1];
+		ipx_del_route(argc-1, argv);
+	}
+	usage();
+	return 0;
+}

ipx-0.75/ipxrcv.c

@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <linux/ipx.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <errno.h>
+
+int
+main(int argc, char **argv)
+{
+	struct sockaddr_ipx	sipx;
+	int	s;
+	int	result;
+	char	msg[100];
+	int	len;
+
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		perror("IPX: socket: ");
+		exit(-1);
+	}
+	sipx.sipx_family = AF_IPX;
+	sipx.sipx_network = 0;
+	sipx.sipx_port = htons(0x5000);
+	sipx.sipx_type = 17;
+	len = sizeof(sipx);
+	result = bind(s, (struct sockaddr *)&sipx, sizeof(sipx));
+	if (result < 0) {
+		perror("IPX: bind: ");
+		exit(-1);
+	}
+
+	msg[0] = '\0';
+	result = recvfrom(s, msg, sizeof(msg),  0, (struct sockaddr *)&sipx, 
+			&len);
+	if (result < 0) {
+		perror("IPX: recvfrom: ");
+	}
+
+	printf("From %08lX:%02X%02X%02X%02X%02X%02X:%04X\n", 
+		htonl(sipx.sipx_network),
+		sipx.sipx_node[0], sipx.sipx_node[1],
+		sipx.sipx_node[2], sipx.sipx_node[3],
+		sipx.sipx_node[4], sipx.sipx_node[5],
+		htons(sipx.sipx_port));
+	printf("\tGot \"%s\"\n", msg);
+	return 0;
+}
+		
+
+	
+

ipx-0.75/ipxsend.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <linux/ipx.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <errno.h>
+
+int
+main(int argc, char **argv)
+{
+	struct sockaddr_ipx	sipx;
+	int	s;
+	int	result;
+	char	msg[100] = "Hi Mom";
+	int	len = sizeof(sipx);
+
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		perror("IPX: socket: ");
+		exit(-1);
+	}
+	sipx.sipx_family = AF_IPX;
+	sipx.sipx_network = 0;
+	sipx.sipx_port = 0;
+	sipx.sipx_type = 17;
+
+	result = bind(s, (struct sockaddr *)&sipx, sizeof(sipx));
+	if (result < 0) {
+		perror("IPX: bind: ");
+		exit(-1);
+	}
+
+	result = getsockname(s, (struct sockaddr *)&sipx, &len);
+	sipx.sipx_port = htons(0x5000);
+	result = sendto(s, msg, sizeof(msg), 0, (struct sockaddr *)&sipx, 
+			sizeof(sipx));
+	if (result < 0) {
+		perror("IPX: send: ");
+		exit(-1);
+	}
+	return 0;
+}
+		
+
+	
+

ipx-0.75/rip.c

@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <linux/ipx.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <errno.h>
+
+struct rip_data {
+	unsigned long	rip_net;
+	unsigned short	rip_hops __attribute__ ((packed));
+	unsigned short	rip_ticks __attribute__ ((packed));
+};
+	
+int
+main(int argc, char **argv)
+{
+	struct sockaddr_ipx	sipx;
+	int	result;
+	int	s;
+	char	msg[1024];
+	int	len;
+	char	*bptr;
+	struct rip_data	*rp;
+
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		perror("IPX: socket: ");
+		exit(-1);
+	}
+	sipx.sipx_family = AF_IPX;
+	sipx.sipx_network = 0;
+	sipx.sipx_port = htons(0x453);
+	sipx.sipx_type = 17;
+	result = bind(s, (struct sockaddr *)&sipx, sizeof(sipx));
+	if (result < 0) {
+		perror("IPX: bind: ");
+		exit(-1);
+	}
+
+	 while (1) {
+		len = sizeof(sipx);
+		result = recvfrom(s, msg, sizeof(msg),  0, 
+				(struct sockaddr *)&sipx, &len);
+		if (result < 0) {
+			perror("IPX: recvfrom");
+			exit(-1);
+		}
+		bptr = msg;
+		result -= 2;
+		printf("RIP packet from: %08lX:%02X%02X%02X%02X%02X%02X\n",
+			htonl(sipx.sipx_network),
+			sipx.sipx_node[0], sipx.sipx_node[1],
+			sipx.sipx_node[2], sipx.sipx_node[3],
+			sipx.sipx_node[4], sipx.sipx_node[5]);
+		bptr += 2;
+		rp = (struct rip_data *) bptr;
+		while (result >= sizeof(struct rip_data)) {
+			printf("\tNET: %08lX HOPS: %d\n", ntohl(rp->rip_net),
+				ntohs(rp->rip_hops));
+			result -= sizeof(struct rip_data);
+			rp++;
+		}
+	}
+}
+		
+
+	
+

ipx-0.75/sap.c

@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <linux/ipx.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <errno.h>
+
+
+struct sap_data {
+	unsigned short	sap_type __attribute__ ((packed));
+	char	sap_name[48] __attribute__ ((packed));
+	unsigned long	sap_net __attribute__ ((packed));
+	unsigned char	sap_node[6] __attribute__ ((packed));
+	unsigned short	sap_sock __attribute__ ((packed));
+	unsigned short	sap_hops __attribute__ ((packed));
+};
+	
+int
+main(int argc, char **argv)
+{
+	int	s;
+	int	result;
+	struct sockaddr_ipx	sipx;
+	char	msg[1024];
+	long	val = 0;
+	int	len;
+	char	*bptr;
+	struct sap_data	*sp;
+
+	s = socket(AF_IPX, SOCK_DGRAM, AF_IPX);
+	if (s < 0) {
+		perror("IPX: socket: ");
+		exit(-1);
+	}
+
+	result = setsockopt(s, SOL_SOCKET, SO_DEBUG, &val, 4);
+	if (result < 0) {
+		perror("IPX: setsockopt: ");
+		exit(-1);
+	}
+
+	sipx.sipx_family = PF_IPX;
+	sipx.sipx_network = 0L;
+	sipx.sipx_port = htons(0x452);
+	sipx.sipx_type = 17;
+
+	result = bind(s, (struct sockaddr *)&sipx, sizeof(sipx));
+	if (result < 0) {
+		perror("IPX: bind: ");
+		exit(-1);
+	}
+
+	 while (1) {
+		len = 1024;
+		result = recvfrom(s, msg, sizeof(msg),  0, 
+			(struct sockaddr *)&sipx, &len);
+		if (result < 0) {
+			perror("IPX: recvfrom: ");
+			exit(-1);
+		}
+		bptr = msg;
+		result -= 2;
+		printf("SAP: OP is %x %x\n", bptr[0], bptr[1]);
+		printf("Length is %d\n", result);
+		if (bptr[1] != 2)
+			continue;
+
+		bptr += 2;
+		sp = (struct sap_data *) bptr;
+		while (result >= sizeof(struct sap_data)) {
+			int	i;
+			
+			sp->sap_name[32] = '\0';
+			for (i = 31; (i > 0) && (sp->sap_name[i] == '_'); i--);
+			i++;
+			sp->sap_name[i] = '\0';
+			printf("NAME: %s TYPE: %x HOPS: %x\n", sp->sap_name,
+				ntohs(sp->sap_type), ntohs(sp->sap_hops));
+			printf("%lx:%x %x %x %x %x %x: %x\n", 
+				ntohl(sp->sap_net),
+				sp->sap_node[0],
+				sp->sap_node[1],
+				sp->sap_node[2],
+				sp->sap_node[3],
+				sp->sap_node[4],
+				sp->sap_node[5],
+				ntohs(sp->sap_sock));
+			result -= sizeof(struct sap_data);
+			sp++;
+		}
+	}
+}
+		
+
+	
+

kernel-1.2/linux/ncp.h

@@ -0,0 +1,298 @@
+/*
+ *  ncp_fs.h
+ *
+ *  Copyright (C) 1995 by Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_NCP_H
+#define _LINUX_NCP_H
+
+#include <linux/types.h>
+#include <linux/ipx.h>
+
+#define NCP_PTYPE                (0x11)
+#define NCP_PORT                 (0x0451)
+
+#define NCP_ALLOC_SLOT_REQUEST   (0x1111)
+#define NCP_REQUEST              (0x2222)
+#define NCP_DEALLOC_SLOT_REQUEST (0x5555)
+
+struct ncp_request_header {
+	__u16   type      __attribute__ ((packed));
+	__u8    sequence  __attribute__ ((packed));
+	__u8    conn_low  __attribute__ ((packed));
+	__u8    task      __attribute__ ((packed));
+	__u8    conn_high __attribute__ ((packed));
+	__u8    function  __attribute__ ((packed));
+	__u8    data[0]   __attribute__ ((packed));
+};
+
+#define NCP_REPLY                (0x3333)
+#define NCP_POSITIVE_ACK         (0x9999)
+
+struct ncp_reply_header {
+	__u16   type             __attribute__ ((packed));
+	__u8    sequence         __attribute__ ((packed));
+	__u8    conn_low         __attribute__ ((packed));
+	__u8    task             __attribute__ ((packed));
+	__u8    conn_high        __attribute__ ((packed));
+	__u8    completion_code  __attribute__ ((packed));
+	__u8    connection_state __attribute__ ((packed));
+	__u8    data[0]          __attribute__ ((packed));
+};
+
+
+#define NCP_BINDERY_USER (0x0001)
+#define NCP_BINDERY_UGROUP (0x0002)
+#define NCP_BINDERY_PQUEUE (0x0003)
+#define NCP_BINDERY_FSERVER (0x0004)
+#define NCP_BINDERY_NAME_LEN (48)
+struct ncp_bindery_object {
+	__u32   object_id;
+	__u16   object_type;
+	__u8    object_name[NCP_BINDERY_NAME_LEN];
+	__u8    object_flags;
+	__u8    object_security;
+	__u8    object_has_prop;
+};
+
+struct nw_property {
+	__u8    value[128];
+	__u8    more_flag;
+	__u8    property_flag;
+};
+
+struct prop_net_address {
+	__u32 network                __attribute__ ((packed));
+	__u8  node[IPX_NODE_LEN]     __attribute__ ((packed));
+	__u16 port                   __attribute__ ((packed));
+};
+
+#define NCP_VOLNAME_LEN (16)
+#define NCP_NUMBER_OF_VOLUMES (64)
+struct ncp_volume_info {
+	__u32   total_blocks;
+	__u32   free_blocks;
+	__u32   purgeable_blocks;
+	__u32   not_yet_purgeable_blocks;
+	__u32   total_dir_entries;
+	__u32   available_dir_entries;
+	__u8    sectors_per_block;
+	char    volume_name[NCP_VOLNAME_LEN+1];
+};
+
+struct ncp_filesearch_info {
+	__u8    volume_number;
+	__u16   directory_id;
+	__u16   sequence_no;
+	__u8    access_rights;
+};
+
+#define NCP_MAX_FILENAME 14
+
+/* these define the attribute byte as seen by NCP */
+#define aRONLY     (1L<<0)
+#define aHIDDEN    (1L<<1)
+#define aSYSTEM    (1L<<2)
+#define aEXECUTE   (1L<<3)
+#define aDIR       (1L<<4)
+#define aARCH      (1L<<5)
+
+#define AR_READ      (0x01)
+#define AR_WRITE     (0x02)
+#define AR_EXCLUSIVE (0x20)
+
+#define NCP_FILE_ID_LEN 6
+struct ncp_file_info {
+	__u8    file_id[NCP_FILE_ID_LEN];
+        char    file_name[NCP_MAX_FILENAME+1];
+	__u8    file_attributes;
+	__u8    file_mode;
+	__u32   file_length;
+	__u16   creation_date;
+	__u16   access_date;
+	__u16   update_date;
+	__u16   update_time;
+};
+
+
+/*  Defines for ReturnInformationMask */
+#define RIM_NAME	      (0x0001L)
+#define RIM_SPACE_ALLOCATED   (0x0002L)
+#define RIM_ATTRIBUTES	      (0x0004L)
+#define RIM_DATA_SIZE	      (0x0008L)
+#define RIM_TOTAL_SIZE	      (0x0010L)
+#define RIM_EXT_ATTR_INFO     (0x0020L)
+#define RIM_ARCHIVE	      (0x0040L)
+#define RIM_MODIFY	      (0x0080L)
+#define RIM_CREATION	      (0x0100L)
+#define RIM_OWNING_NAMESPACE  (0x0200L)
+#define RIM_DIRECTORY	      (0x0400L)
+#define RIM_RIGHTS	      (0x0800L)
+#define RIM_ALL 	      (0x0FFFL)
+#define RIM_COMPRESSED_INFO   (0x80000000L)
+
+/* open/create modes */
+#define OC_MODE_OPEN	  0x01
+#define OC_MODE_TRUNCATE  0x02
+#define OC_MODE_REPLACE   0x02
+#define OC_MODE_CREATE	  0x08
+
+/* open/create results */
+#define OC_ACTION_NONE	   0x00
+#define OC_ACTION_OPEN	   0x01
+#define OC_ACTION_CREATE   0x02
+#define OC_ACTION_TRUNCATE 0x04
+#define OC_ACTION_REPLACE  0x04
+
+/* access rights attributes */
+#ifndef AR_READ_ONLY
+#define AR_READ_ONLY	   0x0001
+#define AR_WRITE_ONLY	   0x0002
+#define AR_DENY_READ	   0x0004
+#define AR_DENY_WRITE	   0x0008
+#define AR_COMPATIBILITY   0x0010
+#define AR_WRITE_THROUGH   0x0040
+#define AR_OPEN_COMPRESSED 0x0100
+#endif
+
+struct nw_info_struct
+{
+	__u32 spaceAlloc                  __attribute__ ((packed));
+	__u32 attributes                  __attribute__ ((packed));
+	__u16 flags                       __attribute__ ((packed));
+	__u32 dataStreamSize              __attribute__ ((packed));
+	__u32 totalStreamSize             __attribute__ ((packed));
+	__u16 numberOfStreams             __attribute__ ((packed));
+	__u16 creationTime                __attribute__ ((packed));
+	__u16 creationDate                __attribute__ ((packed));
+	__u32 creatorID                   __attribute__ ((packed));
+	__u16 modifyTime                  __attribute__ ((packed));
+	__u16 modifyDate                  __attribute__ ((packed));
+	__u32 modifierID                  __attribute__ ((packed));
+	__u16 lastAccessDate              __attribute__ ((packed));
+	__u16 archiveTime                 __attribute__ ((packed));
+	__u16 archiveDate                 __attribute__ ((packed));
+	__u32 archiverID                  __attribute__ ((packed));
+	__u16 inheritedRightsMask         __attribute__ ((packed));
+	__u32 dirEntNum                   __attribute__ ((packed));
+	__u32 DosDirNum                   __attribute__ ((packed));
+	__u32 volNumber                   __attribute__ ((packed));
+	__u32 EADataSize                  __attribute__ ((packed));
+	__u32 EAKeyCount                  __attribute__ ((packed));
+	__u32 EAKeySize                   __attribute__ ((packed));
+	__u32 NSCreator                   __attribute__ ((packed));
+	__u8  nameLen                     __attribute__ ((packed));
+	__u8  entryName[256]              __attribute__ ((packed));
+};
+
+/* modify mask - use with MODIFY_DOS_INFO structure */
+#define DM_ATTRIBUTES		  (0x0002L)
+#define DM_CREATE_DATE		  (0x0004L)
+#define DM_CREATE_TIME		  (0x0008L)
+#define DM_CREATOR_ID		  (0x0010L)
+#define DM_ARCHIVE_DATE 	  (0x0020L)
+#define DM_ARCHIVE_TIME 	  (0x0040L)
+#define DM_ARCHIVER_ID		  (0x0080L)
+#define DM_MODIFY_DATE		  (0x0100L)
+#define DM_MODIFY_TIME		  (0x0200L)
+#define DM_MODIFIER_ID		  (0x0400L)
+#define DM_LAST_ACCESS_DATE	  (0x0800L)
+#define DM_INHERITED_RIGHTS_MASK  (0x1000L)
+#define DM_MAXIMUM_SPACE	  (0x2000L)
+
+struct nw_modify_dos_info
+{
+	__u32 attributes                  __attribute__ ((packed));
+	__u16 creationDate                __attribute__ ((packed));
+	__u16 creationTime                __attribute__ ((packed));
+	__u32 creatorID                   __attribute__ ((packed));
+	__u16 modifyDate                  __attribute__ ((packed));
+	__u16 modifyTime                  __attribute__ ((packed));
+	__u32 modifierID                  __attribute__ ((packed));
+	__u16 archiveDate                 __attribute__ ((packed));
+	__u16 archiveTime                 __attribute__ ((packed));
+	__u32 archiverID                  __attribute__ ((packed));
+	__u16 lastAccessDate              __attribute__ ((packed));
+	__u16 inheritanceGrantMask        __attribute__ ((packed));
+	__u16 inheritanceRevokeMask       __attribute__ ((packed));
+	__u32 maximumSpace                __attribute__ ((packed));
+};
+
+struct nw_file_info {
+	struct nw_info_struct i;
+	int   opened;
+	int   access;
+	__u32 server_file_handle          __attribute__ ((packed));
+	__u8  open_create_action          __attribute__ ((packed));
+	__u8  file_handle[6]              __attribute__ ((packed));
+};
+
+struct nw_search_sequence {
+	__u8  volNumber                   __attribute__ ((packed));
+	__u32 dirBase                     __attribute__ ((packed));
+	__u32 sequence                    __attribute__ ((packed));
+};
+
+struct nw_queue_job_entry {
+	__u16 InUse                       __attribute__ ((packed));
+	__u32 prev                        __attribute__ ((packed));
+	__u32 next                        __attribute__ ((packed));
+	__u32 ClientStation               __attribute__ ((packed));
+	__u32 ClientTask                  __attribute__ ((packed));
+	__u32 ClientObjectID              __attribute__ ((packed));
+	__u32 TargetServerID              __attribute__ ((packed));
+	__u8  TargetExecTime[6]           __attribute__ ((packed));
+	__u8  JobEntryTime[6]             __attribute__ ((packed));
+	__u32 JobNumber                   __attribute__ ((packed));
+	__u16 JobType                     __attribute__ ((packed));
+	__u16 JobPosition                 __attribute__ ((packed));
+	__u16 JobControlFlags             __attribute__ ((packed));
+	__u8  FileNameLen                 __attribute__ ((packed));
+	char  JobFileName[13]             __attribute__ ((packed));
+	__u32 JobFileHandle               __attribute__ ((packed));
+	__u32 ServerStation               __attribute__ ((packed));
+	__u32 ServerTaskNumber            __attribute__ ((packed));
+	__u32 ServerObjectID              __attribute__ ((packed));
+	char  JobTextDescription[50]      __attribute__ ((packed));
+	char  ClientRecordArea[152]       __attribute__ ((packed));
+};
+
+struct queue_job {
+	struct nw_queue_job_entry j;
+	__u8 file_handle[6];
+};
+
+#define QJE_OPER_HOLD	0x80
+#define QJE_USER_HOLD	0x40
+#define QJE_ENTRYOPEN	0x20
+#define QJE_SERV_RESTART    0x10
+#define QJE_SERV_AUTO	    0x08
+
+/* ClientRecordArea for print jobs */
+
+#define   KEEP_ON        0x0400
+#define   NO_FORM_FEED   0x0800
+#define   NOTIFICATION   0x1000
+#define   DELETE_FILE    0x2000
+#define   EXPAND_TABS    0x4000
+#define   PRINT_BANNER   0x8000
+
+struct print_job_record {
+    __u8  Version                         __attribute__ ((packed));
+    __u8  TabSize                         __attribute__ ((packed));
+    __u16 Copies                          __attribute__ ((packed));
+    __u16 CtrlFlags                       __attribute__ ((packed));
+    __u16 Lines                           __attribute__ ((packed));
+    __u16 Rows                            __attribute__ ((packed));
+    char  FormName[16]                    __attribute__ ((packed));
+    __u8  Reserved[6]                     __attribute__ ((packed));
+    char  BannerName[13]                  __attribute__ ((packed));
+    char  FnameBanner[13]                 __attribute__ ((packed));
+    char  FnameHeader[14]                 __attribute__ ((packed));
+    char  Path[80]                        __attribute__ ((packed));
+};
+
+
+#endif /* _LINUX_NCP_H */

kernel-1.2/linux/ncp_fs.h

@@ -0,0 +1,149 @@
+/*
+ *  ncp_fs.h
+ *
+ *  Copyright (C) 1995 by Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_NCP_FS_H
+#define _LINUX_NCP_FS_H
+
+#include <linux/fs.h>
+#include <linux/in.h>
+#include <linux/types.h>
+
+#include <linux/ncp_mount.h>
+#include <linux/ncp_fs_sb.h>
+#include <linux/ncp_fs_i.h>
+
+/*
+ * ioctl commands
+ */
+
+struct ncp_ioctl_request {
+	unsigned int   function;
+	unsigned int   size;
+	char          *data;
+};
+
+#define	NCP_IOC_NCPREQUEST		_IOR('n', 1, unsigned char *)
+#define	NCP_IOC_GETMOUNTUID		_IOR('u', 1, uid_t)
+
+/*
+ * The packet size to allocate. One page should be enough.
+ */
+#define NCP_PACKET_SIZE 4070
+
+#define NCP_MAXPATHLEN 255
+#define NCP_MAXNAMELEN 14
+
+#ifdef __KERNEL__
+
+/* The readdir cache size controls how many directory entries are
+ * cached.
+ */
+#define NCP_READDIR_CACHE_SIZE        64
+
+
+#define NCP_MAX_RPC_TIMEOUT (60) /* 6 seconds */
+
+/* Guess, what 0x564c is :-) */
+#define NCP_SUPER_MAGIC  0x564c
+
+
+#define NCP_SBP(sb)          ((struct ncp_server *)((sb)->u.generic_sbp))
+#define NCP_INOP(inode)      ((struct ncp_inode_info *)((inode)->u.generic_ip))
+
+#define NCP_SERVER(inode)    NCP_SBP((inode)->i_sb)
+#define NCP_FINFO(inode)     (&(NCP_INOP(inode)->finfo))
+#define NCP_ISTRUCT(inode)   (&(NCP_FINFO(inode)->i))
+
+static inline int min(int a, int b) {
+  return a<b ? a : b;
+}
+
+#ifdef DEBUG_NCP_MALLOC
+
+#include <linux/malloc.h>
+
+extern int ncp_malloced;
+extern int ncp_current_malloced;
+
+static inline void *
+ncp_kmalloc(unsigned int size, int priority)
+{
+        ncp_malloced += 1;
+        ncp_current_malloced += 1;
+        return kmalloc(size, priority);
+}
+
+static inline void
+ncp_kfree_s(void *obj, int size)
+{
+        ncp_current_malloced -= 1;
+        kfree_s(obj, size);
+}
+
+#else /* DEBUG_NCP_MALLOC */
+
+#define ncp_kmalloc(s,p) kmalloc(s,p)
+#define ncp_kfree_s(o,s) kfree_s(o,s)
+
+#endif /* DEBUG_NCP_MALLOC */
+
+#if DEBUG_NCP > 0
+#define DPRINTK(format, args...) printk(format , ## args)
+#else
+#define DPRINTK(format, args...)
+#endif
+
+#if DEBUG_NCP > 1
+#define DDPRINTK(format, args...) printk(format , ## args)
+#else
+#define DDPRINTK(format, args...)
+#endif
+
+
+/* linux/fs/ncpfs/file.c */
+extern struct inode_operations ncp_file_inode_operations;
+int ncp_make_open(struct inode *i, int right);
+
+/* linux/fs/ncpfs/dir.c */
+extern struct inode_operations ncp_dir_inode_operations;
+void ncp_free_inode_info(struct ncp_inode_info *i);
+void ncp_free_all_inodes(struct ncp_server *server);
+void ncp_init_root(struct ncp_server *server);
+int  ncp_stat_root(struct ncp_server *server);
+void ncp_init_dir_cache(void);
+void ncp_invalid_dir_cache(unsigned long ino);
+void ncp_invalidate_all_inodes(struct ncp_server *server);
+void ncp_free_dir_cache(void);
+int  ncp_date_dos2unix(__u16 time, __u16 date);
+void ncp_date_unix2dos(int unix_date, __u16 *time, __u16 *date);
+
+
+/* linux/fs/ncpfs/ioctl.c */
+int ncp_ioctl (struct inode * inode, struct file * filp,
+               unsigned int cmd, unsigned long arg);
+
+/* linux/fs/ncpfs/inode.c */
+struct super_block *ncp_read_super(struct super_block *sb,
+                                   void *raw_data, int silent);
+void ncp_invalidate_connection(struct ncp_server *server);
+int ncp_conn_is_valid(struct ncp_server *server);
+
+/* linux/fs/ncpfs/sock.c */
+int ncp_request(struct ncp_server *server, int function);
+int ncp_connect(struct ncp_server *server);
+int ncp_disconnect(struct ncp_server *server);
+int ncp_catch_watchdog(struct ncp_server *server);
+int ncp_dont_catch_watchdog(struct ncp_server *server);
+void ncp_lock_server(struct ncp_server *server);
+void ncp_unlock_server(struct ncp_server *server);
+
+/* linux/fs/ncpfs/mmap.c */
+int ncp_mmap(struct inode * inode, struct file * file, struct vm_area_struct * vma);
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_NCP_FS_H */

kernel-1.2/linux/ncp_fs_i.h

@@ -0,0 +1,35 @@
+/*
+ *  ncp_fs_i.h
+ *
+ *  Copyright (C) 1995 by Paal-Kr. Engstad and Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_NCP_FS_I
+#define _LINUX_NCP_FS_I
+
+#include <linux/ncp.h>
+
+#ifdef __KERNEL__
+
+enum ncp_inode_state {
+        INODE_VALID = 19,       /* Inode currently in use */
+        INODE_LOOKED_UP,        /* directly before iget */
+        INODE_CACHED,           /* in a path to an inode which is in use */
+        INODE_INVALID
+};
+
+/*
+ * ncp fs inode data (in memory only)
+ */
+struct ncp_inode_info {
+        enum ncp_inode_state state;
+        int nused;              /* for directories:
+                                   number of references in memory */
+        struct ncp_inode_info *dir;
+        struct ncp_inode_info *next, *prev;
+	struct nw_file_info finfo;
+};
+
+#endif
+#endif

kernel-1.2/linux/ncp_fs_sb.h

@@ -0,0 +1,61 @@
+/*
+ *  ncp_fs_sb.h
+ *
+ *  Copyright (C) 1995 by Volker Lendecke
+ *
+ */
+
+#ifndef _NCP_FS_SB
+#define _NCP_FS_SB
+
+#include <linux/ncp_mount.h>
+#include <linux/types.h>
+
+#ifdef __KERNEL__
+
+#define NCP_DEFAULT_BUFSIZE 1024
+
+struct ncp_server {
+
+	struct ncp_mount_data m; /* Nearly all of the mount data is of
+				    interest for us later, so we store
+				    it completely. */
+
+	struct file *ncp_filp;	/* File pointer to ncp socket */
+
+	struct file *wdog_filp;	/* File pointer to wdog socket */
+	void *data_ready;	/* The wdog socket gets a new
+				   data_ready callback. We store the
+				   old one for checking purposes and
+				   to reset it on unmounting. */
+
+	u8         sequence;
+	u8         task;
+	u16        connection;	/* Remote connection number */
+
+	u8         completion;	/* Status message from server */
+	u8         conn_status;	/* Bit 4 = 1 ==> Server going down, no
+				   requests allowed anymore */
+
+	int        buffer_size;	/* Negotiated bufsize */
+
+	int        reply_size;	/* Size of last reply */
+
+	int        packet_size;
+	unsigned char *packet;	/* Here we prepare requests and
+				   receive replies */
+
+	int        lock;	/* To prevent mismatch in protocols. */
+	struct wait_queue *wait;
+
+	int        current_size; /* for packet preparation */
+	int        has_subfunction;
+	int        ncp_reply_size;
+
+        struct ncp_inode_info root;
+	char       root_path;	/* '\0' */
+};
+
+#endif /* __KERNEL__ */
+
+#endif

kernel-1.2/linux/ncp_mount.h

@@ -0,0 +1,49 @@
+/*
+ *  ncp_mount.h
+ *
+ *  Copyright (C) 1995 by Volker Lendecke
+ *
+ */
+
+#ifndef _LINUX_NCP_MOUNT_H
+#define _LINUX_NCP_MOUNT_H
+
+#include <linux/types.h>
+#include <linux/ipx.h>
+#include <linux/ncp.h>
+#include <linux/ncp_fs_i.h>
+
+#define NCP_MOUNT_VERSION 1
+
+#define NCP_USERNAME_LEN (NCP_BINDERY_NAME_LEN)
+#define NCP_PASSWORD_LEN 20
+
+/* Values for flags */
+#define NCP_MOUNT_SOFT 0x0001
+#define NCP_MOUNT_INTR 0x0002
+
+struct ncp_mount_data {
+	int version;
+	unsigned int ncp_fd;	/* The socket to the ncp port */
+	unsigned int wdog_fd;	/* Watchdog packets come here */
+	unsigned int message_fd; /* Not used yet, maybe for messages */
+        uid_t mounted_uid;      /* Who may umount() this filesystem? */
+
+	struct sockaddr_ipx serv_addr;
+	unsigned char server_name[49];
+
+	unsigned char username[NCP_USERNAME_LEN+1];
+	unsigned char password[NCP_PASSWORD_LEN+1];
+
+	unsigned int time_out;	/* How long should I wait after
+				   sending a NCP request? */
+	unsigned int retry_count; /* And how often should I retry? */
+	unsigned int flags;
+
+        uid_t uid;
+        gid_t gid;
+        mode_t file_mode;
+        mode_t dir_mode;
+};
+
+#endif

kernel-1.2/src/Makefile

@@ -0,0 +1,67 @@
+#
+# Makefile for the linux ncp-filesystem routines.
+#
+
+INCLUDES =  -I/usr/src/linux/include -I..
+
+CFLAGS = -Wall -Wstrict-prototypes -O2 -DMODULE -fomit-frame-pointer \
+	$(INCLUDES) \
+#         -DDEBUG_NCP=1 -DDEBUG_NCP_MALLOC
+#         -DDEBUG_NCP_MALLOC
+
+CC     = gcc -D__KERNEL__ -I.
+AS     = as
+ARCH   = i386
+
+.c.s:
+	$(CC) $(CFLAGS) -S $<
+.c.o:
+	$(CC) $(CFLAGS) -c $<
+.s.o:
+	$(AS) -o $*.o $<
+
+OBJS=	dir.o inode.o file.o sock.o ioctl.o ncplib_kernel.o
+
+all: ncpfs.o
+
+ncpfs.o: $(OBJS)
+	$(LD) -r -o ncpfs.o $(OBJS)
+
+ncplib_kernel.o: ncplib_kernel.c ncplib_kernel.h
+	$(CC) $(CFLAGS) -finline-functions -c $<
+
+dep:
+	$(CPP) -M $(INCLUDES) *.c > .depend
+
+clean:
+	rm -f *.o *~
+
+realclean: clean
+	rm -f ncpmount ncptest .depend $(DISTFILE) *.out
+
+modules: ncpfs.o
+
+SRCPATH=$(shell pwd)
+SRCDIR=$(shell basename $(SRCPATH))
+DISTFILE=$(SRCDIR).tgz
+BACKUPFILE=ncpfs01.tgz
+HOME=/home/me
+
+backup: 
+	(rm -f $(DISTFILE); cd ..; tar cvf - $(SRCDIR) | gzip -1 \
+          > $(HOME)/tarz/backup/$(BACKUPFILE))
+	(cd $(HOME)/tarz/backup; ls -l $(BACKUPFILE); mcopy $(BACKUPFILE) a:)
+
+dist: realclean
+	rm -fr mnt
+	(cd ..; \
+         tar cvf - $(SRCDIR) | \
+            gzip -9 > $(DISTFILE); \
+         mv $(DISTFILE) $(SRCDIR))
+
+#
+# include a dependency file if one exists
+#
+ifeq (.depend,$(wildcard .depend))
+include .depend
+endif

kernel-1.2/src/dir.c

@@ -0,0 +1,971 @@
+/*
+ *  dir.c
+ *
+ *  Copyright (C) 1995 by Volker Lendecke
+ *
+ */
+
+#include <linux/config.h>
+#ifdef MODULE
+#include <linux/module.h>
+#include <linux/version.h>
+#else
+#define MOD_INC_USE_COUNT
+#define MOD_DEC_USE_COUNT
+#endif
+
+#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/stat.h>
+#include <linux/kernel.h>
+#include <linux/malloc.h>
+#include <linux/mm.h>
+#include <linux/ncp_fs.h>
+#include <asm/segment.h>
+#include <linux/errno.h>
+#include "ncplib_kernel.h"
+
+struct ncp_dirent {
+	struct nw_info_struct i;
+	struct nw_search_sequence s; /* given back for i */
+	unsigned long f_pos;
+};
+
+static int 
+ncp_dir_read(struct inode *inode, struct file *filp, char *buf, int count);
+
+static int 
+ncp_readdir(struct inode *inode, struct file *filp,
+	    struct dirent *dirent, int count);
+
+static int
+ncp_read_volume_list(struct ncp_server *server, int start_with,
+		     int cache_size);
+
+static int
+ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
+	       int cache_size, struct ncp_dirent *entry);
+
+static struct inode *
+ncp_iget(struct inode *dir, struct nw_file_info *finfo);
+
+static struct ncp_inode_info *
+ncp_find_inode(struct inode *dir, const char *name);
+
+static int
+ncp_lookup(struct inode *dir, const char *__name,
+           int len, struct inode **result);
+
+static int 
+ncp_create(struct inode *dir, const char *name, int len, int mode, 
+           struct inode **result);
+
+static int 
+ncp_mkdir(struct inode *dir, const char *name, int len, int mode);
+
+static int 
+ncp_rmdir(struct inode *dir, const char *name, int len);
+
+static int
+ncp_unlink(struct inode *dir, const char *name, int len);
+
+static int
+ncp_rename(struct inode *old_dir, const char *old_name, int old_len, 
+           struct inode *new_dir, const char *new_name, int new_len);
+
+static inline void
+str_upper(char *name)
+{
+	while (*name) {
+		if (*name >= 'a' && *name <= 'z')
+			*name -= ('a' - 'A');
+		name++;
+	}
+}
+
+static inline void
+str_lower(char *name)
+{
+	while (*name) {
+		if (*name >= 'A' && *name <= 'Z')
+			*name += ('a' - 'A');
+		name ++;
+	}
+}
+
+static struct file_operations ncp_dir_operations = {
+        NULL,			/* lseek - default */
+	ncp_dir_read,		/* read - bad */
+	NULL,			/* write - bad */
+	ncp_readdir,		/* readdir */
+	NULL,			/* select - default */
+	ncp_ioctl,		/* ioctl - default */
+	NULL,                   /* mmap */
+	NULL,			/* no special open code */
+	NULL,			/* no special release code */
+	NULL			/* fsync */
+};
+
+struct inode_operations ncp_dir_inode_operations = {
+	&ncp_dir_operations,	/* default directory file ops */
+	ncp_create,		/* create */
+	ncp_lookup,    		/* lookup */
+	NULL,			/* link */
+	ncp_unlink,    		/* unlink */
+	NULL,			/* symlink */
+	ncp_mkdir,     		/* mkdir */
+	ncp_rmdir,     		/* rmdir */
+	NULL,			/* mknod */
+	ncp_rename,    		/* rename */
+	NULL,			/* readlink */
+	NULL,			/* follow_link */
+	NULL,			/* bmap */
+	NULL,			/* truncate */
+	NULL,			/* permission */
+	NULL                    /* smap */
+};
+
+
+static int 
+ncp_dir_read(struct inode *inode, struct file *filp, char *buf, int count)
+{
+	return -EISDIR;
+}
+
+#define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
+#define ROUND_UP(x) (((x)+3) & ~3)
+
+/* In ncpfs, we have unique inodes across all mounted filesystems, for
+   all inodes that are in memory. That's why it's enough to index the
+   directory cache by the inode number. */
+
+static unsigned long      c_ino = 0;
+static int                c_size;
+static int                c_seen_eof;
+static int                c_last_returned_index;
+static struct ncp_dirent* c_entry = NULL;
+
+static int
+ncp_readdir(struct inode *inode, struct file *filp,
+	    struct dirent *dirent, int count)
+{
+	int result, i = 0;
+        int index = 0;
+	struct ncp_dirent *entry = NULL;
+        struct ncp_server *server = NCP_SERVER(inode);
+	struct ncp_inode_info *dir = (struct ncp_inode_info *)(inode->i_ino);
+
+	int filldir(struct dirent *dirent,
+		    const char *name, int len,
+		    int f_pos, ino_t ino)
+	{
+		memcpy_tofs(dirent->d_name, name, len);
+		put_fs_byte(0, &(dirent->d_name[len]));
+		put_fs_long(ino, &dirent->d_ino);
+		put_fs_word(len, &dirent->d_reclen);
+		put_fs_word(f_pos, &dirent->d_off);
+		return 1;
+	}
+		
+
+	DDPRINTK("ncp_readdir: filp->f_pos = %d\n", (int)filp->f_pos);
+	DDPRINTK("ncp_readdir: inode->i_ino = %ld, c_ino = %ld\n",
+		 inode->i_ino, c_ino);
+
+	if (!inode || !S_ISDIR(inode->i_mode)) {
+		printk("ncp_readdir: inode is NULL or not a directory\n");
+		return -EBADF;
+	}
+
+	if (c_entry == NULL) 
+	{
+		i = sizeof (struct ncp_dirent) * NCP_READDIR_CACHE_SIZE;
+		c_entry = (struct ncp_dirent *) ncp_kmalloc(i, GFP_KERNEL);
+		if (c_entry == NULL) {
+			printk("ncp_readdir: no MEMORY for cache\n");
+			return -ENOMEM;
+		}
+	}
+
+        if (filp->f_pos == 0) {
+                ncp_invalid_dir_cache(inode->i_ino);
+		if (filldir(dirent,".",1, filp->f_pos, (int)dir) < 0) {
+			return 0;
+		}
+		filp->f_pos += 1;
+		return ROUND_UP(NAME_OFFSET(dirent)+i+1);
+        }
+
+	if (filp->f_pos == 1) {
+		if (filldir(dirent,"..",2, filp->f_pos, (int)(dir->dir)) < 0) {
+			return 0;
+		}
+		filp->f_pos += 1;
+		return ROUND_UP(NAME_OFFSET(dirent)+i+1);
+	}
+
+	
+
+	if (inode->i_ino == c_ino) {
+		for (i = 0; i < c_size; i++) {
+			if (filp->f_pos == c_entry[i].f_pos) {
+                                entry = &c_entry[i];
+                                c_last_returned_index = i;
+                                index = i;
+                                break;
+			}
+		}
+                if ((entry == NULL) && c_seen_eof)
+                        return 0;
+	}
+
+	if (entry == NULL) {
+		DDPRINTK("ncp_readdir: Not found in cache.\n");
+
+		if (inode->i_ino == (int)&(server->root)) {
+
+			result = ncp_read_volume_list(server, filp->f_pos,
+						      NCP_READDIR_CACHE_SIZE);
+			DPRINTK("ncp_read_volume_list returned %d\n", result);
+
+		} else {
+
+			result = ncp_do_readdir(server, inode, filp->f_pos,
+						NCP_READDIR_CACHE_SIZE,
+						c_entry);
+			DPRINTK("ncp_readdir returned %d\n", result);
+		}
+			
+		
+		if (result < 0) {
+			c_ino = 0;
+			return result;
+		}
+
+		if (result > 0) {
+                        c_seen_eof = (result < NCP_READDIR_CACHE_SIZE);
+			c_ino  = inode->i_ino;
+			c_size = result;
+			entry = c_entry;
+                        c_last_returned_index = 0;
+                        index = 0;
+
+			for (i = 0; i < c_size; i++) {
+				str_lower(c_entry[i].i.entryName);
+			}
+		}
+	}
+
+        if (entry == NULL) {
+                /* Nothing found, even from a ncp call */
+                return 0;
+        }
+
+        if (index < c_size) {
+
+                /* We found it.  For getwd(), we have to return the
+                   correct inode in d_ino if the inode is currently in
+                   use. Otherwise the inode number does not
+                   matter. (You can argue a lot about this..) */ 
+
+                struct ncp_inode_info *ino_info;
+                ino_info = ncp_find_inode(inode, entry->i.entryName);
+					  
+
+                /* Some programs seem to be confused about a zero
+                   inode number, so we set it to one.  Thanks to
+                   Gordon Chaffee for this one. */
+                if (ino_info == NULL) {
+                        ino_info = (struct ncp_inode_info *) 1;
+                }
+
+		DDPRINTK("ncp_readdir: entry->path= %s\n", entry->i.entryName);
+		DDPRINTK("ncp_readdir: entry->f_pos = %ld\n", entry->f_pos);
+
+                if (filldir(dirent, entry->i.entryName, entry->i.nameLen,
+                            entry->f_pos, (ino_t)ino_info) < 0) {
+                        return 0;
+                }
+
+                filp->f_pos += 1;
+                index += 1;
+                entry += 1;
+		return ROUND_UP(NAME_OFFSET(dirent)+i+1);
+	}
+	return 0;
+}
+
+static int
+ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
+{
+	struct ncp_dirent *entry = c_entry;
+
+	int total_count = 2;
+	int i;
+
+#if 1
+	if (fpos < 2) {
+		printk("OOPS, we expect fpos >= 2");
+		fpos = 2;
+	}
+#endif
+
+	for (i=0; i<NCP_NUMBER_OF_VOLUMES; i++) {
+
+		struct ncp_volume_info info;
+
+		if (ncp_get_volume_info_with_number(server, i, &info) != 0) {
+			return total_count;
+		}
+
+		if (strlen(info.volume_name) > 0) {
+			if (total_count < fpos) {
+				DPRINTK("ncp_read_volumes: skipped vol: %s\n",
+					info.volume_name);
+			} else if (total_count >= fpos + cache_size) {
+				return (total_count - fpos);
+			} else {
+				DPRINTK("ncp_read_volumes: found vol: %s\n",
+					info.volume_name);
+
+				if (ncp_do_lookup(server, NULL,
+						  info.volume_name,
+						  &(entry->i)) != 0) {
+					printk("ncpfs: could not lookup vol "
+					       "%s\n", info.volume_name);
+					continue;
+				}
+
+				entry->f_pos = total_count;
+				entry += 1;
+			}
+			total_count += 1;
+		}
+	}
+
+	return (total_count - fpos);
+}
+
+static int
+ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
+	       int cache_size, struct ncp_dirent *entry)
+{
+	static struct nw_search_sequence seq;
+	static struct inode *last_dir;
+	static int total_count;
+
+#if 1
+	if (fpos < 2) {
+		printk("OOPS, we expect fpos >= 2");
+		fpos = 2;
+	}
+#endif
+	DPRINTK("ncp_do_readdir: fpos = %d\n", fpos);
+
+	if (fpos == 2) {
+		last_dir = NULL;
+		total_count = 2;
+	}
+
+	if ((fpos != total_count) || (dir != last_dir)) {
+
+		total_count = 2;
+		last_dir = dir;
+
+		DPRINTK("ncp_do_readdir: re-used seq for %s\n",
+			NCP_ISTRUCT(dir)->entryName);
+
+		if (ncp_initialize_search(server, NCP_ISTRUCT(dir), &seq)!=0) {
+			DPRINTK("ncp_init_search failed\n");
+			return total_count - fpos;
+		}
+	}
+
+	while (total_count < fpos + cache_size) {
+
+		if (ncp_search_for_file_or_subdir(server, &seq,
+						  &(entry->i)) != 0) {
+			return total_count - fpos;
+		}
+
+		if (total_count < fpos) {
+			DPRINTK("ncp_do_readdir: skipped file: %s\n",
+				entry->i.entryName);
+		} else {
+			DDPRINTK("ncp_do_r: file: %s, f_pos=%d,total_count=%d",
+				 entry->i.entryName, fpos, total_count);
+			entry->s = seq;
+			entry->f_pos = total_count;
+			entry += 1;
+		}
+		total_count += 1;
+	}
+
+	return (total_count - fpos);
+}
+
+void
+ncp_init_dir_cache(void)
+{
+        c_ino   = 0;
+        c_entry = NULL;
+}
+
+void
+ncp_invalid_dir_cache(unsigned long ino)
+{
+	if (ino == c_ino) {
+                c_ino = 0;
+                c_seen_eof = 0;
+        }
+}
+
+void
+ncp_free_dir_cache(void)
+{
+        DPRINTK("ncp_free_dir_cache: enter\n");
+        
+        if (c_entry == NULL)
+                return;
+
+        ncp_kfree_s(c_entry,
+                    sizeof(struct ncp_dirent) * NCP_READDIR_CACHE_SIZE);
+        c_entry = NULL;
+
+        DPRINTK("ncp_free_dir_cache: exit\n");
+}
+
+
+static struct inode *
+ncp_iget(struct inode *dir, struct nw_file_info *finfo)
+{
+	struct inode *inode;
+        struct ncp_inode_info *new_inode_info;
+        struct ncp_inode_info *root;
+
+	if (!dir) {
+		printk("ncp_iget: dir is NULL\n");
+		return NULL;
+	}
+
+	if (!finfo) {
+		printk("ncp_iget: finfo is NULL\n");
+		return NULL;
+	}
+
+        new_inode_info = ncp_kmalloc(sizeof(struct ncp_inode_info),
+                                     GFP_KERNEL);
+
+        if (new_inode_info == NULL) {
+                printk("ncp_iget: could not alloc mem for %s\n",
+		       finfo->i.entryName);
+                return NULL;
+        }
+
+        new_inode_info->state = INODE_LOOKED_UP;
+        new_inode_info->nused = 0;
+        new_inode_info->dir   = NCP_INOP(dir);
+        new_inode_info->finfo = *finfo;
+
+        NCP_INOP(dir)->nused += 1;
+
+        /* We have to link the new inode_info into the doubly linked
+           list of inode_infos to make a complete linear search
+           possible. */
+
+        root = &(NCP_SERVER(dir)->root);
+
+        new_inode_info->prev = root;
+        new_inode_info->next = root->next;
+        root->next->prev = new_inode_info;
+        root->next = new_inode_info;
+        
+	if (!(inode = iget(dir->i_sb, (int)new_inode_info))) {
+		printk("ncp_iget: iget failed!");
+		return NULL;
+	}
+
+	return inode;
+}
+
+void
+ncp_free_inode_info(struct ncp_inode_info *i)
+{
+        if (i == NULL) {
+                printk("ncp_free_inode: i == NULL\n");
+                return;
+        }
+
+        i->state = INODE_CACHED;
+        while ((i->nused == 0) && (i->state == INODE_CACHED)) {
+                struct ncp_inode_info *dir = i->dir;
+
+                i->next->prev = i->prev;
+                i->prev->next = i->next;
+
+		DDPRINTK("ncp_free_inode_info: freeing %s\n",
+			 i->finfo.i.entryName);
+
+                ncp_kfree_s(i, sizeof(struct ncp_inode_info));
+
+                if (dir == i) return;
+
+                (dir->nused)--;
+                i = dir;
+        }
+}
+        
+void
+ncp_init_root(struct ncp_server *server)
+{
+        struct ncp_inode_info *root = &(server->root);
+	struct nw_info_struct *i = &(root->finfo.i);
+	unsigned short dummy;
+
+	DPRINTK("ncp_init_root: server %s\n", server->m.server_name);
+	DPRINTK("ncp_init_root: i = %x\n", (int)i);
+
+        root->finfo.opened = 0;
+	i->attributes  = aDIR;
+	i->dataStreamSize = 1024;
+	ncp_date_unix2dos(0, &(i->creationTime), &(i->creationDate));
+	ncp_date_unix2dos(0, &(i->modifyTime), &(i->modifyDate));
+	ncp_date_unix2dos(0, &dummy, &(i->lastAccessDate));
+	i->nameLen = 0;
+        i->entryName[0] = '\0';
+
+        root->state = INODE_LOOKED_UP;
+        root->nused = 1;
+        root->dir   = root;
+        root->next = root->prev = root;
+        return;
+}
+
+void
+ncp_free_all_inodes(struct ncp_server *server)
+{
+        /* Here nothing should be to do. I do not know whether it's
+           better to leave some memory allocated or be stuck in an
+           endless loop */
+#if 1
+        struct ncp_inode_info *root = &(server->root);
+
+        if (root->next != root) {
+                printk("ncp_free_all_inodes: INODES LEFT!!!\n");
+        }
+
+        while (root->next != root) {
+                printk("ncp_free_all_inodes: freeing inode\n");
+                ncp_free_inode_info(root->next);
+                /* In case we have an endless loop.. */
+                schedule();
+        }
+#endif        
+        
+        return;
+}
+
+/* We will search the inode that belongs to this name, currently by a
+   complete linear search through the inodes belonging to this
+   filesystem. This has to be fixed. */
+static struct ncp_inode_info *
+ncp_find_inode(struct inode *dir, const char *name)
+{
+	struct ncp_server *server = NCP_SERVER(dir);
+	struct nw_info_struct *dir_info = NCP_ISTRUCT(dir);
+        struct ncp_inode_info *result = &(server->root);
+
+        if (name == NULL) {
+                return NULL;
+	}
+
+        do {
+		if (   (result->dir->finfo.i.DosDirNum == dir_info->DosDirNum)
+		    && (strcmp(result->finfo.i.entryName, name) == 0))
+                        return result;
+                result = result->next;
+
+        } while (result != &(server->root));
+
+        return NULL;
+}
+
+static int 
+ncp_lookup(struct inode *dir, const char *__name, int len,
+           struct inode **result)
+{
+	struct nw_file_info finfo;
+	struct ncp_server *server;
+        struct ncp_inode_info *result_info;
+        int found_in_cache;
+
+	*result = NULL;
+
+	if (!dir || !S_ISDIR(dir->i_mode)) {
+		printk("ncp_lookup: inode is NULL or not a directory.\n");
+		iput(dir);
+		return -ENOENT;
+	}
+
+        DDPRINTK("ncp_lookup: %s, len %d\n", __name, len);
+
+	server = NCP_SERVER(dir);
+
+	/* Fast cheat for . */
+	if (len == 0 || (len == 1 && __name[0] == '.')) {
+		*result = dir;
+		return 0;
+	}
+
+	/* ..and for .. */
+	if (len == 2 && __name[0] == '.' && __name[1] == '.') {
+		struct ncp_inode_info *parent = NCP_INOP(dir)->dir;
+
+		if (parent->state == INODE_CACHED) {
+			parent->state = INODE_LOOKED_UP;
+		}
+
+		*result = iget(dir->i_sb, (int)parent);
+		iput(dir);
+		if (*result == 0)
+			return -EACCES;
+		else
+			return 0;
+	}
+
+        result_info = ncp_find_inode(dir, __name);
+
+        if (result_info != 0) {
+
+                if (result_info->state == INODE_CACHED)
+                        result_info->state = INODE_LOOKED_UP;
+
+                /* Here we convert the inode_info address into an
+                   inode number */
+
+                *result = iget(dir->i_sb, (int)result_info);
+                iput(dir);
+
+                if (*result == NULL) {
+                        return -EACCES;
+                }
+
+		return 0;
+        }
+
+        /* If the file is in the dir cache, we do not have to ask the
+           server. */
+
+        found_in_cache = 0;
+        
+        if (dir->i_ino == c_ino) {
+                int first = c_last_returned_index;
+                int i;
+
+                i = first;
+                do {
+                        DDPRINTK("ncp_lookup: trying index: %d, name: %s\n",
+                                i, c_entry[i].i.entryName);
+                        if (strcmp(c_entry[i].i.entryName, __name) == 0) {
+                                DPRINTK("ncp_lookup: found in cache!\n");
+				finfo.i = c_entry[i].i;
+				found_in_cache = 1;
+				break;
+                        }
+                        i = (i + 1) % c_size;
+                } while (i != first);
+        }
+
+        if (found_in_cache == 0) {
+
+		char this_name[len+1];
+
+		memcpy(this_name, __name, len);
+		this_name[len] = 0;
+		str_upper(this_name);
+
+		DDPRINTK("ncp_lookup: do_lookup on %s/%s\n",
+			 NCP_ISTRUCT(dir)->entryName, this_name);
+
+		if (ncp_do_lookup(server,
+				  dir->i_ino == (int)&(NCP_SERVER(dir)->root)
+				  ? NULL : NCP_ISTRUCT(dir),
+				  this_name,
+				  &(finfo.i)) != 0) {
+                        iput(dir);
+                        return -ENOENT;
+                }
+        }
+
+	finfo.opened = 0;
+	str_lower(finfo.i.entryName);
+
+	if (!(*result = ncp_iget(dir, &finfo))) {
+		iput(dir);
+		return -EACCES;
+	}
+
+	iput(dir);
+	return 0;
+}
+
+static int 
+ncp_create(struct inode *dir, const char *name, int len, int mode,
+           struct inode **result)
+{
+	struct nw_file_info finfo;
+	__u8 _name[len+1];
+
+	*result = NULL;
+
+	if (!dir || !S_ISDIR(dir->i_mode)) {
+		printk("ncp_create: inode is NULL or not a directory\n");
+		iput(dir);
+		return -ENOENT;
+	}
+
+	strncpy(_name, name, len);
+	_name[len] = '\0';
+	str_upper(_name);
+
+	if (ncp_open_create_file_or_subdir(NCP_SERVER(dir),
+					   NCP_ISTRUCT(dir), _name,
+					   OC_MODE_CREATE|OC_MODE_OPEN,
+					   0, AR_READ|AR_WRITE,
+					   &finfo) != 0) {
+		iput(dir);
+		return -EACCES;
+	}
+
+        ncp_invalid_dir_cache(dir->i_ino);
+
+	str_lower(finfo.i.entryName);
+	finfo.access = O_RDWR;
+
+	if (!(*result = ncp_iget(dir, &finfo)) < 0) {
+		ncp_close_file(NCP_SERVER(dir), finfo.file_handle);
+		iput(dir);
+		return -EINVAL;
+	}
+
+	iput(dir);
+	return 0;	
+}
+
+static int
+ncp_mkdir(struct inode *dir, const char *name, int len, int mode)
+{
+	int error;
+	struct nw_file_info new_dir;
+	__u8 _name[len+1];
+
+	strncpy(_name, name, len);
+	_name[len] = '\0';
+	str_upper(_name);
+
+	if (!dir || !S_ISDIR(dir->i_mode)) {
+		printk("ncp_mkdir: inode is NULL or not a directory\n");
+		iput(dir);
+		return -ENOENT;
+	}
+
+	if (ncp_open_create_file_or_subdir(NCP_SERVER(dir),
+					   NCP_ISTRUCT(dir), _name,
+					   OC_MODE_CREATE, aDIR, 0xffff,
+					   &new_dir) != 0) {
+		error = -EACCES;
+	} else {
+		error = 0;
+                ncp_invalid_dir_cache(dir->i_ino);
+        }
+
+	iput(dir);
+	return error;
+}
+
+static int
+ncp_rmdir(struct inode *dir, const char *name, int len)
+{
+	int error;
+	__u8 _name[len+1];
+
+	if (!dir || !S_ISDIR(dir->i_mode)) {
+		printk("ncp_rmdir: inode is NULL or not a directory\n");
+		iput(dir);
+		return -ENOENT;
+	}
+        if (ncp_find_inode(dir, name) != NULL) {
+                error = -EBUSY;
+        }
+	else
+	{
+
+		strncpy(_name, name, len);
+		_name[len] = '\0';
+		str_upper(_name);
+
+                if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
+						    NCP_ISTRUCT(dir),
+						    _name)) == 0) {
+                        ncp_invalid_dir_cache(dir->i_ino);
+		}
+		else
+		{
+			error = -EINVAL;
+		}
+        }
+	iput(dir);
+	return error;
+}
+
+static int
+ncp_unlink(struct inode *dir, const char *name, int len)
+{
+	int error;
+	__u8 _name[len+1];
+
+	if (!dir || !S_ISDIR(dir->i_mode)) {
+		printk("ncp_unlink: inode is NULL or not a directory\n");
+		iput(dir);
+		return -ENOENT;
+	}
+        if (ncp_find_inode(dir, name) != NULL) {
+                error = -EBUSY;
+        }
+	else
+	{
+
+		strncpy(_name, name, len);
+		_name[len] = '\0';
+		str_upper(_name);
+
+                if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
+						    NCP_ISTRUCT(dir),
+						    _name)) == 0) {
+                        ncp_invalid_dir_cache(dir->i_ino);
+		}
+		else
+		{
+			error = -EINVAL;
+		}
+        }
+	iput(dir);
+	return error;
+}
+
+static int
+ncp_rename(struct inode *old_dir, const char *old_name, int old_len,
+           struct inode *new_dir, const char *new_name, int new_len)
+{
+	int res;
+	char _old_name[old_len+1];
+	char _new_name[new_len+1];
+
+	if (!old_dir || !S_ISDIR(old_dir->i_mode)) {
+		printk("ncp_rename: old inode is NULL or not a directory\n");
+                res = -ENOENT;
+                goto finished;
+	}
+
+	if (!new_dir || !S_ISDIR(new_dir->i_mode)) {
+		printk("ncp_rename: new inode is NULL or not a directory\n");
+                res = -ENOENT;
+                goto finished;
+	}
+
+        if (   (ncp_find_inode(old_dir, old_name) != NULL)
+            || (ncp_find_inode(new_dir, new_name) != NULL)) {
+                res = -EBUSY;
+                goto finished;
+        }
+
+	strncpy(_old_name, old_name, old_len);
+	_old_name[old_len] = '\0';
+	str_upper(_old_name);
+
+	strncpy(_new_name, new_name, new_len);
+	_new_name[old_len] = '\0';
+	str_upper(_new_name);
+
+	res = ncp_ren_or_mov_file_or_subdir(NCP_SERVER(old_dir),
+					    NCP_ISTRUCT(old_dir), _old_name,
+					    NCP_ISTRUCT(new_dir), _new_name);
+
+        if (res == 0) {
+                ncp_invalid_dir_cache(old_dir->i_ino);
+                ncp_invalid_dir_cache(new_dir->i_ino);
+        }
+	else
+	{
+		res = -EACCES;
+	}
+	
+ finished:
+	iput(old_dir); 
+	iput(new_dir);
+	return res;
+}
+
+/* The following routines are taken directly from msdos-fs */
+
+/* Linear day numbers of the respective 1sts in non-leap years. */
+
+static int day_n[] = { 0,31,59,90,120,151,181,212,243,273,304,334,0,0,0,0 };
+		  /* JanFebMarApr May Jun Jul Aug Sep Oct Nov Dec */
+
+
+extern struct timezone sys_tz;
+
+static int
+utc2local(int time)
+{
+        return time - sys_tz.tz_minuteswest*60;
+}
+
+static int
+local2utc(int time)
+{
+        return time + sys_tz.tz_minuteswest*60;
+}
+
+/* Convert a MS-DOS time/date pair to a UNIX date (seconds since 1 1 70). */
+
+int
+ncp_date_dos2unix(unsigned short time,unsigned short date)
+{
+	int month,year,secs;
+
+	month = ((date >> 5) & 15)-1;
+	year = date >> 9;
+	secs = (time & 31)*2+60*((time >> 5) & 63)+(time >> 11)*3600+86400*
+	    ((date & 31)-1+day_n[month]+(year/4)+year*365-((year & 3) == 0 &&
+	    month < 2 ? 1 : 0)+3653);
+			/* days since 1.1.70 plus 80's leap day */
+	return local2utc(secs);
+}
+
+
+/* Convert linear UNIX date to a MS-DOS time/date pair. */
+void
+ncp_date_unix2dos(int unix_date,unsigned short *time, unsigned short *date)
+{
+	int day,year,nl_day,month;
+
+	unix_date = utc2local(unix_date);
+	*time = (unix_date % 60)/2+(((unix_date/60) % 60) << 5)+
+	    (((unix_date/3600) % 24) << 11);
+	day = unix_date/86400-3652;
+	year = day/365;
+	if ((year+3)/4+365*year > day) year--;
+	day -= (year+3)/4+365*year;
+	if (day == 59 && !(year & 3)) {
+		nl_day = day;
+		month = 2;
+	}
+	else {
+		nl_day = (year & 3) || day <= 59 ? day : day-1;
+		for (month = 0; month < 12; month++)
+			if (day_n[month] > nl_day) break;
+	}
+	*date = nl_day-day_n[month-1]+1+(month << 5)+(year << 9);
+}

kernel-1.2/src/file.c

@@ -0,0 +1,258 @@
+/*
+ *  file.c
+ *
+ *  Copyright (C) 1995 by Paal-Kr. Engstad and Volker Lendecke
+ *
+ */
+
+/* #include <linux/module.h>*/
+
+#include <linux/config.h>
+#ifdef MODULE
+#include <linux/module.h>
+#include <linux/version.h>
+#else
+#define MOD_INC_USE_COUNT
+#define MOD_DEC_USE_COUNT
+#endif
+
+#include <asm/segment.h>
+#include <asm/system.h>
+
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/fcntl.h>
+#include <linux/stat.h>
+#include <linux/mm.h>
+#include <linux/ncp_fs.h>
+#include "ncplib_kernel.h"
+#include <linux/malloc.h>
+
+static int 
+ncp_fsync(struct inode *inode, struct file *file)
+{
+	return 0;
+}
+
+int
+ncp_make_open(struct inode *i, int right)
+{
+        struct nw_file_info *finfo;
+
+        if (i == NULL) {
+                printk("ncp_make_open: got NULL inode\n");
+                return -EINVAL;
+        }
+
+        finfo = NCP_FINFO(i);
+
+        DPRINTK("ncp_make_open: dirent->opened = %d\n", finfo->opened);
+
+        if (finfo->opened == 0) {
+
+                /* tries max. rights */
+		if (ncp_open_create_file_or_subdir(NCP_SERVER(i),
+						   NULL, NULL,
+						   OC_MODE_OPEN, 0,
+						   AR_READ | AR_WRITE,
+						   finfo) == 0) {
+			finfo->access = O_RDWR;
+		}
+		else if (ncp_open_create_file_or_subdir(NCP_SERVER(i),
+							NULL, NULL,
+							OC_MODE_OPEN, 0,
+							AR_READ,
+							finfo) == 0) {
+			finfo->access = O_RDONLY;
+		} else {
+			return -EACCES;
+		}
+        }
+
+        if (   ((right == O_RDONLY) && (   (finfo->access == O_RDONLY)
+                                        || (finfo->access == O_RDWR)))
+            || ((right == O_WRONLY) && (   (finfo->access == O_WRONLY)
+                                        || (finfo->access == O_RDWR)))
+            || ((right == O_RDWR)   && (finfo->access == O_RDWR)))
+                return 0;
+
+        return -EACCES;
+}
+
+static int 
+ncp_file_read(struct inode *inode, struct file *file, char *buf, int count)
+{
+	int bufsize, to_read, already_read;
+	off_t pos;
+        int errno;
+
+        DPRINTK("ncp_file_read: enter %s\n", NCP_ISTRUCT(inode)->entryName);
+        
+	if (!inode) {
+		DPRINTK("ncp_file_read: inode = NULL\n");
+		return -EINVAL;
+	}
+
+	if (!S_ISREG(inode->i_mode)) {
+		DPRINTK("ncp_file_read: read from non-file, mode %07o\n",
+                        inode->i_mode);
+		return -EINVAL;
+	}
+
+	pos = file->f_pos;
+
+	if (pos + count > inode->i_size)
+		count = inode->i_size - pos;
+
+	if (count <= 0)
+		return 0;
+
+        if ((errno = ncp_make_open(inode, O_RDONLY)) != 0)
+                return errno;
+        
+	bufsize = NCP_SERVER(inode)->buffer_size;
+
+        already_read = 0;
+
+	/* First read in as much as possible for each bufsize. */
+        while (already_read < count) {
+
+		int read_this_time;
+
+		if ((pos % bufsize) != 0) {
+			to_read = bufsize - (pos % bufsize);
+		} else {
+			to_read = bufsize;
+		}
+
+		to_read = min(to_read, count - already_read);
+
+		if (ncp_read(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
+			     pos, to_read, buf, &read_this_time) != 0) {
+			return -EIO; /* This is not exact, i know.. */
+		}
+
+		pos += read_this_time;
+		buf += read_this_time;
+                already_read += read_this_time;
+
+		if (read_this_time < to_read) {
+                        break;
+		}
+	}
+
+        file->f_pos = pos;
+
+	if (!IS_RDONLY(inode)) inode->i_atime = CURRENT_TIME;
+	inode->i_dirt = 1;
+
+        DPRINTK("ncp_file_read: exit %s\n", NCP_ISTRUCT(inode)->entryName);
+
+        return already_read;
+}
+
+static int 
+ncp_file_write(struct inode *inode, struct file *file, char *buf,
+	       int count)
+{
+	int bufsize, to_write, already_written;
+        off_t pos;
+        int errno;
+			  
+	if (!inode) {
+		DPRINTK("ncp_file_write: inode = NULL\n");
+		return -EINVAL;
+	}
+
+	if (!S_ISREG(inode->i_mode)) {
+		DPRINTK("ncp_file_write: write to non-file, mode %07o\n",
+                       inode->i_mode);
+		return -EINVAL;
+	}
+
+        DPRINTK("ncp_file_write: enter %s\n", NCP_ISTRUCT(inode)->entryName);
+
+	if (count <= 0)
+		return 0;
+
+        if ((errno = ncp_make_open(inode, O_RDWR)) != 0)
+                return errno;
+        
+	pos = file->f_pos;
+
+	if (file->f_flags & O_APPEND)
+		pos = inode->i_size;
+
+	bufsize = NCP_SERVER(inode)->buffer_size;
+
+        already_written = 0;
+
+        while (already_written < count) {
+
+		int written_this_time;
+
+		if ((pos % bufsize) != 0) {
+			to_write = bufsize - (pos % bufsize);
+		} else {
+			to_write = bufsize;
+		}
+
+		to_write = min(to_write, count - already_written);
+		if (ncp_write(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
+			      pos, to_write, buf, &written_this_time) != 0) {
+			return -EIO;
+                }
+
+		pos += written_this_time;
+		buf += written_this_time;
+		already_written += written_this_time;
+
+		if (written_this_time < to_write) {
+			break;
+		}
+	}
+
+	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+	inode->i_dirt = 1;
+
+	file->f_pos = pos;
+
+        if (pos > inode->i_size) {
+                inode->i_size = pos;
+        }
+
+        DPRINTK("ncp_file_write: exit %s\n", NCP_ISTRUCT(inode)->entryName);
+
+	return already_written;
+}
+
+static struct file_operations ncp_file_operations = {
+	NULL,			/* lseek - default */
+	ncp_file_read,		/* read */
+	ncp_file_write,		/* write */
+	NULL,			/* readdir - bad */
+	NULL,			/* select - default */
+	ncp_ioctl,		/* ioctl */
+	NULL,			/* mmap */
+	NULL,                   /* open */
+	NULL,                   /* release */
+	ncp_fsync,		/* fsync */
+};
+
+struct inode_operations ncp_file_inode_operations = {
+	&ncp_file_operations,	/* default file operations */
+	NULL,			/* create */
+	NULL,			/* lookup */
+	NULL,			/* link */
+	NULL,			/* unlink */
+	NULL,			/* symlink */
+	NULL,			/* mkdir */
+	NULL,			/* rmdir */
+	NULL,			/* mknod */
+	NULL,			/* rename */
+	NULL,			/* readlink */
+	NULL,			/* follow_link */
+	NULL,			/* bmap */
+	NULL			/* truncate */
+};

kernel-1.2/src/inode.c

@@ -0,0 +1,493 @@
+/*
+ *  inode.c
+ *
+ *  Copyright (C) 1995 by Volker Lendecke
+ *
+ */
+
+#include <linux/config.h>
+#ifdef MODULE
+#include <linux/module.h>
+#include <linux/version.h>
+#else
+#define MOD_INC_USE_COUNT
+#define MOD_DEC_USE_COUNT
+#endif
+
+#include <asm/system.h>
+#include <asm/segment.h>
+
+#include <linux/sched.h>
+#include <linux/ncp_fs.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+#include <linux/stat.h>
+#include <linux/errno.h>
+#include <linux/locks.h>
+#include <linux/fcntl.h>
+#include <linux/malloc.h>
+#include "ncplib_kernel.h"
+
+extern int close_fp(struct file *filp);
+
+static void ncp_put_inode(struct inode *);
+static void ncp_read_inode(struct inode *);
+static void ncp_put_super(struct super_block *);
+static void ncp_statfs(struct super_block *sb, struct statfs *stat);
+static int ncp_notify_change(struct inode *inode, struct iattr *attr);
+
+static struct super_operations ncp_sops = {
+	ncp_read_inode,         /* read inode */
+	ncp_notify_change,	/* notify change */
+	NULL,			/* write inode */
+	ncp_put_inode,		/* put inode */
+	ncp_put_super,		/* put superblock */
+	NULL,			/* write superblock */
+	ncp_statfs,		/* stat filesystem */
+	NULL
+        };
+
+/* ncp_read_inode: Called from iget, it only traverses the allocated
+   ncp_inode_info's and initializes the inode from the data found
+   there.  It does not allocate or deallocate anything. */
+
+static void
+ncp_read_inode(struct inode *inode)
+{
+        /* Our task should be extremely simple here. We only have to
+           look up the infomation somebody else (ncp_iget) put into
+           the inode tree. The address of this information is the
+           inode->i_ino. Just to make sure everything went well, we
+           check it's there. */
+
+        struct ncp_inode_info *inode_info
+                = (struct ncp_inode_info *)(inode->i_ino);
+
+#if 1
+        struct ncp_inode_info *root = &(NCP_SERVER(inode)->root);
+        struct ncp_inode_info *check_info = root;
+
+        do {
+                if (inode_info == check_info) {
+                        if (check_info->state == INODE_LOOKED_UP) {
+                                DDPRINTK("ncp_read_inode: found it!\n");
+                                goto good;
+                        }
+                        else {
+                                printk("ncp_read_inode: "
+                                       "state != INODE_LOOKED_UP\n");
+				goto good;
+                        }
+                }
+                check_info = check_info->next;
+        } while (check_info != root);
+
+        /* Ok, now we're in trouble. The inode info is not there. What
+           should we do now??? */
+        printk("ncp_read_inode: inode info not found\n");
+        return;
+
+ good:
+	DDPRINTK("ncp_read_inode: read entry %s\n",
+		 inode_info->finfo.i.entryName);
+#endif
+        inode_info->state = INODE_VALID;
+
+        NCP_INOP(inode) = inode_info;
+
+        if (NCP_ISTRUCT(inode)->attributes & aDIR) {
+                inode->i_mode = NCP_SERVER(inode)->m.dir_mode;
+		/* for directories in dataStreamSize seems to be some
+		   Object ID ??? */
+		inode->i_size = 0;
+	}
+        else
+	{
+                inode->i_mode = NCP_SERVER(inode)->m.file_mode;
+		inode->i_size = NCP_ISTRUCT(inode)->dataStreamSize;
+	}
+
+        DDPRINTK("ncp_read_inode: inode->i_mode = %u\n", inode->i_mode);
+
+        inode->i_nlink   = 1;
+        inode->i_uid     = NCP_SERVER(inode)->m.uid;
+        inode->i_gid     = NCP_SERVER(inode)->m.gid;
+        inode->i_blksize = 1024;
+        inode->i_rdev    = 0;
+        if ((inode->i_blksize != 0) && (inode->i_size != 0))
+                inode->i_blocks =
+                        (inode->i_size - 1) / inode->i_blksize + 1;
+        else
+                inode->i_blocks = 0;
+
+	inode->i_mtime = ncp_date_dos2unix(NCP_ISTRUCT(inode)->modifyTime,
+					   NCP_ISTRUCT(inode)->modifyDate);
+	inode->i_ctime = ncp_date_dos2unix(NCP_ISTRUCT(inode)->creationTime,
+					   NCP_ISTRUCT(inode)->creationDate);
+	inode->i_atime = ncp_date_dos2unix(0,
+					   NCP_ISTRUCT(inode)->lastAccessDate);
+
+        if (S_ISREG(inode->i_mode))
+                inode->i_op = &ncp_file_inode_operations;
+        else if (S_ISDIR(inode->i_mode))
+                inode->i_op = &ncp_dir_inode_operations;
+        else
+                inode->i_op = NULL;
+
+}
+
+static void
+ncp_put_inode(struct inode *inode)
+{
+        struct nw_file_info *finfo = NCP_FINFO(inode);
+
+        if (finfo->opened != 0) {
+
+                if (ncp_close_file(NCP_SERVER(inode), finfo->file_handle)!=0) {
+                        /* We can't do anything but complain. */
+                        printk("ncp_put_inode: could not close\n");
+                }
+        }
+
+	DDPRINTK("ncp_put_inode: put %s\n",
+		finfo->i.entryName);
+        
+        ncp_free_inode_info(NCP_INOP(inode));
+
+        if (S_ISDIR(inode->i_mode)) {
+                DDPRINTK("ncp_put_inode: put directory %ld\n",
+			 inode->i_ino);
+                ncp_invalid_dir_cache(inode->i_ino);
+        }                
+
+	clear_inode(inode);
+}
+
+struct super_block *
+ncp_read_super(struct super_block *sb, void *raw_data, int silent)
+{
+	struct ncp_mount_data *data = (struct ncp_mount_data *) raw_data;
+        struct ncp_server *server;
+	struct file *ncp_filp;
+	struct file *wdog_filp;
+	dev_t dev = sb->s_dev;
+	int error;
+
+	if (!data) {
+		printk("ncp_read_super: missing data argument\n");
+		sb->s_dev = 0;
+		return NULL;
+	}
+
+	if (data->version != NCP_MOUNT_VERSION) {
+		printk("ncp warning: mount version %s than kernel\n",
+		       (data->version < NCP_MOUNT_VERSION) ?
+                       "older" : "newer");
+	}
+
+
+	if (   (data->ncp_fd >= NR_OPEN)
+	    || ((ncp_filp = current->files->fd[data->ncp_fd]) == NULL)
+	    || (!S_ISSOCK(ncp_filp->f_inode->i_mode))) {
+		printk("ncp_read_super: invalid ncp socket\n");
+		sb->s_dev = 0;
+		return NULL;
+	}
+
+	if (   (data->wdog_fd >= NR_OPEN)
+	    || ((wdog_filp = current->files->fd[data->wdog_fd]) == NULL)
+	    || (!S_ISSOCK(wdog_filp->f_inode->i_mode))) {
+		printk("ncp_read_super: invalid wdog socket\n");
+		sb->s_dev = 0;
+		return NULL;
+	}
+
+        /* We must malloc our own super-block info */
+        server = (struct ncp_server *)ncp_kmalloc(sizeof(struct ncp_server),
+                                                   GFP_KERNEL);
+
+        if (server == NULL) {
+                printk("ncp_read_super: could not alloc ncp_server\n");
+                return NULL;
+        }
+
+	ncp_filp->f_count += 1;
+	wdog_filp->f_count += 1;
+
+	lock_super(sb);
+
+        NCP_SBP(sb) = server;
+        
+	sb->s_blocksize = 1024; /* Eh...  Is this correct? */
+	sb->s_blocksize_bits = 10;
+	sb->s_magic = NCP_SUPER_MAGIC;
+	sb->s_dev = dev;
+	sb->s_op = &ncp_sops;
+
+	server->ncp_filp    = ncp_filp;
+	server->wdog_filp   = wdog_filp;
+	server->lock        = 0;
+	server->wait        = NULL;
+        server->packet      = NULL;
+	server->buffer_size = 0;
+
+        server->m = *data;
+	server->m.file_mode = (server->m.file_mode &
+			       (S_IRWXU|S_IRWXG|S_IRWXO)) | S_IFREG;
+	server->m.dir_mode  = (server->m.dir_mode &
+			       (S_IRWXU|S_IRWXG|S_IRWXO)) | S_IFDIR;
+
+	server->packet_size = NCP_PACKET_SIZE;
+	server->packet      = ncp_kmalloc(NCP_PACKET_SIZE, GFP_KERNEL);
+
+	if (server->packet == NULL) {
+		printk("ncpfs: could not alloc packet\n");
+		error = -ENOMEM;
+		unlock_super(sb);
+		goto fail;
+	}
+   
+        ncp_init_root(server);
+
+        /*
+         * Make the connection to the server
+         */
+
+	if (ncp_catch_watchdog(server) != 0) {
+		printk("ncp_read_super: Could not catch watchdog\n");
+		error = -EINVAL;
+		unlock_super(sb);
+		goto fail;
+	}
+
+	ncp_lock_server(server);
+	error = ncp_connect(server);
+	ncp_unlock_server(server);
+	unlock_super(sb);
+
+	if (error < 0) {
+		sb->s_dev = 0;
+		printk("ncp_read_super: Failed connection, bailing out "
+                       "(error = %d).\n", -error);
+                ncp_kfree_s(server->packet, server->packet_size);
+		ncp_dont_catch_watchdog(server);
+                goto fail;
+	}
+
+        DPRINTK("ncp_read_super: NCP_SBP(sb) = %x\n", (int)NCP_SBP(sb));
+
+	if (!(sb->s_mounted = iget(sb, (int)&(server->root)))) {
+		sb->s_dev = 0;
+		printk("ncp_read_super: get root inode failed\n");
+                goto disconnect;
+	}
+
+	if (ncp_negotiate_buffersize(server, NCP_DEFAULT_BUFSIZE,
+				     &(server->buffer_size)) != 0) {
+		sb->s_dev = 0;
+		printk("ncp_read_super: could not get bufsize\n");
+		goto disconnect;
+	}
+
+	DPRINTK("ncpfs: bufsize = %d\n", server->buffer_size);
+
+/*	if (ncp_login_user(server, server->m.username,
+			   server->m.password) != 0) {
+		sb->s_dev = 0;
+		printk("ncp_read_super: login failed\n");
+		goto disconnect;
+	}
+*/
+
+        MOD_INC_USE_COUNT;
+	return sb;
+
+ disconnect:
+	ncp_lock_server(server);
+	ncp_disconnect(server);
+	ncp_unlock_server(server);
+	ncp_kfree_s(server->packet, server->packet_size);
+	ncp_dont_catch_watchdog(server);
+ fail:
+	ncp_filp->f_count -= 1;
+	wdog_filp->f_count -= 1;
+        ncp_kfree_s(NCP_SBP(sb), sizeof(struct ncp_server));
+        return NULL;
+}
+
+static void
+ncp_put_super(struct super_block *sb)
+{
+        struct ncp_server *server = NCP_SBP(sb);
+
+	lock_super(sb);
+
+	ncp_lock_server(server);
+        ncp_disconnect(server);
+	ncp_unlock_server(server);
+
+	close_fp(server->ncp_filp);
+
+	ncp_dont_catch_watchdog(server);
+	close_fp(server->wdog_filp);
+
+        ncp_free_all_inodes(server);
+
+        ncp_kfree_s(server->packet, server->packet_size);
+
+	sb->s_dev = 0;
+        ncp_kfree_s(NCP_SBP(sb), sizeof(struct ncp_server));
+	NCP_SBP(sb) = NULL;
+
+	unlock_super(sb);
+
+        MOD_DEC_USE_COUNT;
+}
+
+static void 
+ncp_statfs(struct super_block *sb, struct statfs *stat)
+{
+	struct statfs tmp;
+	
+	/* We cannot say how much disk space is left on a mounted
+           NetWare Server, because free space is distributed over
+           volumes, and the current user might have disk quotas. So
+           free space is not that simple to determine. Our decision
+           here is to err conservatively. */
+
+	tmp.f_type = NCP_SUPER_MAGIC;
+	tmp.f_bsize = 512;
+	tmp.f_blocks = 0;
+	tmp.f_bfree = 0;
+	tmp.f_bavail = 0;
+	tmp.f_files = -1;
+	tmp.f_ffree = -1;
+	tmp.f_namelen = 12;
+	memcpy_tofs(stat, &tmp, sizeof(tmp));
+}
+
+static int
+ncp_notify_change(struct inode *inode, struct iattr *attr)
+{
+	int result = 0;
+	int info_mask;
+	struct nw_modify_dos_info info;
+
+	if ((result = inode_change_ok(inode, attr)) < 0)
+		return result;
+
+	if (((attr->ia_valid & ATTR_UID) && 
+	     (attr->ia_uid != NCP_SERVER(inode)->m.uid)))
+		return -EPERM;
+
+	if (((attr->ia_valid & ATTR_GID) && 
+	     (attr->ia_uid != NCP_SERVER(inode)->m.gid)))
+                return -EPERM;
+
+	if (((attr->ia_valid & ATTR_MODE) &&
+	     (attr->ia_mode &
+	      ~(S_IFREG | S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO))))
+		return -EPERM;
+
+	info_mask = 0;
+	memset(&info, 0, sizeof(info));
+
+	if ((attr->ia_valid & ATTR_CTIME) != 0) {
+		info_mask |= (DM_CREATE_TIME|DM_CREATE_DATE);
+		ncp_date_unix2dos(attr->ia_ctime,
+				  &(info.creationTime), &(info.creationDate));
+	}
+	
+	if ((attr->ia_valid & ATTR_MTIME) != 0) {
+		info_mask |= (DM_MODIFY_TIME|DM_MODIFY_DATE);
+		ncp_date_unix2dos(attr->ia_mtime,
+				  &(info.modifyTime), &(info.modifyDate));
+	}
+	
+	if ((attr->ia_valid & ATTR_ATIME) != 0) {
+		__u16 dummy;
+		info_mask |= (DM_LAST_ACCESS_DATE);
+		ncp_date_unix2dos(attr->ia_ctime,
+				  &(dummy), &(info.lastAccessDate));
+	}
+
+	if (info_mask != 0) {
+		if ((result =
+		     ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),
+							NCP_ISTRUCT(inode),
+							info_mask,
+							&info)) != 0) {
+			result = -EACCES;
+		}
+	}
+
+        if ((attr->ia_valid & ATTR_SIZE) != 0) {
+
+		int written;
+
+		DPRINTK("ncpfs: trying to change size of %s to %ld\n",
+			NCP_ISTRUCT(inode)->entryName, attr->ia_size);
+
+		if ((result = ncp_make_open(inode, O_RDWR)) < 0) {
+			return -EACCES;
+		}
+
+		ncp_write(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
+			  attr->ia_size, 0, "", &written);
+
+		/* According to ndir, the changes only take effect after
+		   closing the file */
+		ncp_close_file(NCP_SERVER(inode),
+			       NCP_FINFO(inode)->file_handle);
+		NCP_FINFO(inode)->opened = 0;
+
+		result = 0;
+	}
+
+        ncp_invalid_dir_cache((unsigned long)(NCP_INOP(inode)->dir));
+
+	return result;
+}
+		
+#ifdef DEBUG_NCP_MALLOC
+int ncp_malloced;
+int ncp_current_malloced;
+#endif
+
+#ifdef MODULE
+
+char kernel_version[] = UTS_RELEASE;
+
+static struct file_system_type ncp_fs_type = {
+        ncp_read_super, "ncpfs", 0, NULL
+        };
+
+int
+init_module( void)
+{
+        DPRINTK("ncpfs: init_module called\n");
+
+#ifdef DEBUG_NCP_MALLOC
+        ncp_malloced = 0;
+        ncp_current_malloced = 0;
+#endif
+
+        ncp_init_dir_cache();
+        register_filesystem(&ncp_fs_type);
+        return 0;
+}
+
+void
+cleanup_module(void)
+{
+        DPRINTK("ncpfs: cleanup_module called\n");
+        ncp_free_dir_cache();
+        unregister_filesystem(&ncp_fs_type);
+#ifdef DEBUG_NCP_MALLOC
+        printk("ncp_malloced: %d\n", ncp_malloced);
+        printk("ncp_current_malloced: %d\n", ncp_current_malloced);
+#endif
+}
+
+#endif

kernel-1.2/src/ioctl.c

@@ -0,0 +1,97 @@
+/*
+ *  ioctl.c
+ *
+ *  Copyright (C) 1995 by Volker Lendecke
+ *
+ */
+
+#include <linux/config.h>
+#ifdef MODULE
+#include <linux/module.h>
+#include <linux/version.h>
+#else
+#define MOD_INC_USE_COUNT
+#define MOD_DEC_USE_COUNT
+#endif
+
+#include <asm/segment.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/ncp_fs.h>
+#include <linux/ioctl.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/ncp.h>
+
+int
+ncp_ioctl (struct inode * inode, struct file * filp,
+           unsigned int cmd, unsigned long arg)
+{
+	int result;
+	struct ncp_ioctl_request request;
+	struct ncp_server *server;
+
+	switch(cmd) {
+	case NCP_IOC_NCPREQUEST:
+
+		if (!suser()) {
+			return -EPERM;
+		}
+		
+		if ((result = verify_area(VERIFY_READ, (char *)arg,
+					  sizeof(request))) != 0) {
+			return result;
+		}
+
+		memcpy_fromfs(&request, (struct ncp_ioctl_request *)arg,
+			      sizeof(request));
+
+		if (   (request.function > 255)
+		    || (request.size >
+			NCP_PACKET_SIZE - sizeof(struct ncp_request_header))) {
+			return -EINVAL;
+		}
+
+		if ((result = verify_area(VERIFY_WRITE, (char *)request.data,
+					  NCP_PACKET_SIZE)) != 0) {
+			return result;
+		}
+
+		server = NCP_SERVER(inode);
+		ncp_lock_server(server);
+
+		/* FIXME: We hack around in the server's structures
+                   here to be able to use ncp_request */
+
+		server->has_subfunction = 0;
+		server->current_size =
+			request.size + sizeof(struct ncp_request_header);
+		memcpy_fromfs(server->packet, request.data,
+			      request.size+sizeof(struct ncp_request_header));
+
+		
+		ncp_request(server, request.function);
+
+		DPRINTK("ncp_ioctl: copy %d bytes\n",
+			server->reply_size);
+		memcpy_tofs(request.data, server->packet,
+			    server->reply_size);
+
+		ncp_unlock_server(server);
+
+		return server->reply_size;
+
+        case NCP_IOC_GETMOUNTUID:
+                if ((result = verify_area(VERIFY_WRITE, (uid_t*) arg,
+                                          sizeof(uid_t))) != 0) {
+                        return result;
+                }
+                put_fs_word(NCP_SERVER(inode)->m.mounted_uid, (uid_t*) arg);
+                return 0;
+
+	default:
+		return -EINVAL;
+	}
+	
+	return -EINVAL;
+}

kernel-1.2/src/ncplib_kernel.c

@@ -0,0 +1,590 @@
+#include <linux/config.h>
+#ifdef MODULE
+#include <linux/module.h>
+#include <linux/version.h>
+#else
+#define MOD_INC_USE_COUNT
+#define MOD_DEC_USE_COUNT
+#endif
+
+
+
+#include "ncplib_kernel.h"
+
+typedef __u8  byte;
+typedef __u16 word;
+typedef __u32 dword;
+
+static void
+assert_server_locked(struct ncp_server *server)
+{
+	if (server->lock == 0) {
+		DPRINTK("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_mem_fromfs(struct ncp_server *server, const char *source, int size)
+{
+	assert_server_locked(server);
+	memcpy_fromfs(&(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) {
+		DPRINTK("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 = 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->packet[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;
+}
+
+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) {
+		DPRINTK("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_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 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) {
+
+		DDPRINTK("ncp_do_lookup: looking up vol %s\n", path);
+
+		/* 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;
+}
+
+/* If both dir and name are NULL, then in target there's already a
+   looked-up entry that wants to be opened. */
+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;
+
+	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);
+
+	if (dir != NULL) {
+		ncp_add_handle_path(server, dir->volNumber,
+				    dir->DosDirNum, 1, name);
+	} else {
+		ncp_add_handle_path(server,
+				    target->i.volNumber, target->i.DosDirNum,
+				    1, NULL);
+	}	
+
+	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);
+
+	if (dir != NULL) {
+		/* in target there's a new finfo to fill */
+		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;
+}
+	
+
+/* We have to transfer to/from user space */
+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_tofs(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_fromfs(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;
+}
+

kernel-1.2/src/sock.c

@@ -0,0 +1,543 @@
+/*
+ *  linux/fs/ncp/sock.c
+ *
+ *  Copyright (C) 1992, 1993  Rick Sladkey
+ *
+ *  Modified 1995 by Volker Lendecke to be usable for ncp
+ *
+ */
+
+#include <linux/config.h>
+#ifdef MODULE
+#include <linux/module.h>
+#include <linux/version.h>
+#else
+#define MOD_INC_USE_COUNT
+#define MOD_DEC_USE_COUNT
+#endif
+
+#include <linux/sched.h>
+#include <linux/ncp_fs.h>
+#include <linux/errno.h>
+#include <linux/socket.h>
+#include <linux/fcntl.h>
+#include <linux/stat.h>
+#include <asm/segment.h>
+#include <linux/in.h>
+#include <linux/net.h>
+#include <linux/mm.h>
+#include <linux/netdevice.h>
+#include <linux/ipx.h>
+
+#include <linux/ncp.h>
+#include <linux/ncp_fs.h>
+#include <linux/ncp_fs_sb.h>
+#include "/usr/src/linux/net/inet/sock.h"
+
+
+#define _S(nr) (1<<((nr)-1))
+static void
+ncp_wdog_data_ready(struct sock *sk, int len)
+{
+	struct socket *sock = sk->socket;
+
+	if (!sk->dead)
+	{
+		unsigned char packet_buf[2];
+		struct sockaddr_ipx sender;
+		int addr_len = sizeof(struct sockaddr_ipx);
+		int result;
+		unsigned short fs;
+
+		fs = get_fs();
+		set_fs(get_ds());
+
+		result = sock->ops->recvfrom(sock, (void *)packet_buf, 2, 1, 0,
+					     (struct sockaddr *)&sender,
+					     &addr_len);
+
+		if (   (result != 2)
+		    || (packet_buf[1] != '?')
+		    /* How to check connection number here? */
+		    )
+		{
+			/* Error, throw away the complete packet */
+			sock->ops->recvfrom(sock, (void *)packet_buf, 2, 1, 0,
+					    (struct sockaddr *)&sender,
+					    &addr_len);
+
+			printk("ncpfs: got strange packet on watchdog "
+			       "socket\n");
+			
+		} else {
+			int result;
+			DDPRINTK("ncpfs: got watchdog from:\n");
+			DDPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X,"
+				" conn:%02X,type:%c\n",
+				htonl(sender.sipx_network),
+				sender.sipx_node[0], sender.sipx_node[1],
+				sender.sipx_node[2], sender.sipx_node[3],
+				sender.sipx_node[4], sender.sipx_node[5],
+				ntohs(sender.sipx_port),
+				packet_buf[0], packet_buf[1]);
+
+			packet_buf[1] = 'Y';
+			result = sock->ops->sendto(sock, (void *)packet_buf,
+						   2, 1, 0,
+						   (struct sockaddr *)&sender,
+						   sizeof(sender));
+			DDPRINTK("send result: %d\n", result);
+		}
+		set_fs(fs);
+	}
+}
+
+
+int
+ncp_catch_watchdog(struct ncp_server *server)
+{
+        struct file   *file;
+        struct inode  *inode;
+        struct socket *sock;
+        struct sock   *sk;
+
+        if (   (server == NULL)
+            || ((file  = server->wdog_filp) == NULL)
+            || ((inode = file->f_inode) == NULL)
+            || (!S_ISSOCK(inode->i_mode))) {
+
+                printk("ncp_catch_watchdog: did not get valid server!\n");
+                server->data_ready = NULL;
+                return -EINVAL;
+        }
+
+        sock = &(inode->u.socket_i);
+
+        if (sock->type != SOCK_DGRAM) {
+                printk("ncp_catch_watchdog: did not get SOCK_STREAM\n");
+                server->data_ready = NULL;
+                return -EINVAL;
+        }
+
+        sk   = (struct sock *)(sock->data);
+
+        if (sk == NULL) {
+                printk("ncp_catch_watchdog: sk == NULL");
+                server->data_ready = NULL;
+                return -EINVAL;
+        }
+
+        DDPRINTK("ncp_catch_watchdog.: sk->d_r = %x, server->d_r = %x\n",
+                 (unsigned int)(sk->data_ready),
+                 (unsigned int)(server->data_ready));
+
+        if (sk->data_ready == ncp_wdog_data_ready) {
+                printk("ncp_catch_watchdog: already done\n");
+                return -EINVAL;
+        }
+
+        server->data_ready = sk->data_ready;
+        sk->data_ready = ncp_wdog_data_ready;
+        return 0;
+}
+                
+int
+ncp_dont_catch_watchdog(struct ncp_server *server)
+{
+        struct file   *file;
+        struct inode  *inode;
+        struct socket *sock;
+        struct sock   *sk;
+
+        if (   (server == NULL)
+            || ((file  = server->wdog_filp) == NULL)
+            || ((inode = file->f_inode) == NULL)
+            || (!S_ISSOCK(inode->i_mode))) {
+
+                printk("ncp_dont_catch_watchdog: "
+                       "did not get valid server!\n");
+                return -EINVAL;
+        }
+
+        sock = &(inode->u.socket_i);
+
+        if (sock->type != SOCK_DGRAM) {
+                printk("ncp_dont_catch_watchdog: did not get SOCK_STREAM\n");
+                return -EINVAL;
+        }
+
+        sk   = (struct sock *)(sock->data);
+
+        if (sk == NULL) {
+                printk("ncp_dont_catch_watchdog: sk == NULL");
+                return -EINVAL;
+        }
+
+        if (server->data_ready == NULL) {
+                printk("ncp_dont_catch_watchdog: "
+                       "server->data_ready == NULL\n");
+                return -EINVAL;
+        }
+
+        if (sk->data_ready != ncp_wdog_data_ready) {
+                printk("ncp_dont_catch_watchdog: "
+                       "sk->data_callback != ncp_data_callback\n");
+                return -EINVAL;
+        }
+
+        DDPRINTK("ncp_dont_catch_watchdog: sk->d_r = %x, server->d_r = %x\n",
+                 (unsigned int)(sk->data_ready),
+                 (unsigned int)(server->data_ready));
+
+        sk->data_ready = server->data_ready;
+        server->data_ready = NULL;
+        return 0;
+}
+
+
+
+#define NCP_SLACK_SPACE 1024
+
+#define _S(nr) (1<<((nr)-1))
+
+static int
+do_ncp_rpc_call(struct ncp_server *server, int size)
+{
+	struct file *file;
+	struct inode *inode;
+	struct socket *sock;
+	unsigned short fs;
+	int result;
+	char *start = server->packet;
+	select_table wait_table;
+	struct select_table_entry entry;
+	int (*select) (struct inode *, struct file *, int, select_table *);
+	int init_timeout, max_timeout;
+	int timeout;
+	int retrans;
+	int major_timeout_seen;
+	char *server_name;
+	int n;
+	int addrlen;
+	unsigned long old_mask;
+
+	/* We have to check the result, so store the complete header */
+	struct ncp_request_header request =
+		*((struct ncp_request_header *)(server->packet));
+
+	struct ncp_reply_header reply;	
+
+
+	file = server->ncp_filp;
+	inode = file->f_inode;
+	select = file->f_op->select;
+	sock = &inode->u.socket_i;
+	if (!sock) {
+		printk("ncp_rpc_call: socki_lookup failed\n");
+		return -EBADF;
+	}
+	init_timeout = server->m.time_out;
+	max_timeout = NCP_MAX_RPC_TIMEOUT*HZ/10;
+	retrans = server->m.retry_count;
+	major_timeout_seen = 0;
+	server_name = server->m.server_name;
+	old_mask = current->blocked;
+	current->blocked |= ~(_S(SIGKILL)
+#if 0
+		| _S(SIGSTOP)
+#endif
+		| ((server->m.flags & NCP_MOUNT_INTR)
+		? ((current->sigaction[SIGINT - 1].sa_handler == SIG_DFL
+			? _S(SIGINT) : 0)
+		| (current->sigaction[SIGQUIT - 1].sa_handler == SIG_DFL
+			? _S(SIGQUIT) : 0))
+		: 0));
+	fs = get_fs();
+	set_fs(get_ds());
+	for (n = 0, timeout = init_timeout; ; n++, timeout <<= 1) {
+		DDPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X\n",
+			htonl(server->m.serv_addr.sipx_network),
+			server->m.serv_addr.sipx_node[0],
+			server->m.serv_addr.sipx_node[1],
+			server->m.serv_addr.sipx_node[2],
+			server->m.serv_addr.sipx_node[3],
+			server->m.serv_addr.sipx_node[4],
+			server->m.serv_addr.sipx_node[5],
+			ntohs(server->m.serv_addr.sipx_port));
+		DDPRINTK("ncpfs: req.typ: %04X, con: %d, "
+			"seq: %d",
+			request.type,
+			(request.conn_high << 8) + request.conn_low,
+			request.sequence);
+		DDPRINTK(" func: %d\n",
+			 request.function);
+
+		result = sock->ops->sendto(sock, (void *) start, size, 0, 0,
+					   (struct sockaddr *)
+					   &(server->m.serv_addr),
+					   sizeof(server->m.serv_addr));
+		if (result < 0) {
+			printk("ncp_rpc_call: send error = %d\n", result);
+			break;
+		}
+	re_select:
+		wait_table.nr = 0;
+		wait_table.entry = &entry;
+		current->state = TASK_INTERRUPTIBLE;
+		if (   !select(inode, file, SEL_IN, &wait_table)
+		    && !select(inode, file, SEL_IN, NULL)) {
+			if (timeout > max_timeout) {
+			  /* JEJB/JSP 2/7/94
+			   * This is useful to see if the system is
+			   * hanging */
+			  printk("NCP max timeout reached on %s\n",
+				 server_name);
+			  timeout = max_timeout;
+			}
+			current->timeout = jiffies + timeout;
+			schedule();
+			remove_wait_queue(entry.wait_address, &entry.wait);
+			current->state = TASK_RUNNING;
+			if (current->signal & ~current->blocked) {
+				current->timeout = 0;
+				result = -ERESTARTSYS;
+				break;
+			}
+			if (!current->timeout) {
+				if (n < retrans)
+					continue;
+				if (server->m.flags & NCP_MOUNT_SOFT) {
+					printk("NCP server %s not responding, "
+						"timed out\n", server_name);
+					result = -EIO;
+					break;
+				}
+				n = 0;
+				timeout = init_timeout;
+				init_timeout <<= 1;
+				if (!major_timeout_seen) {
+				  printk("NCP server %s not responding, "
+					 "still trying\n", server_name);
+				}
+				major_timeout_seen = 1;
+				continue;
+			}
+			else
+				current->timeout = 0;
+		}
+		else if (wait_table.nr)
+			remove_wait_queue(entry.wait_address, &entry.wait);
+		current->state = TASK_RUNNING;
+		addrlen = 0;
+
+		/* Get the header from the next packet using a peek, so keep it
+		 * on the recv queue.  If it is wrong, it will be some reply
+		 * we don't now need, so discard it */
+		result = sock->ops->recvfrom(sock, (void *)&reply,
+					     sizeof(reply), 1, MSG_PEEK,
+					     NULL, &addrlen);
+		if (result < 0) {
+			if (result == -EAGAIN) {
+				DPRINTK("ncp_rpc_call: bad select ready\n");
+				goto re_select;
+			}
+			if (result == -ECONNREFUSED) {
+				DPRINTK("ncp_rpc_call: server playing coy\n");
+				goto re_select;
+			}
+			if (result != -ERESTARTSYS) {
+				printk("ncp_rpc_call: recv error = %d\n",
+					-result);
+			}
+			break;
+		}
+		if (   (result     == sizeof(reply))
+		    && (reply.type == NCP_POSITIVE_ACK)) {
+			/* Throw away the packet */
+			DPRINTK("ncp_rpc_call: got positive acknowledge\n");
+			sock->ops->recvfrom(sock, (void *)&reply,
+					    sizeof(reply), 1, 0,
+					    NULL, &addrlen);
+			goto re_select;
+		}
+
+		DDPRINTK("ncpfs: rep.typ: %04X, con: %d, tsk: %d,"
+			"seq: %d\n",
+			reply.type,
+			(reply.conn_high << 8) + reply.conn_low,
+			reply.task,
+			reply.sequence);
+		
+		if (   (result          >= sizeof(reply))
+		    && (reply.type      == NCP_REPLY)
+		    && (   (request.type    == NCP_ALLOC_SLOT_REQUEST)
+			|| (   (reply.sequence  == request.sequence)
+			    && (reply.conn_low  == request.conn_low)
+/* seem to get wrong task from NW311 && (reply.task      == request.task)*/
+			    && (reply.conn_high == request.conn_high)))) {
+			if (major_timeout_seen)
+				printk("NCP server %s OK\n", server_name);
+			break;
+		}
+		/* JEJB/JSP 2/7/94
+		 * we have xid mismatch, so discard the packet and start
+		 * again.  What a hack! but I can't call recvfrom with
+		 * a null buffer yet. */
+		sock->ops->recvfrom(sock, (void *)&reply, sizeof(reply), 1, 0,
+				    NULL, &addrlen);
+#if 1
+		printk("ncp_rpc_call: reply mismatch\n");
+#endif
+		goto re_select;
+	}
+	/* 
+	 * we have the correct reply, so read into the correct place and
+	 * return it
+	 */
+	result = sock->ops->recvfrom(sock, (void *)start, server->packet_size,
+				     1, 0, NULL, &addrlen);
+	if (result < 0) {
+		printk("NCP: notice message: result=%d\n", result);
+	} else if (result < sizeof(struct ncp_reply_header)) {
+		printk("NCP: just caught a too small read memory size..., "
+		       "email to NET channel\n");
+		printk("NCP: result=%d,addrlen=%d\n", result, addrlen);
+		result = -EIO;
+	}
+
+	current->blocked = old_mask;
+	set_fs(fs);
+	return result;
+}
+
+
+/*
+ * We need the server to be locked here, so check!
+ */
+
+static int
+ncp_do_request(struct ncp_server *server, int size)
+{
+	if (server->lock == 0) {
+		printk("ncpfs: Server not locked!\n");
+		return -EIO;
+	}
+
+	return do_ncp_rpc_call(server, size);
+}
+
+/* ncp_do_request assures that at least a complete reply header is
+ * received. It assumes that server->current_size contains the ncp
+ * request size */
+int
+ncp_request(struct ncp_server *server, int function)
+{
+	struct ncp_request_header *h
+		= (struct ncp_request_header *)(server->packet);
+	struct ncp_reply_header *reply
+		= (struct ncp_reply_header *)(server->packet);
+
+	int request_size = server->current_size
+		- sizeof(struct ncp_request_header);
+
+	int result;
+
+	if (server->has_subfunction != 0) {
+		*(__u16 *)&(h->data[0]) = request_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      = (current->pid) & 0xff;
+	h->function  = function;
+
+	if ((result = ncp_do_request(server, request_size + sizeof(*h))) < 0) {
+		DPRINTK("ncp_request_error: %d\n", result);
+		return result;
+	}
+
+	server->completion  = reply->completion_code;
+	server->conn_status = reply->connection_state;
+	server->reply_size  = result;
+	server->ncp_reply_size = result - sizeof(struct ncp_reply_header);
+
+	result = reply->completion_code;
+
+	if (result != 0) {
+		DPRINTK("ncp_completion_code: %d\n", result);
+	}
+	return result;	
+}
+
+int
+ncp_connect(struct ncp_server *server)
+{
+	struct ncp_request_header *h
+		= (struct ncp_request_header *)(server->packet);
+	int result;
+
+	h->type = NCP_ALLOC_SLOT_REQUEST;
+	
+	server->sequence = 0;
+	h->sequence  = server->sequence;
+	h->conn_low  = 0xff;
+	h->conn_high = 0xff;
+	h->task      = (current->pid) & 0xff;
+	h->function  = 0;
+
+	if ((result = ncp_do_request(server, sizeof(*h))) < 0) {
+		return result;
+	}
+
+	server->sequence = 0;
+	server->connection = h->conn_low + (h->conn_high * 256);
+	return 0;
+}
+	
+int
+ncp_disconnect(struct ncp_server *server)
+{
+	struct ncp_request_header *h
+		= (struct ncp_request_header *)(server->packet);
+
+	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      = (current->pid) & 0xff;
+	h->function  = 0;
+
+	return ncp_do_request(server, sizeof(*h));
+}
+
+void
+ncp_lock_server(struct ncp_server *server)
+{
+#if 1
+	/* For testing, only 1 process */
+	if (server->lock != 0) {
+		DPRINTK("ncpfs: server locked!!!\n");
+	}
+#endif
+        while (server->lock)
+		sleep_on(&server->wait);
+	server->lock = 1;
+}
+
+void
+ncp_unlock_server(struct ncp_server *server)
+{
+        if (server->lock != 1) {
+                printk("ncp_unlock_server: was not locked!\n");
+        }
+
+        server->lock = 0;
+        wake_up(&server->wait);
+}
+        

kernel-1.3/linux/ncp.h

@@ -8,7 +8,10 @@
 #ifndef _LINUX_NCP_H
 #define _LINUX_NCP_H
 
+#error "Please use kernel 1.2.13"
+
 #include <linux/types.h>
+#include <linux/ipx.h>
 
 #define NCP_PTYPE                (0x11)
 #define NCP_PORT                 (0x0451)
@@ -51,6 +54,9 @@ struct ncp_bindery_object {
 	__u32   object_id;
 	__u16   object_type;
 	__u8    object_name[NCP_BINDERY_NAME_LEN];
+	__u8    object_flags;
+	__u8    object_security;
+	__u8    object_has_prop;
 };
 
 struct nw_property {
@@ -59,6 +65,11 @@ struct nw_property {
 	__u8    property_flag;
 };
 
+struct prop_net_address {
+	__u32 network                __attribute__ ((packed));
+	__u8  node[IPX_NODE_LEN]     __attribute__ ((packed));
+	__u16 port                   __attribute__ ((packed));
+};
 
 #define NCP_VOLNAME_LEN (16)
 #define NCP_NUMBER_OF_VOLUMES (64)
@@ -263,16 +274,23 @@ struct queue_job {
 
 /* ClientRecordArea for print jobs */
 
+#define   KEEP_ON        0x0400
+#define   NO_FORM_FEED   0x0800
+#define   NOTIFICATION   0x1000
+#define   DELETE_FILE    0x2000
+#define   EXPAND_TABS    0x4000
+#define   PRINT_BANNER   0x8000
+
 struct print_job_record {
     __u8  Version                         __attribute__ ((packed));
-    __u16 TabSize                         __attribute__ ((packed));
+    __u8  TabSize                         __attribute__ ((packed));
     __u16 Copies                          __attribute__ ((packed));
-    __u8  CtrlFlags                       __attribute__ ((packed));
+    __u16 CtrlFlags                       __attribute__ ((packed));
     __u16 Lines                           __attribute__ ((packed));
     __u16 Rows                            __attribute__ ((packed));
     char  FormName[16]                    __attribute__ ((packed));
     __u8  Reserved[6]                     __attribute__ ((packed));
-    char  Banner[13]                      __attribute__ ((packed));
+    char  BannerName[13]                  __attribute__ ((packed));
     char  FnameBanner[13]                 __attribute__ ((packed));
     char  FnameHeader[14]                 __attribute__ ((packed));
     char  Path[80]                        __attribute__ ((packed));

kernel-1.3/src/Makefile

@@ -6,7 +6,7 @@ INCLUDES =  -I/usr/src/linux/include -I..
 
 CFLAGS = -Wall -Wstrict-prototypes -O2 -DMODULE -fomit-frame-pointer \
 	$(INCLUDES) \
-#         -DDEBUG_NCP=2 -DDEBUG_NCP_MALLOC
+#         -DDEBUG_NCP=1 -DDEBUG_NCP_MALLOC
 #         -DDEBUG_NCP_MALLOC
 
 CC     = gcc -D__KERNEL__ -I.
@@ -20,14 +20,14 @@ ARCH   = i386
 .s.o:
 	$(AS) -o $*.o $<
 
-OBJS=	dir.o inode.o file.o sock.o ioctl.o ncplib.o
+OBJS=	dir.o inode.o file.o sock.o ioctl.o ncplib_kernel.o
 
 all: ncpfs.o
 
 ncpfs.o: $(OBJS)
 	$(LD) -r -o ncpfs.o $(OBJS)
 
-ncplib.o: ncplib.c ncplib.h
+ncplib_kernel.o: ncplib_kernel.c ncplib_kernel.h
 	$(CC) $(CFLAGS) -finline-functions -c $<
 
 dep:

kernel-1.3/src/dir.c

@@ -5,8 +5,6 @@
  *
  */
 
-/* #include <linux/module.h>*/
-
 #include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/stat.h>
@@ -16,7 +14,7 @@
 #include <linux/ncp_fs.h>
 #include <asm/segment.h>
 #include <linux/errno.h>
-#include "ncplib.h"
+#include "ncplib_kernel.h"
 
 struct ncp_dirent {
 	struct nw_info_struct i;
@@ -30,6 +28,7 @@ ncp_dir_read(struct inode *inode, struct file *filp, char *buf, int count);
 static int 
 ncp_readdir(struct inode *inode, struct file *filp,
             void *dirent, filldir_t filldir);
+
 static int
 ncp_read_volume_list(struct ncp_server *server, int start_with,
 		     int cache_size);
@@ -194,7 +193,7 @@ ncp_readdir(struct inode *inode, struct file *filp,
 	}
 
 	if (entry == NULL) {
-		DPRINTK("ncp_readdir: Not found in cache.\n");
+		DDPRINTK("ncp_readdir: Not found in cache.\n");
 
 		if (inode->i_ino == (int)&(server->root)) {
 
@@ -285,8 +284,8 @@ ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
 #if 1
 	if (fpos < 2) {
 		printk("OOPS, we expect fpos >= 2");
+		fpos = 2;
 	}
-	fpos = 2;
 #endif
 
 	for (i=0; i<NCP_NUMBER_OF_VOLUMES; i++) {
@@ -329,19 +328,35 @@ static int
 ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
 	       int cache_size, struct ncp_dirent *entry)
 {
-	struct nw_search_sequence seq;
-	int total_count = 2;
+	static struct nw_search_sequence seq;
+	static struct inode *last_dir;
+	static int total_count;
 
 #if 1
 	if (fpos < 2) {
 		printk("OOPS, we expect fpos >= 2");
+		fpos = 2;
 	}
-	fpos = 2;
 #endif
+	DPRINTK("ncp_do_readdir: fpos = %d\n", fpos);
 
-	if (ncp_initialize_search(server, NCP_ISTRUCT(dir), &seq) != 0) {
-		DPRINTK("ncp_init_search failed\n");
-		return total_count - fpos;
+	if (fpos == 2) {
+		last_dir = NULL;
+		total_count = 2;
+	}
+
+	if ((fpos != total_count) || (dir != last_dir)) {
+
+		total_count = 2;
+		last_dir = dir;
+
+		DPRINTK("ncp_do_readdir: re-used seq for %s\n",
+			NCP_ISTRUCT(dir)->entryName);
+
+		if (ncp_initialize_search(server, NCP_ISTRUCT(dir), &seq)!=0) {
+			DPRINTK("ncp_init_search failed\n");
+			return total_count - fpos;
+		}
 	}
 
 	while (total_count < fpos + cache_size) {
@@ -355,8 +370,8 @@ ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
 			DPRINTK("ncp_do_readdir: skipped file: %s\n",
 				entry->i.entryName);
 		} else {
-			DPRINTK("ncp_do_readdir: found file: %s\n",
-				entry->i.entryName);
+			DDPRINTK("ncp_do_r: file: %s, f_pos=%d,total_count=%d",
+				 entry->i.entryName, fpos, total_count);
 			entry->s = seq;
 			entry->f_pos = total_count;
 			entry += 1;
@@ -543,7 +558,7 @@ ncp_find_inode(struct inode *dir, const char *name)
 	}
 
         do {
-		if (   (result->finfo.i.DosDirNum == dir_info->DosDirNum)
+		if (   (result->dir->finfo.i.DosDirNum == dir_info->DosDirNum)
 		    && (strcmp(result->finfo.i.entryName, name) == 0))
                         return result;
                 result = result->next;
@@ -582,7 +597,13 @@ ncp_lookup(struct inode *dir, const char *__name, int len,
 
 	/* ..and for .. */
 	if (len == 2 && __name[0] == '.' && __name[1] == '.') {
-		*result = iget(dir->i_sb, (int)(NCP_INOP(dir)->dir));
+		struct ncp_inode_info *parent = NCP_INOP(dir)->dir;
+
+		if (parent->state == INODE_CACHED) {
+			parent->state = INODE_LOOKED_UP;
+		}
+
+		*result = iget(dir->i_sb, (int)parent);
 		iput(dir);
 		if (*result == 0)
 			return -EACCES;

kernel-1.3/src/file.c

@@ -5,8 +5,6 @@
  *
  */
 
-/* #include <linux/module.h>*/
-
 #include <asm/segment.h>
 #include <asm/system.h>
 
@@ -17,7 +15,7 @@
 #include <linux/stat.h>
 #include <linux/mm.h>
 #include <linux/ncp_fs.h>
-#include "ncplib.h"
+#include "ncplib_kernel.h"
 #include <linux/malloc.h>
 
 static int 

kernel-1.3/src/inode.c

@@ -20,7 +20,7 @@
 #include <linux/locks.h>
 #include <linux/fcntl.h>
 #include <linux/malloc.h>
-#include "ncplib.h"
+#include "ncplib_kernel.h"
 
 extern int close_fp(struct file *filp);
 
@@ -142,12 +142,15 @@ ncp_put_inode(struct inode *inode)
                         printk("ncp_put_inode: could not close\n");
                 }
         }
+
+	DDPRINTK("ncp_put_inode: put %s\n",
+		finfo->i.entryName);
         
         ncp_free_inode_info(NCP_INOP(inode));
 
         if (S_ISDIR(inode->i_mode)) {
-                DPRINTK("ncp_put_inode: put directory %ld\n",
-			inode->i_ino);
+                DDPRINTK("ncp_put_inode: put directory %ld\n",
+			 inode->i_ino);
                 ncp_invalid_dir_cache(inode->i_ino);
         }                
 

kernel-1.3/src/ioctl.c

@@ -4,7 +4,6 @@
  *  Copyright (C) 1995 by Volker Lendecke
  *
  */
-/* #include <linux/module.h>*/
 
 #include <asm/segment.h>
 #include <linux/errno.h>

kernel-1.3/src/ncplib_kernel.c

@@ -1,4 +1,4 @@
-#include "ncplib.h"
+#include "ncplib_kernel.h"
 
 typedef __u8  byte;
 typedef __u16 word;

kernel-1.3/src/ncplib_kernel.h

@@ -1,53 +1,20 @@
 #ifndef _NCPLIB_H
 #define _NCPLIB_H
 
-#include <linux/types.h>
+#include <linux/fs.h>
 #include <linux/ncp.h>
 #include <linux/ncp_fs.h>
-#include <linux/ipx.h>
-
-enum connect_state {
-	NOT_CONNECTED = 0,
-	CONN_MOUNTED,
-	CONN_SOCKET
-};
-
-struct ncp_server {
-	int current_size;
-	int has_subfunction;
-	int silent;
-	int ncp_reply_size;
-	char *packet;
-	int lock;
-
-	enum connect_state is_connected;
-	
-	int mount_fid;
-
-	struct sockaddr_ipx addr;
-	int ncp_sock;
-	int wdog_sock;
-	int wdog_pid;
-	__u8 sequence;
-	__u16 connection;
-	int completion;
-	int conn_status;
-	int reply_size;
-
-	char ncp_data[NCP_PACKET_SIZE];
-};
+#include <linux/ncp_fs_sb.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/malloc.h>
+#include <linux/stat.h>
+#include <linux/fcntl.h>
+#include <asm/segment.h>
+#include <asm/string.h>
 
 #include <linux/ncp.h>
 
-int
-ncp_connect_mount(struct ncp_server *server, const char *mount_point);
-
-int
-ncp_connect(struct ncp_server *server);
-
-int
-ncp_disconnect(struct ncp_server *server);
-
 int
 ncp_negotiate_buffersize(struct ncp_server *server, int size,
 			 int *target);
@@ -59,11 +26,6 @@ ncp_get_bindery_object_id(struct ncp_server *server,
 			  int object_type, char *object_name,
 			  struct ncp_bindery_object *target);
 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
 ncp_login_encrypted(struct ncp_server *server,
 		    struct ncp_bindery_object *object,
 		    unsigned char *key,
@@ -167,7 +129,6 @@ int
 ncp_del_file_or_subdir(struct ncp_server *server,
 		       struct nw_info_struct *dir, char *name);
 
-
 int
 ncp_open_create_file_or_subdir(struct ncp_server *server,
 			       struct nw_info_struct *dir, char *name,
@@ -191,14 +152,5 @@ 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
-ncp_create_queue_job_and_file(struct ncp_server *server,
-			      __u32 queue_id,
-			      struct queue_job *job);
-
-int
-ncp_close_file_and_start_job(struct ncp_server *server,
-			     __u32 queue_id,
-			     struct queue_job *job);
 
 #endif /* _NCPLIB_H */

kernel-1.3/src/sock.c

@@ -7,8 +7,6 @@
  *
  */
 
-/* #include <linux/module.h> */
-
 #include <linux/sched.h>
 #include <linux/ncp_fs.h>
 #include <linux/errno.h>
@@ -80,7 +78,7 @@ ncp_wdog_data_ready(struct sock *sk, int len)
 	{
 		unsigned char packet_buf[2];
 		struct sockaddr_ipx sender;
-		int addr_len;
+		int addr_len = sizeof(struct sockaddr_ipx);
 		int result;
 		unsigned short fs;
 
@@ -104,8 +102,8 @@ ncp_wdog_data_ready(struct sock *sk, int len)
 			
 		} else {
 			int result;
-			DPRINTK("ncpfs: got watchdog from:\n");
-			DPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X,"
+			DDPRINTK("ncpfs: got watchdog from:\n");
+			DDPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X,"
 				" conn:%02X,type:%c\n",
 				htonl(sender.sipx_network),
 				sender.sipx_node[0], sender.sipx_node[1],
@@ -117,7 +115,7 @@ ncp_wdog_data_ready(struct sock *sk, int len)
 			packet_buf[1] = 'Y';
 			result = _sendto(sock, (void *)packet_buf, 2, 1, 0,
 					 &sender, sizeof(sender));
-			DPRINTK("send result: %d\n", result);
+			DDPRINTK("send result: %d\n", result);
 		}
 		set_fs(fs);
 	}
@@ -169,6 +167,7 @@ ncp_catch_watchdog(struct ncp_server *server)
 
         server->data_ready = sk->data_ready;
         sk->data_ready = ncp_wdog_data_ready;
+	sk->allocation = GFP_ATOMIC;
         return 0;
 }
                 
@@ -221,6 +220,7 @@ ncp_dont_catch_watchdog(struct ncp_server *server)
                  (unsigned int)(server->data_ready));
 
         sk->data_ready = server->data_ready;
+	sk->allocation = GFP_KERNEL;
         server->data_ready = NULL;
         return 0;
 }
@@ -286,7 +286,7 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
 	fs = get_fs();
 	set_fs(get_ds());
 	for (n = 0, timeout = init_timeout; ; n++, timeout <<= 1) {
-/*		DDPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X\n",
+		DDPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X\n",
 			htonl(server->m.serv_addr.sipx_network),
 			server->m.serv_addr.sipx_node[0],
 			server->m.serv_addr.sipx_node[1],
@@ -294,7 +294,7 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
 			server->m.serv_addr.sipx_node[3],
 			server->m.serv_addr.sipx_node[4],
 			server->m.serv_addr.sipx_node[5],
-			ntohs(server->m.serv_addr.sipx_port));*/
+			ntohs(server->m.serv_addr.sipx_port));
 		DDPRINTK("ncpfs: req.typ: %04X, con: %d, "
 			"seq: %d",
 			request.type,

man/ipx_interface.8

@@ -0,0 +1,61 @@
+.TH IPX_INTERFACE 8 "IPX Utilities" "Caldera, Inc." 
+.SH NAME
+ipx_interface \- add, delete, or display an IPX interface
+.SH SYNOPSIS
+.B ipx_interface
+add [-p] device frame_type [network number]
+.LP
+.B ipx_interface
+del device frame_type
+.LP
+.B ipx_interface
+check device frame_type
+.LP
+.B ipx_interface
+help
+.SH DESCRIPTION
+.B ipx_interface
+adds, deletes, or displays IPX interfaces depending on the option selected.
+.P
+An IPX interface is the item to which IPX sockets are bound.
+An IPX interface corresponds to an IPX Network Number which corresponds 
+to a physical device and frame type.  A sample IPX Interface would be:
+.LP
+Network Number: 0x00ABCDEF
+.LP
+Device: Eth0 
+.LP
+Frame Type: 802.2.
+.P
+There is a special IPX interface per host known as the 
+.B PRIMARY
+or default interface.
+.SS OPTIONS
+.TP
+.I add
+This option is used to create an IPX interface.  If the 
+.B -p
+flag is used, the interface is made 
+.B
+PRIMARY.
+The network number can be optionally assigned.  If it is not assigned, it
+is set to 0 which indicates it should be detected from the traffic on the
+network.
+.TP
+.I del
+This option is used to delete an IPX interface.
+.TP
+.I check
+This option is used to display the device, frame type, and network number
+of an IPX interface.
+.TP
+.I help
+This option displays information about the utility.
+.SH FILES
+.I /proc/net/ipx_interface /proc/net/ipx_route
+.SH BUGS
+This functionality really belongs in
+.B
+ifconfig(8).
+.SH AUTHOR
+Greg Page <greg.page@caldera.com>

man/ipx_internal_net.8

@@ -0,0 +1,32 @@
+.TH IPX_INTERNAL_NET 8 "IPX Utilities" "Caldera, Inc." 
+.SH NAME
+ipx_internal_net \- add or delete the IPX internal network
+.SH SYNOPSIS
+.B ipx_internal_net
+add network_number node_number
+.LP
+.B ipx_internal_net
+del 
+.SH DESCRIPTION
+.B ipx_internal_net
+adds or deletes the IPX internal network.
+An IPX internal network is a special kind of IPX interface that does
+not have a physical device or frame type.  It is used to provide
+a route-independent address for service providers.   Internal networks
+are optional; however, when one is present it is also the
+Primary Interface.  There can only be one internal network per host.
+.SS OPTIONS
+.TP
+.I add
+This option is used to create the IPX internal network. 
+.TP
+.I del
+This option is used to delete the IPX internal network.
+.SH FILES
+.I /proc/net/ipx_interface /proc/net/ipx_route
+.SH BUGS
+This functionality really belongs in
+.B
+ifconfig(8).
+.SH AUTHOR
+Greg Page <greg.page@caldera.com>

man/ipx_route.8

@@ -0,0 +1,24 @@
+.TH IPX_ROUTE 8 "IPX Utilities" "Caldera, Inc." 
+.SH NAME
+ipx_route \- add or delete IPX route
+.SH SYNOPSIS
+.B ipx_route
+add target_network router_network router_node
+.LP
+.B ipx_route
+del target_network
+.SH DESCRIPTION
+.B ipx_route
+adds or deletes an IPX route.
+The kernel IPX stores only one route per target network at a time.
+.SS OPTIONS
+.TP
+.I add
+This option is used to set up the route to a target network.
+.TP
+.I del
+This option is used to delete the route to a target network.
+.SH FILES
+.I /proc/net/ipx_interface /proc/net/ipx_route
+.SH AUTHOR
+Greg Page <greg.page@caldera.com>

man/ncpmount.8

@@ -1,4 +1,4 @@
-.TH NCPMOUNT 8 25/11/1995 ncpmount ncpmount
+.TH NCPMOUNT 8 11/25/1995 ncpmount ncpmount
 .SH NAME
 ncpmount \- mount program for ncpfs
 .SH SYNOPSIS

man/ncpumount.8

@@ -1,4 +1,4 @@
-.TH NCPUMOUNT 8 25/11/1995 ncpumount ncpumount
+.TH NCPUMOUNT 8 11/25/1995 ncpumount ncpumount
 .SH NAME
 ncpumount \- umount for normal users
 .SH SYNOPSIS

man/slist.1

@@ -0,0 +1,44 @@
+.TH SLIST 1 12/02/1995 slist slist
+.SH NAME
+slist \- list all know NetWare file servers
+.SH SYNOPSIS
+.B slist
+[pattern]
+
+.SH DESCRIPTION
+With 
+.B slist
+you can list all NetWare file servers that are known in your IPX network. 
+.B slist
+is modeled after the well-know DOS utility. As an option, you can give
+a wildcard pattern to slist. This can be convienient if you want to
+know whether a specific server is reachable, of if your IPX network
+contains a lot of servers.
+
+The pattern is converted to upper case, because NetWare stores only upper-case name. So you can find out whether you can access FS311 by typing
+
+.RS 3
+slist fs311
+.RE
+
+Please note that the decorative header is 
+.I not
+printed if slist prints to a pipe. So you can count the number of file
+servers simply by typing 
+
+.RS 3
+slist | wc -l
+.RE
+
+.SH BUGS
+You might need superuser privileges to run slist. This sounds paradox,
+but if your IPX routing table is not administered by an IPX routing
+daemon, slist needs to add a route to the internal network of the
+server that's nearest to you. For ncpmount, this is no problem, as it
+has to be suid root anyway. So you could make slist setuid root. This
+should be safe, because slist does not do much. The second option is
+to run an IPX routing daemon, which automatically adjusts your routing
+tables.
+
+.SH AUTHOR
+Volker Lendecke <lendecke@namu01.gwdg.de>

ncpfs-0.9.lsm

@@ -1,14 +1,14 @@
 Begin3
 Title:          ncpfs
-Version:        0.6
-Entered-date:   25. November 1995
+Version:        0.9
+Entered-date:   02. December 1995
 Description:    With ncpfs you can mount volumes of your novell
                 server under Linux.
 Keywords:       filesystem kernel ncp novell netware
 Author:         lendecke@namu01.gwdg.de (Volker Lendecke)
 Maintained-by:  lendecke@namu01.gwdg.de (Volker Lendecke)
 Primary-site:   linux01.gwdg.de:/pub/ncpfs
-                   ~59k ncpfs-0.6.tgz
-                   ~ 1k ncpfs-0.6.lsm
+                   ~81k ncpfs-0.9.tgz
+                   ~ 1k ncpfs-0.9.lsm
 Copying-policy: GPL
 End

util/Makefile

@@ -4,30 +4,24 @@
 
 INCLUDES =  -I/usr/src/linux/include -I../kernel
 BINDIR = ../bin
-UTILS = ncpmount ncpumount ncptest ipx_configure
+UTILS = $(BINDIR)/ncpmount $(BINDIR)/ncpumount $(BINDIR)/slist ncptest
 
-CFLAGS = -Wall $(INCLUDES) -g
+CFLAGS = -Wall $(INCLUDES) -O2
 CC = gcc
 
 all: $(UTILS)
 
-ncpmount: ncpmount.o ncplib_user.o nwcrypt.o
-	$(CC) -o ncpmount ncpmount.o ncplib_user.o nwcrypt.o
-	cp ncpmount $(BINDIR)
+$(BINDIR)/ncpmount: ncpmount.o ncplib.o
+	$(CC) -o $(BINDIR)/ncpmount ncpmount.o ncplib.o
 
-ncpumount: ncpumount.o ncplib_user.o nwcrypt.o
-	$(CC) -o ncpumount ncpumount.o ncplib_user.o nwcrypt.o
-	cp ncpumount $(BINDIR)
+$(BINDIR)/ncpumount: ncpumount.o ncplib.o
+	$(CC) -o $(BINDIR)/ncpumount ncpumount.o ncplib.o
 
-ipx_configure: ipx_configure.c
-	$(CC) $(CFLAGS) ipx_configure.c -o ipx_configure
-	cp ipx_configure $(BINDIR)
+$(BINDIR)/slist: slist.o ncplib.o
+	$(CC) -o $(BINDIR)/slist slist.o ncplib.o
 
-ncptest: ncptest.o ncplib_user.o nwcrypt.o
-	$(CC) -o ncptest ncptest.o ncplib_user.o nwcrypt.o
-
-nwcrypt.o: nwcrypt.c
-	$(CC) -c -O3 -Wall nwcrypt.c
+ncptest: ncptest.o ncplib.o
+	$(CC) -o ncptest ncptest.o ncplib.o
 
 dep:
 	$(CPP) -M $(INCLUDES) *.c > .depend

util/ipxutil.h

@@ -1,72 +0,0 @@
-
-/*
-
-    IPX support library
-
-    Copyright (C) 1994, 1995  Ales Dryak <e-mail: A.Dryak@sh.cvut.cz>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
-#ifndef __IPXUTIL_H__
-
-#define __IPXUTIL_H__
-
-#include <string.h>
-#include <linux/ipx.h>
-
-#define IPX_RIP_PTYPE (0x01)
-#define IPX_SAP_PTYPE (0x04)
-#define IPX_SAP_PORT  (0x0452)
-#define IPX_RIP_PORT  (0x0453)
-
-#define IPX_SAP_GENERAL_QUERY (0x0001)
-#define IPX_SAP_GENERAL_RESPONSE (0x0002)
-#define IPX_SAP_NEAREST_QUERY (0x0003)
-#define IPX_SAP_NEAREST_RESPONSE (0x0004)
-
-#define IPX_SAP_FILE_SERVER (0x0004)
-
-#define IPX_RIP_REQUEST (0x1)
-#define IPX_RIP_RESPONSE (0x2)
-
-struct ipx_rip_packet {
-	__u16 operation         __attribute__ ((packed));
-	struct ipx_rt_def {
-		__u32 network   __attribute__ ((packed));
-		__u16 hops      __attribute__ ((packed));
-		__u16 ticks     __attribute__ ((packed));
-	} rt[1]                 __attribute__ ((packed));
-};
-
-#define IPX_BROADCAST_NODE "\xff\xff\xff\xff\xff\xff"
-#define IPX_THIS_NODE      "\0\0\0\0\0\0"
-
-
-typedef unsigned long  IPXNet;
-typedef unsigned short IPXPort;
-typedef unsigned char  IPXNode[IPX_NODE_LEN];
-
-void ipx_print_node(IPXNode node);
-void ipx_print_network(IPXNet net);
-void ipx_print_port(IPXPort port);
-void ipx_print_saddr(struct sockaddr_ipx* sipx);
-
-static __inline__ void
-ipx_assign_node(IPXNode dest, IPXNode src) {
-	memcpy(dest, src, IPX_NODE_LEN);
-}
-
-#endif

util/ncplib.c

@@ -1,12 +1,12 @@
-#include "ncplib_user.h"
-#include "nwcrypt.h"
+#include "ncplib.h"
 
 typedef __u8  byte;
 typedef __u16 word;
 typedef __u32 dword;
 
 #include <sys/ioctl.h>
-#include <sys/wait.h>
+/* #include <sys/wait.h> */  /* generates a warning here */
+extern pid_t wait(int *);
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
@@ -16,7 +16,93 @@ typedef __u32 dword;
 #include <unistd.h>
 #include <signal.h>
 #include <fcntl.h>
-#include "ipxutil.h"
+#include <linux/route.h>
+
+/* I know it's terrible to include a .c file here, but I want to keep
+   the file nwcrypt.c intact and separate for legal reasons */
+#include "nwcrypt.c"
+
+void
+ipx_fprint_node(FILE* file,IPXNode node)
+{
+	fprintf(file,"%02X%02X%02X%02X%02X%02X",
+		(unsigned char)node[0],
+		(unsigned char)node[1],
+		(unsigned char)node[2],
+		(unsigned char)node[3],
+		(unsigned char)node[4],
+		(unsigned char)node[5]
+		);
+}
+
+void
+ipx_fprint_network(FILE* file,IPXNet net)
+{
+	fprintf(file,"%08lX",ntohl(net));
+}
+
+void
+ipx_fprint_port(FILE* file,IPXPort port)
+{
+	fprintf(file,"%04X",ntohs(port));
+}
+
+void
+ipx_fprint_saddr(FILE* file,struct sockaddr_ipx* sipx)
+{
+	ipx_fprint_network(file,sipx->sipx_network);
+	fprintf(file,":");
+	ipx_fprint_node(file,sipx->sipx_node);
+	fprintf(file,":");
+	ipx_fprint_port(file,sipx->sipx_port);
+}
+
+void
+ipx_print_node(IPXNode node)
+{
+	ipx_fprint_node(stdout,node);
+}
+
+void
+ipx_print_network(IPXNet net)
+{
+	ipx_fprint_network(stdout,net);
+}
+
+void
+ipx_print_port(IPXPort port)
+{
+	ipx_fprint_port(stdout,port);
+}
+
+void
+ipx_print_saddr(struct sockaddr_ipx* sipx)
+{
+	ipx_fprint_saddr(stdout,sipx);
+}
+
+int
+ipx_sscanf_node(char *buf, unsigned char node[6])
+{
+	int i;
+	int n[6];
+
+	if ((i = sscanf(buf, "%2x%2x%2x%2x%2x%2x",
+			&(n[0]), &(n[1]), &(n[2]),
+			&(n[3]), &(n[4]), &(n[5]))) != 6) {
+								  return i;
+							  }
+
+	for (i=0; i<6; i++) {
+				    node[i] = n[i];
+			    }
+	return 6;
+}
+
+void
+ipx_assign_node(IPXNode dest, IPXNode src) {
+	memcpy(dest, src, IPX_NODE_LEN);
+}
 
 #define ncp_printf printf
 
@@ -78,17 +164,57 @@ ncp_ioctl_request(struct ncp_server *server, int function) {
 	return result;	
 }
 
+static int
+ipx_recvfrom(int sock, void *buf, int len, unsigned int flags,
+	     struct sockaddr_ipx *sender, int *addrlen, int timeout)
+{
+	fd_set rd, wr, ex;
+	struct timeval tv;
+	int result;
+
+	FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&ex);
+	FD_SET(sock, &rd);
+
+	tv.tv_sec  = timeout;
+	tv.tv_usec = 0;
+		
+	if ((result = select(sock+1, &rd, &wr, &ex, &tv)) == -1) {
+		return result;
+	}
+
+	if (FD_ISSET(sock, &rd)) {
+		result = recvfrom(sock, buf, len, flags,
+				  (struct sockaddr *)sender, addrlen);
+	}
+	else
+	{
+		result = -1;
+		errno = ETIMEDOUT;
+	}
+	return result;
+}
+
+static int
+ipx_recv(int sock, void *buf, int len, unsigned int flags, int timeout)
+{
+	struct sockaddr_ipx sender;
+	int addrlen = sizeof(sender);
+
+	return ipx_recvfrom(sock, buf, len, flags, &sender, &addrlen, timeout);
+}
+
+
 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;
+	int len;
+	struct ncp_reply_header *r =
+		(struct ncp_reply_header *)&(server->ncp_data);
 
 	while (retries > 0) {
 		retries -= 1;
@@ -103,37 +229,21 @@ do_ncp_call(struct ncp_server *server, int request_size)
 		}
 
 	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);
+		len = ipx_recv(server->ncp_sock,
+			       server->ncp_data, NCP_PACKET_SIZE, 0, 1);
 
-			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;
-			}
+		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;
@@ -175,7 +285,7 @@ ncp_user_request(struct ncp_server *server, int function)
 
 	result = r->completion_code;
 
-	if (result != 0) {
+	if ((result != 0) && (server->silent == 0)) {
 		ncp_printf("ncp_completion_code: %d\n", result);
 	}
 	return result;	
@@ -188,8 +298,6 @@ install_wdog(struct ncp_server *server)
 	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);
@@ -208,17 +316,10 @@ install_wdog(struct ncp_server *server)
 
 	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;
-		}
+		pktsize = ipx_recvfrom(sock, buf, sizeof(buf), 0,
+				       &sender, &sizeofaddr, 120);
 
 		if (getppid() != parent_pid) {
 			/* our parent has died, so nothing to do
@@ -226,31 +327,121 @@ install_wdog(struct ncp_server *server)
 			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");
-			}
+		if (   (pktsize != 2)
+		    || (buf[1] != '?')) {
+			continue;
 		}
+
+		buf[1] = 'Y';
+		pktsize = sendto(sock, buf, 2, 0,
+				 (struct sockaddr *)&sender,
+				 sizeof(sender));
 	}
 }
 
+static int
+ipx_make_reachable(IPXNet network)
+{
+	struct rtentry rt_def;
+	/* Router */
+	struct sockaddr_ipx *sr = (struct sockaddr_ipx *)&rt_def.rt_gateway;
+	/* Target */
+	struct sockaddr_ipx *st = (struct sockaddr_ipx *)&rt_def.rt_dst;
+
+	struct ipx_rip_packet rip;
+	struct sockaddr_ipx addr;
+	int addrlen;
+	int sock;
+	int opt;
+	int res=-1;
+	int i;
+	int packets;
+
+	if (geteuid() != 0) {
+		errno = EPERM;
+		return -1;
+	}
+
+	memset(&rip, 0, sizeof(rip));
+
+	sock = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
+
+	if (sock == -1) {
+		return -1;
+	}
+
+	opt=1;
+	/* Permit broadcast output */
+	if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &opt,sizeof(opt)) != 0){
+		goto finished;
+	}
+	
+	memset(&addr, 0, sizeof(addr));
+	addr.sipx_family=AF_IPX;
+	addr.sipx_network=htonl(0x0);
+	addr.sipx_port=htons(0x0);
+	addr.sipx_type=IPX_RIP_PTYPE;
+	
+	if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) != 0) {
+		goto finished;
+	}
+	
+	addr.sipx_family = AF_IPX;
+	addr.sipx_network = htonl(0x0);
+	addr.sipx_port = htons(IPX_RIP_PORT);
+	addr.sipx_type = IPX_RIP_PTYPE;
+	ipx_assign_node(addr.sipx_node, IPX_BROADCAST_NODE);
+
+	rip.operation = htons(IPX_RIP_REQUEST);
+	rip.rt[0].network = htonl(network);
+
+	if (sendto(sock, &rip, sizeof(rip), 0,
+		   (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+		goto finished;
+	}
+
+	packets = 3;
+	do
+	{
+		int len;
+
+		if (packets == 0) {
+			goto finished;
+		}
+
+		addrlen = sizeof(struct sockaddr_ipx);
+
+		len = ipx_recvfrom(sock, &rip, sizeof(rip),0, sr, &addrlen, 1);
+		if (len < sizeof(rip)) {
+			packets = packets - 1;
+			continue;
+		}
+	} while (ntohs(rip.operation) != IPX_RIP_RESPONSE);
+
+	if (rip.rt[0].network != htonl(network)) {
+		goto finished;
+	}
+
+	rt_def.rt_flags = RTF_GATEWAY;
+	st->sipx_network = htonl(network);
+	sr->sipx_family = st->sipx_family = AF_IPX;
+	i = 0;
+	do {
+		res = ioctl(sock, SIOCADDRT, &rt_def);
+		i++;
+	}	while ((i < 5) && (res < 0) && (errno == EAGAIN));
+	
+ finished:
+	close(sock);
+
+	if (res != 0) {
+		errno = ENETUNREACH;
+	}
+	return res;
+}
+	
 int
-ncp_connect(struct ncp_server *server)
+ncp_connect_addr(struct ncp_server *server, const struct sockaddr_ipx *target)
 {
 	struct ncp_request_header *h =
 		(struct ncp_request_header *)&(server->ncp_data);
@@ -262,6 +453,7 @@ ncp_connect(struct ncp_server *server)
 	int ncp_port, wdog_port;
 
 	server->is_connected = NOT_CONNECTED;
+	server->silent = 1;
 	
 	ncp_sock  = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
 	if (ncp_sock == -1) {
@@ -322,6 +514,7 @@ ncp_connect(struct ncp_server *server)
 	h->type = NCP_ALLOC_SLOT_REQUEST;
 
 	server->sequence = 0;
+	server->addr = *target;
 	h->sequence = server->sequence;
 	h->conn_low  = 0xff;
 	h->conn_high = 0xff;
@@ -329,10 +522,17 @@ ncp_connect(struct ncp_server *server)
 	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;
+
+		if (   (errno != ENETUNREACH)
+		    || (ipx_make_reachable(htonl(target->sipx_network)) != 0)
+		    || (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);
@@ -345,6 +545,107 @@ ncp_connect(struct ncp_server *server)
 	return 0;
 }
 
+static int
+ipx_sap_find_nearest(int server_type, struct sockaddr_ipx *result)
+{
+	struct sockaddr_ipx addr;
+	char data[1024];
+	int sock;
+	int opt;
+	int res = -1;
+	int saved_errno;
+	int packets;
+	int len;
+
+	struct sap_server_ident *ident;
+
+	sock=socket(AF_IPX,SOCK_DGRAM,PF_IPX);
+	if (sock==-1) {
+		return -1;
+	}
+	
+	opt=1;
+	/* Permit broadcast output */
+	if(setsockopt(sock,SOL_SOCKET,SO_BROADCAST, &opt,sizeof(opt))==-1)
+	{
+		goto finished;
+	}
+	
+	memset(&addr, 0, sizeof(addr));
+	addr.sipx_family=AF_IPX;
+	addr.sipx_network=htonl(0x0);
+	addr.sipx_port=htons(0x0);
+	addr.sipx_type=IPX_SAP_PTYPE;
+	
+	if(bind(sock,(struct sockaddr*)&addr,sizeof(addr))==-1)
+	{
+		goto finished;
+	}
+	
+	*(unsigned short *)data = htons(IPX_SAP_NEAREST_QUERY);
+	*(unsigned short *)&(data[2]) = htons(server_type);
+	
+	memset(&addr, 0, sizeof(addr));
+	addr.sipx_family=AF_IPX;
+	addr.sipx_network=htonl(0x0);
+	ipx_assign_node(addr.sipx_node, IPX_BROADCAST_NODE);
+	addr.sipx_port=htons(IPX_SAP_PORT);
+	addr.sipx_type=IPX_SAP_PTYPE;
+	
+	if (sendto(sock, data, 4, 0,
+		   (struct sockaddr *)&addr, sizeof(addr)) < 0)
+	{
+		goto finished;
+	}
+
+	packets = 5;
+	do
+	{
+		len = ipx_recv(sock, data, 1024, 0, 1);
+		if (len < 66) {
+			packets = packets - 1;
+			continue;
+		}
+	} while (ntohs(*((__u16 *)data)) != IPX_SAP_NEAREST_RESPONSE);
+
+	ident = (struct sap_server_ident *)(data+2);
+
+	result->sipx_family = AF_IPX;
+	result->sipx_network = ident->server_network;
+	result->sipx_port  = ident->server_port;
+	ipx_assign_node(result->sipx_node, ident->server_node);
+	
+	res = 0;
+	
+ finished:
+	saved_errno = errno;
+	close(sock);
+	errno = saved_errno;
+	return res;
+}
+
+
+static int
+ncp_connect_any(struct ncp_server *server)
+{
+	struct sockaddr_ipx addr;
+
+	if (ipx_sap_find_nearest(IPX_SAP_FILE_SERVER, &addr) != 0) {
+		return -1;
+	}
+
+	return ncp_connect_addr(server, &addr);
+}
+
+int
+ncp_connect(struct ncp_server *server, const char *name)
+{
+	if (name == NULL) {
+		return ncp_connect_any(server);
+	}
+	return -1;
+}
+
 static int
 ncp_user_disconnect(struct ncp_server *server)
 {
@@ -609,6 +910,35 @@ ncp_get_bindery_object_id(struct ncp_server *server,
 	return 0;
 }
 
+int
+ncp_scan_bindery_object(struct ncp_server *server,
+			__u32 last_id, __u16 object_type, char *search_string,
+			struct ncp_bindery_object *target)
+{
+	int result;
+	ncp_init_request_s(server, 55);
+	ncp_add_dword(server, htonl(last_id));
+	ncp_add_word(server, htons(object_type));
+	ncp_add_pstring(server, search_string);
+
+	if ((result = ncp_request(server, 23)) != 0) {
+		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),
+	       NCP_BINDERY_NAME_LEN);
+	target->object_flags = ncp_reply_byte(server, 54);
+	target->object_security = ncp_reply_byte(server, 55);
+	target->object_has_prop = ncp_reply_byte(server, 56);
+
+	ncp_unlock_server(server);
+	return 0;
+}
+	
+
 int
 ncp_read_property_value(struct ncp_server *server,
 			int object_type, char *object_name,

util/ncplib.h

@@ -0,0 +1,273 @@
+#ifndef _NCPLIB_H
+#define _NCPLIB_H
+
+#include <linux/types.h>
+#include <linux/ncp.h>
+#include <linux/ncp_fs.h>
+#include <linux/ipx.h>
+
+typedef unsigned long  IPXNet;
+typedef unsigned short IPXPort;
+typedef unsigned char  IPXNode[IPX_NODE_LEN];
+
+#define IPX_RIP_PTYPE (0x01)
+#define IPX_SAP_PTYPE (0x04)
+#define IPX_SAP_PORT  (0x0452)
+#define IPX_RIP_PORT  (0x0453)
+
+#define IPX_SAP_GENERAL_QUERY (0x0001)
+#define IPX_SAP_GENERAL_RESPONSE (0x0002)
+#define IPX_SAP_NEAREST_QUERY (0x0003)
+#define IPX_SAP_NEAREST_RESPONSE (0x0004)
+
+#define IPX_SAP_FILE_SERVER (0x0004)
+
+struct sap_query {
+	unsigned short query_type; /* net order */
+	unsigned short server_type; /* net order */
+};
+
+struct sap_server_ident {
+	unsigned short server_type          __attribute__ ((packed));
+	char           server_name[48]      __attribute__ ((packed));
+	IPXNet         server_network       __attribute__ ((packed));
+	IPXNode        server_node          __attribute__ ((packed));
+	IPXPort        server_port          __attribute__ ((packed));
+	unsigned short intermediate_network __attribute__ ((packed));
+};
+       
+#define IPX_RIP_REQUEST (0x1)
+#define IPX_RIP_RESPONSE (0x2)
+
+struct ipx_rip_packet {
+	__u16 operation         __attribute__ ((packed));
+	struct ipx_rt_def {
+		__u32 network   __attribute__ ((packed));
+		__u16 hops      __attribute__ ((packed));
+		__u16 ticks     __attribute__ ((packed));
+	} rt[1]                 __attribute__ ((packed));
+};
+
+#define IPX_BROADCAST_NODE "\xff\xff\xff\xff\xff\xff"
+#define IPX_THIS_NODE      "\0\0\0\0\0\0"
+
+#ifndef IPX_NODE_LEN
+#define IPX_NODE_LEN (6)
+#endif
+
+void
+ipx_print_node(IPXNode node);
+void
+ipx_print_network(IPXNet net);
+void
+ipx_print_port(IPXPort port);
+void
+ipx_print_saddr(struct sockaddr_ipx* sipx);
+int
+ipx_sscanf_node(char *buf, unsigned char node[IPX_NODE_LEN]);
+void
+ipx_assign_node(IPXNode dest, IPXNode src);
+
+enum connect_state {
+	NOT_CONNECTED = 0,
+	CONN_MOUNTED,
+	CONN_SOCKET
+};
+
+struct ncp_server {
+	int current_size;
+	int has_subfunction;
+	int silent;
+	int ncp_reply_size;
+	char *packet;
+	int lock;
+
+	enum connect_state is_connected;
+	
+	int mount_fid;
+
+	struct sockaddr_ipx addr;
+	int ncp_sock;
+	int wdog_sock;
+	int wdog_pid;
+	__u8 sequence;
+	__u16 connection;
+	int completion;
+	int conn_status;
+	int reply_size;
+
+	char ncp_data[NCP_PACKET_SIZE];
+};
+
+#include <linux/ncp.h>
+
+int
+ncp_connect_mount(struct ncp_server *server, const char *mount_point);
+
+int
+ncp_connect_addr(struct ncp_server *server, const struct sockaddr_ipx *target);
+
+int
+ncp_connect(struct ncp_server *server, const char *server_name);
+
+int
+ncp_disconnect(struct ncp_server *server);
+
+int
+ncp_negotiate_buffersize(struct ncp_server *server, int size,
+			 int *target);
+int
+ncp_get_encryption_key(struct ncp_server *server,
+		       char *target);
+int
+ncp_get_bindery_object_id(struct ncp_server *server,
+			  int object_type, char *object_name,
+			  struct ncp_bindery_object *target);
+int
+ncp_scan_bindery_object(struct ncp_server *server,
+			__u32 last_id, __u16 object_type, char *search_string,
+			struct ncp_bindery_object *target);
+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
+ncp_login_encrypted(struct ncp_server *server,
+		    struct ncp_bindery_object *object,
+		    unsigned char *key,
+		    unsigned char *passwd);
+int
+ncp_login_user(struct ncp_server *server,
+	       unsigned char *username,
+	       unsigned char *password);
+int
+ncp_get_volume_info_with_number(struct ncp_server *server, int n,
+				struct ncp_volume_info *target);
+
+int
+ncp_get_volume_number(struct ncp_server *server, const char *name,
+		      int *target);
+
+int
+ncp_file_search_init(struct ncp_server *server,
+		     int dir_handle, const char *path,
+		     struct ncp_filesearch_info *target);
+
+int
+ncp_file_search_continue(struct ncp_server *server,
+			 struct ncp_filesearch_info *fsinfo,
+			 int attributes, const char *path,
+			 struct ncp_file_info *target);
+
+int
+ncp_get_finfo(struct ncp_server *server,
+	      int dir_handle, const char *path, const char *name,
+	      struct ncp_file_info *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
+ncp_close_file(struct ncp_server *server, const char *file_id);
+
+int
+ncp_create_newfile(struct ncp_server *server,
+		   int dir_handle, const char *path,
+		   int attr,
+		   struct ncp_file_info *target);
+
+int
+ncp_create_file(struct ncp_server *server,
+		int dir_handle, const char *path,
+		int attr,
+		struct ncp_file_info *target);
+
+int
+ncp_erase_file(struct ncp_server *server,
+	       int dir_handle, const char *path,
+	       int attr);
+
+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
+ncp_create_directory(struct ncp_server *server,
+		     int dir_handle, const char *path,
+		     int inherit_mask);
+
+int
+ncp_delete_directory(struct ncp_server *server,
+		     int dir_handle, const char *path);
+
+int
+ncp_rename_directory(struct ncp_server *server,
+		     int dir_handle,
+		     const char *old_path, const char *new_path);
+
+int
+ncp_read(struct ncp_server *server, const char *file_id,
+	 __u32 offset, __u16 to_read,
+	 char *target, int *bytes_read);
+
+int
+ncp_write(struct ncp_server *server, const char *file_id,
+	  __u32 offset, __u16 to_write,
+	  const char *source, int *bytes_written);
+
+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);
+
+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
+ncp_del_file_or_subdir(struct ncp_server *server,
+		       struct nw_info_struct *dir, char *name);
+
+
+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
+ncp_initialize_search(struct ncp_server *server,
+		      struct nw_info_struct *dir,
+		      struct nw_search_sequence *target);
+
+int
+ncp_search_for_file_or_subdir(struct ncp_server *server,
+			      struct nw_search_sequence *seq,
+			      struct nw_info_struct *target);
+
+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
+ncp_create_queue_job_and_file(struct ncp_server *server,
+			      __u32 queue_id,
+			      struct queue_job *job);
+
+int
+ncp_close_file_and_start_job(struct ncp_server *server,
+			     __u32 queue_id,
+			     struct queue_job *job);
+
+#endif /* _NCPLIB_H */

util/ncpmount.c

@@ -28,15 +28,13 @@ extern pid_t waitpid(pid_t, int *, int);
 #include <sys/mount.h>
 #include <mntent.h>
 #include <linux/ipx.h>
-#include <linux/route.h>
 #include <sys/ioctl.h>
 
 #include <linux/fs.h>
 #include <linux/ncp.h>
 #include <linux/ncp_fs.h>
 #include <linux/ncp_mount.h>
-#include "ipxutil.h"
-#include "ncplib_user.h"
+#include "ncplib.h"
 
 static char *progname;
 
@@ -77,105 +75,34 @@ help(void)
                "\n");
 }
 
-struct sap_query {
-	unsigned short query_type; /* net order */
-	unsigned short server_type; /* net order */
-};
-
-struct sap_server_ident {
-	unsigned short server_type          __attribute__ ((packed));
-	char           server_name[48]      __attribute__ ((packed));
-	IPXNet         server_network       __attribute__ ((packed));
-	IPXNode        server_node          __attribute__ ((packed));
-	IPXPort        server_port          __attribute__ ((packed));
-	unsigned short intermediate_network __attribute__ ((packed));
-};
-       
-void
-ipx_fprint_node(FILE* file,IPXNode node)
+int
+ipx_sap_find_server(char *name, int server_type, int timeout,
+		    struct sockaddr_ipx *result)
 {
-	fprintf(file,"%02X%02X%02X%02X%02X%02X",
-		(unsigned char)node[0],
-		(unsigned char)node[1],
-		(unsigned char)node[2],
-		(unsigned char)node[3],
-		(unsigned char)node[4],
-		(unsigned char)node[5]
-		);
-}
-
-void
-ipx_fprint_network(FILE* file,IPXNet net)
-{
-	fprintf(file,"%08lX",ntohl(net));
-}
-
-void
-ipx_fprint_port(FILE* file,IPXPort port)
-{
-	fprintf(file,"%04X",ntohs(port));
-}
-
-void
-ipx_fprint_saddr(FILE* file,struct sockaddr_ipx* sipx)
-{
-	ipx_fprint_network(file,sipx->sipx_network);
-	fprintf(file,":");
-	ipx_fprint_node(file,sipx->sipx_node);
-	fprintf(file,":");
-	ipx_fprint_port(file,sipx->sipx_port);
-}
-
-void
-ipx_print_node(IPXNode node)
-{
-	ipx_fprint_node(stdout,node);
-}
-
-void
-ipx_print_network(IPXNet net)
-{
-	ipx_fprint_network(stdout,net);
-}
-
-void
-ipx_print_port(IPXPort port)
-{
-	ipx_fprint_port(stdout,port);
-}
-
-void
-ipx_print_saddr(struct sockaddr_ipx* sipx)
-{
-	ipx_fprint_saddr(stdout,sipx);
-}
-
-static int
-ipx_make_reachable(__u32 network)
-{
-	struct rtentry rt_def;
-	/* Router */
-	struct sockaddr_ipx *sr = (struct sockaddr_ipx *)&rt_def.rt_gateway;
-	/* Target */
-	struct sockaddr_ipx *st = (struct sockaddr_ipx *)&rt_def.rt_dst;
-
-	fd_set rd, wr, ex;
-	struct timeval tv;
-
-	struct ipx_rip_packet rip;
 	struct sockaddr_ipx addr;
-	int addrlen;
+	char data[1024];
 	int sock;
 	int opt;
-	int res=-1;
-	int i;
+	int res = -1;
+	int name_len = strlen(name);
+	fd_set rd, wr, ex;
+	struct timeval tv;
+	struct sap_server_ident *ident;
 
-	sock = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
+	struct ncp_server server;
+	struct nw_property prop;
+	struct prop_net_address *n_addr = (struct prop_net_address *)&prop;
 
-	if (sock == -1) {
+
+	if (name_len > 48) {
 		return -1;
 	}
 
+	sock=socket(AF_IPX,SOCK_DGRAM,PF_IPX);
+	if (sock==-1) {
+		return -1;
+	}
+	
 	opt=1;
 	/* Permit broadcast output */
 	if(setsockopt(sock,SOL_SOCKET,SO_BROADCAST, &opt,sizeof(opt))==-1)
@@ -188,7 +115,7 @@ ipx_make_reachable(__u32 network)
 	addr.sipx_family=AF_IPX;
 	addr.sipx_network=htonl(0x0);
 	addr.sipx_port=htons(0x0);
-	addr.sipx_type=IPX_RIP_PTYPE;
+	addr.sipx_type=IPX_SAP_PTYPE;
 	
 	if(bind(sock,(struct sockaddr*)&addr,sizeof(addr))==-1)
 	{
@@ -196,153 +123,18 @@ ipx_make_reachable(__u32 network)
 		goto finished;
 	}
 	
-	addr.sipx_family = AF_IPX;
-	addr.sipx_network = htonl(0x0);
-	addr.sipx_port = htons(IPX_RIP_PORT);
-	addr.sipx_type = IPX_RIP_PTYPE;
-	ipx_assign_node(addr.sipx_node, IPX_BROADCAST_NODE);
-
-	rip.operation = htons(IPX_RIP_REQUEST);
-	rip.rt[0].network = htonl(network);
-
-	if (sendto(sock, &rip, sizeof(rip), 0,
-		   (struct sockaddr *)&addr, sizeof(addr)) < 0) {
-		perror("sendto");
-		goto finished;
-	}
-
-	do
-	{
-
-		FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&ex);
-		FD_SET(sock, &rd);
-
-		tv.tv_sec = 3;
-		tv.tv_usec = 0;
-
-		if (select(sock+1, &rd, &wr, &ex, &tv) == -1)
-		{
-			goto finished;
-		}
-
-		if (FD_ISSET(sock, &rd))
-		{
-			int len;
-
-			addrlen = sizeof(struct sockaddr_ipx);
-
-			len = recvfrom(sock, &rip, sizeof(rip), 0,
-				       (struct sockaddr *)sr, &addrlen);
-
-			if (len < sizeof(rip))
-			{
-				continue;
-			}
-		}
-		else
-		{
-			goto finished;
-		}
-	} while (ntohs(rip.operation) != IPX_RIP_RESPONSE);
-
-	if (rip.rt[0].network != htonl(network)) {
-		goto finished;
-	}
-
-	rt_def.rt_flags = RTF_GATEWAY;
-	st->sipx_network = htonl(network);
-	sr->sipx_family = st->sipx_family = AF_IPX;
-	i = 0;
-	do {
-		res = ioctl(sock, SIOCADDRT, &rt_def);
-		i++;
-	}	while ((i < 5) && (res < 0) && (errno == EAGAIN));
-	
-	if (res != 0) {
-
-		switch (errno) {
-		case ENETUNREACH:
-			fprintf(stderr,
-				"%s: Router network (%08lX) not reachable.\n",
-				progname, htonl(sr->sipx_network));
-			break;
-		default:
-			perror("ioctl");
-			break;
-		}
-		goto finished;
-	}
-
- finished:
-	close(sock);
-	return res;
-}
-	
-int
-ipx_sap_find_server(char *name, int server_type, int timeout,
-		    struct sockaddr_ipx *result)
-{
-	struct sockaddr_ipx ipxs;
-	char data[1024];
-	int sock;
-	int opt;
-	int res = -1;
-	int name_len = strlen(name);
-	fd_set rd, wr, ex;
-	struct timeval tv;
-	struct sap_server_ident *ident;
-
-	struct ncp_server server;
-	struct nw_property prop;
-	struct net_address
-	{
-		__u32 network     __attribute__ ((packed));
-		__u8  node[6]     __attribute__ ((packed));
-		__u16 port        __attribute__ ((packed));
-	} *n_addr = (struct net_address *)&prop;
-
-
-	if (name_len > 48) {
-				   return -1;
-			   }
-
-	sock=socket(AF_IPX,SOCK_DGRAM,PF_IPX);
-	if (sock==-1) {
-			      return -1;
-		      }
-	
-	opt=1;
-	/* Permit broadcast output */
-	if(setsockopt(sock,SOL_SOCKET,SO_BROADCAST, &opt,sizeof(opt))==-1)
-	{
-		perror("setsockopt");
-		goto finished;
-	}
-	
-	memset(&ipxs, 0, sizeof(ipxs));
-	ipxs.sipx_family=AF_IPX;
-	ipxs.sipx_network=htonl(0x0);
-	ipxs.sipx_port=htons(0x0);
-	ipxs.sipx_type=IPX_SAP_PTYPE;
-	
-	if(bind(sock,(struct sockaddr*)&ipxs,sizeof(ipxs))==-1)
-	{
-		perror("bind");
-		goto finished;
-	}
-	
 	*(unsigned short *)data = htons(IPX_SAP_NEAREST_QUERY);
 	*(unsigned short *)&(data[2]) = htons(server_type);
 	
-	memset(&ipxs, 0, sizeof(ipxs));
-	ipxs.sipx_family=AF_IPX;
-	ipxs.sipx_network=htonl(0x0);
-	ipx_assign_node(ipxs.sipx_node, IPX_BROADCAST_NODE);
-	ipxs.sipx_port=htons(IPX_SAP_PORT);
-	ipxs.sipx_type=IPX_SAP_PTYPE;
+	memset(&addr, 0, sizeof(addr));
+	addr.sipx_family=AF_IPX;
+	addr.sipx_network=htonl(0x0);
+	ipx_assign_node(addr.sipx_node, IPX_BROADCAST_NODE);
+	addr.sipx_port=htons(IPX_SAP_PORT);
+	addr.sipx_type=IPX_SAP_PTYPE;
 	
 	if (sendto(sock, data, 4, 0,
-		   (struct sockaddr *)&ipxs, sizeof(ipxs)) < 0)
+		   (struct sockaddr *)&addr, sizeof(addr)) < 0)
 	{
 		perror("sendto");
 		goto finished;
@@ -385,18 +177,13 @@ ipx_sap_find_server(char *name, int server_type, int timeout,
            route to the server's internal network. Because this one
            request is not very expensive, we always do it. */
 
-	server.addr.sipx_family = AF_IPX;
-	server.addr.sipx_network = ident->server_network;
-	server.addr.sipx_port  = ident->server_port;
-	ipx_assign_node(server.addr.sipx_node, ident->server_node);
+	addr.sipx_family = AF_IPX;
+	addr.sipx_network = ident->server_network;
+	addr.sipx_port  = ident->server_port;
+	ipx_assign_node(addr.sipx_node, ident->server_node);
 	
-	if (ncp_connect(&server) != 0)
-	{
-		if (   (errno != ENETUNREACH)
-		    || (ipx_make_reachable(ntohl(server.addr.sipx_network))!=0)
-		    || (ncp_connect(&server) != 0)) {
-			goto finished;
-		}
+	if (ncp_connect_addr(&server, &addr) != 0) {
+		goto finished;
 	}
 	
 	if (ncp_read_property_value(&server, NCP_BINDERY_FSERVER,
@@ -407,41 +194,31 @@ ipx_sap_find_server(char *name, int server_type, int timeout,
 		goto finished;
 	}
 	
-	if (ncp_disconnect(&server) != 0)
-	{
+	if (ncp_disconnect(&server) != 0) {
 		goto finished;
 	}
-	
+
 	result->sipx_family = AF_IPX;
 	result->sipx_network = n_addr->network;
 	result->sipx_port = n_addr->port;
 	ipx_assign_node(result->sipx_node, n_addr->node);
 	
+	/* Now we connect to the ultimate target, again with a test
+	   for reachability. This time nothing is done except connecting. */
+
+	if (   (ncp_connect_addr(&server, result) != 0)
+	    || (ncp_disconnect(&server) != 0)) {
+		goto finished;
+	}
+
 	res = 0;
 
+	
  finished:
 	close(sock);
 	return res;
 }
 
-int
-ipx_sscanf_node(char *buf, unsigned char node[6])
-{
-	int i;
-	int n[6];
-
-	if ((i = sscanf(buf, "%2x%2x%2x%2x%2x%2x",
-			&(n[0]), &(n[1]), &(n[2]),
-			&(n[3]), &(n[4]), &(n[5]))) != 6) {
-								  return i;
-							  }
-
-	for (i=0; i<6; i++) {
-				    node[i] = n[i];
-			    }
-	return 6;
-}
-
 static int
 parse_args(int argc, char *argv[], struct ncp_mount_data *data,
            int *got_password, int *upcase_password)
@@ -644,7 +421,8 @@ main(int argc, char *argv[])
                 exit(1);
         }
 
-	memset(&data, 0, sizeof(struct ncp_mount_data));
+	memset(&data, 0, sizeof(data));
+	memset(&serv, 0, sizeof(serv));
 
 	memset(hostname, '\0', MAXHOSTNAMELEN+1);
 	gethostname(hostname, MAXHOSTNAMELEN);
@@ -812,9 +590,6 @@ main(int argc, char *argv[])
 
 	if (ncp_login_user(server, data.username, data.password) != 0) {
 		fprintf(stderr, "login failed\n");
-		fprintf(stderr,
-			"should try to type the username and\n"
-			"password in UPPERCASE.\n");
 		close(server->mount_fid);
 		umount(mount_point);
 		return -1;

util/ncptest.c

@@ -35,8 +35,7 @@ extern pid_t waitpid(pid_t, int *, int);
 #include <linux/ncp.h>
 #include <linux/ncp_fs.h>
 #include <linux/ncp_mount.h>
-#include "ncplib_user.h"
-#include "ipxutil.h"
+#include "ncplib.h"
 
 static char *progname;
 
@@ -49,79 +48,6 @@ str_upper(char *name)
 	}
 }
 
-struct sap_query {
-	unsigned short query_type; /* net order */
-	unsigned short server_type; /* net order */
-};
-
-struct sap_server_ident {
-	unsigned short server_type          __attribute__ ((packed));
-	char           server_name[48]      __attribute__ ((packed));
-	IPXNet         server_network       __attribute__ ((packed));
-	IPXNode        server_node          __attribute__ ((packed));
-	IPXPort        server_port          __attribute__ ((packed));
-	unsigned short intermediate_network __attribute__ ((packed));
-};
-       
-void
-ipx_fprint_node(FILE* file,IPXNode node)
-{
-	fprintf(file,"%02X%02X%02X%02X%02X%02X",
-		(unsigned char)node[0],
-		(unsigned char)node[1],
-		(unsigned char)node[2],
-		(unsigned char)node[3],
-		(unsigned char)node[4],
-		(unsigned char)node[5]
-		);
-}
-
-void
-ipx_fprint_network(FILE* file,IPXNet net)
-{
-	fprintf(file,"%08lX",ntohl(net));
-}
-
-void
-ipx_fprint_port(FILE* file,IPXPort port)
-{
-	fprintf(file,"%04X",ntohs(port));
-}
-
-void
-ipx_fprint_saddr(FILE* file,struct sockaddr_ipx* sipx)
-{
-	ipx_fprint_network(file,sipx->sipx_network);
-	fprintf(file,":");
-	ipx_fprint_node(file,sipx->sipx_node);
-	fprintf(file,":");
-	ipx_fprint_port(file,sipx->sipx_port);
-}
-
-void
-ipx_print_node(IPXNode node)
-{
-	ipx_fprint_node(stdout,node);
-}
-
-void
-ipx_print_network(IPXNet net)
-{
-	ipx_fprint_network(stdout,net);
-}
-
-void
-ipx_print_port(IPXPort port)
-{
-	ipx_fprint_port(stdout,port);
-}
-
-void
-ipx_print_saddr(struct sockaddr_ipx* sipx)
-{
-	ipx_fprint_saddr(stdout,sipx);
-}
-
 int
 ipx_sap_find_server(char *_name, int server_type, int timeout,
 		    struct sockaddr_ipx *result)
@@ -237,25 +163,6 @@ ipx_sap_find_server(char *_name, int server_type, int timeout,
 	return res;
 }
 
-int
-ipx_sscanf_node(char *buf, unsigned char node[6])
-{
-	int i;
-	int n[6];
-
-	if ((i = sscanf(buf, "%2x%2x%2x%2x%2x%2x",
-			&(n[0]), &(n[1]), &(n[2]),
-			&(n[3]), &(n[4]), &(n[5]))) != 6) {
-								  return i;
-							  }
-
-	for (i=0; i<6; i++) {
-				    node[i] = n[i];
-			    }
-	return 6;
-}
-
-
 void
 test_filesearch(struct ncp_server *server)
 {
@@ -560,21 +467,21 @@ test_print(struct ncp_server *server)
 
 	j.j.TargetServerID = 0xffffffff; /* any server */
 	memset(&(j.j.TargetExecTime), 0xff, sizeof(j.j.TargetExecTime)); /* at once */
-	j.j.JobType = 0xffff;
+	j.j.JobType = htons(0);
 	strcpy(j.j.JobTextDescription, "Test Job");
 
 	memset(&pj, 0, sizeof(pj));
 
 	pj.Version = 0;
-	pj.TabSize = 0;
-	pj.Copies = 1;
+	pj.TabSize = 8;
+	pj.Copies = htons(1);
 	pj.CtrlFlags = 0;
-	pj.Lines = 0;
-	pj.Rows = 0;
-	strcpy(pj.FormName, "");
-	strcpy(pj.Banner, "");
-	strcpy(pj.FnameBanner, "");
-	strcpy(pj.FnameHeader, "");
+	pj.Lines = htons(66);
+	pj.Rows = htons(80);
+	strcpy(pj.FormName, "test");
+	strcpy(pj.BannerName, "BannerName");
+	strcpy(pj.FnameBanner, "BannerFile");
+	strcpy(pj.FnameHeader, "HeaderName");
 	strcpy(pj.Path, "");
 
 	memcpy(j.j.ClientRecordArea, &pj, sizeof(pj));
@@ -584,7 +491,8 @@ test_print(struct ncp_server *server)
 		return;
 	}
 
-	if (ncp_write(server, j.file_handle, 0, 5, "hallo", &written) != 0) {
+	if (ncp_write(server, j.file_handle, 0, 5, "hallo, wie geht's?",
+		      &written) != 0) {
 		printf("write error\n");
 		return;
 	}
@@ -597,29 +505,37 @@ test_print(struct ncp_server *server)
 	return;
 }
 
-	
-	       
+void
+test_slist(struct ncp_server *server)
+{
+	struct ncp_bindery_object obj;
+
+	obj.object_id = 0xffffffff;
+
+	while (ncp_scan_bindery_object(server, obj.object_id,
+				       0xffff, "*",
+				       &obj) == 0) {
+		printf("%s\n", obj.object_name);
+	}
+	return;
+}
 
 int
 main(int argc, char **argv)
 {
 	struct ncp_server serv;
 	struct ncp_server *server = &serv;
+	struct sockaddr_ipx addr;
 
 	progname = argv[0];
 
-	if (argc != 2) {
-		printf("usage: %s server\n", argv[0]);
-		exit(1);
-	}
-
-	if (ipx_sap_find_server(argv[1], IPX_SAP_FILE_SERVER,
-				3, &(serv.addr)) != 0) {
+	if (ipx_sap_find_server("nw311", IPX_SAP_FILE_SERVER,
+				3, &addr) != 0) {
 		printf("could not find server %s\n", argv[1]);
 		exit(1);
 	}
 
-	if (ncp_connect(server) != 0) {
+	if (ncp_connect_addr(server, &addr) != 0) {
 		printf("could not connect\n");
 		exit(1);
 	}
@@ -629,7 +545,7 @@ main(int argc, char **argv)
 		exit(1);
 	}
 
-	test_touch(server);
+	test_slist(server);
 
 	ncp_disconnect(server);
 	

util/nwcrypt.c

@@ -89,9 +89,8 @@ typedef unsigned char buf32[32];
 typedef unsigned char buf16[16];
 typedef unsigned char buf8[8];
 typedef unsigned char buf4[4];
-typedef unsigned char u8;
 
-static u8 encrypttable[256] =
+static unsigned char encrypttable[256] =
 {0x7,0x8,0x0,0x8,0x6,0x4,0xE,0x4,0x5,0xC,0x1,0x7,0xB,0xF,0xA,0x8,
  0xF,0x8,0xC,0xC,0x9,0x4,0x1,0xE,0x4,0x6,0x2,0x4,0x0,0xA,0xB,0x9,
  0x2,0xF,0xB,0x1,0xD,0x2,0x1,0x9,0x5,0xE,0x7,0x0,0x0,0x2,0x6,0x6,
@@ -142,7 +141,7 @@ shuffle1(buf32 temp, unsigned char *target)
 }
 
 
-void
+static void
 shuffle(unsigned char *lon, const unsigned char *buf, int buflen,
 	unsigned char *target)
 {
@@ -191,7 +190,7 @@ shuffle(unsigned char *lon, const unsigned char *buf, int buflen,
 }
 
 
-void
+static void
 nw_encrypt(unsigned char *fra,unsigned char *buf,unsigned char *til)
 {
 	buf32 k;

util/nwcrypt.h

@@ -1,5 +0,0 @@
-void
-shuffle(unsigned char *lon, const unsigned char *buf, int buflen,
-	unsigned char *target);
-void
-nw_encrypt(unsigned char *fra,unsigned char *buf,unsigned char *til);

util/slist.c

@@ -0,0 +1,77 @@
+#include "ncplib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+
+void
+main(int argc, char *argv[])
+{
+	struct ncp_server server;
+	struct ncp_bindery_object obj;
+	int found = 0;
+	char default_pattern[2] = "*";
+	char *pattern = default_pattern;
+	char *p;
+
+	if (argc > 2) {
+		printf("usage: %s [pattern]\n", argv[0]);
+		exit(1);
+	}
+
+	if (argc == 2) {
+		pattern = argv[1];
+	}
+
+	for (p = pattern; *p != '\0'; p++) {
+		*p = toupper(*p);
+	}
+
+	memset(&server, 0, sizeof(server));
+
+	if (ncp_connect(&server, NULL) != 0) {
+		perror("ncp_connect");
+		exit(1);
+	}
+
+	if (isatty(1)) {
+		printf("\n%-52s%-10s%-12s\n"
+		       "-----------------------------------------------"
+		       "---------------------------\n",
+		       "Known NetWare File Servers",
+		       "Network",
+		       "Node Address");
+	}
+
+	obj.object_id = 0xffffffff;
+
+	while (ncp_scan_bindery_object(&server, obj.object_id,
+				       NCP_BINDERY_FSERVER, pattern,
+				       &obj) == 0) {
+
+		struct nw_property prop;
+		struct prop_net_address *naddr
+			= (struct prop_net_address *)&prop;
+
+		found = 1;
+
+		printf("%-52s", obj.object_name);
+
+		if (ncp_read_property_value(&server, NCP_BINDERY_FSERVER,
+					    obj.object_name, 1, "NET_ADDRESS",
+					    &prop) == 0) {
+			ipx_print_network(naddr->network);
+			printf("  ");
+			ipx_print_node(naddr->node);
+		}
+		printf("\n");
+	}
+
+	if ((found == 0) && (isatty(1))) {
+		printf("No servers found\n");
+	}
+
+	ncp_disconnect(&server);
+}
+

util/start_ipx

@@ -4,5 +4,4 @@
 # 00001b038b11 is the server's node number.
 #
 ipx_interface add -p eth0 EtherII 10
-ipx_route add 1992 10 00001b3bc0c9
 ipx_route add 1234 10 00001b038b11