237 lines
6.3 KiB
C++
237 lines
6.3 KiB
C++
/* mount.h: mount definitions.
|
|
|
|
Copyright 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
|
|
2008, 2009, 2010, 2011, 2012, 2013, 2014 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. */
|
|
|
|
#ifndef _MOUNT_H
|
|
#define _MOUNT_H
|
|
|
|
enum disk_type
|
|
{
|
|
DT_NODISK,
|
|
DT_CDROM,
|
|
DT_FLOPPY,
|
|
DT_HARDDISK,
|
|
DT_SHARE_SMB,
|
|
DT_SHARE_NFS
|
|
};
|
|
|
|
disk_type get_disk_type (LPCWSTR);
|
|
|
|
/* Don't add new fs types without adding them to fs_names in mount.cc!
|
|
Don't reorder without reordering fs_names in mount.cc! */
|
|
enum fs_info_type
|
|
{
|
|
none = 0,
|
|
fat,
|
|
ntfs,
|
|
refs,
|
|
samba,
|
|
nfs,
|
|
netapp,
|
|
cdrom,
|
|
udf,
|
|
csc_cache,
|
|
sunwnfs,
|
|
unixfs,
|
|
mvfs,
|
|
cifs,
|
|
nwfs,
|
|
ncfsd,
|
|
afs,
|
|
/* Always last. */
|
|
max_fs_type
|
|
};
|
|
|
|
extern struct fs_names_t {
|
|
const char *name;
|
|
bool block_device;
|
|
} fs_names[];
|
|
|
|
#define IMPLEMENT_FS_FLAG(type) \
|
|
bool is_##type (bool val) { if (val) status.fs_type = type; return val; } \
|
|
bool is_##type () const { return status.fs_type == type; }
|
|
|
|
class fs_info
|
|
{
|
|
struct status_flags
|
|
{
|
|
ULONG flags; /* Volume flags */
|
|
ULONG samba_version; /* Samba version if available */
|
|
ULONG name_len; /* MaximumComponentNameLength */
|
|
fs_info_type fs_type; /* Filesystem type */
|
|
unsigned is_remote_drive : 1;
|
|
unsigned has_acls : 1;
|
|
unsigned hasgood_inode : 1;
|
|
unsigned caseinsensitive : 1;
|
|
unsigned has_buggy_open : 1;
|
|
unsigned has_buggy_reopen : 1;
|
|
unsigned has_buggy_fileid_dirinfo : 1;
|
|
unsigned has_buggy_basic_info : 1;
|
|
unsigned has_dos_filenames_only : 1;
|
|
} status;
|
|
ULONG sernum; /* Volume Serial Number */
|
|
char fsn[80]; /* Windows filesystem name */
|
|
|
|
public:
|
|
void clear ()
|
|
{
|
|
memset (&status, 0 , sizeof status);
|
|
sernum = 0UL;
|
|
fsn[0] = '\0';
|
|
}
|
|
fs_info () { clear (); }
|
|
|
|
IMPLEMENT_STATUS_FLAG (ULONG, flags)
|
|
IMPLEMENT_STATUS_FLAG (ULONG, samba_version)
|
|
IMPLEMENT_STATUS_FLAG (ULONG, name_len)
|
|
IMPLEMENT_STATUS_FLAG (bool, is_remote_drive)
|
|
IMPLEMENT_STATUS_FLAG (bool, has_acls)
|
|
IMPLEMENT_STATUS_FLAG (bool, hasgood_inode)
|
|
IMPLEMENT_STATUS_FLAG (bool, caseinsensitive)
|
|
IMPLEMENT_STATUS_FLAG (bool, has_buggy_open)
|
|
IMPLEMENT_STATUS_FLAG (bool, has_buggy_reopen)
|
|
IMPLEMENT_STATUS_FLAG (bool, has_buggy_fileid_dirinfo)
|
|
IMPLEMENT_STATUS_FLAG (bool, has_buggy_basic_info)
|
|
IMPLEMENT_STATUS_FLAG (bool, has_dos_filenames_only)
|
|
IMPLEMENT_FS_FLAG (fat)
|
|
IMPLEMENT_FS_FLAG (ntfs)
|
|
IMPLEMENT_FS_FLAG (refs)
|
|
IMPLEMENT_FS_FLAG (samba)
|
|
IMPLEMENT_FS_FLAG (nfs)
|
|
IMPLEMENT_FS_FLAG (netapp)
|
|
IMPLEMENT_FS_FLAG (cdrom)
|
|
IMPLEMENT_FS_FLAG (udf)
|
|
IMPLEMENT_FS_FLAG (csc_cache)
|
|
IMPLEMENT_FS_FLAG (sunwnfs)
|
|
IMPLEMENT_FS_FLAG (unixfs)
|
|
IMPLEMENT_FS_FLAG (mvfs)
|
|
IMPLEMENT_FS_FLAG (cifs)
|
|
IMPLEMENT_FS_FLAG (nwfs)
|
|
IMPLEMENT_FS_FLAG (ncfsd)
|
|
IMPLEMENT_FS_FLAG (afs)
|
|
fs_info_type what_fs () const { return status.fs_type; }
|
|
bool got_fs () const { return status.fs_type != none; }
|
|
|
|
ULONG serial_number () const { return sernum; }
|
|
|
|
const char *fsname () const { return fsn[0] ? fsn : "unknown"; }
|
|
|
|
bool __reg3 update (PUNICODE_STRING, HANDLE);
|
|
bool inited () const { return !!status.flags; }
|
|
};
|
|
|
|
/* Mount table entry */
|
|
|
|
class mount_item
|
|
{
|
|
public:
|
|
/* FIXME: Nasty static allocation. Need to have a heap in the shared
|
|
area [with the user being able to configure at runtime the max size]. */
|
|
/* Win32-style mounted partition source ("C:\foo\bar").
|
|
native_path[0] == 0 for unused entries. */
|
|
char native_path[CYG_MAX_PATH];
|
|
int native_pathlen;
|
|
|
|
/* POSIX-style mount point ("/foo/bar") */
|
|
char posix_path[CYG_MAX_PATH];
|
|
int posix_pathlen;
|
|
|
|
unsigned flags;
|
|
|
|
void init (const char *dev, const char *path, unsigned flags);
|
|
|
|
struct mntent *getmntent ();
|
|
int build_win32 (char *, const char *, unsigned *, unsigned);
|
|
};
|
|
|
|
/* Warning: Decreasing this value will cause cygwin.dll to ignore existing
|
|
higher numbered registry entries. Don't change this number willy-nilly.
|
|
What we need is to have a more dynamic allocation scheme, but the current
|
|
scheme should be satisfactory for a long while yet. */
|
|
#define MAX_MOUNTS 64
|
|
|
|
class reg_key;
|
|
struct device;
|
|
|
|
/* NOTE: Do not make gratuitous changes to the names or organization of the
|
|
below class. The layout is checksummed to determine compatibility between
|
|
different cygwin versions. */
|
|
class mount_info
|
|
{
|
|
public:
|
|
int nmounts;
|
|
mount_item mount[MAX_MOUNTS];
|
|
|
|
static bool got_usr_bin;
|
|
static bool got_usr_lib;
|
|
static int root_idx;
|
|
|
|
/* cygdrive_prefix is used as the root of the path automatically
|
|
prepended to a path when the path has no associated mount.
|
|
cygdrive_flags are the default flags for the cygdrives. */
|
|
char cygdrive[CYG_MAX_PATH];
|
|
size_t cygdrive_len;
|
|
unsigned cygdrive_flags;
|
|
private:
|
|
int posix_sorted[MAX_MOUNTS];
|
|
int native_sorted[MAX_MOUNTS];
|
|
|
|
public:
|
|
void init (bool);
|
|
int add_item (const char *dev, const char *path, unsigned flags);
|
|
int del_item (const char *path, unsigned flags);
|
|
|
|
unsigned set_flags_from_win32_path (const char *path);
|
|
int conv_to_win32_path (const char *src_path, char *dst, device&,
|
|
unsigned *flags = NULL);
|
|
int conv_to_posix_path (PWCHAR src_path, char *posix_path,
|
|
int keep_rel_p);
|
|
int conv_to_posix_path (const char *src_path, char *posix_path,
|
|
int keep_rel_p);
|
|
struct mntent *getmntent (int x);
|
|
|
|
int write_cygdrive_info (const char *cygdrive_prefix, unsigned flags);
|
|
int get_cygdrive_info (char *user, char *system, char* user_flags,
|
|
char* system_flags);
|
|
void cygdrive_posix_path (const char *src, char *dst, int trailing_slash_p);
|
|
int get_mounts_here (const char *parent_dir, int,
|
|
PUNICODE_STRING mount_points,
|
|
PUNICODE_STRING cygd);
|
|
|
|
private:
|
|
void sort ();
|
|
void mount_slash ();
|
|
void create_root_entry (const PWCHAR root);
|
|
|
|
bool from_fstab_line (char *line, bool user);
|
|
bool from_fstab (bool user, WCHAR [], PWCHAR);
|
|
|
|
int cygdrive_win32_path (const char *src, char *dst, int& unit);
|
|
};
|
|
|
|
class dos_drive_mappings
|
|
{
|
|
struct mapping
|
|
{
|
|
mapping *next;
|
|
size_t doslen;
|
|
size_t ntlen;
|
|
wchar_t *dospath;
|
|
wchar_t *ntdevpath;
|
|
};
|
|
mapping *mappings;
|
|
|
|
public:
|
|
dos_drive_mappings ();
|
|
~dos_drive_mappings ();
|
|
wchar_t *fixup_if_match (wchar_t *path);
|
|
};
|
|
#endif
|