newlib/winsup/cygwin/fhandler_netdrive.cc

333 lines
8.1 KiB
C++
Raw Normal View History

/* fhandler_netdrive.cc: fhandler for // and //MACHINE handling
Copyright 2005, 2006, 2007, 2008 Red Hat, Inc.
This file is part of Cygwin.
This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */
#include "winsup.h"
#include <stdlib.h>
#include "cygerrno.h"
#include "security.h"
#include "path.h"
#include "fhandler.h"
#include "dtable.h"
#include "cygheap.h"
#include "cygthread.h"
#include <winnetwk.h>
#include <dirent.h>
enum
{
GET_RESOURCE_INFO = 0,
GET_RESOURCE_OPENENUM = 1,
GET_RESOURCE_OPENENUMTOP = 2,
GET_RESOURCE_ENUM = 3
};
struct netdriveinf
{
int what;
int ret;
PVOID in;
PVOID out;
DWORD outsize;
HANDLE sem;
};
struct net_hdls
{
HANDLE net;
HANDLE dom;
};
static DWORD WINAPI
thread_netdrive (void *arg)
{
netdriveinf *ndi = (netdriveinf *) arg;
char provider[256], *dummy = NULL;
LPNETRESOURCE nro;
DWORD cnt, size;
struct net_hdls *nh;
ReleaseSemaphore (ndi->sem, 1, NULL);
switch (ndi->what)
{
case GET_RESOURCE_INFO:
nro = (LPNETRESOURCE) alloca (size = 4096);
ndi->ret = WNetGetResourceInformation ((LPNETRESOURCE) ndi->in,
nro, &size, &dummy);
break;
case GET_RESOURCE_OPENENUMTOP:
nro = (LPNETRESOURCE) alloca (size = 4096);
nh = (struct net_hdls *) ndi->out;
ndi->ret = WNetGetProviderName (WNNC_NET_LANMAN, provider,
(size = 256, &size));
if (ndi->ret != NO_ERROR)
break;
memset (nro, 0, sizeof *nro);
nro->dwScope = RESOURCE_GLOBALNET;
nro->dwType = RESOURCETYPE_ANY;
nro->dwDisplayType = RESOURCEDISPLAYTYPE_GROUP;
nro->dwUsage = RESOURCEUSAGE_RESERVED | RESOURCEUSAGE_CONTAINER;
nro->lpRemoteName = provider;
nro->lpProvider = provider;
ndi->ret = WNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
RESOURCEUSAGE_ALL, nro, &nh->net);
if (ndi->ret != NO_ERROR)
break;
while ((ndi->ret = WNetEnumResource (nh->net, (cnt = 1, &cnt), nro,
(size = 4096, &size))) == NO_ERROR)
{
ndi->ret = WNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
RESOURCEUSAGE_ALL, nro, &nh->dom);
if (ndi->ret == NO_ERROR)
break;
}
break;
case GET_RESOURCE_OPENENUM:
nro = (LPNETRESOURCE) alloca (size = 4096);
nh = (struct net_hdls *) ndi->out;
ndi->ret = WNetGetProviderName (WNNC_NET_LANMAN, provider,
(size = 256, &size));
if (ndi->ret != NO_ERROR)
break;
((LPNETRESOURCE) ndi->in)->lpProvider = provider;
ndi->ret = WNetGetResourceInformation ((LPNETRESOURCE) ndi->in,
nro, &size, &dummy);
if (ndi->ret != NO_ERROR)
2005-08-12 04:39:13 +02:00
break;
ndi->ret = WNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
RESOURCEUSAGE_ALL, nro, &nh->dom);
break;
case GET_RESOURCE_ENUM:
nh = (struct net_hdls *) ndi->in;
if (!nh->dom)
{
ndi->ret = ERROR_NO_MORE_ITEMS;
break;
}
while ((ndi->ret = WNetEnumResource (nh->dom, (cnt = 1, &cnt),
(LPNETRESOURCE) ndi->out,
&ndi->outsize)) != NO_ERROR
&& nh->net)
2005-08-12 04:39:13 +02:00
{
WNetCloseEnum (nh->dom);
nh->dom = NULL;
nro = (LPNETRESOURCE) alloca (size = 4096);
while ((ndi->ret = WNetEnumResource (nh->net, (cnt = 1, &cnt), nro,
(size = 4096, &size))) == NO_ERROR)
{
ndi->ret = WNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
RESOURCEUSAGE_ALL, nro, &nh->dom);
if (ndi->ret == NO_ERROR)
break;
}
if (ndi->ret != NO_ERROR)
break;
}
break;
}
ReleaseSemaphore (ndi->sem, 1, NULL);
return 0;
}
static DWORD
create_thread_and_wait (int what, PVOID in, PVOID out, DWORD outsize,
const char *name)
{
netdriveinf ndi = { what, 0, in, out, outsize,
CreateSemaphore (&sec_none_nih, 0, 2, NULL) };
cygthread *thr = new cygthread (thread_netdrive, 0, &ndi, name);
if (thr->detach (ndi.sem))
ndi.ret = ERROR_OPERATION_ABORTED;
CloseHandle (ndi.sem);
return ndi.ret;
}
/* Returns 0 if path doesn't exist, >0 if path is a directory,
-1 if path is a file, -2 if it's a symlink. */
int
fhandler_netdrive::exists ()
{
char *to;
const char *from;
size_t len = strlen (get_name ());
if (len == 2)
return 1;
char namebuf[len + 1];
for (to = namebuf, from = get_name (); *from; to++, from++)
*to = (*from == '/') ? '\\' : *from;
*to = '\0';
NETRESOURCE nr = {0};
nr.dwScope = RESOURCE_GLOBALNET;
nr.dwType = RESOURCETYPE_DISK;
nr.lpLocalName = NULL;
nr.lpRemoteName = namebuf;
DWORD ret = create_thread_and_wait (GET_RESOURCE_INFO, &nr, NULL, 0,
"WNetGetResourceInformation");
if (ret != ERROR_MORE_DATA && ret != NO_ERROR)
return 0;
return 1;
}
fhandler_netdrive::fhandler_netdrive ():
fhandler_virtual ()
{
}
int
fhandler_netdrive::fstat (struct __stat64 *buf)
{
const char *path = get_name ();
debug_printf ("fstat (%s)", path);
fhandler_base::fstat (buf);
buf->st_mode = S_IFDIR | STD_RBITS | STD_XBITS;
* smallprint.cc (__small_vswprintf): Fix uninitialized usage of `w'. Revamp advisory file locking to avoid cross reference pointers as well as to allow BSD flock semantics. More agressively delete unused nodes and sync objects. * fhandler.h (fhandler_base::ino): Rename from namehash. Fix comment. (fhandler_base::node): Remove. (fhandler_base::unique_id): Add. (fhandler_base::del_my_locks): New method. (get_ino): Rename from get_namehash. Change usage throughout Cygwin. (get_unique_id): New method. * fhandler.cc (fhandler_base::close): Call own del_my_locks method. Fix comment. (fhandler_base::fhandler_base): Accommodate new and changed members. (fhandler_base::fixup_after_fork): Call del_my_locks. (fhandler_base::fixup_after_exec): Ditto for files with close-on-exec flag set. * fhandler_disk_file.cc (get_ino_by_handle): Rename from readdir_get_ino_by_handle. Accommodate throughout. (fhandler_base::open_fs): Fill ino with inode number if FS has good inodes. Allocate a LUID and store in unique_id to recognize file descriptors referencing the same file object. * flock.cc: Drop flock TODO comments. Use explicit types __dev32_t and __ino64_t instead of dev_t and ino_t. (LOCK_OBJ_NAME_LEN): Change to reflect longer lf_id length. (get_obj_handle_count): New method. (lockf_t::lf_id): Change type to long long. (inode_t::get_lock_obj_handle_count): Drop in favor of static function get_obj_handle_count. (inode_t::del_locks): Remove. (inode_t::get): Add create_if_missing flag argument. (inode_t::del_my_locks): Reimplement to handle POSIX and BSD flock locks. Return if node can be deleted or not. (inode_t::~inode_t): Ditto. Close handles to i_dir and i_mtx. (fixup_lockf_after_fork): Remove. (fhandler_base::del_my_locks): New method. (fixup_lockf_after_exec): Check if node can be deleted. (inode_t::get): Only create node if create_if_missing is set. Lock the returned node here before unlocking the node list. (inode_t::get_all_locks_list): Accommodate new lf_id length. (inode_t::create_lock_obj): Ditto. (lockf_t::open_lock_obj): Ditto. Change return type to bool. De-const. Set lf_obj instead of returning a handle. (lockf_t::del_lock_obj): Call SetEvent only if new incoming parameters allow it. Explain how it's supposed to work. (fhandler_disk_file::lock): Only fetch file length in SEEK_END case. Use NtQueryInformationFile(FileStandardInformation) instead of calling fstat_by_handle. Always unlock node before returning. Use fhandler's unique id to create lf_id for BSD flock locks. Rely on node lock from inode_t::get. Call del_lock_obj on removed locks here to allow explicit unlocking. Delete node if no lock exists on the file anymore. (lf_setlock): Get file handle as additional parameter. Handle the fact that lf_getblock now always opens the attached event object. Reactivate erroneously applied patch which deactivates setting thread priority. Additionally handle blocking on BSD flock locks. (lf_clearlock): Get file handle as additional parameter. (lf_getlock): Close event handle opened by lf_getblock. (lf_getblock): Open potentially blocking event object here and check its signal state if it's a BSD flock lock. (lf_wakelock): Get file handle as additional parameter. * fork.cc (frok::child): Drop call to fixup_lockf_after_fork. * ntdll.h (struct _EVENT_BASIC_INFORMATION): Define. (enum _EVENT_INFORMATION_CLASS): Define. (NtQueryEvent): Declare. * fhandler.h (fhandler_base::fs_flags): Remove. (fhandler_base::set_fs_flags): Remove. (fhandler_base::get_fs_flags): Remove. * fhandler.cc (fhandler_base::write): Check for sparse file using pc.fs_flags(). * fhandler_disk_file.cc (fhandler_disk_file::ftruncate): Ditto. The return of the volume serial number in fs_info. * fhandler.h (get_dev): New method. * fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Drop call to NtQueryVolumeInformationFile(FileFsVolumeInformation). Just use get_dev() method. * fhandler_fifo.cc (fhandler_fifo::open) Use device ID and inode number to generate fifo name. * path.h (fs_info::sernum): New member. (fs_info::serial_number): New method. (path_conv::fs_serial_number): New method. * path.cc (fs_info::update): Fetch volume serial number and store in sernum.
2008-03-31 20:03:25 +02:00
buf->st_ino = get_ino ();
return 0;
}
int
fhandler_netdrive::readdir (DIR *dir, dirent *de)
{
NETRESOURCE *nro;
DWORD ret;
int res;
if (!dir->__d_position)
{
size_t len = strlen (get_name ());
char *namebuf = NULL;
NETRESOURCE nr = { 0 };
struct net_hdls *nh;
if (len != 2) /* // */
2005-08-12 04:39:13 +02:00
{
const char *from;
char *to;
namebuf = (char *) alloca (len + 1);
for (to = namebuf, from = get_name (); *from; to++, from++)
*to = (*from == '/') ? '\\' : *from;
*to = '\0';
}
nr.lpRemoteName = namebuf;
nr.dwType = RESOURCETYPE_DISK;
nro = (NETRESOURCE *) alloca (4096);
nh = (struct net_hdls *) ccalloc (HEAP_FHANDLER, 1, sizeof *nh);
ret = create_thread_and_wait (len == 2 ? GET_RESOURCE_OPENENUMTOP
: GET_RESOURCE_OPENENUM,
&nr, nh, 0, "WNetOpenEnum");
if (ret != NO_ERROR)
{
dir->__handle = INVALID_HANDLE_VALUE;
res = geterrno_from_win_error (ret);
goto out;
}
dir->__handle = (HANDLE) nh;
}
ret = create_thread_and_wait (GET_RESOURCE_ENUM, dir->__handle,
2005-08-12 04:39:13 +02:00
nro = (LPNETRESOURCE) alloca (16384),
16384, "WnetEnumResource");
if (ret != NO_ERROR)
res = geterrno_from_win_error (ret);
else
{
dir->__d_position++;
char *bs = strrchr (nro->lpRemoteName, '\\');
strcpy (de->d_name, bs ? bs + 1 : nro->lpRemoteName);
if (strlen (get_name ()) == 2)
{
strlwr (de->d_name);
de->d_ino = hash_path_name (get_ino (), de->d_name);
}
else
{
* dir.cc (readdir_worker): Drop dir parameter from call to readdir_get_ino. * fhandler.h (fhandler_disk_file::readdir_helper): Switch file name parameter to PUNICODE_STRING. * fhandler_disk_file.cc: Drop including ntdef.h. (class __DIR_mounts): Store mount points in UNICODE. Additionally store cygdrive prefix in unicode here. Change methods accordingly. (__DIR_mounts::eval_ino): Call new stat_worker instead of lstat64. (__DIR_mounts::~__DIR_mounts): New destructor to free UNICODE buffers. (path_conv::ndisk_links): Rewrite using native NT functions. (fhandler_base::fstat_by_handle): Use NAME_MAX instead of CYG_MAX_PATH. Always set pfvi->VolumeSerialNumber to non-0. Remove last resort code. (fhandler_base::fstat_by_name): Rewrite using native NT functions. (fhandler_base::fstat_fs): Always call fstat_by_name if fstat_by_handle fails. (fhandler_base::fstat_helper): Rely on dwVolumeSerialNumber. (fhandler_disk_file::facl): Call fstat_by_name if fstat_by_handle fails. (DIR_BUF_SIZE): Define using NAME_MAX instead of CYG_MAX_PATH. (__DIR_cache): Remove __name. (d_dirname): Remove. (fhandler_disk_file::opendir): Drop pathname length check. Remove outdated comment. Use get_name method instead of accessing pc.normalized_path directly. (readdir_get_ino): Drop unused dir parameter. Accomodate throughout. Allocate fname dynamically. Call new stat_worker instead of lstat64. Call NtOpenFile instead of CreateFile. Call NtClose instead of CloseHandle. (fhandler_disk_file::readdir_helper): Use native NT functions. Check for volume mount points and use correct inode number. (fhandler_disk_file::readdir): Simplify slightly. Use get_name instead of pc.normalized_path. (fhandler_disk_file::rewinddir): Use RtlInitUnicodeString. (fhandler_cygdrive::fstat): Ignore floppy drives. Set st_nlink correctly. (fhandler_cygdrive::readdir): Ignore floppy drives. * fhandler_netdrive.cc (fhandler_netdrive::readdir): Accommodate change to readdir_get_ino. * fhandler_proc.cc (PROC_DIR_COUNT): Define. (fhandler_proc::fstat): Evaluate correct link count for /proc. * ntdll.h (struct _FILE_DIRECTORY_INFORMATION): Define. (NtFsControlFile): Declare. (RtlAppendUnicodeToString): Declare. (RtlAppendUnicodeStringToString): Declare. (RtlCompareUnicodeString): Declare. (RtlCopyUnicodeString): Declare. (RtlCreateUnicodeStringFromAsciiz): Declare. (RtlEqualUnicodeString): Declare. (RtlFreeUnicodeString): Declare. (RtlInitEmptyUnicodeString): Declare. (RtlSecondsSince1970ToTime): Declare. (RtlInitEmptyUnicodeString): Define as inline function. (RtlInitCountedUnicodeString): Define as inline function. * path.cc (path_conv::check): New method with PUNICODE_STRING as path, preliminary implementation. (mount_info::get_mounts_here): Change to create UNICODE_STRINGs. Also copy cygpath prefix into UNICODE_STRING. (is_floppy): Drop 9x consideration. * path.h: Drop including ntdef.h. (path_conv::check): Add declaration. (path_conv::path_conv): Add constructor for UNICODE_STRING paths. * shared_info.h (mount_info::get_mounts_here): Change declaration. * syscalls.cc: Drop forward declaration of stat_worker. (stat_worke): Take path_conv as parameter. Drop nofollow flag. (stat64): Create matching path_conv and call stat_worker with it. (lstat64): Ditto. * winsup.h: Include ntdef.h. (stat_worker): Declare. (readdir_get_ino): Change declaration.
2007-07-26 19:30:54 +02:00
de->d_ino = readdir_get_ino (nro->lpRemoteName, false);
/* We can't trust remote inode numbers of only 32 bit. That means,
all remote inode numbers when running under NT4, as well as
remote NT4 NTFS, as well as shares of Samba version < 3.0. */
if (de->d_ino <= UINT_MAX)
de->d_ino = hash_path_name (0, nro->lpRemoteName);
}
res = 0;
}
out:
syscall_printf ("%d = readdir (%p, %p)", res, dir, de);
return res;
}
void
fhandler_netdrive::seekdir (DIR *dir, _off64_t pos)
{
rewinddir (dir);
if (pos < 0)
return;
while (dir->__d_position < pos)
if (!readdir (dir, dir->__d_dirent))
break;
}
void
fhandler_netdrive::rewinddir (DIR *dir)
{
if (dir->__handle != INVALID_HANDLE_VALUE)
{
struct net_hdls *nh = (struct net_hdls *) dir->__handle;
if (nh->dom)
WNetCloseEnum (nh->dom);
if (nh->net)
WNetCloseEnum (nh->net);
cfree (nh);
}
dir->__handle = INVALID_HANDLE_VALUE;
return fhandler_virtual::rewinddir (dir);
}
int
fhandler_netdrive::closedir (DIR *dir)
{
rewinddir (dir);
return fhandler_virtual::closedir (dir);
}
int
fhandler_netdrive::open (int flags, mode_t mode)
{
int res = fhandler_virtual::open (flags, mode);
if (!res)
goto out;
nohandle (true);
if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
{
set_errno (EEXIST);
res = 0;
goto out;
}
else if (flags & O_WRONLY)
{
set_errno (EISDIR);
res = 0;
goto out;
}
res = 1;
set_flags ((flags & ~O_TEXT) | O_BINARY | O_DIROPEN);
set_open_status ();
out:
syscall_printf ("%d = fhandler_netdrive::open (%p, %d)", res, flags, mode);
return res;
}