source/lib/util_hnd.c

   1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-2000,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   8  *  Copyright (C) Elrond                            2000
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25
  26 #include "includes.h"
  27
  28
  29 extern int DEBUGLEVEL;
  30
  31
  32 struct policy
  33 {
  34         struct policy *next, *prev;
  35         int pnum;
  36         BOOL open;
  37         POLICY_HND pol_hnd;
  38         uint32 access_mask;
  39         vuser_key key;
  40
  41         char *name;
  42
  43         int type;
  44         void (*free_fn) (void *);
  45         void *dev;
  46 };
  47
  48 /****************************************************************************
  49   i hate this.  a global policy handle cache.  yuk.
  50 ****************************************************************************/
  51 struct policy_cache *get_global_hnd_cache(void)
  52 {
  53         static struct policy_cache *cache = NULL;
  54
  55         if (cache == NULL)
  56         {
  57                 cache = init_policy_cache(1024);
  58         }
  59         return cache;
  60 }
  61
  62 /****************************************************************************
  63   create a unique policy handle
  64 ****************************************************************************/
  65 static void create_pol_hnd(POLICY_HND *hnd)
  66 {
  67         static uint32 pol_hnd_low = 0;
  68         NTTIME ntt;
  69
  70         if (hnd == NULL)
  71                 return;
  72
  73         ZERO_STRUCTP(hnd);
  74
  75         pol_hnd_low++;
  76
  77         unix_to_nt_time(&ntt, time(NULL));
  78
  79         hnd->ptr = 0;
  80         hnd->uuid.time_low = ntt.low;
  81         hnd->uuid.time_mid = (ntt.high & 0xffff);
  82         hnd->uuid.time_hi_and_version = ((ntt.high >> 16) & 0xffff);
  83         SIVAL(hnd->uuid.remaining, 0, sys_getpid());
  84         SIVAL(hnd->uuid.remaining, 4, pol_hnd_low);
  85 }
  86
  87 /****************************************************************************
  88   initialise policy handle states...
  89 ****************************************************************************/
  90 struct policy_cache *init_policy_cache(int num_pol_hnds)
  91 {
  92         struct policy_cache *cache = malloc(sizeof(struct policy_cache));
  93         if (cache != NULL)
  94         {
  95                 cache->bmap = NULL;
  96                 cache->Policy = NULL;
  97         }
  98         return cache;
  99 }
 100
 101 /****************************************************************************
 102  free policy handle states...
 103 ****************************************************************************/
 104 void free_policy_cache(struct policy_cache *cache)
 105 {
 106         free(cache);
 107 }
 108
 109 /****************************************************************************
 110   find policy by handle
 111 ****************************************************************************/
 112 static struct policy *find_policy(struct policy_cache *cache,
 113                                   const POLICY_HND *hnd)
 114 {
 115         struct policy *p;
 116
 117         if (cache == NULL)
 118         {
 119                 DEBUG(0, ("find_policy: NULL cache\n"));
 120                 SMB_ASSERT(False);
 121         }
 122
 123         if (hnd == NULL)
 124         {
 125                 DEBUG(0, ("find_policy: NULL handle\n"));
 126                 SMB_ASSERT(False);
 127                 return NULL;
 128         }
 129
 130         for (p = cache->Policy; p; p = p->next)
 131         {
 132                 DEBUG(10, ("Compare policy hnd[%x] ", p->pnum));
 133                 dump_data(10, (const char *)hnd, sizeof(*hnd));
 134                 if (memcmp(&p->pol_hnd, hnd, sizeof(*hnd)) == 0)
 135                 {
 136                         DEBUG(4, ("Found policy hnd[%x] ", p->pnum));
 137                         dump_data(4, (const char *)hnd, sizeof(*hnd));
 138                         return p;
 139                 }
 140         }
 141
 142         DEBUG(4, ("cache->Policy not found: "));
 143         dump_data(4, (const char *)hnd, sizeof(*hnd));
 144
 145         return NULL;
 146 }
 147
 148 /****************************************************************************
 149   set the name of a POLICY_HND
 150 ****************************************************************************/
 151 BOOL policy_hnd_set_name(struct policy_cache *cache,
 152                          POLICY_HND *hnd, const char *name)
 153 {
 154         struct policy *p = find_policy(cache, hnd);
 155         if (!p)
 156         {
 157                 DEBUG(3, ("Error setting name for policy\n"));
 158                 return False;
 159         }
 160         safe_free(p->name);
 161         if (name)
 162         {
 163                 DEBUG(4, ("policy(pnum=%x): setting name to %s\n",
 164                           p->pnum, name));
 165                 p->name = strdup(name);
 166                 return (p->name != NULL);
 167         }
 168         else
 169         {
 170                 DEBUG(4, ("policy(pnum=%x): setting name to %s\n",
 171                           p->pnum, "NULL"));
 172                 p->name = NULL;
 173                 return True;
 174         }
 175 }
 176
 177 /****************************************************************************
 178   get the name of a POLICY_HND
 179 ****************************************************************************/
 180 static const char *pol_get_name(const struct policy *p)
 181 {
 182         if (!p)
 183         {
 184                 return "(NULL)";
 185         }
 186         if (p->name)
 187         {
 188                 return p->name;
 189         }
 190         return "";
 191 }
 192
 193 /****************************************************************************
 194   get the name of a POLICY_HND, public interface
 195 ****************************************************************************/
 196 const char *policy_hnd_get_name(struct policy_cache *cache,
 197                                 const POLICY_HND *hnd)
 198 {
 199         const char *name;
 200         struct policy *p = find_policy(cache, hnd);
 201
 202         if (!p)
 203         {
 204                 DEBUG(3, ("Error getting name for policy\n"));
 205                 return "(invalid POLICY_HND)";
 206         }
 207         name = pol_get_name(p);
 208         DEBUG(4, ("policy(pnum=%x %s): getting name\n", p->pnum, name));
 209         return name;
 210 }
 211
 212
 213 /****************************************************************************
 214   find first available policy slot.  copies a policy handle for you.
 215 ****************************************************************************/
 216 BOOL dup_policy_hnd(struct policy_cache *cache,
 217                     POLICY_HND *hnd, const POLICY_HND *from)
 218 {
 219         struct policy *p = find_policy(cache, from);
 220
 221         if (!p || !p->open)
 222         {
 223                 return False;
 224         }
 225         DEBUG(5, ("policy(pnum=%x %s): Duplicating policy\n",
 226                   p->pnum, pol_get_name(p)));
 227         return register_policy_hnd(cache, &p->key, hnd, p->access_mask);
 228 }
 229
 230 /****************************************************************************
 231   find first available policy slot.  creates a policy handle for you.
 232 ****************************************************************************/
 233 BOOL register_policy_hnd(struct policy_cache *cache,
 234                          const vuser_key * key,
 235                          POLICY_HND *hnd, uint32 access_mask)
 236 {
 237         struct policy *p;
 238         static int count = 1;
 239
 240         p = (struct policy *)malloc(sizeof(*p));
 241         if (!p)
 242         {
 243                 DEBUG(0, ("ERROR: out of memory!\n"));
 244                 return False;
 245         }
 246
 247         ZERO_STRUCTP(p);
 248
 249         p->open = True;
 250         p->pnum = count++;
 251         p->access_mask = access_mask;
 252         if (key != NULL)
 253         {
 254                 p->key = *key;
 255         }
 256         else
 257         {
 258                 p->key.vuid = UID_FIELD_INVALID;
 259                 p->key.pid = sys_getpid();
 260         }
 261
 262
 263         DLIST_ADD(cache->Policy, p);
 264
 265         DEBUG(4, ("Opened policy hnd[%x] ", p->pnum));
 266         DEBUG(10, ("register_policy_hnd: vuser [%d, %x]\n",
 267                    p->key.pid, p->key.vuid));
 268
 269         memcpy(&p->pol_hnd, hnd, sizeof(*hnd));
 270         dump_data(4, (char *)hnd, sizeof(*hnd));
 271
 272         return True;
 273 }
 274
 275 /****************************************************************************
 276   find first available policy slot.  creates a policy handle for you.
 277 ****************************************************************************/
 278 BOOL open_policy_hnd(struct policy_cache *cache,
 279                      const vuser_key * key,
 280                      POLICY_HND *hnd, uint32 access_mask)
 281 {
 282         create_pol_hnd(hnd);
 283         return register_policy_hnd(cache, key, hnd, access_mask);
 284 }
 285
 286 /****************************************************************************
 287   find first available policy slot.  creates a policy handle for you.
 288 ****************************************************************************/
 289 BOOL open_policy_hnd_link(struct policy_cache *cache,
 290                           const POLICY_HND *parent_hnd,
 291                           POLICY_HND *hnd, uint32 access_mask)
 292 {
 293         const vuser_key *key = get_policy_vuser_key(cache, parent_hnd);
 294         if (key == NULL)
 295         {
 296                 return False;
 297         }
 298         create_pol_hnd(hnd);
 299         return register_policy_hnd(cache, key, hnd, access_mask);
 300 }
 301
 302 /****************************************************************************
 303   find policy index by handle
 304 ****************************************************************************/
 305 int find_policy_by_hnd(struct policy_cache *cache, const POLICY_HND *hnd)
 306 {
 307         struct policy *p = find_policy(cache, hnd);
 308
 309         return p ? p->pnum : -1;
 310 }
 311
 312
 313 /****************************************************************************
 314   set pol state.
 315 ****************************************************************************/
 316 BOOL set_policy_state(struct policy_cache *cache, POLICY_HND *hnd,
 317                       void (*fn) (void *), void *dev)
 318 {
 319         struct policy *p = find_policy(cache, hnd);
 320
 321         if (p && p->open)
 322         {
 323                 DEBUG(5, ("policy(pnum=%x %s): Setting policy state\n",
 324                           p->pnum, pol_get_name(p)));
 325
 326                 p->dev = dev;
 327                 p->free_fn = fn;
 328                 return True;
 329         }
 330
 331         DEBUG(3, ("Error setting policy state\n"));
 332
 333         return False;
 334 }
 335
 336 /****************************************************************************
 337   get pol state.
 338 ****************************************************************************/
 339 void *get_policy_state_info(struct policy_cache *cache, const POLICY_HND *hnd)
 340 {
 341         struct policy *p = find_policy(cache, hnd);
 342
 343         if (p != NULL && p->open)
 344         {
 345                 DEBUG(5, ("policy(pnum=%x %s): Getting policy state\n",
 346                           p->pnum, pol_get_name(p)));
 347                 return p->dev;
 348         }
 349
 350         DEBUG(3, ("Error getting policy state\n"));
 351         return NULL;
 352 }
 353
 354 /****************************************************************************
 355   set the type of the state of a POLICY_HND
 356 ****************************************************************************/
 357 BOOL policy_hnd_set_state_type(struct policy_cache *cache,
 358                                POLICY_HND *hnd, int type)
 359 {
 360         struct policy *p = find_policy(cache, hnd);
 361
 362         if (!p || !p->open)
 363         {
 364                 DEBUG(3, ("Error setting type for policy state\n"));
 365                 return False;
 366         }
 367         DEBUG(4, ("policy(pnum=%x %s): setting type to %d\n",
 368                   p->pnum, pol_get_name(p), type));
 369         p->type = type;
 370         return True;
 371 }
 372
 373 /****************************************************************************
 374   get the type of the state of a POLICY_HND
 375 ****************************************************************************/
 376 int policy_hnd_get_state_type(struct policy_cache *cache,
 377                               const POLICY_HND *hnd)
 378 {
 379         struct policy *p = find_policy(cache, hnd);
 380
 381         if (!p || !p->open)
 382         {
 383                 DEBUG(3, ("Error getting type for policy state\n"));
 384                 return -1;
 385         }
 386         DEBUG(4, ("policy(pnum=%x %s): getting type %d\n",
 387                   p->pnum, pol_get_name(p), p->type));
 388
 389         return p->type;
 390 }
 391
 392 /****************************************************************************
 393   check the type of the state of a POLICY_HND
 394 ****************************************************************************/
 395 BOOL policy_hnd_check_state_type(struct policy_cache *cache,
 396                                  const POLICY_HND *hnd, int type)
 397 {
 398         struct policy *p = find_policy(cache, hnd);
 399         BOOL ret;
 400
 401         if (!p || !p->open)
 402         {
 403                 DEBUG(3, ("Error checking type for policy state\n"));
 404                 return False;
 405         }
 406
 407         ret = (p->type == type);
 408
 409         if (ret)
 410         {
 411                 DEBUG(4, ("policy(pnum=%x %s): checking if type %d is %d\n",
 412                           p->pnum, pol_get_name(p), p->type, type));
 413         }
 414         else
 415         {
 416                 DEBUG(3, ("policy(pnum=%x %s): type %d is not %d\n",
 417                           p->pnum, pol_get_name(p), p->type, type));
 418         }
 419
 420         return ret;
 421 }
 422
 423 /****************************************************************************
 424   close an lsa policy
 425 ****************************************************************************/
 426 BOOL close_policy_hnd(struct policy_cache *cache, POLICY_HND *hnd)
 427 {
 428         struct policy *p = find_policy(cache, hnd);
 429
 430         if (!p)
 431         {
 432                 DEBUG(3, ("Error closing policy\n"));
 433                 return False;
 434         }
 435
 436         DEBUG(5, ("policy(pnum=%x %s): Closing\n", p->pnum, pol_get_name(p)));
 437
 438         DLIST_REMOVE(cache->Policy, p);
 439
 440         ZERO_STRUCTP(hnd);
 441
 442         if (p->free_fn != NULL)
 443         {
 444                 p->free_fn(p->dev);
 445         }
 446         else
 447         {
 448                 safe_free(p->dev);
 449         }
 450
 451         safe_free(p->name);
 452         free(p);
 453
 454         DEBUG(10, ("policy closed\n"));
 455
 456         return True;
 457 }
 458
 459 /****************************************************************************
 460   get pol state.
 461 ****************************************************************************/
 462 BOOL policy_link_key(struct policy_cache *cache, const POLICY_HND *hnd,
 463                      POLICY_HND *to)
 464 {
 465         struct policy *p = find_policy(cache, hnd);
 466         struct policy *pto = find_policy(cache, to);
 467
 468         if (p != NULL && p->open && pto != NULL && pto->open)
 469         {
 470                 DEBUG(3, ("Linking policy key pnum=%x pid=%d vuid=%x\n",
 471                           p->key.pid, p->key.vuid, p->pnum));
 472                 pto->key = p->key;
 473                 return True;
 474         }
 475
 476         DEBUG(3, ("Error getting policy link states\n"));
 477         return False;
 478 }
 479
 480 /****************************************************************************
 481   get pol state.
 482 ****************************************************************************/
 483 const vuser_key *get_policy_vuser_key(struct policy_cache *cache,
 484                                       const POLICY_HND *hnd)
 485 {
 486         struct policy *p = find_policy(cache, hnd);
 487
 488         if (p != NULL && p->open)
 489         {
 490                 DEBUG(5, ("Getting policy vuser_key pnum=%x pid=%d vuid=%x\n",
 491                           p->pnum, p->key.pid, p->key.vuid));
 492                 return &p->key;
 493         }
 494
 495         DEBUG(3, ("Error getting policy state\n"));
 496         return NULL;
 497 }
 498
 499 /****************************************************************************
 500   get user session key.
 501 ****************************************************************************/
 502 BOOL pol_get_usr_sesskey(struct policy_cache *cache, const POLICY_HND *hnd,
 503                          uchar usr_sess_key[16])
 504 {
 505         const vuser_key *key = get_policy_vuser_key(cache, hnd);
 506         user_struct *vuser;
 507
 508         if (key == NULL || key->vuid == UID_FIELD_INVALID)
 509         {
 510                 memset(usr_sess_key, 0, 16);
 511                 return True;
 512         }
 513         vuser = get_valid_user_struct(key);
 514         if (vuser == NULL)
 515         {
 516                 DEBUG(10, ("pol_get_usr_sesskey: no vuser struct\n"));
 517                 return False;
 518         }
 519         memcpy(usr_sess_key, vuser->usr.user_sess_key, 16);
 520         vuid_free_user_struct(vuser);
 521         return True;
 522 }