source: trunk-3.0/source/rpc_server/srv_netlog.c@ 101

Last change on this file since 101 was 1, checked in by Paul Smedley, 19 years ago

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