source3/rpc_server/srv_netlog.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-1997,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   6  *  Copyright (C) Paul Ashton                       1997,
   7  *  Copyright (C) Jeremy Allison               1998-2001,
   8  *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2003.
   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 3 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, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 /* This is the interface to the netlogon pipe. */
  25
  26 #include "includes.h"
  27
  28 #undef DBGC_CLASS
  29 #define DBGC_CLASS DBGC_RPC_SRV
  30
  31 /*************************************************************************
  32  api_net_req_chal:
  33  *************************************************************************/
  34
  35 static BOOL api_net_req_chal(pipes_struct *p)
  36 {
  37         NET_Q_REQ_CHAL q_u;
  38         NET_R_REQ_CHAL r_u;
  39         prs_struct *data = &p->in_data.data;
  40         prs_struct *rdata = &p->out_data.rdata;
  41
  42         ZERO_STRUCT(q_u);
  43         ZERO_STRUCT(r_u);
  44
  45         /* grab the challenge... */
  46         if(!net_io_q_req_chal("", &q_u, data, 0)) {
  47                 DEBUG(0,("api_net_req_chal: Failed to unmarshall NET_Q_REQ_CHAL.\n"));
  48                 return False;
  49         }
  50
  51         r_u.status = _net_req_chal(p, &q_u, &r_u);
  52
  53         /* store the response in the SMB stream */
  54         if(!net_io_r_req_chal("", &r_u, rdata, 0)) {
  55                 DEBUG(0,("api_net_req_chal: Failed to marshall NET_R_REQ_CHAL.\n"));
  56                 return False;
  57         }
  58
  59         return True;
  60 }
  61
  62 /*************************************************************************
  63  api_net_auth:
  64  *************************************************************************/
  65
  66 static BOOL api_net_auth(pipes_struct *p)
  67 {
  68         NET_Q_AUTH q_u;
  69         NET_R_AUTH r_u;
  70         prs_struct *data = &p->in_data.data;
  71         prs_struct *rdata = &p->out_data.rdata;
  72
  73         ZERO_STRUCT(q_u);
  74         ZERO_STRUCT(r_u);
  75
  76         /* grab the challenge... */
  77         if(!net_io_q_auth("", &q_u, data, 0)) {
  78                 DEBUG(0,("api_net_auth: Failed to unmarshall NET_Q_AUTH.\n"));
  79                 return False;
  80         }
  81
  82         r_u.status = _net_auth(p, &q_u, &r_u);
  83
  84         /* store the response in the SMB stream */
  85         if(!net_io_r_auth("", &r_u, rdata, 0)) {
  86                 DEBUG(0,("api_net_auth: Failed to marshall NET_R_AUTH.\n"));
  87                 return False;
  88         }
  89
  90         return True;
  91 }
  92
  93 /*************************************************************************
  94  api_net_auth_2:
  95  *************************************************************************/
  96
  97 static BOOL api_net_auth_2(pipes_struct *p)
  98 {
  99         NET_Q_AUTH_2 q_u;
 100         NET_R_AUTH_2 r_u;
 101         prs_struct *data = &p->in_data.data;
 102         prs_struct *rdata = &p->out_data.rdata;
 103
 104         ZERO_STRUCT(q_u);
 105         ZERO_STRUCT(r_u);
 106
 107         /* grab the challenge... */
 108         if(!net_io_q_auth_2("", &q_u, data, 0)) {
 109                 DEBUG(0,("api_net_auth_2: Failed to unmarshall NET_Q_AUTH_2.\n"));
 110                 return False;
 111         }
 112
 113         r_u.status = _net_auth_2(p, &q_u, &r_u);
 114
 115         /* store the response in the SMB stream */
 116         if(!net_io_r_auth_2("", &r_u, rdata, 0)) {
 117                 DEBUG(0,("api_net_auth_2: Failed to marshall NET_R_AUTH_2.\n"));
 118                 return False;
 119         }
 120
 121         return True;
 122 }
 123
 124 /*************************************************************************
 125  api_net_srv_pwset:
 126  *************************************************************************/
 127
 128 static BOOL api_net_srv_pwset(pipes_struct *p)
 129 {
 130         NET_Q_SRV_PWSET q_u;
 131         NET_R_SRV_PWSET r_u;
 132         prs_struct *data = &p->in_data.data;
 133         prs_struct *rdata = &p->out_data.rdata;
 134
 135         ZERO_STRUCT(q_u);
 136         ZERO_STRUCT(r_u);
 137
 138         /* grab the challenge and encrypted password ... */
 139         if(!net_io_q_srv_pwset("", &q_u, data, 0)) {
 140                 DEBUG(0,("api_net_srv_pwset: Failed to unmarshall NET_Q_SRV_PWSET.\n"));
 141                 return False;
 142         }
 143
 144         r_u.status = _net_srv_pwset(p, &q_u, &r_u);
 145
 146         /* store the response in the SMB stream */
 147         if(!net_io_r_srv_pwset("", &r_u, rdata, 0)) {
 148                 DEBUG(0,("api_net_srv_pwset: Failed to marshall NET_R_SRV_PWSET.\n"));
 149                 return False;
 150         }
 151
 152         return True;
 153 }
 154
 155 /*************************************************************************
 156  api_net_sam_logoff:
 157  *************************************************************************/
 158
 159 static BOOL api_net_sam_logoff(pipes_struct *p)
 160 {
 161         NET_Q_SAM_LOGOFF q_u;
 162         NET_R_SAM_LOGOFF r_u;
 163         prs_struct *data = &p->in_data.data;
 164         prs_struct *rdata = &p->out_data.rdata;
 165
 166         ZERO_STRUCT(q_u);
 167         ZERO_STRUCT(r_u);
 168
 169         if(!net_io_q_sam_logoff("", &q_u, data, 0)) {
 170                 DEBUG(0,("api_net_sam_logoff: Failed to unmarshall NET_Q_SAM_LOGOFF.\n"));
 171                 return False;
 172         }
 173
 174         r_u.status = _net_sam_logoff(p, &q_u, &r_u);
 175
 176         /* store the response in the SMB stream */
 177         if(!net_io_r_sam_logoff("", &r_u, rdata, 0)) {
 178                 DEBUG(0,("api_net_sam_logoff: Failed to marshall NET_R_SAM_LOGOFF.\n"));
 179                 return False;
 180         }
 181
 182         return True;
 183 }
 184
 185 /*************************************************************************
 186  api_net_sam_logon:
 187  *************************************************************************/
 188
 189 static BOOL api_net_sam_logon(pipes_struct *p)
 190 {
 191         NET_Q_SAM_LOGON q_u;
 192         NET_R_SAM_LOGON r_u;
 193         prs_struct *data = &p->in_data.data;
 194         prs_struct *rdata = &p->out_data.rdata;
 195
 196         ZERO_STRUCT(q_u);
 197         ZERO_STRUCT(r_u);
 198
 199         if(!net_io_q_sam_logon("", &q_u, data, 0)) {
 200                 DEBUG(0, ("api_net_sam_logon: Failed to unmarshall NET_Q_SAM_LOGON.\n"));
 201                 return False;
 202         }
 203
 204         r_u.status = _net_sam_logon(p, &q_u, &r_u);
 205
 206         /* store the response in the SMB stream */
 207         if(!net_io_r_sam_logon("", &r_u, rdata, 0)) {
 208                 DEBUG(0,("api_net_sam_logon: Failed to marshall NET_R_SAM_LOGON.\n"));
 209                 return False;
 210         }
 211
 212         return True;
 213 }
 214
 215 /*************************************************************************
 216  api_net_trust_dom_list:
 217  *************************************************************************/
 218
 219 static BOOL api_net_trust_dom_list(pipes_struct *p)
 220 {
 221         NET_Q_TRUST_DOM_LIST q_u;
 222         NET_R_TRUST_DOM_LIST r_u;
 223         prs_struct *data = &p->in_data.data;
 224         prs_struct *rdata = &p->out_data.rdata;
 225
 226         ZERO_STRUCT(q_u);
 227         ZERO_STRUCT(r_u);
 228
 229         /* grab the lsa trusted domain list query... */
 230         if(!net_io_q_trust_dom("", &q_u, data, 0)) {
 231                 DEBUG(0,("api_net_trust_dom_list: Failed to unmarshall NET_Q_TRUST_DOM_LIST.\n"));
 232                 return False;
 233         }
 234
 235         /* construct reply. */
 236         r_u.status = _net_trust_dom_list(p, &q_u, &r_u);
 237
 238         /* store the response in the SMB stream */
 239         if(!net_io_r_trust_dom("", &r_u, rdata, 0)) {
 240                 DEBUG(0,("net_reply_trust_dom_list: Failed to marshall NET_R_TRUST_DOM_LIST.\n"));
 241                 return False;
 242         }
 243
 244         return True;
 245 }
 246
 247 /*************************************************************************
 248  api_net_logon_ctrl2:
 249  *************************************************************************/
 250
 251 static BOOL api_net_logon_ctrl2(pipes_struct *p)
 252 {
 253         NET_Q_LOGON_CTRL2 q_u;
 254         NET_R_LOGON_CTRL2 r_u;
 255         prs_struct *data = &p->in_data.data;
 256         prs_struct *rdata = &p->out_data.rdata;
 257
 258         ZERO_STRUCT(q_u);
 259         ZERO_STRUCT(r_u);
 260
 261
 262         /* grab the lsa netlogon ctrl2 query... */
 263         if(!net_io_q_logon_ctrl2("", &q_u, data, 0)) {
 264                 DEBUG(0,("api_net_logon_ctrl2: Failed to unmarshall NET_Q_LOGON_CTRL2.\n"));
 265                 return False;
 266         }
 267
 268         r_u.status = _net_logon_ctrl2(p, &q_u, &r_u);
 269
 270         if(!net_io_r_logon_ctrl2("", &r_u, rdata, 0)) {
 271                 DEBUG(0,("net_reply_logon_ctrl2: Failed to marshall NET_R_LOGON_CTRL2.\n"));
 272                 return False;
 273         }
 274
 275         return True;
 276 }
 277
 278 /*************************************************************************
 279  api_net_logon_ctrl:
 280  *************************************************************************/
 281
 282 static BOOL api_net_logon_ctrl(pipes_struct *p)
 283 {
 284         NET_Q_LOGON_CTRL q_u;
 285         NET_R_LOGON_CTRL r_u;
 286         prs_struct *data = &p->in_data.data;
 287         prs_struct *rdata = &p->out_data.rdata;
 288
 289         ZERO_STRUCT(q_u);
 290         ZERO_STRUCT(r_u);
 291
 292         /* grab the lsa netlogon ctrl query... */
 293         if(!net_io_q_logon_ctrl("", &q_u, data, 0)) {
 294                 DEBUG(0,("api_net_logon_ctrl: Failed to unmarshall NET_Q_LOGON_CTRL.\n"));
 295                 return False;
 296         }
 297
 298         r_u.status = _net_logon_ctrl(p, &q_u, &r_u);
 299
 300         if(!net_io_r_logon_ctrl("", &r_u, rdata, 0)) {
 301                 DEBUG(0,("net_reply_logon_ctrl2: Failed to marshall NET_R_LOGON_CTRL.\n"));
 302                 return False;
 303         }
 304
 305         return True;
 306 }
 307
 308 /*************************************************************************
 309  api_net_sam_logon_ex:
 310  *************************************************************************/
 311
 312 static BOOL api_net_sam_logon_ex(pipes_struct *p)
 313 {
 314         NET_Q_SAM_LOGON_EX q_u;
 315         NET_R_SAM_LOGON_EX r_u;
 316         prs_struct *data = &p->in_data.data;
 317         prs_struct *rdata = &p->out_data.rdata;
 318
 319         ZERO_STRUCT(q_u);
 320         ZERO_STRUCT(r_u);
 321
 322         if(!net_io_q_sam_logon_ex("", &q_u, data, 0)) {
 323                 DEBUG(0, ("api_net_sam_logon_ex: Failed to unmarshall NET_Q_SAM_LOGON_EX.\n"));
 324                 return False;
 325         }
 326
 327         r_u.status = _net_sam_logon_ex(p, &q_u, &r_u);
 328
 329         /* store the response in the SMB stream */
 330         if(!net_io_r_sam_logon_ex("", &r_u, rdata, 0)) {
 331                 DEBUG(0,("api_net_sam_logon_ex: Failed to marshall NET_R_SAM_LOGON_EX.\n"));
 332                 return False;
 333         }
 334
 335         return True;
 336 }
 337
 338
 339 /*************************************************************************
 340  api_ds_enum_dom_trusts:
 341  *************************************************************************/
 342
 343 #if 0   /* JERRY */
 344 static BOOL api_ds_enum_dom_trusts(pipes_struct *p)
 345 {
 346         DS_Q_ENUM_DOM_TRUSTS q_u;
 347         DS_R_ENUM_DOM_TRUSTS r_u;
 348
 349         prs_struct *data = &p->in_data.data;
 350         prs_struct *rdata = &p->out_data.rdata;
 351
 352         ZERO_STRUCT(q_u);
 353         ZERO_STRUCT(r_u);
 354
 355         DEBUG(6,("api_ds_enum_dom_trusts\n"));
 356
 357         if ( !ds_io_q_enum_domain_trusts("", data, 0, &q_u) ) {
 358                 DEBUG(0,("api_ds_enum_domain_trusts: Failed to unmarshall DS_Q_ENUM_DOM_TRUSTS.\n"));
 359                 return False;
 360         }
 361
 362         r_u.status = _ds_enum_dom_trusts(p, &q_u, &r_u);
 363
 364         if ( !ds_io_r_enum_domain_trusts("", rdata, 0, &r_u) ) {
 365                 DEBUG(0,("api_ds_enum_domain_trusts: Failed to marshall DS_R_ENUM_DOM_TRUSTS.\n"));
 366                 return False;
 367         }
 368
 369         DEBUG(6,("api_ds_enum_dom_trusts\n"));
 370
 371         return True;
 372 }
 373 #endif  /* JERRY */
 374
 375 /*******************************************************************
 376  array of \PIPE\NETLOGON operations
 377  ********************************************************************/
 378 static struct api_struct api_net_cmds [] =
 379     {
 380       { "NET_REQCHAL"       , NET_REQCHAL       , api_net_req_chal       },
 381       { "NET_AUTH"          , NET_AUTH          , api_net_auth           },
 382       { "NET_AUTH2"         , NET_AUTH2         , api_net_auth_2         },
 383       { "NET_SRVPWSET"      , NET_SRVPWSET      , api_net_srv_pwset      },
 384       { "NET_SAMLOGON"      , NET_SAMLOGON      , api_net_sam_logon      },
 385       { "NET_SAMLOGOFF"     , NET_SAMLOGOFF     , api_net_sam_logoff     },
 386       { "NET_LOGON_CTRL2"   , NET_LOGON_CTRL2   , api_net_logon_ctrl2    },
 387       { "NET_TRUST_DOM_LIST", NET_TRUST_DOM_LIST, api_net_trust_dom_list },
 388       { "NET_LOGON_CTRL"    , NET_LOGON_CTRL    , api_net_logon_ctrl     },
 389       { "NET_SAMLOGON_EX"   , NET_SAMLOGON_EX   , api_net_sam_logon_ex   },
 390 #if 0   /* JERRY */
 391       { "DS_ENUM_DOM_TRUSTS", DS_ENUM_DOM_TRUSTS, api_ds_enum_dom_trusts }
 392 #endif  /* JERRY */
 393     };
 394
 395 void netlog_get_pipe_fns( struct api_struct **fns, int *n_fns )
 396 {
 397         *fns = api_net_cmds;
 398         *n_fns = sizeof(api_net_cmds) / sizeof(struct api_struct);
 399 }
 400
 401 NTSTATUS rpc_net_init(void)
 402 {
 403   return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "NETLOGON", "lsass", api_net_cmds,
 404                                     sizeof(api_net_cmds) / sizeof(struct api_struct));
 405 }