source/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  ********************************************************************/
  33
  34 static bool proxy_netr_call(pipes_struct *p, uint8 opnum)
  35 {
  36         struct api_struct *fns;
  37         int n_fns;
  38
  39         netlogon_get_pipe_fns(&fns, &n_fns);
  40
  41         if (opnum >= n_fns) {
  42                 return false;
  43         }
  44
  45         if (fns[opnum].opnum != opnum) {
  46                 smb_panic("NETLOGON function table not sorted");
  47         }
  48
  49         return fns[opnum].fn(p);
  50 }
  51
  52 /*************************************************************************
  53  api_net_req_chal:
  54  *************************************************************************/
  55
  56 static bool api_net_req_chal(pipes_struct *p)
  57 {
  58         NET_Q_REQ_CHAL q_u;
  59         NET_R_REQ_CHAL r_u;
  60         prs_struct *data = &p->in_data.data;
  61         prs_struct *rdata = &p->out_data.rdata;
  62
  63         ZERO_STRUCT(q_u);
  64         ZERO_STRUCT(r_u);
  65
  66         /* grab the challenge... */
  67         if(!net_io_q_req_chal("", &q_u, data, 0)) {
  68                 DEBUG(0,("api_net_req_chal: Failed to unmarshall NET_Q_REQ_CHAL.\n"));
  69                 return False;
  70         }
  71
  72         r_u.status = _net_req_chal(p, &q_u, &r_u);
  73
  74         /* store the response in the SMB stream */
  75         if(!net_io_r_req_chal("", &r_u, rdata, 0)) {
  76                 DEBUG(0,("api_net_req_chal: Failed to marshall NET_R_REQ_CHAL.\n"));
  77                 return False;
  78         }
  79
  80         return True;
  81 }
  82
  83 /*************************************************************************
  84  api_net_auth:
  85  *************************************************************************/
  86
  87 static bool api_net_auth(pipes_struct *p)
  88 {
  89         NET_Q_AUTH q_u;
  90         NET_R_AUTH r_u;
  91         prs_struct *data = &p->in_data.data;
  92         prs_struct *rdata = &p->out_data.rdata;
  93
  94         ZERO_STRUCT(q_u);
  95         ZERO_STRUCT(r_u);
  96
  97         /* grab the challenge... */
  98         if(!net_io_q_auth("", &q_u, data, 0)) {
  99                 DEBUG(0,("api_net_auth: Failed to unmarshall NET_Q_AUTH.\n"));
 100                 return False;
 101         }
 102
 103         r_u.status = _net_auth(p, &q_u, &r_u);
 104
 105         /* store the response in the SMB stream */
 106         if(!net_io_r_auth("", &r_u, rdata, 0)) {
 107                 DEBUG(0,("api_net_auth: Failed to marshall NET_R_AUTH.\n"));
 108                 return False;
 109         }
 110
 111         return True;
 112 }
 113
 114 /*************************************************************************
 115  api_net_auth_2:
 116  *************************************************************************/
 117
 118 static bool api_net_auth_2(pipes_struct *p)
 119 {
 120         NET_Q_AUTH_2 q_u;
 121         NET_R_AUTH_2 r_u;
 122         prs_struct *data = &p->in_data.data;
 123         prs_struct *rdata = &p->out_data.rdata;
 124
 125         ZERO_STRUCT(q_u);
 126         ZERO_STRUCT(r_u);
 127
 128         /* grab the challenge... */
 129         if(!net_io_q_auth_2("", &q_u, data, 0)) {
 130                 DEBUG(0,("api_net_auth_2: Failed to unmarshall NET_Q_AUTH_2.\n"));
 131                 return False;
 132         }
 133
 134         r_u.status = _net_auth_2(p, &q_u, &r_u);
 135
 136         /* store the response in the SMB stream */
 137         if(!net_io_r_auth_2("", &r_u, rdata, 0)) {
 138                 DEBUG(0,("api_net_auth_2: Failed to marshall NET_R_AUTH_2.\n"));
 139                 return False;
 140         }
 141
 142         return True;
 143 }
 144
 145 /*************************************************************************
 146  api_net_srv_pwset:
 147  *************************************************************************/
 148
 149 static bool api_net_srv_pwset(pipes_struct *p)
 150 {
 151         NET_Q_SRV_PWSET q_u;
 152         NET_R_SRV_PWSET r_u;
 153         prs_struct *data = &p->in_data.data;
 154         prs_struct *rdata = &p->out_data.rdata;
 155
 156         ZERO_STRUCT(q_u);
 157         ZERO_STRUCT(r_u);
 158
 159         /* grab the challenge and encrypted password ... */
 160         if(!net_io_q_srv_pwset("", &q_u, data, 0)) {
 161                 DEBUG(0,("api_net_srv_pwset: Failed to unmarshall NET_Q_SRV_PWSET.\n"));
 162                 return False;
 163         }
 164
 165         r_u.status = _net_srv_pwset(p, &q_u, &r_u);
 166
 167         /* store the response in the SMB stream */
 168         if(!net_io_r_srv_pwset("", &r_u, rdata, 0)) {
 169                 DEBUG(0,("api_net_srv_pwset: Failed to marshall NET_R_SRV_PWSET.\n"));
 170                 return False;
 171         }
 172
 173         return True;
 174 }
 175
 176 /*************************************************************************
 177  api_net_sam_logoff:
 178  *************************************************************************/
 179
 180 static bool api_net_sam_logoff(pipes_struct *p)
 181 {
 182         NET_Q_SAM_LOGOFF q_u;
 183         NET_R_SAM_LOGOFF r_u;
 184         prs_struct *data = &p->in_data.data;
 185         prs_struct *rdata = &p->out_data.rdata;
 186
 187         ZERO_STRUCT(q_u);
 188         ZERO_STRUCT(r_u);
 189
 190         if(!net_io_q_sam_logoff("", &q_u, data, 0)) {
 191                 DEBUG(0,("api_net_sam_logoff: Failed to unmarshall NET_Q_SAM_LOGOFF.\n"));
 192                 return False;
 193         }
 194
 195         r_u.status = _net_sam_logoff(p, &q_u, &r_u);
 196
 197         /* store the response in the SMB stream */
 198         if(!net_io_r_sam_logoff("", &r_u, rdata, 0)) {
 199                 DEBUG(0,("api_net_sam_logoff: Failed to marshall NET_R_SAM_LOGOFF.\n"));
 200                 return False;
 201         }
 202
 203         return True;
 204 }
 205
 206 /*************************************************************************
 207  api_net_sam_logon:
 208  *************************************************************************/
 209
 210 static bool api_net_sam_logon(pipes_struct *p)
 211 {
 212         NET_Q_SAM_LOGON q_u;
 213         NET_R_SAM_LOGON r_u;
 214         prs_struct *data = &p->in_data.data;
 215         prs_struct *rdata = &p->out_data.rdata;
 216
 217         ZERO_STRUCT(q_u);
 218         ZERO_STRUCT(r_u);
 219
 220         if(!net_io_q_sam_logon("", &q_u, data, 0)) {
 221                 DEBUG(0, ("api_net_sam_logon: Failed to unmarshall NET_Q_SAM_LOGON.\n"));
 222                 return False;
 223         }
 224
 225         r_u.status = _net_sam_logon(p, &q_u, &r_u);
 226
 227         /* store the response in the SMB stream */
 228         if(!net_io_r_sam_logon("", &r_u, rdata, 0)) {
 229                 DEBUG(0,("api_net_sam_logon: Failed to marshall NET_R_SAM_LOGON.\n"));
 230                 return False;
 231         }
 232
 233         return True;
 234 }
 235
 236 /*************************************************************************
 237  api_net_trust_dom_list:
 238  *************************************************************************/
 239
 240 static bool api_net_trust_dom_list(pipes_struct *p)
 241 {
 242         return proxy_netr_call(p, NDR_NETR_NETRENUMERATETRUSTEDDOMAINS);
 243 }
 244
 245 /*************************************************************************
 246  api_net_logon_ctrl2:
 247  *************************************************************************/
 248
 249 static bool api_net_logon_ctrl2(pipes_struct *p)
 250 {
 251         NET_Q_LOGON_CTRL2 q_u;
 252         NET_R_LOGON_CTRL2 r_u;
 253         prs_struct *data = &p->in_data.data;
 254         prs_struct *rdata = &p->out_data.rdata;
 255
 256         ZERO_STRUCT(q_u);
 257         ZERO_STRUCT(r_u);
 258
 259
 260         /* grab the lsa netlogon ctrl2 query... */
 261         if(!net_io_q_logon_ctrl2("", &q_u, data, 0)) {
 262                 DEBUG(0,("api_net_logon_ctrl2: Failed to unmarshall NET_Q_LOGON_CTRL2.\n"));
 263                 return False;
 264         }
 265
 266         r_u.status = _net_logon_ctrl2(p, &q_u, &r_u);
 267
 268         if(!net_io_r_logon_ctrl2("", &r_u, rdata, 0)) {
 269                 DEBUG(0,("net_reply_logon_ctrl2: Failed to marshall NET_R_LOGON_CTRL2.\n"));
 270                 return False;
 271         }
 272
 273         return True;
 274 }
 275
 276 /*************************************************************************
 277  api_net_logon_ctrl:
 278  *************************************************************************/
 279
 280 static bool api_net_logon_ctrl(pipes_struct *p)
 281 {
 282         return proxy_netr_call(p, NDR_NETR_LOGONCONTROL);
 283 }
 284
 285 /*************************************************************************
 286  api_net_sam_logon_ex:
 287  *************************************************************************/
 288
 289 static bool api_net_sam_logon_ex(pipes_struct *p)
 290 {
 291         NET_Q_SAM_LOGON_EX q_u;
 292         NET_R_SAM_LOGON_EX r_u;
 293         prs_struct *data = &p->in_data.data;
 294         prs_struct *rdata = &p->out_data.rdata;
 295
 296         ZERO_STRUCT(q_u);
 297         ZERO_STRUCT(r_u);
 298
 299         if(!net_io_q_sam_logon_ex("", &q_u, data, 0)) {
 300                 DEBUG(0, ("api_net_sam_logon_ex: Failed to unmarshall NET_Q_SAM_LOGON_EX.\n"));
 301                 return False;
 302         }
 303
 304         r_u.status = _net_sam_logon_ex(p, &q_u, &r_u);
 305
 306         /* store the response in the SMB stream */
 307         if(!net_io_r_sam_logon_ex("", &r_u, rdata, 0)) {
 308                 DEBUG(0,("api_net_sam_logon_ex: Failed to marshall NET_R_SAM_LOGON_EX.\n"));
 309                 return False;
 310         }
 311
 312         return True;
 313 }
 314
 315 /*******************************************************************
 316  array of \PIPE\NETLOGON operations
 317  ********************************************************************/
 318 static struct api_struct api_net_cmds [] =
 319     {
 320       { "NET_REQCHAL"       , NET_REQCHAL       , api_net_req_chal       },
 321       { "NET_AUTH"          , NET_AUTH          , api_net_auth           },
 322       { "NET_AUTH2"         , NET_AUTH2         , api_net_auth_2         },
 323       { "NET_SRVPWSET"      , NET_SRVPWSET      , api_net_srv_pwset      },
 324       { "NET_SAMLOGON"      , NET_SAMLOGON      , api_net_sam_logon      },
 325       { "NET_SAMLOGOFF"     , NET_SAMLOGOFF     , api_net_sam_logoff     },
 326       { "NET_LOGON_CTRL2"   , NET_LOGON_CTRL2   , api_net_logon_ctrl2    },
 327       { "NET_TRUST_DOM_LIST", NET_TRUST_DOM_LIST, api_net_trust_dom_list },
 328       { "NET_LOGON_CTRL"    , NET_LOGON_CTRL    , api_net_logon_ctrl     },
 329       { "NET_SAMLOGON_EX"   , NET_SAMLOGON_EX   , api_net_sam_logon_ex   },
 330     };
 331
 332 void netlog_get_pipe_fns( struct api_struct **fns, int *n_fns )
 333 {
 334         *fns = api_net_cmds;
 335         *n_fns = sizeof(api_net_cmds) / sizeof(struct api_struct);
 336 }
 337
 338 NTSTATUS rpc_net_init(void)
 339 {
 340   return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "NETLOGON", "lsass", api_net_cmds,
 341                                     sizeof(api_net_cmds) / sizeof(struct api_struct));
 342 }