source/rpc_client/cli_connect.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
  29 struct user_creds *usr_creds = NULL;
  30 vuser_key *user_key = NULL;
  31
  32 extern int DEBUGLEVEL;
  33
  34 enum
  35 { MSRPC_NONE, MSRPC_LOCAL, MSRPC_SMB };
  36
  37 struct cli_connection
  38 {
  39         char *srv_name;
  40         char *pipe_name;
  41         struct user_creds usr_creds;
  42
  43         int type;
  44
  45         union
  46         {
  47                 struct ncacn_np *smb;
  48                 struct msrpc_local *local;
  49                 void *cli;
  50         }
  51         msrpc;
  52
  53         cli_auth_fns *auth;
  54         void *auth_info;
  55         void *auth_creds;
  56 };
  57
  58 static struct cli_connection **con_list = NULL;
  59 static uint32 num_cons = 0;
  60
  61 void init_connections(void)
  62 {
  63         con_list = NULL;
  64         num_cons = 0;
  65
  66         init_cli_use();
  67 }
  68
  69 static void free_con_array(uint32 num_entries,
  70                            struct cli_connection **entries)
  71 {
  72         void (*fn) (void *) = (void (*)(void *))&cli_connection_free;
  73         free_void_array(num_entries, (void **)entries, *fn);
  74 }
  75
  76 static struct cli_connection *add_con_to_array(uint32 * len,
  77                                                struct cli_connection ***array,
  78                                                struct cli_connection *con)
  79 {
  80         return (struct cli_connection *)add_item_to_array(len,
  81                                                           (void ***)array,
  82                                                           (void *)con);
  83
  84 }
  85 void free_connections(void)
  86 {
  87         DEBUG(3, ("free_connections: closing all MSRPC connections\n"));
  88         free_con_array(num_cons, con_list);
  89         free_cli_use();
  90
  91         init_connections();
  92 }
  93
  94 static struct cli_connection *cli_con_get(const char *srv_name,
  95                                           const char *pipe_name,
  96                                           cli_auth_fns * auth,
  97                                           void *auth_creds, BOOL reuse)
  98 {
  99         struct cli_connection *con = NULL;
 100         BOOL is_new_connection = False;
 101
 102         vuser_key key;
 103
 104         con = (struct cli_connection *)malloc(sizeof(*con));
 105
 106         if (con == NULL)
 107         {
 108                 return NULL;
 109         }
 110
 111         memset(con, 0, sizeof(*con));
 112         con->type = MSRPC_NONE;
 113
 114         copy_user_creds(&con->usr_creds, NULL);
 115         con->usr_creds.reuse = reuse;
 116
 117         if (srv_name != NULL)
 118         {
 119                 con->srv_name = strdup(srv_name);
 120         }
 121         if (pipe_name != NULL)
 122         {
 123                 con->pipe_name = strdup(pipe_name);
 124         }
 125
 126         if (strequal(srv_name, "\\\\."))
 127         {
 128                 con->type = MSRPC_LOCAL;
 129                 become_root(False);
 130                 con->msrpc.local = ncalrpc_l_use_add(pipe_name, user_key,
 131                                                      reuse,
 132                                                      &is_new_connection);
 133                 /*
 134                  * XXX - this rebinds on the same pipe,
 135                  * only necessary, when the loopback connection
 136                  * was first iniated as a forward
 137                  */
 138                 is_new_connection = True;
 139                 unbecome_root(False);
 140         }
 141         else
 142         {
 143                 struct ntuser_creds *ntc = NULL;
 144                 if (usr_creds != NULL)
 145                 {
 146                         ntc = &usr_creds->ntc;
 147                 }
 148                 con->type = MSRPC_SMB;
 149                 con->msrpc.smb =
 150                         ncacn_np_use_add(pipe_name, user_key, srv_name,
 151                                          ntc, reuse,
 152                                          &is_new_connection);
 153
 154                 if (con->msrpc.smb == NULL)
 155                 {
 156                         cli_connection_free(con);
 157                         return NULL;
 158                 }
 159
 160                 key = con->msrpc.smb->smb->nt.key;
 161                 con->msrpc.smb->smb->nt.key.pid = 0;
 162                 con->msrpc.smb->smb->nt.key.vuid = UID_FIELD_INVALID;
 163                 copy_nt_creds(&con->usr_creds.ntc,
 164                               &con->msrpc.smb->smb->usr);
 165         }
 166
 167         if (con->msrpc.cli != NULL)
 168         {
 169                 if (is_new_connection)
 170                 {
 171                         RPC_IFACE abstract;
 172                         RPC_IFACE transfer;
 173
 174                         con->auth_info = NULL;
 175                         con->auth_creds = auth_creds;
 176
 177                         if (auth != NULL)
 178                         {
 179                                 con->auth = auth;
 180                         }
 181                         else
 182                         {
 183                                 extern cli_auth_fns cli_noauth_fns;
 184                                 con->auth = &cli_noauth_fns;
 185                         }
 186
 187                         if (!rpc_pipe_bind(con, pipe_name, &abstract,
 188                                                         &transfer))
 189                         {
 190                                 DEBUG(0, ("rpc_pipe_bind failed\n"));
 191                                 cli_connection_free(con);
 192                                 return NULL;
 193                         }
 194                 }
 195                 else
 196                 {
 197                         con->auth_info = cli_conn_get_auth_creds(con);
 198                         con->auth = cli_conn_get_authfns(con);
 199                         if (con->auth_info != NULL)
 200                         {
 201                                 DEBUG(1,("cli_con_get: TODO: auth reuse\n"));
 202                                 cli_connection_free(con);
 203                                 return NULL;
 204                         }
 205                         else
 206                         {
 207                                 extern cli_auth_fns cli_noauth_fns;
 208                                 con->auth = &cli_noauth_fns;
 209                         }
 210                 }
 211         }
 212
 213         if (con->msrpc.cli == NULL)
 214         {
 215                 cli_connection_free(con);
 216                 return NULL;
 217         }
 218
 219         if (con->type == MSRPC_SMB)
 220         {
 221                 con->msrpc.smb->smb->nt.key = key;
 222         }
 223         add_con_to_array(&num_cons, &con_list, con);
 224         return con;
 225 }
 226
 227 /****************************************************************************
 228 terminate client connection
 229 ****************************************************************************/
 230 void cli_connection_free(struct cli_connection *con)
 231 {
 232         BOOL closed = False;
 233         int i;
 234
 235         DEBUG(10, ("cli_connection_free: %d\n", __LINE__));
 236
 237         if (con->msrpc.cli != NULL)
 238         {
 239                 switch (con->type)
 240                 {
 241                         case MSRPC_LOCAL:
 242                         {
 243                                 DEBUG(10, ("msrpc local connection\n"));
 244                                 ncalrpc_l_use_del(con->pipe_name,
 245                                                   &con->msrpc.local->nt.key,
 246                                                   False, &closed);
 247                                 con->msrpc.local = NULL;
 248                                 break;
 249                         }
 250                         case MSRPC_SMB:
 251                         {
 252                                 DEBUG(10, ("msrpc smb connection\n"));
 253                                 ncacn_np_use_del(con->srv_name,
 254                                                  con->pipe_name,
 255                                                  &con->msrpc.smb->smb->nt.key,
 256                                                  False, &closed);
 257                                 con->msrpc.smb = NULL;
 258                                 break;
 259                         }
 260                 }
 261         }
 262
 263         DEBUG(10, ("cli_connection_free: closed: %s\n", BOOLSTR(closed)));
 264
 265         if (con->msrpc.cli != NULL)
 266         {
 267                 free(con->msrpc.cli);
 268         }
 269         con->msrpc.cli = NULL;
 270
 271         if (con->srv_name != NULL)
 272         {
 273                 free(con->srv_name);
 274                 con->srv_name = NULL;
 275         }
 276         if (con->pipe_name != NULL)
 277         {
 278                 free(con->pipe_name);
 279                 con->pipe_name = NULL;
 280         }
 281
 282         if (con->auth_info != NULL)
 283         {
 284                 free(con->auth_info);
 285                 con->auth_info = NULL;
 286         }
 287
 288         memset(&con->usr_creds, 0, sizeof(con->usr_creds));
 289
 290         for (i = 0; i < num_cons; i++)
 291         {
 292                 if (con == con_list[i])
 293                 {
 294                         con_list[i] = NULL;
 295                 }
 296         }
 297
 298         free(con);
 299 }
 300
 301 /****************************************************************************
 302 terminate client state
 303 ****************************************************************************/
 304 void cli_connection_unlink(struct cli_connection *con)
 305 {
 306         if (con != NULL)
 307         {
 308                 cli_connection_free(con);
 309         }
 310         return;
 311 }
 312
 313 /****************************************************************************
 314 init client state
 315 ****************************************************************************/
 316 BOOL cli_connection_init(const char *srv_name, const char *pipe_name,
 317                          struct cli_connection **con)
 318 {
 319         return cli_connection_init_auth(srv_name, pipe_name, con, NULL, NULL);
 320 }
 321
 322 /****************************************************************************
 323 init client state
 324 ****************************************************************************/
 325 BOOL cli_connection_init_auth(const char *srv_name, const char *pipe_name,
 326                               struct cli_connection **con,
 327                               cli_auth_fns * auth, void *auth_creds)
 328 {
 329         BOOL reuse = True;
 330
 331         /*
 332          * allocate
 333          */
 334
 335         DEBUG(10, ("cli_connection_init_auth: %s %s\n",
 336                    srv_name != NULL ? srv_name : "<null>", pipe_name));
 337
 338         *con = cli_con_get(srv_name, pipe_name, auth, auth_creds, reuse);
 339
 340         return (*con) != NULL;
 341 }
 342
 343 /****************************************************************************
 344 obtain client state
 345 ****************************************************************************/
 346 BOOL cli_connection_getsrv(const char *srv_name, const char *pipe_name,
 347                            struct cli_connection **con)
 348 {
 349         int i;
 350         struct cli_connection *auth_con = NULL;
 351
 352         if (con_list == NULL || num_cons == 0)
 353         {
 354                 return False;
 355         }
 356
 357         (*con) = NULL;
 358
 359         for (i = 0; i < num_cons; i++)
 360         {
 361                 if (con_list[i] != NULL &&
 362                     strequal(con_list[i]->srv_name, srv_name) &&
 363                     strequal(con_list[i]->pipe_name, pipe_name))
 364                 {
 365                         extern cli_auth_fns cli_noauth_fns;
 366                         (*con) = con_list[i];
 367                         /* authenticated connections take priority. HACK! */
 368                         if ((*con)->auth != &cli_noauth_fns)
 369                         {
 370                                 auth_con = (*con);
 371                         }
 372                 }
 373         }
 374
 375         if (auth_con != NULL)
 376         {
 377                 (*con) = auth_con;
 378         }
 379
 380         return (*con) != NULL;
 381 }
 382
 383 /****************************************************************************
 384 obtain client state
 385 ****************************************************************************/
 386 BOOL cli_connection_get(const POLICY_HND * pol, struct cli_connection **con)
 387 {
 388         return get_policy_con(get_global_hnd_cache(), pol, con);
 389 }
 390
 391 /****************************************************************************
 392 link a child policy handle to a parent one
 393 ****************************************************************************/
 394 BOOL cli_pol_link(POLICY_HND * to, const POLICY_HND * from)
 395 {
 396         struct cli_connection *con = NULL;
 397
 398         if (!cli_connection_get(from, &con))
 399         {
 400                 DEBUG(0, ("cli_pol_link: no connection\n"));
 401                 return False;
 402         }
 403
 404         /* fix this when access masks are actually working! */
 405         DEBUG(10, ("cli_pol_link: lkclXXXX - MAXIMUM_ALLOWED access_mask\n"));
 406
 407         return dup_policy_hnd(get_global_hnd_cache(), to, from) &&
 408                 set_policy_con(get_global_hnd_cache(), to, con, NULL);
 409 }
 410
 411 /****************************************************************************
 412 set a user session key associated with a connection
 413 ****************************************************************************/
 414 BOOL cli_get_usr_sesskey(const POLICY_HND * pol, uchar usr_sess_key[16])
 415 {
 416         struct ntdom_info *nt;
 417         struct cli_connection *con;
 418         if (!cli_connection_get(pol, &con))
 419         {
 420                 return False;
 421         }
 422         if (con == NULL)
 423         {
 424                 DEBUG(0, ("cli_get_usr_sesskey: no connection\n"));
 425                 return False;
 426         }
 427         nt = cli_conn_get_ntinfo(con);
 428         if (nt == NULL)
 429         {
 430                 DEBUG(0, ("cli_get_usr_sesskey: no ntdom_info\n"));
 431                 return False;
 432         }
 433
 434         memcpy(usr_sess_key, nt->usr_sess_key, sizeof(nt->usr_sess_key));
 435
 436         return True;
 437 }
 438
 439 /****************************************************************************
 440 set a user session key associated with a connection
 441 ****************************************************************************/
 442 BOOL cli_set_con_usr_sesskey(struct cli_connection *con,
 443                              const uchar usr_sess_key[16])
 444 {
 445         struct ntdom_info *nt;
 446         if (con == NULL)
 447         {
 448                 return False;
 449         }
 450         nt = cli_conn_get_ntinfo(con);
 451         if (nt != NULL)
 452         {
 453                 memcpy(nt->usr_sess_key, usr_sess_key,
 454                        sizeof(nt->usr_sess_key));
 455         }
 456
 457
 458         return True;
 459 }
 460
 461 /****************************************************************************
 462  get auth functions associated with an msrpc session.
 463 ****************************************************************************/
 464 const vuser_key *cli_con_sec_ctx(struct cli_connection *con)
 465 {
 466         struct ntdom_info *nt;
 467         if (con == NULL)
 468         {
 469                 return False;
 470         }
 471         nt = cli_conn_get_ntinfo(con);
 472         if (nt != NULL && nt->key.vuid != UID_FIELD_INVALID)
 473         {
 474                 return &nt->key;
 475         }
 476         return NULL;
 477 }
 478
 479 /****************************************************************************
 480  get auth functions associated with an msrpc session.
 481 ****************************************************************************/
 482 struct cli_auth_fns *cli_conn_get_authfns(struct cli_connection *con)
 483 {
 484         return con != NULL ? con->auth : NULL;
 485 }
 486
 487 /****************************************************************************
 488  get auth info associated with an msrpc session.
 489 ****************************************************************************/
 490 void *cli_conn_get_auth_creds(struct cli_connection *con)
 491 {
 492         return con != NULL ? con->auth_creds : NULL;
 493 }
 494
 495 /****************************************************************************
 496  get auth info associated with an msrpc session.
 497 ****************************************************************************/
 498 void *cli_conn_get_auth_info(struct cli_connection *con)
 499 {
 500         return con != NULL ? con->auth_info : NULL;
 501 }
 502
 503 /****************************************************************************
 504  set auth info associated with an msrpc session.
 505 ****************************************************************************/
 506 BOOL cli_conn_set_auth_info(struct cli_connection *con, void *auth_info)
 507 {
 508         con->auth_info = auth_info;
 509         return auth_info != NULL;
 510 }
 511
 512 /****************************************************************************
 513  get nt creds (HACK ALERT!) associated with an msrpc session.
 514 ****************************************************************************/
 515 struct ntdom_info *cli_conn_get_ntinfo(struct cli_connection *con)
 516 {
 517         if (con == NULL)
 518         {
 519                 return NULL;
 520         }
 521         if (con->msrpc.cli == NULL)
 522         {
 523                 DEBUG(1, ("cli_conn_get_ntinfo: NULL msrpc (closed)\n"));
 524                 return NULL;
 525         }
 526
 527         switch (con->type)
 528         {
 529                 case MSRPC_LOCAL:
 530                 {
 531                         return &con->msrpc.local->nt;
 532                 }
 533                 case MSRPC_SMB:
 534                 {
 535                         return &con->msrpc.smb->smb->nt;
 536                 }
 537         }
 538         return NULL;
 539 }
 540
 541 /****************************************************************************
 542 get a user session key associated with a connection associated with a
 543 policy handle.
 544 ****************************************************************************/
 545 BOOL cli_get_con_sesskey(struct cli_connection *con, uchar sess_key[16])
 546 {
 547         struct ntdom_info *nt;
 548         if (con == NULL)
 549         {
 550                 return False;
 551         }
 552         nt = cli_conn_get_ntinfo(con);
 553         memcpy(sess_key, nt->sess_key, sizeof(nt->sess_key));
 554
 555         dump_data_pw("sess_key:", sess_key, 16);
 556
 557         return True;
 558 }
 559
 560 /****************************************************************************
 561 get a server name associated with a connection associated with a
 562 policy handle.
 563 ****************************************************************************/
 564 BOOL cli_con_get_srvname(struct cli_connection *con, char *srv_name)
 565 {
 566         char *desthost = NULL;
 567
 568         if (con == NULL)
 569         {
 570                 return False;
 571         }
 572
 573         switch (con->type)
 574         {
 575                 case MSRPC_SMB:
 576                 {
 577                         desthost = con->msrpc.smb->smb->desthost;
 578                         break;
 579                 }
 580                 case MSRPC_LOCAL:
 581                 {
 582                         desthost = con->srv_name;
 583                         break;
 584                 }
 585         }
 586
 587         if (strnequal("\\\\", desthost, 2))
 588         {
 589                 fstrcpy(srv_name, desthost);
 590         }
 591         else
 592         {
 593                 fstrcpy(srv_name, "\\\\");
 594                 fstrcat(srv_name, desthost);
 595         }
 596
 597         return True;
 598 }
 599
 600 /****************************************************************************
 601 get a user session key associated with a connection associated with a
 602 policy handle.
 603 ****************************************************************************/
 604 BOOL cli_get_sesskey(const POLICY_HND * pol, uchar sess_key[16])
 605 {
 606         struct cli_connection *con = NULL;
 607
 608         if (!cli_connection_get(pol, &con))
 609         {
 610                 return False;
 611         }
 612
 613         return cli_get_con_sesskey(con, sess_key);
 614 }
 615
 616 /****************************************************************************
 617 get a user session key associated with a connection associated with a
 618 policy handle.
 619 ****************************************************************************/
 620 BOOL cli_get_sesskey_srv(const char *srv_name, uchar sess_key[16])
 621 {
 622         struct cli_connection *con = NULL;
 623
 624         if (!cli_connection_getsrv(srv_name, PIPE_NETLOGON, &con))
 625         {
 626                 return False;
 627         }
 628
 629         return cli_get_con_sesskey(con, sess_key);
 630 }
 631
 632 /****************************************************************************
 633 get a user session key associated with a connection associated with a
 634 policy handle.
 635 ****************************************************************************/
 636 void cli_con_gen_next_creds(struct cli_connection *con,
 637                             DOM_CRED * new_clnt_cred)
 638 {
 639         struct ntdom_info *nt = cli_conn_get_ntinfo(con);
 640         gen_next_creds(nt, new_clnt_cred);
 641 }
 642
 643 /****************************************************************************
 644 get a user session key associated with a connection associated with a
 645 policy handle.
 646 ****************************************************************************/
 647 void cli_con_get_cli_cred(struct cli_connection *con, DOM_CRED * clnt_cred)
 648 {
 649         struct ntdom_info *nt = cli_conn_get_ntinfo(con);
 650         memcpy(clnt_cred, &nt->clnt_cred, sizeof(*clnt_cred));
 651 }
 652
 653 /****************************************************************************
 654 get a user session key associated with a connection associated with a
 655 policy handle.
 656 ****************************************************************************/
 657 BOOL cli_con_deal_with_creds(struct cli_connection *con,
 658                              DOM_CRED * rcv_srv_cred)
 659 {
 660         struct ntdom_info *nt = cli_conn_get_ntinfo(con);
 661         return clnt_deal_with_creds(nt->sess_key, &nt->clnt_cred,
 662                                     rcv_srv_cred);
 663 }
 664
 665 /****************************************************************************
 666 get a user session key associated with a connection associated with a
 667 policy handle.
 668 ****************************************************************************/
 669 BOOL cli_con_set_creds(const char *srv_name, const uchar sess_key[16],
 670                        DOM_CRED * cred)
 671 {
 672         struct cli_connection *con = NULL;
 673         struct ntdom_info *nt;
 674
 675         if (!cli_connection_getsrv(srv_name, PIPE_NETLOGON, &con))
 676         {
 677                 return False;
 678         }
 679
 680         nt = cli_conn_get_ntinfo(con);
 681
 682         memcpy(nt->sess_key, sess_key, 16);
 683         memcpy(&nt->clnt_cred, cred, sizeof(*cred));
 684
 685         return True;
 686 }
 687
 688 /****************************************************************************
 689  send a request on an rpc pipe.
 690  ****************************************************************************/
 691 BOOL rpc_hnd_ok(const POLICY_HND *hnd)
 692 {
 693         struct cli_connection *con = NULL;
 694
 695         return cli_connection_get(hnd, &con) && rpc_con_ok(con);
 696 }
 697
 698 /****************************************************************************
 699  send a request on an rpc pipe.
 700  ****************************************************************************/
 701 BOOL rpc_hnd_pipe_req(const POLICY_HND * hnd, uint8 op_num,
 702                       prs_struct * data, prs_struct * rdata)
 703 {
 704         struct cli_connection *con = NULL;
 705
 706         if (!cli_connection_get(hnd, &con))
 707         {
 708                 return False;
 709         }
 710
 711         if (!rpc_con_ok(con)) return False;
 712
 713         return rpc_con_pipe_req(con, op_num, data, rdata);
 714 }
 715
 716 /****************************************************************************
 717  send a request on an rpc pipe.
 718  ****************************************************************************/
 719 BOOL rpc_con_pipe_req(struct cli_connection *con, uint8 op_num,
 720                       prs_struct * data, prs_struct * rdata)
 721 {
 722         BOOL ret;
 723         DEBUG(10, ("rpc_con_pipe_req: op_num %d offset %d used: %d\n",
 724                    op_num, prs_offset(data), prs_data_size(data)));
 725         prs_dump("in_rpcclient", (int)op_num, data);
 726         prs_realloc_data(data, data->offset);
 727         ret = rpc_api_pipe_req(con, op_num, data, rdata);
 728         prs_dump("out_rpcclient", (int)op_num, rdata);
 729         return ret;
 730 }
 731
 732 /****************************************************************************
 733  write to a pipe
 734 ****************************************************************************/
 735 BOOL rpc_api_write(struct cli_connection *con, prs_struct * data)
 736 {
 737         switch (con->type)
 738         {
 739                 case MSRPC_SMB:
 740                 {
 741                         struct cli_state *cli = con->msrpc.smb->smb;
 742                         int fnum = con->msrpc.smb->fnum;
 743                         return cli_write(cli, fnum, 0x0008,
 744                                          data->data, 0,
 745                                          prs_data_size(data),
 746                                          prs_data_size(data)) > 0;
 747                 }
 748                 case MSRPC_LOCAL:
 749                 {
 750                         data->offset = prs_data_size(data);
 751                         prs_link(NULL, data, NULL);
 752                         return msrpc_send(con->msrpc.local->fd, data);
 753                 }
 754         }
 755         return False;
 756 }
 757
 758 BOOL rpc_api_rcv_pdu(struct cli_connection *con, prs_struct * rdata)
 759 {
 760         switch (con->type)
 761         {
 762                 case MSRPC_SMB:
 763                 {
 764                         struct cli_state *cli = con->msrpc.smb->smb;
 765                         int fnum = con->msrpc.smb->fnum;
 766                         return cli_rcv_pdu(con, cli, fnum, rdata);
 767                 }
 768                 case MSRPC_LOCAL:
 769                 {
 770                         BOOL ret;
 771                         ret = msrpc_send(con->msrpc.local->fd, NULL);
 772                         ret = msrpc_receive(con->msrpc.local->fd, rdata);
 773                         rdata->io = True;
 774                         rdata->offset = 0;
 775                         rdata->start = 0;
 776                         rdata->end = prs_data_size(rdata);
 777                         return ret;
 778                 }
 779         }
 780         return False;
 781 }
 782
 783 /* this allows us to detect dead servers. The cli->fd is set to -1 when
 784    we get an error */
 785 BOOL rpc_con_ok(struct cli_connection *con)
 786 {
 787         if (!con) return False;
 788
 789         switch (con->type)
 790         {
 791                 case MSRPC_SMB:
 792                         {
 793                                 struct cli_state *cli;
 794                                 if (!con->msrpc.smb) return False;
 795                                 cli = con->msrpc.smb->smb;
 796                                 if (cli->fd == -1) return False;
 797                                 return True;
 798                         }
 799                         break;
 800
 801                 case MSRPC_LOCAL:
 802                         return True;
 803         }
 804         return False;
 805 }
 806
 807
 808 BOOL rpc_api_send_rcv_pdu(struct cli_connection *con, prs_struct * data,
 809                           prs_struct * rdata)
 810 {
 811         switch (con->type)
 812         {
 813                 case MSRPC_SMB:
 814                 {
 815                         struct ntdom_info *nt = cli_conn_get_ntinfo(con);
 816                         struct cli_state *cli = con->msrpc.smb->smb;
 817                         int fnum = con->msrpc.smb->fnum;
 818                         if (cli->fd == -1) return False;
 819                         return cli_send_and_rcv_pdu(con, cli, fnum, data,
 820                                                     rdata, nt->max_xmit_frag);
 821                 }
 822                 case MSRPC_LOCAL:
 823                 {
 824                         BOOL ret;
 825                         data->offset = prs_data_size(data);
 826                         prs_link(NULL, data, NULL);
 827                         ret = msrpc_send(con->msrpc.local->fd, data) &&
 828                                 msrpc_receive(con->msrpc.local->fd, rdata);
 829                         rdata->io = True;
 830                         rdata->offset = 0;
 831                         rdata->start = 0;
 832                         rdata->end = prs_data_size(rdata);
 833                         return ret;
 834                 }
 835         }
 836         return False;
 837 }
 838
 839 /* connection policy state-info */
 840
 841 struct con_info
 842 {
 843         struct cli_connection *con;
 844         void (*free_con) (struct cli_connection *);
 845 };
 846
 847 static void free_policy_con(void *dev)
 848 {
 849         struct con_info *con = (struct con_info *)dev;
 850         DEBUG(10, ("free policy connection\n"));
 851         if (con->free_con != NULL)
 852         {
 853                 con->free_con(con->con);
 854         }
 855         free(dev);
 856 }
 857
 858 /****************************************************************************
 859   set con state
 860 ****************************************************************************/
 861 BOOL set_policy_con(struct policy_cache *cache, POLICY_HND * hnd,
 862                     struct cli_connection *con,
 863                     void (*free_fn) (struct cli_connection *))
 864 {
 865         struct con_info *dev = (struct con_info *)malloc(sizeof(*dev));
 866
 867         if (dev != NULL)
 868         {
 869                 dev->con = con;
 870                 dev->free_con = free_fn;
 871                 if (set_policy_state(cache, hnd,
 872                                      free_policy_con, (void *)dev))
 873                 {
 874                         DEBUG(5, ("setting policy con\n"));
 875                         return True;
 876                 }
 877                 free(dev);
 878         }
 879
 880         DEBUG(3, ("Error setting policy con state\n"));
 881         return False;
 882 }
 883
 884 /****************************************************************************
 885   get con state
 886 ****************************************************************************/
 887 BOOL get_policy_con(struct policy_cache *cache, const POLICY_HND * hnd,
 888                     struct cli_connection **con)
 889 {
 890         struct con_info *dev;
 891         dev = (struct con_info *)get_policy_state_info(cache, hnd);
 892
 893         if (dev != NULL)
 894         {
 895                 DEBUG(5, ("Getting policy con state\n"));
 896                 (*con) = dev->con;
 897                 return True;
 898         }
 899
 900         DEBUG(3, ("Error getting policy con state\n"));
 901         return False;
 902 }