shithub: drawterm

Info  •  Files  •  Log  •  Branches

devfs-win32: allow access to all windows drive letters exporting them under /mnt/term/C: ect... 64-bit file offsets

--- a/kern/devfs-win32.c

+++ b/kern/devfs-win32.c

@@ -1,16 +1,8 @@

-/*

- * Disable Unicode until the calls to FindFirstFile etc

- * are changed to use wide character strings.

- */

-#undef UNICODE

 #include	<windows.h>

 #include	<sys/types.h>

 #include	<sys/stat.h>

 #include	<fcntl.h>

-#ifndef NAME_MAX

-#	define NAME_MAX 256

-#endif

 #include	"u.h"

 #include	"lib.h"

 #include	"dat.h"

@@ -20,48 +12,149 @@

 typedef struct DIR	DIR;

 typedef	struct Ufsinfo	Ufsinfo;

+

 enum

 {

-	NUID	= 256,

-	NGID	= 256,

 	MAXPATH	= 1024,

-	MAXCOMP	= 128

+	TPATH_ROOT	= 0,	// ""

+	TPATH_VOLUME	= 1,	// "C:"

+	TPATH_FILE	= 2,	// "C:\bla"

 };

 struct DIR

 {

-	HANDLE	handle;

-	char*	path;

-	int	index;

+	// for FindFileFirst()

+	HANDLE		handle;

 	WIN32_FIND_DATA	wfd;

+

+	// for GetLogicalDriveStrings()

+	TCHAR		*drivebuf;

+	TCHAR		*drivep;

+

+	// dont move to the next item

+	int		keep;

 };

 struct Ufsinfo

 {

 	int	mode;

-	int	fd;

-	int	uid;

-	int	gid;

+	HANDLE	fh;

 	DIR*	dir;

-	ulong	offset;

+	vlong	offset;

 	QLock	oq;

-	char nextname[NAME_MAX];

 };

-DIR*	opendir(char*);

-int	readdir(char*, DIR*);

-void	closedir(DIR*);

-void	rewinddir(DIR*);

+static	void	fspath(Chan *, char *, TCHAR *, int);

+static	ulong	fsdirread(Chan*, uchar*, int, vlong);

+static	int	fsomode(int);

+static	ulong	fsaccess(int);

+static	ulong	pathtype(TCHAR *);

+static	int	checkvolume(TCHAR *);

-char	*base = "c:/.";

+char *base = "";

-static	Qid	fsqid(char*, struct stat *);

-static	void	fspath(Chan*, char*, char*);

-// static	void	fsperm(Chan*, int);

-static	ulong	fsdirread(Chan*, uchar*, int, ulong);

-static	int	fsomode(int);

-static  int	chown(char *path, int uid, int);

+static ulong

+unixtime(FILETIME *ft)

+{

+	vlong t;

+	t = ((vlong)ft->dwHighDateTime << 32)|((vlong)ft->dwLowDateTime);

+	t -= 116444736000000000LL;

+	return ((t<0)?(-1 - (-t - 1)) : t)/10000000;

+}

+static uvlong

+pathhash(TCHAR *p)

+{

+	uvlong h;

+	h = 0LL;

+	for(; *p; p++)

+		h += *p * 13;

+	return h;

+}

+

+static ulong

+wfdtodmode(WIN32_FIND_DATA *wfd)

+{

+	int m;

+	m = DMREAD|DMWRITE|DMEXEC;

+	if(wfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)

+		m |= DMDIR;

+	if(wfd->dwFileAttributes & FILE_ATTRIBUTE_READONLY)

+		m &= ~DMWRITE;

+	m |= (m & 07)<<3;

+	m |= (m & 07)<<6;

+	return m;

+}

+

+static Qid

+wfdtoqid(TCHAR *path, WIN32_FIND_DATA *wfd)

