3 * Unix SMB/Netbios implementation.
5 * RPC Pipe client / server routines
6 * Copyright (C) Andrew Tridgell 1992-1998,
7 * Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
8 * Copyright (C) Paul Ashton 1997-1998.
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.
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.
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.
32 extern int DEBUGLEVEL;
34 /****************************************************************************
36 ****************************************************************************/
37 BOOL svc_open_sc_man( const char *srv_name, char *db_name,
43 SVC_Q_OPEN_SC_MAN q_o;
44 BOOL valid_pol = False;
46 struct cli_state *cli = NULL;
49 if (!cli_state_init(srv_name, PIPE_SVCCTL, &cli, &fnum))
54 if (hnd == NULL) return False;
56 prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
57 prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True );
59 /* create and send a MSRPC command with api SVC_OPEN_SC_MAN */
61 DEBUG(4,("SVC Open SC_MAN\n"));
63 make_svc_q_open_sc_man(&q_o, srv_name, db_name, des_access);
65 /* turn parameters into data stream */
66 svc_io_q_open_sc_man("", &q_o, &buf, 0);
68 /* send the data on \PIPE\ */
69 if (rpc_api_pipe_req(cli, fnum, SVC_OPEN_SC_MAN, &buf, &rbuf))
71 SVC_R_OPEN_SC_MAN r_o;
76 svc_io_r_open_sc_man("", &r_o, &rbuf, 0);
79 if (p && r_o.status != 0)
81 /* report error code */
82 DEBUG(1,("SVC_OPEN_SC_MAN: %s\n", get_nt_error_msg(r_o.status)));
88 /* ok, at last: we're happy. return the policy handle */
89 memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
91 valid_pol = register_policy_hnd(hnd) &&
92 set_policy_cli_state(hnd, cli, fnum,
104 /****************************************************************************
105 do a SVC Open Service
106 ****************************************************************************/
107 BOOL svc_open_service( POLICY_HND *scm_hnd,
108 const char *srv_name,
114 SVC_Q_OPEN_SERVICE q_o;
115 BOOL valid_pol = False;
117 struct cli_state *cli = NULL;
118 uint16 fnum = 0xffff;
120 if (!cli_state_get(scm_hnd, &cli, &fnum))
125 if (hnd == NULL || scm_hnd == NULL) return False;
127 prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
128 prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True );
130 /* create and send a MSRPC command with api SVC_OPEN_SERVICE */
132 DEBUG(4,("SVC Open Service\n"));
134 make_svc_q_open_service(&q_o, scm_hnd, srv_name, des_access);
136 /* turn parameters into data stream */
137 svc_io_q_open_service("", &q_o, &buf, 0);
139 /* send the data on \PIPE\ */
140 if (rpc_api_pipe_req(cli, fnum, SVC_OPEN_SERVICE, &buf, &rbuf))
142 SVC_R_OPEN_SERVICE r_o;
147 svc_io_r_open_service("", &r_o, &rbuf, 0);
148 p = rbuf.offset != 0;
150 if (p && r_o.status != 0)
152 /* report error code */
153 DEBUG(1,("SVC_OPEN_SC_MAN: %s\n", get_nt_error_msg(r_o.status)));
159 /* ok, at last: we're happy. return the policy handle */
160 memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
161 valid_pol = register_policy_hnd(hnd) &&
162 set_policy_cli_state(hnd, cli, fnum,
174 /****************************************************************************
175 do a SVC Enumerate Services
176 ****************************************************************************/
177 BOOL svc_enum_svcs( POLICY_HND *hnd,
178 uint32 services_type, uint32 services_state,
179 uint32 *buf_size, uint32 *resume_hnd,
181 ENUM_SRVC_STATUS **svcs, uint32 *num_svcs)
185 SVC_Q_ENUM_SVCS_STATUS q_o;
186 BOOL valid_pol = False;
188 struct cli_state *cli = NULL;
189 uint16 fnum = 0xffff;
191 if (!cli_state_get(hnd, &cli, &fnum))
196 if (hnd == NULL || buf_size == NULL || dos_error == NULL || num_svcs == NULL)
201 prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
202 prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True );
204 /* create and send a MSRPC command with api SVC_ENUM_SVCS_STATUS */
206 DEBUG(4,("SVC Enum Services Status\n"));
208 make_svc_q_enum_svcs_status(&q_o, hnd,
209 services_type, services_state,
210 *buf_size, *resume_hnd);
212 /* turn parameters into data stream */
213 svc_io_q_enum_svcs_status("", &q_o, &buf, 0);
215 /* send the data on \PIPE\ */
216 if (rpc_api_pipe_req(cli, fnum, SVC_ENUM_SVCS_STATUS, &buf, &rbuf))
218 SVC_R_ENUM_SVCS_STATUS r_o;
223 svc_io_r_enum_svcs_status("", &r_o, &rbuf, 0);
224 p = rbuf.offset != 0;
226 if (p && r_o.dos_status != 0)
230 if (r_o.dos_status != ERRmoredata)
232 smb_safe_err_msg(ERRDOS, r_o.dos_status,
233 errmsg, sizeof(errmsg));
234 /* report error code */
235 DEBUG(1,("SVC_ENUM_SVCS_STATUS: %s\n", errmsg));
237 p = r_o.dos_status == ERRmoredata;
243 (*num_svcs) = r_o.num_svcs;
244 (*resume_hnd) = get_enum_hnd(&r_o.resume_hnd);
245 (*buf_size) = r_o.more_buf_size;
246 (*dos_error) = r_o.dos_status;
258 /****************************************************************************
259 do a SVC Stop Service
260 ****************************************************************************/
261 BOOL svc_stop_service( POLICY_HND *hnd,
266 SVC_Q_STOP_SERVICE q_c;
267 BOOL valid_cfg = False;
269 struct cli_state *cli = NULL;
270 uint16 fnum = 0xffff;
272 if (!cli_state_get(hnd, &cli, &fnum))
277 if (hnd == NULL) return False;
279 /* create and send a MSRPC command with api SVC_STOP_SERVICE */
281 prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
282 prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True );
284 DEBUG(4,("SVC Stop Service\n"));
286 /* store the parameters */
287 make_svc_q_stop_service(&q_c, hnd, unknown);
289 /* turn parameters into data stream */
290 svc_io_q_stop_service("", &q_c, &buf, 0);
292 /* send the data on \PIPE\ */
293 if (rpc_api_pipe_req(cli, fnum, SVC_STOP_SERVICE, &buf, &rbuf))
295 SVC_R_STOP_SERVICE r_c;
300 svc_io_r_stop_service("", &r_c, &rbuf, 0);
301 p = rbuf.offset != 0;
303 if (p && r_c.status != 0)
305 /* report error code */
306 DEBUG(1,("SVC_START_SERVICE: %s\n", get_nt_error_msg(r_c.status)));
323 /****************************************************************************
324 do a SVC Start Service
325 ****************************************************************************/
326 BOOL svc_start_service( POLICY_HND *hnd,
332 SVC_Q_START_SERVICE q_c;
333 BOOL valid_cfg = False;
335 struct cli_state *cli = NULL;
336 uint16 fnum = 0xffff;
338 if (!cli_state_get(hnd, &cli, &fnum))
343 if (hnd == NULL) return False;
345 /* create and send a MSRPC command with api SVC_START_SERVICE */
347 prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
348 prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True );
350 DEBUG(4,("SVC Start Service\n"));
352 /* store the parameters */
353 make_svc_q_start_service(&q_c, hnd, argc, argv);
355 /* turn parameters into data stream */
356 svc_io_q_start_service("", &q_c, &buf, 0);
358 /* send the data on \PIPE\ */
359 if (rpc_api_pipe_req(cli, fnum, SVC_START_SERVICE, &buf, &rbuf))
361 SVC_R_START_SERVICE r_c;
366 svc_io_r_start_service("", &r_c, &rbuf, 0);
367 p = rbuf.offset != 0;
369 if (p && r_c.status != 0)
371 /* report error code */
372 DEBUG(1,("SVC_START_SERVICE: %s\n", get_nt_error_msg(r_c.status)));
389 /****************************************************************************
390 do a SVC Query Service Config
391 ****************************************************************************/
392 BOOL svc_query_svc_cfg( POLICY_HND *hnd,
393 QUERY_SERVICE_CONFIG *cfg,
398 SVC_Q_QUERY_SVC_CONFIG q_c;
399 BOOL valid_cfg = False;
401 struct cli_state *cli = NULL;
402 uint16 fnum = 0xffff;
404 if (!cli_state_get(hnd, &cli, &fnum))
409 if (hnd == NULL || buf_size == NULL) return False;
411 /* create and send a MSRPC command with api SVC_QUERY_SVC_CONFIG */
413 prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
414 prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True );
416 DEBUG(4,("SVC Query Service Config\n"));
418 /* store the parameters */
419 make_svc_q_query_svc_config(&q_c, hnd, *buf_size);
421 /* turn parameters into data stream */
422 svc_io_q_query_svc_config("", &q_c, &buf, 0);
424 /* send the data on \PIPE\ */
425 if (rpc_api_pipe_req(cli, fnum, SVC_QUERY_SVC_CONFIG, &buf, &rbuf))
427 SVC_R_QUERY_SVC_CONFIG r_c;
435 svc_io_r_query_svc_config("", &r_c, &rbuf, 0);
436 p = rbuf.offset != 0;
438 if (p && r_c.status != 0)
440 /* report error code */
441 DEBUG(1,("SVC_QUERY_SVC_CONFIG: %s\n", get_nt_error_msg(r_c.status)));
447 valid_cfg = r_c.buf_size != 0;
458 /****************************************************************************
460 ****************************************************************************/
461 BOOL svc_close(POLICY_HND *hnd)
466 BOOL valid_close = False;
468 struct cli_state *cli = NULL;
469 uint16 fnum = 0xffff;
471 if (!cli_state_get(hnd, &cli, &fnum))
476 if (hnd == NULL) return False;
478 /* create and send a MSRPC command with api SVC_CLOSE */
480 prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
481 prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True );
483 DEBUG(4,("SVC Close\n"));
485 /* store the parameters */
486 make_svc_q_close(&q_c, hnd);
488 /* turn parameters into data stream */
489 svc_io_q_close("", &q_c, &buf, 0);
491 /* send the data on \PIPE\ */
492 if (rpc_api_pipe_req(cli, fnum, SVC_CLOSE, &buf, &rbuf))
499 svc_io_r_close("", &r_c, &rbuf, 0);
500 p = rbuf.offset != 0;
502 if (p && r_c.status != 0)
504 /* report error code */
505 DEBUG(1,("SVC_CLOSE: %s\n", get_nt_error_msg(r_c.status)));
511 /* check that the returned policy handle is all zeros */
515 for (i = 0; i < sizeof(r_c.pol.data); i++)
517 if (r_c.pol.data[i] != 0)
525 DEBUG(1,("SVC_CLOSE: non-zero handle returned\n"));
530 close_policy_hnd(hnd);
538 /****************************************************************************
539 do a SVC Change Service Config
540 ****************************************************************************/
541 BOOL svc_change_svc_cfg( POLICY_HND *hnd,
542 uint32 service_type, uint32 start_type,
544 uint32 error_control,
545 char* bin_path_name, char* load_order_grp,
547 char* dependencies, char* service_start_name,
553 SVC_Q_CHANGE_SVC_CONFIG q_c;
554 BOOL valid_cfg = False;
556 struct cli_state *cli = NULL;
557 uint16 fnum = 0xffff;
559 if (!cli_state_get(hnd, &cli, &fnum))
564 if (hnd == NULL) return False;
566 /* create and send a MSRPC command with api SVC_CHANGE_SVC_CONFIG */
568 prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
569 prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True );
571 DEBUG(4,("SVC Change Service Config\n"));
573 /* store the parameters */
574 make_svc_q_change_svc_config(&q_c, hnd,
575 service_type, start_type,
576 unknown_0, error_control,
577 bin_path_name, load_order_grp,
579 dependencies, service_start_name,
580 password, disp_name);
582 /* turn parameters into data stream */
583 svc_io_q_change_svc_config("", &q_c, &buf, 0);
585 /* send the data on \PIPE\ */
586 if (rpc_api_pipe_req(cli, fnum, SVC_CHANGE_SVC_CONFIG, &buf, &rbuf))
588 SVC_R_CHANGE_SVC_CONFIG r_c;
593 svc_io_r_change_svc_config("", &r_c, &rbuf, 0);
594 p = rbuf.offset != 0;
596 if (p && r_c.status != 0)
598 /* report error code */
599 DEBUG(1,("SVC_CHANGE_SVC_CONFIG: %s\n", get_nt_error_msg(r_c.status)));