diff options
Diffstat (limited to 'winsup/cygwin/cygheap.h')
| -rw-r--r-- | winsup/cygwin/cygheap.h | 177 |
1 files changed, 157 insertions, 20 deletions
diff --git a/winsup/cygwin/cygheap.h b/winsup/cygwin/cygheap.h index 1972411c7..6f81eaa41 100644 --- a/winsup/cygwin/cygheap.h +++ b/winsup/cygwin/cygheap.h @@ -1,6 +1,6 @@ /* cygheap.h: Cygwin heap manager. - Copyright 2000, 2001 Red Hat, Inc. + Copyright 2000, 2001, 2002 Red Hat, Inc. This file is part of Cygwin. @@ -48,7 +48,6 @@ struct cygheap_root_mount_info /* CGF: FIXME This doesn't belong here */ -int path_prefix_p (const char *path1, const char *path2, int len1) __attribute__ ((regparm (3))); class cygheap_root { /* Root directory information. @@ -86,6 +85,15 @@ public: const char *native_path () const { return m->native_path; } }; +enum homebodies +{ + CH_HOMEDRIVE, + CH_HOMEPATH, + CH_HOME +}; + +struct passwd; + class cygheap_user { /* Extendend user information. @@ -94,41 +102,73 @@ class cygheap_user char *pname; /* user's name */ char *plogsrv; /* Logon server, may be FQDN */ char *pdomain; /* Logon domain of the user */ + char *homedrive; /* User's home drive */ + char *homepath; /* User's home path */ + char *pwinname; /* User's name as far as Windows knows it */ + char *puserprof; /* User profile */ PSID psid; /* buffer for user's SID */ + PSID orig_psid; /* Remains intact even after impersonation */ public: - uid_t orig_uid; /* Remains intact even after impersonation */ - uid_t orig_gid; /* Ditto */ - uid_t real_uid; /* Remains intact on seteuid, replaced by setuid */ - gid_t real_gid; /* Ditto */ + __uid32_t orig_uid; /* Remains intact even after impersonation */ + __gid32_t orig_gid; /* Ditto */ + __uid32_t real_uid; /* Remains intact on seteuid, replaced by setuid */ + __gid32_t real_gid; /* Ditto */ + user_groups groups; /* Primary and supp SIDs */ /* token is needed if set(e)uid should be called. It can be set by a call to `set_impersonation_token()'. */ HANDLE token; BOOL impersonated; + /* CGF 2002-06-27. I removed the initializaton from this constructor + since this class is always allocated statically. That means that everything + is zero anyway so there is no need to initialize it to zero. Since the + token initialization is always handled during process startup as well, + I've removed the constructor entirely. Please reinstate this f this + situation ever changes. cygheap_user () : pname (NULL), plogsrv (NULL), pdomain (NULL), - psid (NULL), token (INVALID_HANDLE_VALUE) {} + homedrive (NULL), homepath (NULL), psid (NULL), + token (INVALID_HANDLE_VALUE) {} + */ + ~cygheap_user (); void set_name (const char *new_name); const char *name () const { return pname; } - void set_logsrv (const char *new_logsrv); - const char *logsrv () const { return plogsrv; } - - void set_domain (const char *new_domain); - const char *domain () const { return pdomain; } + const char *env_logsrv (const char *, size_t); + const char *env_homepath (const char *, size_t); + const char *env_homedrive (const char *, size_t); + const char *env_userprofile (const char *, size_t); + const char *env_domain (const char *, size_t); + const char *env_name (const char *, size_t); + const char *logsrv () + { + const char *p = env_logsrv ("LOGONSERVER=", sizeof ("LOGONSERVER=") - 1); + return (p == almost_null) ? NULL : p; + } + const char *winname () + { + const char *p = env_name ("USERNAME=", sizeof ("USERNAME=") - 1); + return (p == almost_null) ? NULL : p; + } + const char *domain () + { + const char *p = env_domain ("USERDOMAIN=", sizeof ("USERDOMAIN=") - 1); + return (p == almost_null) ? NULL : p; + } BOOL set_sid (PSID new_sid); + BOOL set_orig_sid (); PSID sid () const { return psid; } - - void operator =(cygheap_user &user) + PSID orig_sid () const { return orig_psid; } + const char *ontherange (homebodies what, struct passwd * = NULL); + bool issetuid () const { - set_name (user.name ()); - set_logsrv (user.logsrv ()); - set_domain (user.domain ()); - set_sid (user.sid ()); + return impersonated && token != INVALID_HANDLE_VALUE; } + const char *cygheap_user::test_uid (char *&, const char *, size_t) + __attribute__ ((regparm (3))); }; /* cwd cache stuff. */ @@ -140,7 +180,7 @@ struct cwdstuff char *posix; char *win32; DWORD hash; - muto *lock; + muto *cwd_lock; char *get (char *buf, int need_posix = 1, int with_chroot = 0, unsigned ulen = MAX_PATH); DWORD get_hash (); void init (); @@ -149,6 +189,15 @@ struct cwdstuff void set (const char *win32_cwd, const char *posix_cwd = NULL); }; +#ifdef DEBUGGING +struct cygheap_debug +{ + handle_list starth; + handle_list *endh; + handle_list freeh[500]; +}; +#endif + struct init_cygheap { _cmalloc_entry *chain; @@ -165,8 +214,12 @@ struct init_cygheap HANDLE shared_h; HANDLE console_h; HANDLE etc_changed_h; + char *cygwin_regname; cwdstuff cwd; dtable fdtab; +#ifdef DEBUGGING + cygheap_debug debug; +#endif bool etc_changed (); }; @@ -176,10 +229,92 @@ struct init_cygheap extern init_cygheap *cygheap; extern void *cygheap_max; +class cygheap_fdmanip +{ + protected: + int fd; + fhandler_base **fh; + bool locked; + public: + cygheap_fdmanip (): fh (NULL) {} + virtual ~cygheap_fdmanip () + { + if (locked) + ReleaseResourceLock (LOCK_FD_LIST, WRITE_LOCK | READ_LOCK, "cygheap_fdmanip"); + } + void release () + { + cygheap->fdtab.release (fd); + } + operator int &() {return fd;} + operator fhandler_base* &() {return *fh;} + void operator = (fhandler_base *fh) {*this->fh = fh;} + fhandler_base *operator -> () const {return *fh;} + bool isopen () const + { + if (*fh) + return true; + set_errno (EBADF); + return false; + } +}; + +class cygheap_fdnew : public cygheap_fdmanip +{ + public: + cygheap_fdnew (int seed_fd = -1, bool lockit = true) + { + if (lockit) + SetResourceLock (LOCK_FD_LIST, WRITE_LOCK | READ_LOCK, "cygheap_fdnew"); + if (seed_fd < 0) + fd = cygheap->fdtab.find_unused_handle (); + else + fd = cygheap->fdtab.find_unused_handle (seed_fd + 1); + if (fd >= 0) + { + locked = lockit; + fh = cygheap->fdtab + fd; + } + else + { + set_errno (EMFILE); + if (lockit) + ReleaseResourceLock (LOCK_FD_LIST, WRITE_LOCK | READ_LOCK, "cygheap_fdnew"); + locked = false; + } + } + void operator = (fhandler_base *fh) {*this->fh = fh;} +}; + +class cygheap_fdget : public cygheap_fdmanip +{ + public: + cygheap_fdget (int fd, bool lockit = false, bool do_set_errno = true) + { + if (lockit) + SetResourceLock (LOCK_FD_LIST, READ_LOCK, "cygheap_fdget"); + if (fd >= 0 && fd < (int) cygheap->fdtab.size + && *(fh = cygheap->fdtab + fd) != NULL) + { + this->fd = fd; + locked = lockit; + } + else + { + this->fd = -1; + if (do_set_errno) + set_errno (EBADF); + if (lockit) + ReleaseResourceLock (LOCK_FD_LIST, READ_LOCK, "cygheap_fdget"); + locked = false; + } + } +}; + class child_info; void *__stdcall cygheap_setup_for_child (child_info *ci, bool dup_later) __attribute__ ((regparm(2))); void __stdcall cygheap_setup_for_child_cleanup (void *, child_info *, bool) __attribute__ ((regparm(3))); -void __stdcall cygheap_fixup_in_child (child_info *, bool); +void __stdcall cygheap_fixup_in_child (bool); extern "C" { void __stdcall cfree (void *) __attribute__ ((regparm(1))); void *__stdcall cmalloc (cygheap_types, DWORD) __attribute__ ((regparm(2))); @@ -187,5 +322,7 @@ void *__stdcall crealloc (void *, DWORD) __attribute__ ((regparm(2))); void *__stdcall ccalloc (cygheap_types, DWORD, DWORD) __attribute__ ((regparm(3))); char *__stdcall cstrdup (const char *) __attribute__ ((regparm(1))); char *__stdcall cstrdup1 (const char *) __attribute__ ((regparm(1))); +void __stdcall cfree_and_set (char *&, char * = NULL) __attribute__ ((regparm(2))); void __stdcall cygheap_init (); +extern DWORD _cygheap_start; } |