+{

+	ulong t;

+	WIN32_FIND_DATA f;

+	Qid q;

+

+	t = pathtype(path);

+

+	switch(t){

+	case TPATH_VOLUME:

+	case TPATH_ROOT:

+		q.type = QTDIR;

+		q.path = pathhash(path);

+		q.vers = 0;

+		break;

+

+	case TPATH_FILE:

+		if(!wfd){

+			HANDLE h;

+			if((h = FindFirstFile(path, &f))==INVALID_HANDLE_VALUE)

+				oserror();

+			FindClose(h);

+			wfd = &f;

+		}

+		q.type = (wfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? QTDIR : QTFILE;

+		q.path = pathhash(path);

+		q.vers = unixtime(&wfd->ftLastWriteTime);

+		break;

+	}

+	return q;

+}

+

+static void

+wfdtodir(TCHAR *path, Dir *d, WIN32_FIND_DATA *wfd)

+{

+	WIN32_FIND_DATA f;

+

+	d->uid	= "nul";

+	d->gid	= "nul";

+	d->muid	= "nul";

+

+	switch(pathtype(path)){

+	case TPATH_VOLUME:

+	case TPATH_ROOT:

+		wfd = nil;

+		d->mode = 0777 | DMDIR;

+		d->atime = 0;

+		d->mtime = 0;

+		d->length = 0;

+		break;

+

+	case TPATH_FILE:

+		if(!wfd){

+			HANDLE h;

+			if((h = FindFirstFile(path, &f))==INVALID_HANDLE_VALUE)

+				oserror();

+			FindClose(h);

+			wfd = &f;

+		}

+		d->mode		= wfdtodmode(wfd);

+		d->atime	= unixtime(&wfd->ftLastAccessTime);

+		d->mtime	= unixtime(&wfd->ftLastWriteTime);

+		d->length	= ((uvlong)wfd->nFileSizeHigh << 32)|((uvlong)wfd->nFileSizeLow);

+		break;

+	}

+	d->qid = wfdtoqid(path, wfd);

+}

+

 /* clumsy hack, but not worse than the Path stuff in the last one */

 static char*

 uc2name(Chan *c)

@@ -69,10 +162,12 @@

 	char *s;

 	if(c->name == nil)

-		return "/";

+		return "";

 	s = c2name(c);

 	if(s[0]=='#' && s[1]=='U')

-		return s+2;

+		s += 2;

+	if(*s=='/')

+		s++;

 	return s;

 }

@@ -88,29 +183,69 @@

 		return t;

 	return t+1;

 }

+

+static ulong

+pathtype(TCHAR *path)

+{

+	int n;

+	n = wcslen(path);

+	if(n < 2){

+		return TPATH_ROOT;

+	}

+	if(n==2){

+		return TPATH_VOLUME;

+	}

+	return TPATH_FILE;

+}

+

+static int

+checkvolume(TCHAR *path)

+{

+	TCHAR vol[MAX_PATH];

+	TCHAR volname[MAX_PATH];

+	TCHAR fsysname[MAX_PATH];

+	DWORD complen;

+	DWORD flags;

+

+	wcsncpy(vol, path, MAX_PATH);

+#ifdef UNICODE

+	wcsncat(vol, L"\\", MAXPATH);

+#else

+	wcsncat(vol, "\\", MAXPATH);

+#endif

+

+	if(!GetVolumeInformation(

+		vol,

+		volname,

+		MAX_PATH,

+		NULL,

+		&complen,

+		&flags,

+		fsysname,

+		MAX_PATH)){

+		return 0;

+	}

+	return 1;	

+}

+

+static int

+getfileowner(TCHAR *path, char *owner, int nowner)

+{

+	strncpy(owner, "Bill", nowner);

+	return 1;

+}

 static Chan*

 fsattach(char *spec)

 {

 	Chan *c;

-	struct stat stbuf;

 	static int devno;

 	Ufsinfo *uif;

-

-	if(stat(base, &stbuf) < 0)

-		error(strerror(errno));

-

 	c = devattach('U', spec);

-

 	uif = mallocz(sizeof(Ufsinfo), 1);

-	uif->gid = stbuf.st_gid;

-	uif->uid = stbuf.st_uid;

-	uif->mode = stbuf.st_mode;

-

 	c->aux = uif;

 	c->dev = devno++;

 	c->qid.type = QTDIR;

-/*print("fsattach %s\n", c2name(c));*/

 	return c;

 }

