ncpfs/dir.c

/*
 *  dir.c
 *
 *  Copyright (C) 1995 by Volker Lendecke
 *
 */

/* #include <linux/module.h>*/

#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.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,
            void *dirent, filldir_t filldir);
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;
}

/* 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,
            void *dirent, filldir_t filldir)
{
	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);

	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;
        }

	if (filp->f_pos == 1) {
		if (filldir(dirent,"..",2, filp->f_pos, (int)(dir->dir)) < 0) {
			return 0;
		}
		filp->f_pos += 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) {
		DPRINTK("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;
        }

        while (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) {
                        break;
                }

                if (   (inode->i_ino != c_ino)
                    || (entry->f_pos != filp->f_pos)) {
                        /* Someone has destroyed the cache while we slept
                           in filldir */
                        break;
                }
                filp->f_pos += 1;
                index += 1;
                entry += 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)
{
	struct nw_search_sequence seq;
	int total_count = 2;

#if 1
	if (fpos < 2) {
		printk("OOPS, we expect fpos >= 2");
	}
	fpos = 2;
#endif

	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 {
			DPRINTK("ncp_do_readdir: found file: %s\n",
				entry->i.entryName);
			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->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] == '.') {
		*result = iget(dir->i_sb, (int)(NCP_INOP(dir)->dir));
		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);
}