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