winsup/cygwin/cygheap.h

   1 /* cygheap.h: Cygwin heap manager.
   2
   3    Copyright 2000, 2001, 2002 Red Hat, Inc.
   4
   5 This file is part of Cygwin.
   6
   7 This software is a copyrighted work licensed under the terms of the
   8 Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
   9 details. */
  10
  11 #undef cfree
  12
  13 enum cygheap_types
  14 {
  15   HEAP_FHANDLER,
  16   HEAP_STR,
  17   HEAP_ARGV,
  18   HEAP_BUF,
  19   HEAP_MOUNT,
  20   HEAP_1_START,
  21   HEAP_1_STR,
  22   HEAP_1_ARGV,
  23   HEAP_1_BUF,
  24   HEAP_1_EXEC,
  25   HEAP_1_MAX = 100
  26 };
  27
  28 #define incygheap(s) (cygheap && ((char *) (s) >= (char *) cygheap) && ((char *) (s) <= ((char *) cygheap_max)))
  29
  30 struct _cmalloc_entry
  31 {
  32   union
  33   {
  34     DWORD b;
  35     char *ptr;
  36   };
  37   struct _cmalloc_entry *prev;
  38   char data[0];
  39 };
  40
  41 struct cygheap_root_mount_info
  42 {
  43   char posix_path[MAX_PATH];
  44   unsigned posix_pathlen;
  45   char native_path[MAX_PATH];
  46   unsigned native_pathlen;
  47 };
  48
  49 /* CGF: FIXME This doesn't belong here */
  50
  51 class cygheap_root
  52 {
  53   /* Root directory information.
  54      This is used after a chroot is called. */
  55   struct cygheap_root_mount_info *m;
  56
  57 public:
  58   bool posix_ok (const char *path)
  59   {
  60     if (!m)
  61       return 1;
  62     return path_prefix_p (m->posix_path, path, m->posix_pathlen);
  63   }
  64   bool ischroot_native (const char *path)
  65   {
  66     if (!m)
  67       return 1;
  68     return strncasematch (m->native_path, path, m->native_pathlen)
  69             && (path[m->native_pathlen] == '\\' || !path[m->native_pathlen]);
  70   }
  71   const char *unchroot (const char *path)
  72   {
  73     if (!m)
  74       return path;
  75     const char *p = path + m->posix_pathlen;
  76     if (!*p)
  77       p = "/";
  78     return p;
  79   }
  80   bool exists () {return !!m;}
  81   void set (const char *posix, const char *native);
  82   size_t posix_length () const { return m->posix_pathlen; }
  83   const char *posix_path () const { return m->posix_path; }
  84   size_t native_length () const { return m->native_pathlen; }
  85   const char *native_path () const { return m->native_path; }
  86 };
  87
  88 enum homebodies
  89 {
  90   CH_HOMEDRIVE,
  91   CH_HOMEPATH,
  92   CH_HOME
  93 };
  94
  95 struct passwd;
  96 class cygheap_user
  97 {
  98   /* Extendend user information.
  99      The information is derived from the internal_getlogin call
 100      when on a NT system. */
 101   char  *pname;         /* user's name */
 102   char  *plogsrv;       /* Logon server, may be FQDN */
 103   char  *pdomain;       /* Logon domain of the user */
 104   char  *homedrive;     /* User's home drive */
 105   char  *homepath;      /* User's home path */
 106   PSID   psid;          /* buffer for user's SID */
 107   PSID   orig_psid;     /* Remains intact even after impersonation */
 108 public:
 109   __uid32_t orig_uid;      /* Remains intact even after impersonation */
 110   __gid32_t orig_gid;      /* Ditto */
 111   __uid32_t real_uid;      /* Remains intact on seteuid, replaced by setuid */
 112   __gid32_t real_gid;      /* Ditto */
 113
 114   /* token is needed if set(e)uid should be called. It can be set by a call
 115      to `set_impersonation_token()'. */
 116   HANDLE token;
 117   BOOL   impersonated;
 118
 119   cygheap_user () : pname (NULL), plogsrv (NULL), pdomain (NULL),
 120                     homedrive (NULL), homepath (NULL),
 121                     psid (NULL), token (INVALID_HANDLE_VALUE) {}
 122   ~cygheap_user ();
 123
 124   void set_name (const char *new_name);
 125   const char *name () const { return pname; }
 126
 127   const char *env_logsrv ();
 128   const char *env_homepath ();
 129   const char *env_homedrive ();
 130   const char *env_userprofile ();
 131   const char *env_domain ();
 132   const char *env_name ();
 133
 134   BOOL set_sid (PSID new_sid);
 135   BOOL set_orig_sid ();
 136   PSID sid () const { return psid; }
 137   PSID orig_sid () const { return orig_psid; }
 138   const char *ontherange (homebodies what, struct passwd * = NULL);
 139 };
 140
 141 /* cwd cache stuff.  */
 142
 143 class muto;
 144
 145 struct cwdstuff
 146 {
 147   char *posix;
 148   char *win32;
 149   DWORD hash;
 150   muto *cwd_lock;
 151   char *get (char *buf, int need_posix = 1, int with_chroot = 0, unsigned ulen = MAX_PATH);
 152   DWORD get_hash ();
 153   void init ();
 154   void fixup_after_exec (char *win32, char *posix, DWORD hash);
 155   bool get_initial ();
 156   void set (const char *win32_cwd, const char *posix_cwd = NULL);
 157 };
 158
 159 struct init_cygheap
 160 {
 161   _cmalloc_entry *chain;
 162   char *buckets[32];
 163   struct /* User heap stuff. */
 164     {
 165       void *heapbase;
 166       void *heapptr;
 167       void *heaptop;
 168     };
 169   cygheap_root root;
 170   cygheap_user user;
 171   mode_t umask;
 172   HANDLE shared_h;
 173   HANDLE console_h;
 174   HANDLE etc_changed_h;
 175   char *cygwin_regname;
 176   cwdstuff cwd;
 177   dtable fdtab;
 178
 179   bool etc_changed ();
 180 };
 181
 182 #define CYGHEAPSIZE (sizeof (init_cygheap) + (4000 * sizeof (fhandler_union)) + (2 * 65536))
 183
 184 extern init_cygheap *cygheap;
 185 extern void *cygheap_max;
 186
 187 class cygheap_fdmanip
 188 {
 189  protected:
 190   int fd;
 191   fhandler_base **fh;
 192   bool locked;
 193  public:
 194   cygheap_fdmanip (): fh (NULL) {}
 195   virtual ~cygheap_fdmanip ()
 196   {
 197     if (locked)
 198       ReleaseResourceLock (LOCK_FD_LIST, WRITE_LOCK | READ_LOCK, "cygheap_fdmanip");
 199   }
 200   void release ()
 201   {
 202     cygheap->fdtab.release (fd);
 203   }
 204   operator int &() {return fd;}
 205   operator fhandler_base* &() {return *fh;}
 206   void operator = (fhandler_base *fh) {*this->fh = fh;}
 207   fhandler_base *operator -> () const {return *fh;}
 208   bool isopen () const
 209   {
 210     if (*fh)
 211       return true;
 212     set_errno (EBADF);
 213     return false;
 214   }
 215 };
 216
 217 class cygheap_fdnew : public cygheap_fdmanip
 218 {
 219  public:
 220   cygheap_fdnew (int seed_fd = -1, bool lockit = true)
 221   {
 222     if (lockit)
 223       SetResourceLock (LOCK_FD_LIST, WRITE_LOCK | READ_LOCK, "cygheap_fdnew");
 224     if (seed_fd < 0)
 225       fd = cygheap->fdtab.find_unused_handle ();
 226     else
 227       fd = cygheap->fdtab.find_unused_handle (seed_fd + 1);
 228     if (fd >= 0)
 229       {
 230         locked = lockit;
 231         fh = cygheap->fdtab + fd;
 232       }
 233     else
 234       {
 235         set_errno (EMFILE);
 236         if (lockit)
 237           ReleaseResourceLock (LOCK_FD_LIST, WRITE_LOCK | READ_LOCK, "cygheap_fdnew");
 238         locked = false;
 239       }
 240   }
 241   void operator = (fhandler_base *fh) {*this->fh = fh;}
 242 };
 243
 244 class cygheap_fdget : public cygheap_fdmanip
 245 {
 246  public:
 247   cygheap_fdget (int fd, bool lockit = false, bool do_set_errno = true)
 248   {
 249     if (lockit)
 250       SetResourceLock (LOCK_FD_LIST, READ_LOCK, "cygheap_fdget");
 251     if (fd >= 0 && fd < (int) cygheap->fdtab.size
 252         && *(fh = cygheap->fdtab + fd) != NULL)
 253       {
 254         this->fd = fd;
 255         locked = lockit;
 256       }
 257     else
 258       {
 259         this->fd = -1;
 260         if (do_set_errno)
 261           set_errno (EBADF);
 262         if (lockit)
 263           ReleaseResourceLock (LOCK_FD_LIST, READ_LOCK, "cygheap_fdget");
 264         locked = false;
 265       }
 266   }
 267 };
 268
 269 class child_info;
 270 void *__stdcall cygheap_setup_for_child (child_info *ci, bool dup_later) __attribute__ ((regparm(2)));
 271 void __stdcall cygheap_setup_for_child_cleanup (void *, child_info *, bool) __attribute__ ((regparm(3)));
 272 void __stdcall cygheap_fixup_in_child (child_info *, bool);
 273 extern "C" {
 274 void __stdcall cfree (void *) __attribute__ ((regparm(1)));
 275 void *__stdcall cmalloc (cygheap_types, DWORD) __attribute__ ((regparm(2)));
 276 void *__stdcall crealloc (void *, DWORD) __attribute__ ((regparm(2)));
 277 void *__stdcall ccalloc (cygheap_types, DWORD, DWORD) __attribute__ ((regparm(3)));
 278 char *__stdcall cstrdup (const char *) __attribute__ ((regparm(1)));
 279 char *__stdcall cstrdup1 (const char *) __attribute__ ((regparm(1)));
 280 void __stdcall cygheap_init ();
 281 }