source/rpc_client/ncacn_np_use.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    SMB client generic functions
   5    Copyright (C) Andrew Tridgell              1994-2000
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-2000
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #define NO_SYSLOG
  24
  25 #include "includes.h"
  26 #include "rpc_parse.h"
  27 #include "rpc_client.h"
  28 #include "trans2.h"
  29
  30 extern int DEBUGLEVEL;
  31 extern pstring global_myname;
  32
  33 struct ncacn_np_use
  34 {
  35         struct ncacn_np *cli;
  36         uint32 num_users;
  37 };
  38
  39 static struct ncacn_np_use **msrpcs = NULL;
  40 static uint32 num_msrpcs = 0;
  41
  42 /****************************************************************************
  43 terminate client connection
  44 ****************************************************************************/
  45 static void ncacn_np_shutdown(struct ncacn_np *cli)
  46 {
  47         if (cli != NULL)
  48         {
  49                 if (cli->smb != NULL)
  50                 {
  51                         if (cli->smb->initialised)
  52                         {
  53                                 cli_nt_session_close(cli->smb, cli->fnum);
  54                         }
  55                         cli_net_use_del(cli->smb->desthost,
  56                                         &cli->smb->usr, False, False);
  57                 }
  58         }
  59 }
  60
  61 static BOOL ncacn_np_establish_connection(struct ncacn_np *cli,
  62                                    const char *srv_name,
  63                                    const struct ntuser_creds *ntc,
  64                                    const char *pipe_name,
  65                                    BOOL reuse)
  66 {
  67         BOOL new_smb_conn;
  68         cli->smb = cli_net_use_add(srv_name, ntc,
  69                                    True, &new_smb_conn);
  70         if (cli->smb == NULL)
  71         {
  72                 return False;
  73         }
  74         if (!cli_nt_session_open(cli->smb, pipe_name, &cli->fnum))
  75         {
  76                 cli_net_use_del(srv_name, ntc, False, NULL);
  77                 return False;
  78         }
  79         fstrcpy(cli->pipe_name, pipe_name);
  80         dump_data_pw("sess key:", cli->smb->nt.usr_sess_key, 16);
  81         return True;
  82 }
  83
  84 #if 0
  85
  86 /* Useful for debugging rpc caching */
  87
  88 static void dump_msrpcs(void)
  89 {
  90         int i;
  91
  92         for (i = 0; i < num_msrpcs; i++) {
  93                 if (msrpcs[i]) {
  94                         DEBUG(3, ("[%d]: %s %s num_users=%d np_use=0x%08x "
  95                                   " np=0x%08x smb=0x%08x\n",
  96                                   i, msrpcs[i]->cli->smb->desthost,
  97                                   msrpcs[i]->cli->pipe_name,
  98                                   msrpcs[i]->num_users,
  99                                   msrpcs[i],
 100                                   msrpcs[i]->cli,
 101                                   msrpcs[i]->cli->smb));
 102                 } else {
 103                         DEBUG(3, ("[%d]: NULL\n", i));
 104                 }
 105         }
 106 }
 107
 108 #endif
 109
 110 /****************************************************************************
 111 terminate client connection
 112 ****************************************************************************/
 113 static void ncacn_np_use_free(struct ncacn_np_use *cli)
 114 {
 115         if (cli->cli != NULL)
 116         {
 117                 int i;
 118
 119                 /* Check that another connection doesn't have this same smb
 120                    open. */
 121
 122                 for (i = 0; i < num_msrpcs; i++)
 123                 {
 124                         if (msrpcs[i] && msrpcs[i] != cli &&
 125                             msrpcs[i]->cli &&
 126                             msrpcs[i]->cli->smb == cli->cli->smb) {
 127                                 goto no_shutdown;
 128                         }
 129                 }
 130
 131                 if (cli->cli->initialised)
 132                 {
 133                         ncacn_np_shutdown(cli->cli);
 134                 }
 135         no_shutdown:
 136
 137                 ZERO_STRUCTP(cli->cli);
 138                 free(cli->cli);
 139         }
 140
 141         ZERO_STRUCTP(cli);
 142         free(cli);
 143 }
 144
 145 /****************************************************************************
 146 free a client array
 147 ****************************************************************************/
 148 static void free_ncacn_np_array(uint32 num_entries,
 149                                 struct ncacn_np_use **entries)
 150 {
 151         void (*fn) (void *) = (void (*)(void *))&ncacn_np_use_free;
 152         free_void_array(num_entries, (void **)entries, *fn);
 153 }
 154
 155 /****************************************************************************
 156 add a client state to the array
 157 ****************************************************************************/
 158 static struct ncacn_np_use *add_ncacn_np_to_array(uint32 * len,
 159                                                   struct ncacn_np_use
 160                                                   ***array,
 161                                                   struct ncacn_np_use *cli)
 162 {
 163         int i;
 164         for (i = 0; i < num_msrpcs; i++)
 165         {
 166                 if (msrpcs[i] == NULL)
 167                 {
 168                         msrpcs[i] = cli;
 169                         return cli;
 170                 }
 171         }
 172
 173         return (struct ncacn_np_use *)add_item_to_array(len,
 174                                                         (void ***)array,
 175                                                         (void *)cli);
 176
 177 }
 178
 179 /****************************************************************************
 180 initiate client array
 181 ****************************************************************************/
 182 void init_ncacn_np_use(void)
 183 {
 184         msrpcs = NULL;
 185         num_msrpcs = 0;
 186 }
 187
 188 /****************************************************************************
 189 terminate client array
 190 ****************************************************************************/
 191 void free_ncacn_np_use(void)
 192 {
 193         free_ncacn_np_array(num_msrpcs, msrpcs);
 194         init_ncacn_np_use();
 195 }
 196
 197 /****************************************************************************
 198 find client state.  server name, user name, domain name and password must all
 199 match.
 200 ****************************************************************************/
 201 static struct ncacn_np_use *ncacn_np_find(const char *srv_name,
 202                                           const char *pipe_name,
 203                                           const vuser_key * key,
 204                                           const struct ntuser_creds
 205                                           *usr_creds, BOOL reuse)
 206 {
 207         int i;
 208         const char *sv_name = srv_name;
 209
 210         if (strnequal("\\PIPE\\", pipe_name, 6))
 211         {
 212                 pipe_name = &pipe_name[6];
 213         }
 214
 215         if (strnequal("\\\\", sv_name, 2))
 216         {
 217                 sv_name = &sv_name[2];
 218         }
 219
 220         if (usr_creds != NULL)
 221         {
 222                 DEBUG(10, ("ncacn_np_find: %s %s %s",
 223                            srv_name, usr_creds->user_name, usr_creds->domain));
 224         }
 225         else
 226         {
 227                 DEBUG(10,("ncacn_np_find: %s (no creds)\n", srv_name));
 228         }
 229
 230         if (key != NULL)
 231         {
 232                 DEBUG(10, ("[%d,%x]", key->pid, key->vuid));
 233         }
 234         DEBUG(10, ("\n"));
 235
 236         for (i = 0; i < num_msrpcs; i++)
 237         {
 238                 char *ncacn_np_srv_name = NULL;
 239                 struct ncacn_np_use *c = msrpcs[i];
 240                 vuser_key k;
 241
 242                 char *ncacn_np_name = NULL;
 243
 244                 if (c == NULL || c->cli == NULL || c->cli->smb == NULL ||
 245                     c->cli->smb->fd == -1 ||
 246                     !c->cli->initialised)
 247                 {
 248                         continue;
 249                 }
 250
 251                 ncacn_np_name = c->cli->pipe_name;
 252                 ncacn_np_srv_name = c->cli->smb->desthost;
 253
 254                 k = c->cli->smb->nt.key;
 255
 256                 DEBUG(10, ("ncacn_np_find[%d]: %s %s %s %s [%d,%x]\n",
 257                            i, ncacn_np_name, ncacn_np_srv_name,
 258                            c->cli->smb->usr.user_name,
 259                            c->cli->smb->usr.domain, k.pid, k.vuid));
 260
 261                 if (strnequal("\\\\", ncacn_np_srv_name, 2))
 262                 {
 263                         ncacn_np_srv_name = &ncacn_np_srv_name[2];
 264                 }
 265
 266                 if (strnequal("\\PIPE\\", ncacn_np_name, 6))
 267                 {
 268                         ncacn_np_name = &ncacn_np_name[6];
 269                 }
 270
 271                 if (!strequal(ncacn_np_name, pipe_name))
 272                 {
 273                         continue;
 274                 }
 275                 if (!strequal(ncacn_np_srv_name, sv_name))
 276                 {
 277                         continue;
 278                 }
 279                 if (key != NULL && (k.pid != key->pid || k.vuid != key->vuid))
 280                 {
 281                         continue;
 282                 }
 283                 if (usr_creds == NULL)
 284                 {
 285                         if (reuse)
 286                         {
 287                                 return c;
 288                         }
 289                         else
 290                         {
 291                                 continue;
 292                         }
 293                 }
 294                 if (!strequal
 295                     (usr_creds->user_name, c->cli->smb->usr.user_name))
 296                 {
 297                         continue;
 298                 }
 299                 if (!reuse
 300                     && !pwd_compare(&usr_creds->pwd, &c->cli->smb->usr.pwd))
 301                 {
 302                         DEBUG(100, ("password doesn't match\n"));
 303                         continue;
 304                 }
 305                 if (usr_creds->domain[0] == 0)
 306                 {
 307                         return c;
 308                 }
 309                 if (strequal(usr_creds->domain, c->cli->smb->usr.domain))
 310                 {
 311                         return c;
 312                 }
 313         }
 314
 315         return NULL;
 316 }
 317
 318 /****************************************************************************
 319 initialise a msrpcent structure
 320 ****************************************************************************/
 321 struct ncacn_np *ncacn_np_initialise(struct ncacn_np *msrpc,
 322                                      const vuser_key * key)
 323 {
 324         if (!msrpc)
 325         {
 326                 msrpc = (struct ncacn_np *)malloc(sizeof(*msrpc));
 327                 if (!msrpc)
 328                         return NULL;
 329                 ZERO_STRUCTP(msrpc);
 330         }
 331
 332         if (msrpc->initialised)
 333         {
 334                 ncacn_np_shutdown(msrpc);
 335         }
 336
 337         ZERO_STRUCTP(msrpc);
 338
 339         msrpc->fnum = -1;
 340         msrpc->initialised = 1;
 341
 342         return msrpc;
 343 }
 344
 345 /****************************************************************************
 346 create a new client state from user credentials
 347 ****************************************************************************/
 348 static struct ncacn_np_use *ncacn_np_use_get(const char *pipe_name,
 349                                              const vuser_key * key)
 350 {
 351         struct ncacn_np_use *cli =
 352                 (struct ncacn_np_use *)malloc(sizeof(*cli));
 353
 354         if (cli == NULL)
 355         {
 356                 return NULL;
 357         }
 358
 359         memset(cli, 0, sizeof(*cli));
 360
 361         cli->cli = ncacn_np_initialise(NULL, key);
 362
 363         if (cli->cli == NULL)
 364         {
 365                 return NULL;
 366         }
 367
 368         return cli;
 369 }
 370
 371 /****************************************************************************
 372 init client state
 373 ****************************************************************************/
 374 struct ncacn_np *ncacn_np_use_add(const char *pipe_name,
 375                                   const vuser_key * key,
 376                                   const char *srv_name,
 377                                   const struct ntuser_creds *ntc,
 378                                   BOOL reuse, BOOL *is_new_connection)
 379 {
 380         struct ncacn_np_use *cli;
 381         DEBUG(10, ("ncacn_np_use_add: %s, %s\n", srv_name, pipe_name));
 382
 383         (*is_new_connection) = False;
 384         cli = ncacn_np_find(srv_name, pipe_name, key, ntc, reuse);
 385
 386         if (cli != NULL)
 387         {
 388                 cli->num_users++;
 389                 return cli->cli;
 390         }
 391
 392         /*
 393          * allocate
 394          */
 395
 396         (*is_new_connection) = True;
 397
 398         cli = ncacn_np_use_get(pipe_name, key);
 399
 400         if (!ncacn_np_establish_connection
 401             (cli->cli, srv_name, ntc, pipe_name, True))
 402         {
 403                 DEBUG(0, ("ncacn_np_use_add: connection failed\n"));
 404                 ncacn_np_use_free(cli);
 405                 return NULL;
 406         }
 407
 408         if (key != NULL)
 409         {
 410                 cli->cli->smb->nt.key = *key;
 411         }
 412         else
 413         {
 414                 cli->cli->smb->nt.key.pid = sys_getpid();
 415                 cli->cli->smb->nt.key.vuid = UID_FIELD_INVALID;
 416 #if 0
 417                 NET_USER_INFO_3 usr;
 418                 uid_t uid = getuid();
 419                 gid_t gid = getgid();
 420                 char *name = uidtoname(uid);
 421
 422                 ZERO_STRUCT(usr);
 423
 424                 cli->cli->smb->nt.key.pid = sys_getpid();
 425                 cli->cli->smb->nt.key.vuid =
 426                         register_vuid(cli->cli->smb->nt.key.pid, uid, gid,
 427                                       name, name, False, &usr);
 428 #endif
 429         }
 430
 431         add_ncacn_np_to_array(&num_msrpcs, &msrpcs, cli);
 432         cli->num_users++;
 433         return cli->cli;
 434 }
 435
 436 /****************************************************************************
 437 delete a client state
 438 ****************************************************************************/
 439 BOOL ncacn_np_use_del(const char *srv_name, const char *pipe_name,
 440                       const vuser_key * key,
 441                       BOOL force_close, BOOL *connection_closed)
 442 {
 443         int i;
 444         DEBUG(10, ("ncacn_np_net_use_del: %s, %s. force close: %s ",
 445                    srv_name, pipe_name, BOOLSTR(force_close)));
 446         if (key != NULL)
 447         {
 448                 DEBUG(3, ("[%d,%x]", key->pid, key->vuid));
 449         }
 450         DEBUG(10, ("\n"));
 451
 452         if (connection_closed != NULL)
 453         {
 454                 *connection_closed = False;
 455         }
 456
 457         if (strnequal("\\PIPE\\", pipe_name, 6))
 458         {
 459                 pipe_name = &pipe_name[6];
 460         }
 461
 462         if (strnequal("\\\\", srv_name, 2))
 463         {
 464                 srv_name = &srv_name[2];
 465         }
 466
 467         for (i = 0; i < num_msrpcs; i++)
 468         {
 469                 char *ncacn_np_name = NULL;
 470                 char *ncacn_np_srv_name = NULL;
 471                 struct ncacn_np_use *c = msrpcs[i];
 472                 vuser_key k;
 473
 474                 if (c == NULL || c->cli == NULL || c->cli->smb == NULL)
 475                         continue;
 476
 477                 ncacn_np_name = c->cli->pipe_name;
 478                 ncacn_np_srv_name = c->cli->smb->desthost;
 479
 480                 k = c->cli->smb->nt.key;
 481
 482                 DEBUG(10, ("use_del[%d]: %s %s %s %s [%d,%x]\n",
 483                            i, ncacn_np_name, ncacn_np_srv_name,
 484                            c->cli->smb->usr.user_name,
 485                            c->cli->smb->usr.domain, k.pid, k.vuid));
 486
 487                 if (strnequal("\\PIPE\\", ncacn_np_name, 6))
 488                 {
 489                         ncacn_np_name = &ncacn_np_name[6];
 490                 }
 491                 if (!strequal(ncacn_np_name, pipe_name))
 492                 {
 493                         continue;
 494                 }
 495                 if (strnequal("\\\\", ncacn_np_srv_name, 2))
 496                 {
 497                         ncacn_np_srv_name = &ncacn_np_srv_name[2];
 498                 }
 499                 if (!strequal(ncacn_np_srv_name, srv_name))
 500                 {
 501                         continue;
 502                 }
 503                 if (key->pid != k.pid || key->vuid != k.vuid)
 504                 {
 505                         continue;
 506                 }
 507                 /* decrement number of users */
 508                 c->num_users--;
 509                 DEBUG(3, ("idx: %i num_users now: %d\n",
 510                            i, c->num_users));
 511                 if (force_close || c->num_users == 0)
 512                 {
 513                         ncacn_np_use_free(c);
 514                         msrpcs[i] = NULL;
 515                         if (connection_closed != NULL)
 516                         {
 517                                 *connection_closed = True;
 518                         }
 519                 }
 520                 return True;
 521         }
 522
 523         return False;
 524 }
 525
 526 /****************************************************************************
 527 enumerate client states
 528 ****************************************************************************/
 529 void ncacn_np_use_enum(uint32 * num_cons, struct use_info ***use)
 530 {
 531         int i;
 532         *num_cons = 0;
 533         *use = NULL;
 534         for (i = 0; i < num_msrpcs; i++)
 535         {
 536                 struct use_info item;
 537                 ZERO_STRUCT(item);
 538                 if (msrpcs[i] == NULL)
 539                         continue;
 540                 item.connected = msrpcs[i]->cli != NULL ? True : False;
 541                 if (item.connected)
 542                 {
 543                         item.srv_name = msrpcs[i]->cli->pipe_name;
 544                         item.key = msrpcs[i]->cli->smb->nt.key;
 545                 }
 546
 547                 add_use_info_to_array(num_cons, use, &item);
 548         }
 549 }