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, 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(3, ("Duplicating policy state pnum=%x\n", p->pnum));
 226         return register_policy_hnd(cache, &p->key, hnd, p->access_mask);
 227 }
 228
 229 /****************************************************************************
 230   find first available policy slot.  creates a policy handle for you.
 231 ****************************************************************************/
 232 BOOL register_policy_hnd(struct policy_cache *cache,
 233                          const vuser_key * key,
 234                          POLICY_HND *hnd, uint32 access_mask)
 235 {
 236         struct policy *p;
 237         static int count = 1;
 238
 239         p = (struct policy *)malloc(sizeof(*p));
 240         if (!p)
 241         {
 242                 DEBUG(0, ("ERROR: out of memory!\n"));
 243                 return False;
 244         }
 245
 246         ZERO_STRUCTP(p);
 247
 248         p->open = True;
 249         p->pnum = count++;
 250         p->access_mask = access_mask;
 251         if (key != NULL)
 252         {
 253                 p->key = *key;
 254         }
 255         else
 256         {
 257                 p->key.vuid = UID_FIELD_INVALID;
 258                 p->key.pid = getpid();
 259         }
 260
 261
 262         DLIST_ADD(cache->Policy, p);
 263
 264         DEBUG(4, ("Opened policy hnd[%x] ", p->pnum));
 265         DEBUG(10, ("register_policy_hnd: vuser [%d, %x]\n",
 266                    p->key.pid, p->key.vuid));
 267
 268         memcpy(&p->pol_hnd, hnd, sizeof(*hnd));
 269         dump_data(4, (char *)hnd, sizeof(*hnd));
 270
 271         return True;
 272 }
 273
 274 /****************************************************************************
 275   find first available policy slot.  creates a policy handle for you.
 276 ****************************************************************************/
 277 BOOL open_policy_hnd(struct policy_cache *cache,
 278                      const vuser_key * key,
 279                      POLICY_HND *hnd, uint32 access_mask)
 280 {
 281         create_pol_hnd(hnd);
 282         return register_policy_hnd(cache, key, hnd, access_mask);
 283 }
 284
 285 /****************************************************************************
 286   find first available policy slot.  creates a policy handle for you.
 287 ****************************************************************************/
 288 BOOL open_policy_hnd_link(struct policy_cache *cache,
 289                           const POLICY_HND *parent_hnd,
 290                           POLICY_HND *hnd, uint32 access_mask)
 291 {
 292         const vuser_key *key = get_policy_vuser_key(cache, parent_hnd);
 293         if (key == NULL)
 294         {
 295                 return False;
 296         }
 297         create_pol_hnd(hnd);
 298         return register_policy_hnd(cache, key, hnd, access_mask);
 299 }
 300
 301 /****************************************************************************
 302   find policy index by handle
 303 ****************************************************************************/
 304 int find_policy_by_hnd(struct policy_cache *cache, const POLICY_HND *hnd)
 305 {
 306         struct policy *p = find_policy(cache, hnd);
 307
 308         return p ? p->pnum : -1;
 309 }
 310
 311
 312 /****************************************************************************
 313   set pol state.
 314 ****************************************************************************/
 315 BOOL set_policy_state(struct policy_cache *cache, POLICY_HND *hnd,
 316                       void (*fn) (void *), void *dev)
 317 {
 318         struct policy *p = find_policy(cache, hnd);
 319
 320         if (p && p->open)
 321         {
 322                 DEBUG(3, ("policy(pnum=%x %s): Setting policy state\n",
 323                           p->pnum, pol_get_name(p)));
 324
 325                 p->dev = dev;
 326                 p->free_fn = fn;
 327                 return True;
 328         }
 329
 330         DEBUG(3, ("Error setting policy state\n"));
 331
 332         return False;
 333 }
 334
 335 /****************************************************************************
 336   get pol state.
 337 ****************************************************************************/
 338 void *get_policy_state_info(struct policy_cache *cache, const POLICY_HND *hnd)
 339 {
 340         struct policy *p = find_policy(cache, hnd);
 341
 342         if (p != NULL && p->open)
 343         {
 344                 DEBUG(3, ("policy(pnum=%x %s): Getting policy state\n",
 345                           p->pnum, pol_get_name(p)));
 346                 return p->dev;
 347         }
 348
 349         DEBUG(3, ("Error getting policy state\n"));
 350         return NULL;
 351 }
 352
 353 /****************************************************************************
 354   set the type of the state of a POLICY_HND
 355 ****************************************************************************/
 356 BOOL policy_hnd_set_state_type(struct policy_cache *cache,
 357                                POLICY_HND *hnd, int type)
 358 {
 359         struct policy *p = find_policy(cache, hnd);
 360
 361         if (!p || !p->open)
 362         {
 363                 DEBUG(3, ("Error setting type for policy state\n"));
 364                 return False;
 365         }
 366         DEBUG(4, ("policy(pnum=%x %s): setting type to %d\n",
 367                   p->pnum, pol_get_name(p), type));
 368         p->type = type;
 369         return True;
 370 }
 371
 372 /****************************************************************************
 373   get the type of the state of a POLICY_HND
 374 ****************************************************************************/
 375 int policy_hnd_get_state_type(struct policy_cache *cache,
 376                               const POLICY_HND *hnd)
 377 {
 378         struct policy *p = find_policy(cache, hnd);
 379
 380         if (!p || !p->open)
 381         {
 382                 DEBUG(3, ("Error getting type for policy state\n"));
 383                 return -1;
 384         }
 385         DEBUG(4, ("policy(pnum=%x %s): getting type %d\n",
 386                   p->pnum, pol_get_name(p), p->type));
 387
 388         return p->type;
 389 }
 390
 391 /****************************************************************************
 392   check the type of the state of a POLICY_HND
 393 ****************************************************************************/
 394 BOOL policy_hnd_check_state_type(struct policy_cache *cache,
 395                                  const POLICY_HND *hnd, int type)
 396 {
 397         struct policy *p = find_policy(cache, hnd);
 398         BOOL ret;
 399
 400         if (!p || !p->open)
 401         {
 402                 DEBUG(3, ("Error checking type for policy state\n"));
 403                 return False;
 404         }
 405
 406         ret = (p->type == type);
 407
 408         if (ret)
 409         {
 410                 DEBUG(4, ("policy(pnum=%x %s): checking if type %d is %d\n",
 411                           p->pnum, pol_get_name(p), p->type, type));
 412         }
 413         else
 414         {
 415                 DEBUG(3, ("policy(pnum=%x %s): type %d is not %d\n",
 416                           p->pnum, pol_get_name(p), p->type, type));
 417         }
 418
 419         return ret;
 420 }
 421
 422 /****************************************************************************
 423   close an lsa policy
 424 ****************************************************************************/
 425 BOOL close_policy_hnd(struct policy_cache *cache, POLICY_HND *hnd)
 426 {
 427         struct policy *p = find_policy(cache, hnd);
 428
 429         if (!p)
 430         {
 431                 DEBUG(3, ("Error closing policy\n"));
 432                 return False;
 433         }
 434
 435         DEBUG(3, ("policy(pnum=%x %s): Closing\n", p->pnum, pol_get_name(p)));
 436
 437         DLIST_REMOVE(cache->Policy, p);
 438
 439         ZERO_STRUCTP(hnd);
 440
 441         if (p->free_fn != NULL)
 442         {
 443                 p->free_fn(p->dev);
 444         }
 445         else
 446         {
 447                 safe_free(p->dev);
 448         }
 449
 450         safe_free(p->name);
 451         free(p);
 452
 453         DEBUG(10, ("policy closed\n"));
 454
 455         return True;
 456 }
 457
 458 /****************************************************************************
 459   get pol state.
 460 ****************************************************************************/
 461 BOOL policy_link_key(struct policy_cache *cache, const POLICY_HND *hnd,
 462                      POLICY_HND *to)
 463 {
 464         struct policy *p = find_policy(cache, hnd);
 465         struct policy *pto = find_policy(cache, to);
 466
 467         if (p != NULL && p->open && pto != NULL && pto->open)
 468         {
 469                 DEBUG(3, ("Linking policy key pnum=%x pid=%d vuid=%x\n",
 470                           p->key.pid, p->key.vuid, p->pnum));
 471                 pto->key = p->key;
 472                 return True;
 473         }
 474
 475         DEBUG(3, ("Error getting policy link states\n"));
 476         return False;
 477 }
 478
 479 /****************************************************************************
 480   get pol state.
 481 ****************************************************************************/
 482 const vuser_key *get_policy_vuser_key(struct policy_cache *cache,
 483                                       const POLICY_HND *hnd)
 484 {
 485         struct policy *p = find_policy(cache, hnd);
 486
 487         if (p != NULL && p->open)
 488         {
 489                 DEBUG(3, ("Getting policy vuser_key pnum=%x pid=%d vuid=%x\n",
 490                           p->pnum, p->key.pid, p->key.vuid));
 491                 return &p->key;
 492         }
 493
 494         DEBUG(3, ("Error getting policy state\n"));
 495         return NULL;
 496 }
 497
 498 /****************************************************************************
 499   get user session key.
 500 ****************************************************************************/
 501 BOOL pol_get_usr_sesskey(struct policy_cache *cache, const POLICY_HND *hnd,
 502                          uchar usr_sess_key[16])
 503 {
 504         const vuser_key *key = get_policy_vuser_key(cache, hnd);
 505         user_struct *vuser;
 506
 507         if (key == NULL || key->vuid == UID_FIELD_INVALID)
 508         {
 509                 memset(usr_sess_key, 0, 16);
 510                 return True;
 511         }
 512         vuser = get_valid_user_struct(key);
 513         if (vuser == NULL)
 514         {
 515                 DEBUG(10, ("pol_get_usr_sesskey: no vuser struct\n"));
 516                 return False;
 517         }
 518         memcpy(usr_sess_key, vuser->usr.user_sess_key, 16);
 519         vuid_free_user_struct(vuser);
 520         return True;
 521 }