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  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  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         DEBUG(6,("api_net_trust_dom_list: %d\n", __LINE__));
 230
 231         /* grab the lsa trusted domain list query... */
 232         if(!net_io_q_trust_dom("", &q_u, data, 0)) {
 233                 DEBUG(0,("api_net_trust_dom_list: Failed to unmarshall NET_Q_TRUST_DOM_LIST.\n"));
 234                 return False;
 235         }
 236
 237         /* construct reply. */
 238         r_u.status = _net_trust_dom_list(p, &q_u, &r_u);
 239
 240         /* store the response in the SMB stream */
 241         if(!net_io_r_trust_dom("", &r_u, rdata, 0)) {
 242                 DEBUG(0,("net_reply_trust_dom_list: Failed to marshall NET_R_TRUST_DOM_LIST.\n"));
 243                 return False;
 244         }
 245
 246         DEBUG(6,("api_net_trust_dom_list: %d\n", __LINE__));
 247
 248         return True;
 249 }
 250
 251 /*************************************************************************
 252  api_net_logon_ctrl2:
 253  *************************************************************************/
 254
 255 static BOOL api_net_logon_ctrl2(pipes_struct *p)
 256 {
 257         NET_Q_LOGON_CTRL2 q_u;
 258         NET_R_LOGON_CTRL2 r_u;
 259         prs_struct *data = &p->in_data.data;
 260         prs_struct *rdata = &p->out_data.rdata;
 261
 262         ZERO_STRUCT(q_u);
 263         ZERO_STRUCT(r_u);
 264
 265         DEBUG(6,("api_net_logon_ctrl2: %d\n", __LINE__));
 266
 267         /* grab the lsa netlogon ctrl2 query... */
 268         if(!net_io_q_logon_ctrl2("", &q_u, data, 0)) {
 269                 DEBUG(0,("api_net_logon_ctrl2: Failed to unmarshall NET_Q_LOGON_CTRL2.\n"));
 270                 return False;
 271         }
 272
 273         r_u.status = _net_logon_ctrl2(p, &q_u, &r_u);
 274
 275         if(!net_io_r_logon_ctrl2("", &r_u, rdata, 0)) {
 276                 DEBUG(0,("net_reply_logon_ctrl2: Failed to marshall NET_R_LOGON_CTRL2.\n"));
 277                 return False;
 278         }
 279
 280         DEBUG(6,("api_net_logon_ctrl2: %d\n", __LINE__));
 281
 282         return True;
 283 }
 284
 285 /*************************************************************************
 286  api_net_logon_ctrl:
 287  *************************************************************************/
 288
 289 static BOOL api_net_logon_ctrl(pipes_struct *p)
 290 {
 291         NET_Q_LOGON_CTRL q_u;
 292         NET_R_LOGON_CTRL 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         DEBUG(6,("api_net_logon_ctrl: %d\n", __LINE__));
 300
 301         /* grab the lsa netlogon ctrl query... */
 302         if(!net_io_q_logon_ctrl("", &q_u, data, 0)) {
 303                 DEBUG(0,("api_net_logon_ctrl: Failed to unmarshall NET_Q_LOGON_CTRL.\n"));
 304                 return False;
 305         }
 306
 307         r_u.status = _net_logon_ctrl(p, &q_u, &r_u);
 308
 309         if(!net_io_r_logon_ctrl("", &r_u, rdata, 0)) {
 310                 DEBUG(0,("net_reply_logon_ctrl2: Failed to marshall NET_R_LOGON_CTRL2.\n"));
 311                 return False;
 312         }
 313
 314         DEBUG(6,("api_net_logon_ctrl2: %d\n", __LINE__));
 315
 316         return True;
 317 }
 318
 319 /*******************************************************************
 320  array of \PIPE\NETLOGON operations
 321  ********************************************************************/
 322 static struct api_struct api_net_cmds [] =
 323 {
 324         { "NET_REQCHAL"       , NET_REQCHAL       , api_net_req_chal       },
 325         { "NET_AUTH"          , NET_AUTH          , api_net_auth           },
 326         { "NET_AUTH2"         , NET_AUTH2         , api_net_auth_2         },
 327         { "NET_SRVPWSET"      , NET_SRVPWSET      , api_net_srv_pwset      },
 328         { "NET_SAMLOGON"      , NET_SAMLOGON      , api_net_sam_logon      },
 329         { "NET_SAMLOGOFF"     , NET_SAMLOGOFF     , api_net_sam_logoff     },
 330         { "NET_LOGON_CTRL2"   , NET_LOGON_CTRL2   , api_net_logon_ctrl2    },
 331         { "NET_TRUST_DOM_LIST", NET_TRUST_DOM_LIST, api_net_trust_dom_list },
 332         { "NET_LOGON_CTRL"    , NET_LOGON_CTRL    , api_net_logon_ctrl     },
 333         {  NULL               , 0                 , NULL                   }
 334 };
 335
 336 /*******************************************************************
 337  receives a netlogon pipe and responds.
 338  ********************************************************************/
 339
 340 BOOL api_netlog_rpc(pipes_struct *p)
 341 {
 342         return api_rpcTNP(p, "api_netlog_rpc", api_net_cmds);
 343 }