source3/rpc_client/cli_lsarpc.c

   1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-1997,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   8  *  Copyright (C) Paul Ashton                       1997.
   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 #ifdef SYSLOG
  27 #undef SYSLOG
  28 #endif
  29
  30 #include "includes.h"
  31
  32 extern int DEBUGLEVEL;
  33
  34
  35 /****************************************************************************
  36 do a LSA Open Policy
  37 ****************************************************************************/
  38 BOOL lsa_open_policy(struct cli_state *cli,
  39                         char *server_name, POLICY_HND *hnd,
  40                         BOOL sec_qos)
  41 {
  42         prs_struct rbuf;
  43         prs_struct buf;
  44         LSA_Q_OPEN_POL q_o;
  45         LSA_SEC_QOS qos;
  46         BOOL valid_pol = False;
  47
  48         if (hnd == NULL) return False;
  49
  50         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
  51         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
  52
  53         /* create and send a MSRPC command with api LSA_OPENPOLICY */
  54
  55         DEBUG(4,("LSA Open Policy\n"));
  56
  57         /* store the parameters */
  58         if (sec_qos)
  59         {
  60                 make_lsa_sec_qos(&qos, 2, 1, 0, 0x20000000);
  61                 make_q_open_pol(&q_o, 0x5c, 0, 0, &qos);
  62         }
  63         else
  64         {
  65                 make_q_open_pol(&q_o, 0x5c, 0, 0x1, NULL);
  66         }
  67
  68         /* turn parameters into data stream */
  69         lsa_io_q_open_pol("", &q_o, &buf, 0);
  70
  71         /* send the data on \PIPE\ */
  72         if (rpc_api_pipe_req(cli, LSA_OPENPOLICY, &buf, &rbuf))
  73         {
  74                 LSA_R_OPEN_POL r_o;
  75                 BOOL p;
  76
  77                 lsa_io_r_open_pol("", &r_o, &rbuf, 0);
  78                 p = rbuf.offset != 0;
  79
  80                 if (p && r_o.status != 0)
  81                 {
  82                         /* report error code */
  83                         DEBUG(0,("LSA_OPENPOLICY: %s\n", get_nt_error_msg(r_o.status)));
  84                         p = False;
  85                 }
  86
  87                 if (p)
  88                 {
  89                         /* ok, at last: we're happy. return the policy handle */
  90                         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
  91                         valid_pol = True;
  92                 }
  93         }
  94
  95         prs_mem_free(&rbuf);
  96         prs_mem_free(&buf );
  97
  98         return valid_pol;
  99 }
 100
 101 /****************************************************************************
 102 do a LSA Lookup Names
 103 ****************************************************************************/
 104 BOOL lsa_lookup_names(struct cli_state *cli,
 105                         POLICY_HND *hnd,
 106                         int num_names,
 107                         char **names,
 108                         DOM_SID **sids,
 109                         int *num_sids)
 110 {
 111         prs_struct rbuf;
 112         prs_struct buf;
 113         LSA_Q_LOOKUP_NAMES q_l;
 114         BOOL valid_response = False;
 115
 116         if (hnd == NULL || num_sids == 0 || sids == NULL) return False;
 117
 118         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 119         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 120
 121         /* create and send a MSRPC command with api LSA_LOOKUP_NAMES */
 122
 123         DEBUG(4,("LSA Lookup NAMEs\n"));
 124
 125         /* store the parameters */
 126         make_q_lookup_names(&q_l, hnd, num_names, names);
 127
 128         /* turn parameters into data stream */
 129         lsa_io_q_lookup_names("", &q_l, &buf, 0);
 130
 131         /* send the data on \PIPE\ */
 132         if (rpc_api_pipe_req(cli, LSA_LOOKUPNAMES, &buf, &rbuf))
 133         {
 134                 LSA_R_LOOKUP_NAMES r_l;
 135                 DOM_R_REF ref;
 136                 DOM_RID2 t_rids[MAX_LOOKUP_SIDS];
 137                 BOOL p;
 138
 139                 ZERO_STRUCT(ref);
 140                 ZERO_STRUCT(t_rids);
 141
 142                 r_l.dom_ref = &ref;
 143                 r_l.dom_rid = t_rids;
 144
 145                 lsa_io_r_lookup_names("", &r_l, &rbuf, 0);
 146                 p = rbuf.offset != 0;
 147
 148                 if (p && r_l.status != 0)
 149                 {
 150                         /* report error code */
 151                         DEBUG(0,("LSA_LOOKUP_NAMES: %s\n", get_nt_error_msg(r_l.status)));
 152                         p = False;
 153                 }
 154
 155                 if (p)
 156                 {
 157                         if (r_l.undoc_buffer != 0 && ref.undoc_buffer != 0)
 158                         {
 159                                 valid_response = True;
 160                         }
 161                 }
 162
 163                 if (num_sids != NULL && valid_response)
 164                 {
 165                         (*num_sids) = r_l.num_entries;
 166                 }
 167                 if (valid_response)
 168                 {
 169                         int i;
 170                         for (i = 0; i < r_l.num_entries; i++)
 171                         {
 172                                 if (t_rids[i].rid_idx >= ref.num_ref_doms_1 &&
 173                                     t_rids[i].rid_idx != 0xffffffff)
 174                                 {
 175                                         DEBUG(0,("LSA_LOOKUP_NAMES: domain index %d out of bounds\n",
 176                                                   t_rids[i].rid_idx));
 177                                         valid_response = False;
 178                                         break;
 179                                 }
 180                         }
 181                 }
 182
 183                 if (sids != NULL && valid_response && r_l.num_entries != 0)
 184                 {
 185                         (*sids) = (DOM_SID*)malloc((*num_sids) * sizeof(DOM_SID));
 186                 }
 187
 188                 if (sids != NULL && (*sids) != NULL)
 189                 {
 190                         int i;
 191                         /* take each name, construct a SID */
 192                         for (i = 0; i < (*num_sids); i++)
 193                         {
 194                                 uint32 dom_idx = t_rids[i].rid_idx;
 195                                 DOM_SID *sid = &(*sids)[i];
 196                                 if (dom_idx != 0xffffffff)
 197                                 {
 198                                         sid_copy(sid, &ref.ref_dom[dom_idx].ref_dom.sid);
 199                                 }
 200                                 else
 201                                 {
 202                                         ZERO_STRUCTP(sid);
 203                                 }
 204                         }
 205                 }
 206         }
 207
 208         prs_mem_free(&rbuf);
 209         prs_mem_free(&buf );
 210
 211         return valid_response;
 212 }
 213
 214 /****************************************************************************
 215 do a LSA Lookup SIDs
 216 ****************************************************************************/
 217 BOOL lsa_lookup_sids(struct cli_state *cli,
 218                         POLICY_HND *hnd,
 219                         int num_sids,
 220                         DOM_SID **sids,
 221                         char ***names,
 222                         int *num_names)
 223 {
 224         prs_struct rbuf;
 225         prs_struct buf;
 226         LSA_Q_LOOKUP_SIDS q_l;
 227         BOOL valid_response = False;
 228
 229         if (hnd == NULL || num_sids == 0 || sids == NULL) return False;
 230
 231         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 232         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 233
 234         /* create and send a MSRPC command with api LSA_LOOKUP_SIDS */
 235
 236         DEBUG(4,("LSA Lookup SIDs\n"));
 237
 238         /* store the parameters */
 239         make_q_lookup_sids(&q_l, hnd, num_sids, sids, 1);
 240
 241         /* turn parameters into data stream */
 242         lsa_io_q_lookup_sids("", &q_l, &buf, 0);
 243
 244         /* send the data on \PIPE\ */
 245         if (rpc_api_pipe_req(cli, LSA_LOOKUPSIDS, &buf, &rbuf))
 246         {
 247                 LSA_R_LOOKUP_SIDS r_l;
 248                 DOM_R_REF ref;
 249                 LSA_TRANS_NAME_ENUM t_names;
 250                 BOOL p;
 251
 252                 r_l.dom_ref = &ref;
 253                 r_l.names   = &t_names;
 254
 255                 lsa_io_r_lookup_sids("", &r_l, &rbuf, 0);
 256                 p = rbuf.offset != 0;
 257
 258                 if (p && r_l.status != 0)
 259                 {
 260                         /* report error code */
 261                         DEBUG(0,("LSA_LOOKUP_SIDS: %s\n", get_nt_error_msg(r_l.status)));
 262                         p = False;
 263                 }
 264
 265                 if (p)
 266                 {
 267                         if (t_names.ptr_trans_names != 0 && ref.undoc_buffer != 0)
 268                         {
 269                                 valid_response = True;
 270                         }
 271                 }
 272
 273                 if (num_names != NULL && valid_response)
 274                 {
 275                         (*num_names) = t_names.num_entries;
 276                 }
 277                 if (valid_response)
 278                 {
 279                         int i;
 280                         for (i = 0; i < t_names.num_entries; i++)
 281                         {
 282                                 if (t_names.name[i].domain_idx >= ref.num_ref_doms_1)
 283                                 {
 284                                         DEBUG(0,("LSA_LOOKUP_SIDS: domain index out of bounds\n"));
 285                                         valid_response = False;
 286                                         break;
 287                                 }
 288                         }
 289                 }
 290
 291                 if (names != NULL && valid_response && t_names.num_entries != 0)
 292                 {
 293                         (*names) = (char**)malloc((*num_names) * sizeof(char*));
 294                 }
 295
 296                 if (names != NULL && (*names) != NULL)
 297                 {
 298                         int i;
 299                         /* take each name, construct a \DOMAIN\name string */
 300                         for (i = 0; i < (*num_names); i++)
 301                         {
 302                                 fstring name;
 303                                 fstring dom_name;
 304                                 fstring full_name;
 305                                 uint32 dom_idx = t_names.name[i].domain_idx;
 306
 307                                 if (dom_idx != 0xffffffff)
 308                                 {
 309                                         fstrcpy(dom_name, unistr2_to_str(&ref.ref_dom[dom_idx].uni_dom_name));
 310                                         fstrcpy(name    , unistr2_to_str(&t_names.uni_name[i]));
 311
 312                                         memset(full_name, 0, sizeof(full_name));
 313
 314                                         slprintf(full_name, sizeof(full_name)-1, "%s\\%s",
 315                                                  dom_name, name);
 316
 317                                         (*names)[i] = strdup(full_name);
 318                                 }
 319                                 else
 320                                 {
 321                                         (*names)[i] = NULL;
 322                                 }
 323                         }
 324                 }
 325         }
 326
 327         prs_mem_free(&rbuf);
 328         prs_mem_free(&buf );
 329
 330         return valid_response;
 331 }
 332
 333 /****************************************************************************
 334 do a LSA Query Info Policy
 335 ****************************************************************************/
 336 BOOL lsa_query_info_pol(struct cli_state *cli,
 337                         POLICY_HND *hnd, uint16 info_class,
 338                         fstring domain_name, DOM_SID *domain_sid)
 339 {
 340         prs_struct rbuf;
 341         prs_struct buf;
 342         LSA_Q_QUERY_INFO q_q;
 343         BOOL valid_response = False;
 344
 345         ZERO_STRUCTP(domain_sid);
 346         domain_name[0] = 0;
 347
 348         if (hnd == NULL || domain_name == NULL || domain_sid == NULL) return False;
 349
 350         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 351         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 352
 353         /* create and send a MSRPC command with api LSA_QUERYINFOPOLICY */
 354
 355         DEBUG(4,("LSA Query Info Policy\n"));
 356
 357         /* store the parameters */
 358         make_q_query(&q_q, hnd, info_class);
 359
 360         /* turn parameters into data stream */
 361         lsa_io_q_query("", &q_q, &buf, 0);
 362
 363         /* send the data on \PIPE\ */
 364         if (rpc_api_pipe_req(cli, LSA_QUERYINFOPOLICY, &buf, &rbuf))
 365         {
 366                 LSA_R_QUERY_INFO r_q;
 367                 BOOL p;
 368
 369                 lsa_io_r_query("", &r_q, &rbuf, 0);
 370                 p = rbuf.offset != 0;
 371
 372                 if (p && r_q.status != 0)
 373                 {
 374                         /* report error code */
 375                         DEBUG(0,("LSA_QUERYINFOPOLICY: %s\n", get_nt_error_msg(r_q.status)));
 376                         p = False;
 377                 }
 378
 379                 if (p && r_q.info_class != q_q.info_class)
 380                 {
 381                         /* report different info classes */
 382                         DEBUG(0,("LSA_QUERYINFOPOLICY: error info_class (q,r) differ - (%x,%x)\n",
 383                                         q_q.info_class, r_q.info_class));
 384                         p = False;
 385                 }
 386
 387                 if (p)
 388                 {
 389                         fstring sid_str;
 390                         /* ok, at last: we're happy. */
 391                         switch (r_q.info_class)
 392                         {
 393                                 case 3:
 394                                 {
 395                                         if (r_q.dom.id3.buffer_dom_name != 0)
 396                                         {
 397                                                 char *dom_name = unistrn2(r_q.dom.id3.uni_domain_name.buffer,
 398                                                                           r_q.dom.id3.uni_domain_name.uni_str_len);
 399                                                 fstrcpy(domain_name, dom_name);
 400                                         }
 401                                         if (r_q.dom.id3.buffer_dom_sid != 0)
 402                                         {
 403                                                 *domain_sid = r_q.dom.id3.dom_sid.sid;
 404                                         }
 405
 406                                         valid_response = True;
 407                                         break;
 408                                 }
 409                                 case 5:
 410                                 {
 411                                         if (r_q.dom.id5.buffer_dom_name != 0)
 412                                         {
 413                                                 char *dom_name = unistrn2(r_q.dom.id5.uni_domain_name.buffer,
 414                                                                           r_q.dom.id5.uni_domain_name.uni_str_len);
 415                                                 fstrcpy(domain_name, dom_name);
 416                                         }
 417                                         if (r_q.dom.id5.buffer_dom_sid != 0)
 418                                         {
 419                                                 *domain_sid = r_q.dom.id5.dom_sid.sid;
 420                                         }
 421
 422                                         valid_response = True;
 423                                         break;
 424                                 }
 425                                 default:
 426                                 {
 427                                         DEBUG(3,("LSA_QUERYINFOPOLICY: unknown info class\n"));
 428                                         domain_name[0] = 0;
 429
 430                                         break;
 431                                 }
 432                         }
 433
 434                         sid_to_string(sid_str, domain_sid);
 435                         DEBUG(3,("LSA_QUERYINFOPOLICY (level %x): domain:%s  domain sid:%s\n",
 436                                   r_q.info_class, domain_name, sid_str));
 437                 }
 438         }
 439
 440         prs_mem_free(&rbuf);
 441         prs_mem_free(&buf );
 442
 443         return valid_response;
 444 }
 445
 446 /****************************************************************************
 447 do a LSA Close
 448 ****************************************************************************/
 449 BOOL lsa_close(struct cli_state *cli, POLICY_HND *hnd)
 450 {
 451         prs_struct rbuf;
 452         prs_struct buf;
 453         LSA_Q_CLOSE q_c;
 454     BOOL valid_close = False;
 455
 456         if (hnd == NULL) return False;
 457
 458         /* create and send a MSRPC command with api LSA_OPENPOLICY */
 459
 460         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 461         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 462
 463         DEBUG(4,("LSA Close\n"));
 464
 465         /* store the parameters */
 466         make_lsa_q_close(&q_c, hnd);
 467
 468         /* turn parameters into data stream */
 469         lsa_io_q_close("", &q_c, &buf, 0);
 470
 471         /* send the data on \PIPE\ */
 472         if (rpc_api_pipe_req(cli, LSA_CLOSE, &buf, &rbuf))
 473         {
 474                 LSA_R_CLOSE r_c;
 475                 BOOL p;
 476
 477                 lsa_io_r_close("", &r_c, &rbuf, 0);
 478                 p = rbuf.offset != 0;
 479
 480                 if (p && r_c.status != 0)
 481                 {
 482                         /* report error code */
 483                         DEBUG(0,("LSA_CLOSE: %s\n", get_nt_error_msg(r_c.status)));
 484                         p = False;
 485                 }
 486
 487                 if (p)
 488                 {
 489                         /* check that the returned policy handle is all zeros */
 490                         int i;
 491                         valid_close = True;
 492
 493                         for (i = 0; i < sizeof(r_c.pol.data); i++)
 494                         {
 495                                 if (r_c.pol.data[i] != 0)
 496                                 {
 497                                         valid_close = False;
 498                                         break;
 499                                 }
 500                         }
 501                         if (!valid_close)
 502                         {
 503                                 DEBUG(0,("LSA_CLOSE: non-zero handle returned\n"));
 504                         }
 505                 }
 506         }
 507
 508         prs_mem_free(&rbuf);
 509         prs_mem_free(&buf );
 510
 511         return valid_close;
 512 }
 513
 514