@@ -130,25 +265,27 @@

 static int

 fswalk1(Chan *c, char *name)

 {

-	struct stat stbuf;

-	char path[MAXPATH];

-	Ufsinfo *uif;

+	HANDLE h;

+	WIN32_FIND_DATA wfd;

+	TCHAR path[MAXPATH];

-	fspath(c, name, path);

+	fspath(c, name, path, MAXPATH);

-	/*	print("** fs walk '%s' -> %s\n", path, name); */

+	switch(pathtype(path)){

+	case TPATH_VOLUME:

+		if(!checkvolume(path))

+			return 0;

+	case TPATH_ROOT:

+		c->qid = wfdtoqid(path, nil);

+		break;

-	if(stat(path, &stbuf) < 0)

-		return 0;

-

-	uif = c->aux;

-

-	uif->gid = stbuf.st_gid;

-	uif->uid = stbuf.st_uid;

-	uif->mode = stbuf.st_mode;

-

-	c->qid = fsqid(path, &stbuf);

-

+	case TPATH_FILE:

+		if((h = FindFirstFile(path, &wfd)) == INVALID_HANDLE_VALUE)

+			return 0;

+		FindClose(h);

+		c->qid = wfdtoqid(path, &wfd);

+		break;

+	}

 	return 1;

 }

@@ -190,25 +327,21 @@

 fsstat(Chan *c, uchar *buf, int n)

 {

 	Dir d;

-	struct stat stbuf;

-	char path[MAXPATH];

+	TCHAR path[MAXPATH];

+	char owner[MAXPATH];

 	if(n < BIT16SZ)

 		error(Eshortstat);

+	fspath(c, 0, path, MAXPATH);

+	d.name = lastelem(c);

+	wfdtodir(path, &d, nil);

-	fspath(c, 0, path);

-	if(stat(path, &stbuf) < 0)

-		error(strerror(errno));

+	if(getfileowner(path, owner, MAXPATH)){

+		d.uid = owner;

+		d.gid = owner;

+		d.muid = owner;

+	}

-	d.name = lastelem(c);

-	d.uid = "unknown";

-	d.gid = "unknown";

-	d.muid = "unknown";

-	d.qid = c->qid;

-	d.mode = (c->qid.type<<24)|(stbuf.st_mode&0777);

-	d.atime = stbuf.st_atime;

-	d.mtime = stbuf.st_mtime;

-	d.length = stbuf.st_size;

 	d.type = 'U';

 	d.dev = c->dev;

 	return convD2M(&d, buf, n);

@@ -217,11 +350,11 @@

 static Chan*

 fsopen(Chan *c, int mode)

 {

-	char path[MAXPATH];

+	TCHAR path[MAXPATH];

+	ulong t;

 	int m, isdir;

 	Ufsinfo *uif;

-/*print("fsopen %s\n", c2name(c));*/

 	m = mode & (OTRUNC|3);

 	switch(m) {

 	case 0:

@@ -240,31 +373,55 @@

 	}

 	isdir = c->qid.type & QTDIR;

-

 	if(isdir && mode != OREAD)

 		error(Eperm);

-

 	m = fsomode(m & 3);

 	c->mode = openmode(mode);

-

 	uif = c->aux;

-

-	fspath(c, 0, path);

-	if(isdir) {

-		uif->dir = opendir(path);

-		if(uif->dir == 0)

-			error(strerror(errno));

-	}	

-	else {

-		if(mode & OTRUNC)

-			m |= O_TRUNC;

-		uif->fd = open(path, m|_O_BINARY, 0666);

-

-		if(uif->fd < 0)

-			error(strerror(errno));

-	}

 	uif->offset = 0;

-

+	fspath(c, 0, path, MAXPATH);

+	t = pathtype(path);

+	if(isdir){

+		DIR *d;

+		d = malloc(sizeof(*d));

+		switch(t){

+		case TPATH_ROOT:

+			d->drivebuf = malloc(sizeof(TCHAR)*MAX_PATH);

+			if(GetLogicalDriveStrings(MAX_PATH-1, d->drivebuf) == 0){

+				free(d->drivebuf);

+				d->drivebuf = nil;

+				oserror();

+			}

+			d->drivep = d->drivebuf;

+			break;

+		case TPATH_VOLUME:

+		case TPATH_FILE:

+#ifdef UNICODE

+			wcsncat(path, L"\\*.*", MAXPATH);

+#else

+			wcsncat(path, "\\*.*", MAXPATH);

+#endif

+			if((d->handle = FindFirstFile(path, &d->wfd)) == INVALID_HANDLE_VALUE){

+				free(d);

+				oserror();

+			}

+			break;

+		}

+		d->keep = 1;

+		uif->dir = d;

+	} else {

+		uif->dir = nil;

+		if((uif->fh = CreateFile(

+			path,

+			fsaccess(mode),

+			FILE_SHARE_READ | FILE_SHARE_WRITE,

+			NULL,

+			(mode & OTRUNC) ? TRUNCATE_EXISTING : OPEN_EXISTING,

+			FILE_ATTRIBUTE_NORMAL,

+			0)) == INVALID_HANDLE_VALUE){

+			oserror();

+		}	

+	}

 	c->offset = 0;

 	c->flag |= COPEN;

 	return c;

@@ -273,58 +430,59 @@

 static void

 fscreate(Chan *c, char *name, int mode, ulong perm)

 {

-	int fd, m;

-	char path[MAXPATH];

-	struct stat stbuf;

+	int m;

+	TCHAR path[MAXPATH];

 	Ufsinfo *uif;

+	ulong t;

 	m = fsomode(mode&3);

-	fspath(c, name, path);

+	fspath(c, name, path, MAXPATH);

+	t = pathtype(path);

 	uif = c->aux;

 	if(perm & DMDIR) {

-		if(m)

+		TCHAR *p;

+		DIR *d;

+		if(m || t!=TPATH_FILE)

 			error(Eperm);

-

-		if(mkdir(path) < 0)

-			error(strerror(errno));

-

-		fd = open(path, 0);

-		if(fd >= 0) {

-			chmod(path, perm & 0777);

-			chown(path, uif->uid, uif->uid);

+		if(!CreateDirectory(path, NULL))

+			oserror();

+		d = malloc(sizeof(*d));

+		p = &path[wcslen(path)];

+#ifdef UNICODE

+		wcsncat(path, L"\\*.*", MAXPATH);

+#else

+		wcsncat(path, "\\*.*", MAXPATH);

+#endif

+		if((d->handle = FindFirstFile(path, &d->wfd)) == INVALID_HANDLE_VALUE){

+			free(d);

+			oserror();

 		}

-		close(fd);

-

-		uif->dir = opendir(path);

-		if(uif->dir == 0)

-			error(strerror(errno));

+		*p = 0;

+		d->keep = 1;

+		uif->dir = d;

+	} else {

+		uif->dir = nil;

+		if((uif->fh = CreateFile(

+			path,

+			fsaccess(mode),

+			FILE_SHARE_READ | FILE_SHARE_WRITE,

+			NULL,

+			CREATE_NEW,

+			FILE_ATTRIBUTE_NORMAL,

+			0)) == INVALID_HANDLE_VALUE){

+			oserror();

+		}	

 	}

-	else {

-		fd = open(path, _O_WRONLY|_O_BINARY|_O_CREAT|_O_TRUNC, 0666);

-		if(fd >= 0) {

-			if(m != 1) {

-				close(fd);

-				fd = open(path, m|_O_BINARY);

-			}

-			chmod(path, perm & 0777);

-			chown(path, uif->uid, uif->gid);

-		}

-		if(fd < 0)

-			error(strerror(errno));

-		uif->fd = fd;

-	}

-

-	if(stat(path, &stbuf) < 0)

-		error(strerror(errno));

-	c->qid = fsqid(path, &stbuf);

+	c->qid = wfdtoqid(path, nil);

 	c->offset = 0;

 	c->flag |= COPEN;

 	c->mode = openmode(mode);

 }

+

 static void

 fsclose(Chan *c)

 {

@@ -331,14 +489,19 @@

 	Ufsinfo *uif;

 	uif = c->aux;

-

 	if(c->flag & COPEN) {

-		if(c->qid.type & QTDIR)

-			closedir(uif->dir);

-		else

-			close(uif->fd);

+		if(uif->dir){

+			if(uif->dir->drivebuf){

+				free(uif->dir->drivebuf);

+				uif->dir->drivebuf = nil;

+			} else {

+				FindClose(uif->dir->handle);

+				free(uif->dir);

+			}

+		} else {

+			CloseHandle(uif->fh);

+		}

 	}

-

 	free(uif);

 }

@@ -345,10 +508,10 @@

 static long

 fsread(Chan *c, void *va, long n, vlong offset)

 {

-	int fd, r;

+	HANDLE fh;

+	DWORD r;

 	Ufsinfo *uif;

-/*print("fsread %s\n", c2name(c));*/

 	if(c->qid.type & QTDIR)

 		return fsdirread(c, va, n, offset);

@@ -358,22 +521,22 @@

 		qunlock(&uif->oq);

 		nexterror();

 	}

-	fd = uif->fd;

+	fh = uif->fh;

 	if(uif->offset != offset) {

-		r = lseek(fd, offset, 0);

-		if(r < 0)

-			error(strerror(errno));

+		LONG high;

+		high = offset>>32;

+		offset = SetFilePointer(fh, (LONG)(offset & 0xFFFFFFFF), &high, FILE_BEGIN);

+		offset |= (vlong)high<<32;

 		uif->offset = offset;

 	}

-

-	n = read(fd, va, n);

-	if(n < 0)

-		error(strerror(errno));

-

+	r = 0;

+	if(!ReadFile(fh, va, (DWORD)n, &r, NULL)){

+		oserror();

+	}

+	n = r;

 	uif->offset += n;

 	qunlock(&uif->oq);

 	poperror();

-

 	return n;

 }

@@ -380,32 +543,35 @@

 static long

 fswrite(Chan *c, void *va, long n, vlong offset)

 {

-	int fd, r;

+	HANDLE fh;

+	DWORD w;

 	Ufsinfo *uif;

-	uif = c->aux;

+	if(c->qid.type & QTDIR)

+		return fsdirread(c, va, n, offset);

+	uif = c->aux;

 	qlock(&uif->oq);

 	if(waserror()) {

 		qunlock(&uif->oq);

 		nexterror();

 	}

-	fd = uif->fd;

+	fh = uif->fh;

 	if(uif->offset != offset) {

-		r = lseek(fd, offset, 0);

-		if(r < 0)

-			error(strerror(errno));

+		LONG high;

+		high = offset>>32;

+		offset = SetFilePointer(fh, (LONG)(offset & 0xFFFFFFFF), &high, FILE_BEGIN);

+		offset |= (vlong)high<<32;

 		uif->offset = offset;

 	}

-

-	n = write(fd, va, n);

-	if(n < 0)

-		error(strerror(errno));

-

+	w = 0;

+	if(!WriteFile(fh, va, (DWORD)n, &w, NULL)){

+		oserror();

+	}

+	n = w;

 	uif->offset += n;

 	qunlock(&uif->oq);

 	poperror();

-

 	return n;

 }

@@ -412,114 +578,103 @@

 static void

 fsremove(Chan *c)

 {

-	int n;

-	char path[MAXPATH];

+	TCHAR path[MAXPATH];

-	fspath(c, 0, path);

-	if(c->qid.type & QTDIR)

-		n = rmdir(path);

-	else

-		n = remove(path);

-	if(n < 0)

-		error(strerror(errno));

+	fspath(c, 0, path, MAXPATH);

+	if(c->qid.type & QTDIR){

+		if(!RemoveDirectory(path))

+			error("RemoveDirectory...");

+	} else {

+		if(!DeleteFile(path))

+			error("DeleteFile...");

+	}

 }

 static int

 fswstat(Chan *c, uchar *buf, int n)

 {

+	TCHAR path[MAXPATH];

+	char strs[MAXPATH*3];

 	Dir d;

-	struct stat stbuf;

-	char old[MAXPATH], new[MAXPATH];

-	char strs[MAXPATH*3], *p;

-	Ufsinfo *uif;

+	ulong t;

 	if (convM2D(buf, n, &d, strs) != n)

 		error(Ebadstat);

-	

-	fspath(c, 0, old);

-	if(stat(old, &stbuf) < 0)

-		error(strerror(errno));

+	fspath(c, 0, path, MAXPATH);

+	t = pathtype(path);

+	if(t != TPATH_FILE)

+		error(Ebadstat);

+	/* change name */

+	if(d.name[0]){

+		int l;

+		TCHAR newpath[MAXPATH];

+		wcsncpy(newpath, path, MAXPATH);

-	uif = c->aux;

-

-//	if(uif->uid != stbuf.st_uid)

-//		error(Eowner);

-

-	if(d.name[0] && strcmp(d.name, lastelem(c)) != 0) {

-		fspath(c, 0, old);

-		strcpy(new, old);

-		p = strrchr(new, '/');

-		strcpy(p+1, d.name);

-		if(rename(old, new) < 0)

-			error(strerror(errno));

+		/* replace last path-element with d.name */

+		l = wcslen(newpath)-1;

+		if(l <= 0)

+			error(Ebadstat);

+		for(;l>0; l--){

+			if(newpath[l-1]=='\\')

+				break;

+		}

+		if(l <= 0)

+			error(Ebadstat);

+		newpath[l] = 0;

+#ifdef UNICODE

+		if(!MultiByteToWideChar(CP_UTF8,0,d.name,-1,&newpath[l],MAXPATH-l-1))

+			oserror();

+#else

+		wcsncpy(&newpath[l], d.name, MAXPATH-l-1);

+#endif

+		if(wcscmp(path, newpath)!=0){

+			if(!MoveFile(path, newpath))

+				oserror();

+			wcsncpy(path, newpath, MAXPATH);

+		}

 	}

-	fspath(c, 0, old);

-	if(~d.mode != 0 && (int)(d.mode&0777) != (int)(stbuf.st_mode&0777)) {

-		if(chmod(old, d.mode&0777) < 0)

-			error(strerror(errno));

-		uif->mode &= ~0777;

-		uif->mode |= d.mode&0777;

-	}

-/*

-	p = name2pass(gid, d.gid);

-	if(p == 0)

-		error(Eunknown);

-

-	if(p->id != stbuf.st_gid) {

-		if(chown(old, stbuf.st_uid, p->id) < 0)

-			error(sys_errlist[errno]);

-

-		uif->gid = p->id;

-	}

-*/

-	return n;

+	/* fixme: change attributes */

+	c->qid = wfdtoqid(path, nil);

+	return n;	

 }

-static Qid

-fsqid(char *p, struct stat *st)

-{

-	Qid q;

-	int dev;

-	ulong h;

-	static int nqdev;

-	static uchar *qdev;

-	if(qdev == 0)

-		qdev = mallocz(65536U, 1);

-

-	q.type = 0;

-	if((st->st_mode&S_IFMT) ==  S_IFDIR)

-		q.type = QTDIR;

-

-	dev = st->st_dev & 0xFFFFUL;

-	if(qdev[dev] == 0)

-		qdev[dev] = ++nqdev;

-

-	h = 0;

-	while(*p != '\0')

-		h += *p++ * 13;

-	

-	q.path = (vlong)qdev[dev]<<32;

-	q.path |= h;

-	q.vers = st->st_mtime;

-

-	return q;

-}

-

 static void

-fspath(Chan *c, char *ext, char *path)

+_fspath(Chan *c, char *ext, char *path, int npath)

 {

-	strcpy(path, base);

-	strcat(path, "/");

-	strcat(path, uc2name(c));

+	*path = 0;

+	strncat(path, uc2name(c), npath);

 	if(ext) {

-		strcat(path, "/");

-		strcat(path, ext);

+		if(*path)

+			strncat(path, "/", npath);

+		strncat(path, ext, npath);

 	}

 	cleanname(path);

+	if(*path == '.')

+		*path = 0;

 }

+static void

+fspath(Chan *c, char *ext, TCHAR *path, int npath)

+{

+	TCHAR *p;

+#ifdef UNICODE

+	char buf[MAXPATH];

+	_fspath(c, ext, buf, sizeof(buf));

+	if(!MultiByteToWideChar(CP_UTF8,0,buf,-1,path,npath)){

+		oserror();

+	}

+#else

+	_fspath(c, ext, path, npath);

+#endif

+	/* make a DOS path */

+	for(p=path; *p; p++){

+		if(*p == '/')

+			*p = '\\';

+	}

+}

+

 static int

 isdots(char *name)

 {

@@ -534,78 +689,116 @@

 	return 0;

 }

-static int

-p9readdir(char *name, Ufsinfo *uif)

-{

-	if(uif->nextname[0]){

-		strcpy(name, uif->nextname);

-		uif->nextname[0] = 0;

-		return 1;

-	}

-

-	return readdir(name, uif->dir);

-}

-

 static ulong

-fsdirread(Chan *c, uchar *va, int count, ulong offset)

+fsdirread(Chan *c, uchar *va, int count, vlong offset)

 {

 	int i;

+	ulong t;

 	Dir d;

 	long n;

-	char de[NAME_MAX];

-	struct stat stbuf;

-	char path[MAXPATH], dirpath[MAXPATH];

 	Ufsinfo *uif;

+	char de[MAX_PATH*3];

+	int ndirpath;

+	TCHAR dirpath[MAXPATH];

-/*print("fsdirread %s\n", c2name(c));*/

 	i = 0;

 	uif = c->aux;

-

 	errno = 0;

+

+	fspath(c, 0, dirpath, MAXPATH);

+	ndirpath = wcslen(dirpath);

+	t = pathtype(dirpath);

+

 	if(uif->offset != offset) {

 		if(offset != 0)

 			error("bad offset in fsdirread");

 		uif->offset = offset;  /* sync offset */

-		uif->nextname[0] = 0;

-		rewinddir(uif->dir);

+		switch(t){

+		case TPATH_ROOT:

+			uif->dir->drivep = uif->dir->drivebuf;

+			break;

+		case TPATH_VOLUME:

+		case TPATH_FILE:

+			FindClose(uif->dir->handle);

+#ifdef UNICODE

+			wcsncat(dirpath, L"\\*.*", MAXPATH);

+#else

+			wcsncat(dirpath, "\\*.*", MAXPATH);

+#endif

+			if((uif->dir->handle = FindFirstFile(dirpath, &uif->dir->wfd))==INVALID_HANDLE_VALUE){

+				oserror();

+			}

+			break;

+		}

+		uif->dir->keep = 1;

 	}

-	fspath(c, 0, dirpath);

-

 	while(i+BIT16SZ < count) {

-		if(!p9readdir(de, uif))

-			break;

+		char owner[MAXPATH];

+		if(!uif->dir->keep) {

+			switch(t){

+			case TPATH_ROOT:

+				uif->dir->drivep += 4;

+				if(*uif->dir->drivep == 0)

+					goto out;

+				break;

+			case TPATH_VOLUME:

+			case TPATH_FILE:

+				if(!FindNextFile(uif->dir->handle, &uif->dir->wfd))

+					goto out;

+				break;

+			}

+		} else {

+			uif->dir->keep = 0;

+		}

+		if(t == TPATH_ROOT){

+			uif->dir->drivep[2] = 0;

+#ifdef UNICODE

+			WideCharToMultiByte(CP_UTF8,0,uif->dir->drivep,-1,de,sizeof(de),0,0);

+#else

+			strncpy(de, uif->dir->drivep, sizeof(de));

+#endif

+		} else {

+#ifdef UNICODE

+			WideCharToMultiByte(CP_UTF8,0,uif->dir->wfd.cFileName,-1,de,sizeof(de),0,0);

+#else

+			strncpy(de, uif->dir->wfd.cFileName, sizeof(de));

+#endif

+		}

 		if(de[0]==0 || isdots(de))

 			continue;

-

 		d.name = de;

-		sprint(path, "%s/%s", dirpath, de);

-		memset(&stbuf, 0, sizeof stbuf);

+		dirpath[ndirpath] = 0;		

+		if(t == TPATH_ROOT){

+			wcsncat(dirpath, uif->dir->drivep, MAXPATH);

+			wfdtodir(dirpath, &d, nil);

+		} else {

+#ifdef UNICODE

+			wcsncat(dirpath, L"\\", MAXPATH);

+#else

+			wcsncat(dirpath, "\\", MAXPATH);

+#endif

+			wcsncat(dirpath, uif->dir->wfd.cFileName, MAXPATH);

+			wfdtodir(dirpath, &d, &uif->dir->wfd);

+		}

-		if(stat(path, &stbuf) < 0) {

-			print("dir: bad path %s\n", path);

-			/* but continue... probably a bad symlink */

+		if(getfileowner(dirpath, owner, MAXPATH)){

+			d.uid = owner;

+			d.gid = owner;

+			d.muid = owner;

 		}

-		d.uid = "unknown";

-		d.gid = "unknown";

-		d.muid = "unknown";

-		d.qid = fsqid(path, &stbuf);

-		d.mode = (d.qid.type<<24)|(stbuf.st_mode&0777);

-		d.atime = stbuf.st_atime;

-		d.mtime = stbuf.st_mtime;

-		d.length = stbuf.st_size;

 		d.type = 'U';

 		d.dev = c->dev;

 		n = convD2M(&d, (uchar*)va+i, count-i);

 		if(n == BIT16SZ){

-			strcpy(uif->nextname, de);

+			uif->dir->keep = 1;

 			break;

 		}

 		i += n;

 	}

-/*print("got %d\n", i);*/

+out:

 	uif->offset += i;

 	return i;

 }

@@ -625,65 +818,29 @@

 	error(Ebadarg);

 	return 0;

 }

-void

-closedir(DIR *d)

-{

-	FindClose(d->handle);

-	free(d->path);

-}

-int

-readdir(char *name, DIR *d)

+static ulong

+fsaccess(int m)

 {

-	if(d->index != 0) {

-		if(FindNextFile(d->handle, &d->wfd) == FALSE)

-			return 0;

+	ulong a;

+	a = 0;

+	switch(m & 3){

+	default:

+		error(Eperm);

+		break;

+	case OREAD:

+		a = GENERIC_READ;

+		break;

+	case OWRITE:

+		a = GENERIC_WRITE;

+		break;

+	case ORDWR:

+		a = GENERIC_READ | GENERIC_WRITE;

+		break;

 	}

-	strcpy(name, (char*)d->wfd.cFileName);

-	d->index++;

-

-	return 1;

+	return a;

 }

-void

-rewinddir(DIR *d)

-{

-	FindClose(d->handle);

-	d->handle = FindFirstFile(d->path, &d->wfd);

-	d->index = 0;

-}

-

-static int

-chown(char *path, int uid, int perm)

-{

-/*	panic("chown"); */

-	return 0;

-}

-

-DIR*

-opendir(char *p)

-{

-	DIR *d;

-	char path[MAX_PATH];

-

-	

-	snprint(path, sizeof(path), "%s/*.*", p);

-

-	d = mallocz(sizeof(DIR), 1);

-	if(d == 0)

-		return 0;

-

-	d->index = 0;

-

-	d->handle = FindFirstFile(path, &d->wfd);

-	if(d->handle == INVALID_HANDLE_VALUE) {

-		free(d);

-		return 0;

-	}

-

-	d->path = strdup(path);

-	return d;

-}

 Dev fsdevtab = {

 	'U',