2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Gerald (Jerry) Carter 2005,
5 * Copyright (C) Marcin Krzysztof Porwit 2005.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 /* TODO - Do the OpenService service name matching case-independently, or at least make it an option. */
28 #define DBGC_CLASS DBGC_RPC_SRV
30 #define SERVICEDB_VERSION_V1 1 /* Will there be more? */
31 #define INTERNAL_SERVICES_LIST "NETLOGON Spooler"
34 /* scripts will execute from the following libdir, if they are in the enable svcctl=<list of scripts> */
35 /* these should likely be symbolic links. Note that information about them will be extracted from the files themselves */
36 /* using the LSB standard keynames for various information */
38 #define SVCCTL_SCRIPT_DIR "/svcctl/"
41 struct service_control_op_table
{
43 SERVICE_CONTROL_OPS
*ops
;
46 extern SERVICE_CONTROL_OPS spoolss_svc_ops
;
48 struct service_control_op_table svcctl_ops
[] = {
49 { "Spooler", &spoolss_svc_ops
},
55 /********************************************************************
56 ********************************************************************/
58 static NTSTATUS
svcctl_access_check( SEC_DESC
*sec_desc
, NT_USER_TOKEN
*token
,
59 uint32 access_desired
, uint32
*access_granted
)
63 /* maybe add privilege checks in here later */
65 se_access_check( sec_desc
, token
, access_desired
, access_granted
, &result
);
70 /********************************************************************
71 ********************************************************************/
73 static SEC_DESC
* construct_scm_sd( TALLOC_CTX
*ctx
)
82 /* basic access for Everyone */
84 init_sec_access(&mask
, SC_MANAGER_READ_ACCESS
);
85 init_sec_ace(&ace
[i
++], &global_sid_World
, SEC_ACE_TYPE_ACCESS_ALLOWED
, mask
, 0);
87 /* Full Access 'BUILTIN\Administrators' */
89 init_sec_access(&mask
,SC_MANAGER_ALL_ACCESS
);
90 init_sec_ace(&ace
[i
++], &global_sid_Builtin_Administrators
, SEC_ACE_TYPE_ACCESS_ALLOWED
, mask
, 0);
93 /* create the security descriptor */
95 if ( !(acl
= make_sec_acl(ctx
, NT4_ACL_REVISION
, i
, ace
)) )
98 if ( !(sd
= make_sec_desc(ctx
, SEC_DESC_REVISION
, SEC_DESC_SELF_RELATIVE
, NULL
, NULL
, NULL
, acl
, &sd_size
)) )
104 /********************************************************************
105 ********************************************************************/
107 static SEC_DESC
* construct_service_sd( TALLOC_CTX
*ctx
)
116 /* basic access for Everyone */
118 init_sec_access(&mask
, SERVICE_READ_ACCESS
);
119 init_sec_ace(&ace
[i
++], &global_sid_World
, SEC_ACE_TYPE_ACCESS_ALLOWED
, mask
, 0);
121 init_sec_access(&mask
,SERVICE_EXECUTE_ACCESS
);
122 init_sec_ace(&ace
[i
++], &global_sid_Builtin_Power_Users
, SEC_ACE_TYPE_ACCESS_ALLOWED
, mask
, 0);
124 init_sec_access(&mask
,SERVICE_ALL_ACCESS
);
125 init_sec_ace(&ace
[i
++], &global_sid_Builtin_Server_Operators
, SEC_ACE_TYPE_ACCESS_ALLOWED
, mask
, 0);
126 init_sec_ace(&ace
[i
++], &global_sid_Builtin_Administrators
, SEC_ACE_TYPE_ACCESS_ALLOWED
, mask
, 0);
128 /* create the security descriptor */
130 if ( !(acl
= make_sec_acl(ctx
, NT4_ACL_REVISION
, i
, ace
)) )
133 if ( !(sd
= make_sec_desc(ctx
, SEC_DESC_REVISION
, SEC_DESC_SELF_RELATIVE
, NULL
, NULL
, NULL
, acl
, &sd_size
)) )
139 /******************************************************************
140 free() function for REGISTRY_KEY
141 *****************************************************************/
143 static void free_service_handle_info(void *ptr
)
145 SERVICE_INFO
*info
= (SERVICE_INFO
*)ptr
;
147 SAFE_FREE(info
->name
);
151 /******************************************************************
152 Find a registry key handle and return a SERVICE_INFO
153 *****************************************************************/
155 static SERVICE_INFO
*find_service_info_by_hnd(pipes_struct
*p
, POLICY_HND
*hnd
)
157 SERVICE_INFO
*service_info
= NULL
;
159 if( !find_policy_by_hnd( p
, hnd
, (void **)&service_info
) ) {
160 DEBUG(2,("find_service_info_by_hnd: handle not found"));
167 /******************************************************************
168 *****************************************************************/
170 static WERROR
create_open_service_handle( pipes_struct
*p
, POLICY_HND
*handle
,
171 const char *service
, uint32 access_granted
)
173 SERVICE_INFO
*info
= NULL
;
175 if ( !(info
= SMB_MALLOC_P( SERVICE_INFO
)) )
178 ZERO_STRUCTP( info
);
180 /* the Service Manager has a NULL name */
183 info
->type
= SVC_HANDLE_IS_SCM
;
187 info
->type
= SVC_HANDLE_IS_SERVICE
;
189 if ( !(info
->name
= SMB_STRDUP( service
)) ) {
190 free_service_handle_info( info
);
194 /* lookup the SERVICE_CONTROL_OPS */
196 for ( i
=0; svcctl_ops
[i
].name
; i
++ ) {
197 if ( strequal( svcctl_ops
[i
].name
, service
) )
198 info
->ops
= svcctl_ops
[i
].ops
;
202 info
->access_granted
= access_granted
;
204 /* store the SERVICE_INFO and create an open handle */
206 if ( !create_policy_hnd( p
, handle
, free_service_handle_info
, info
) ) {
207 free_service_handle_info( info
);
208 return WERR_ACCESS_DENIED
;
214 /********************************************************************
215 ********************************************************************/
217 WERROR
_svcctl_open_scmanager(pipes_struct
*p
, SVCCTL_Q_OPEN_SCMANAGER
*q_u
, SVCCTL_R_OPEN_SCMANAGER
*r_u
)
220 uint32 access_granted
= 0;
223 /* perform access checks */
225 if ( !(sec_desc
= construct_scm_sd( p
->mem_ctx
)) )
228 status
= svcctl_access_check( sec_desc
, p
->pipe_user
.nt_user_token
, q_u
->access
, &access_granted
);
229 if ( !NT_STATUS_IS_OK(status
) )
230 return ntstatus_to_werror( status
);
232 return create_open_service_handle( p
, &r_u
->handle
, NULL
, access_granted
);
235 /********************************************************************
236 ********************************************************************/
238 WERROR
_svcctl_open_service(pipes_struct
*p
, SVCCTL_Q_OPEN_SERVICE
*q_u
, SVCCTL_R_OPEN_SERVICE
*r_u
)
241 uint32 access_granted
= 0;
244 SERVICE_INFO
*scm_info
;
246 rpcstr_pull(service
, q_u
->servicename
.buffer
, sizeof(service
), q_u
->servicename
.uni_str_len
*2, 0);
248 DEBUG(5, ("_svcctl_open_service: Attempting to open Service [%s], \n", service
));
251 /* based on my tests you can open a service if you have a valid scm handle */
253 if ( !(scm_info
= find_service_info_by_hnd( p
, &q_u
->handle
)) )
256 /* perform access checks */
258 if ( !(sec_desc
= construct_service_sd( p
->mem_ctx
)) )
261 status
= svcctl_access_check( sec_desc
, p
->pipe_user
.nt_user_token
, q_u
->access
, &access_granted
);
262 if ( !NT_STATUS_IS_OK(status
) )
263 return ntstatus_to_werror( status
);
266 if ( ! get_service_info(service_tdb
, service
, info
) ) {
267 return WERR_NO_SUCH_SERVICE
;
270 return create_open_service_handle( p
, &r_u
->handle
, service
, access_granted
);
273 /********************************************************************
274 ********************************************************************/
276 WERROR
_svcctl_close_service(pipes_struct
*p
, SVCCTL_Q_CLOSE_SERVICE
*q_u
, SVCCTL_R_CLOSE_SERVICE
*r_u
)
278 return close_policy_hnd( p
, &q_u
->handle
) ? WERR_OK
: WERR_BADFID
;
281 /********************************************************************
282 ********************************************************************/
284 WERROR
_svcctl_get_display_name(pipes_struct
*p
, SVCCTL_Q_GET_DISPLAY_NAME
*q_u
, SVCCTL_R_GET_DISPLAY_NAME
*r_u
)
288 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
290 /* can only use an SCM handle here */
292 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SCM
) )
295 rpcstr_pull(service
, q_u
->servicename
.buffer
, sizeof(service
), q_u
->servicename
.uni_str_len
*2, 0);
297 /* need a tdb lookup here or something */
299 fstrcpy( displayname
, "FIX ME!" );
301 init_svcctl_r_get_display_name( r_u
, displayname
);
306 /********************************************************************
307 ********************************************************************/
309 WERROR
_svcctl_query_status(pipes_struct
*p
, SVCCTL_Q_QUERY_STATUS
*q_u
, SVCCTL_R_QUERY_STATUS
*r_u
)
311 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
313 /* perform access checks */
315 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
318 if ( !(info
->access_granted
& SC_RIGHT_SVC_QUERY_STATUS
) )
319 return WERR_ACCESS_DENIED
;
321 /* try the service specific status call */
324 return info
->ops
->service_status( &r_u
->svc_status
);
326 /* default action for now */
328 r_u
->svc_status
.type
= 0x0020;
329 r_u
->svc_status
.state
= 0x0004;
330 r_u
->svc_status
.controls_accepted
= 0x0005;
336 /*********************************************************************
337 TODO - for internal services, do similar to external services, except
338 we have to call the right status routine...
339 **********************************************************************/
341 static WERROR
enum_internal_services(TALLOC_CTX
*tcx
,ENUM_SERVICES_STATUS
**svc_ptr
, int existing_services
, int *added
)
343 int num_services
= 2;
345 ENUM_SERVICES_STATUS
*services
=NULL
;
347 if (!svc_ptr
|| !(*svc_ptr
))
353 /* *svc_ptr has the pointer to the array if there is one already. NULL if not. */
354 if ((existing_services
>0) && svc_ptr
&& *svc_ptr
) { /* reallocate vs. allocate */
355 DEBUG(8,("enum_internal_services: REALLOCing %d services\n", num_services
));
356 services
= TALLOC_REALLOC_ARRAY(tcx
,*svc_ptr
,ENUM_SERVICES_STATUS
,existing_services
+num_services
);
361 if ( !(services
= TALLOC_ARRAY( tcx
, ENUM_SERVICES_STATUS
, num_services
)) )
366 if (existing_services
> 0) {
367 i
+= existing_services
;
369 DEBUG(8,("enum_internal_services: Creating %d services, starting index %d\n", num_services
,existing_services
));
371 init_unistr( &services
[i
].servicename
, "Spooler" );
372 init_unistr( &services
[i
].displayname
, "Print Spooler" );
374 services
[i
].status
.type
= 0x110;
375 services
[i
].status
.controls_accepted
= 0x0;
376 services
[i
].status
.win32_exit_code
= 0x0;
377 services
[i
].status
.service_exit_code
= 0x0;
378 services
[i
].status
.check_point
= 0x0;
379 services
[i
].status
.wait_hint
= 0x0;
380 if ( !lp_disable_spoolss() )
381 services
[i
].status
.state
= SVCCTL_RUNNING
;
383 services
[i
].status
.state
= SVCCTL_STOPPED
;
387 init_unistr( &services
[i
].servicename
, "NETLOGON" );
388 init_unistr( &services
[i
].displayname
, "Net Logon" );
390 services
[i
].status
.type
= 0x20;
391 services
[i
].status
.controls_accepted
= 0x0;
392 services
[i
].status
.win32_exit_code
= 0x0;
393 services
[i
].status
.service_exit_code
= 0x0;
394 services
[i
].status
.check_point
= 0x0;
395 services
[i
].status
.wait_hint
= 0x0;
396 if ( lp_servicenumber("NETLOGON") != -1 )
397 services
[i
].status
.state
= SVCCTL_RUNNING
;
399 services
[i
].status
.state
= SVCCTL_STOPPED
;
401 *added
= num_services
;
406 /********************************************************************
407 ********************************************************************/
409 WERROR
_svcctl_enum_services_status(pipes_struct
*p
, SVCCTL_Q_ENUM_SERVICES_STATUS
*q_u
, SVCCTL_R_ENUM_SERVICES_STATUS
*r_u
)
411 ENUM_SERVICES_STATUS
*services
= NULL
;
412 uint32 num_int_services
= 0;
413 uint32 num_ext_services
= 0;
416 WERROR result
= WERR_OK
;
417 WERROR ext_result
= WERR_OK
;
418 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
420 /* perform access checks */
422 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SCM
) )
425 if ( !(info
->access_granted
& SC_RIGHT_MGR_ENUMERATE_SERVICE
) )
426 return WERR_ACCESS_DENIED
;
428 /* num_services = str_list_count( lp_enable_svcctl() ); */
430 /* here's where we'll read the db of external services */
431 /* _svcctl_read_LSB_data(NULL,NULL); */
432 /* init_svcctl_db(); */
434 num_int_services
= 0;
436 num_int_services
= num_internal_services();
438 num_ext_services
= num_external_services();
440 if ( !(services
= TALLOC_ARRAY(p
->mem_ctx
, ENUM_SERVICES_STATUS
, num_int_services
+num_ext_services
)) )
443 result
= enum_internal_services(p
->mem_ctx
, &services
, 0, &num_int_services
);
445 if (W_ERROR_IS_OK(result
)) {
446 DEBUG(8,("_svcctl_enum_services_status: Got %d internal services\n", num_int_services
));
449 ext_result
=enum_external_services(p
->mem_ctx
, &services
, num_int_services
, &num_ext_services
);
451 if (W_ERROR_IS_OK(ext_result
)) {
452 DEBUG(8,("_svcctl_enum_services_status: Got %d external services\n", num_ext_services
));
455 DEBUG(8,("_svcctl_enum_services_status: total of %d services\n", num_int_services
+num_ext_services
));
458 for (i
=0;i
<num_int_services
+num_ext_services
;i
++) {
459 buffer_size
+= svcctl_sizeof_enum_services_status(&services
[i
]);
463 buffer_size
+= buffer_size
% 4;
464 DEBUG(8,("_svcctl_enum_services_status: buffer size passed %d, we need %d\n",
465 q_u
->buffer_size
, buffer_size
));
467 if (buffer_size
> q_u
->buffer_size
) {
468 num_int_services
= 0;
469 num_ext_services
= 0;
470 result
= WERR_MORE_DATA
;
473 rpcbuf_init(&r_u
->buffer
, q_u
->buffer_size
, p
->mem_ctx
);
475 if ( W_ERROR_IS_OK(result
) ) {
476 for ( i
=0; i
<num_int_services
+num_ext_services
; i
++ )
477 svcctl_io_enum_services_status( "", &services
[i
], &r_u
->buffer
, 0 );
480 r_u
->needed
= (buffer_size
> q_u
->buffer_size
) ? buffer_size
: q_u
->buffer_size
;
481 r_u
->returned
= num_int_services
+num_ext_services
;
483 if ( !(r_u
->resume
= TALLOC_P( p
->mem_ctx
, uint32
)) )
491 /********************************************************************
492 ********************************************************************/
494 WERROR
_svcctl_start_service(pipes_struct
*p
, SVCCTL_Q_START_SERVICE
*q_u
, SVCCTL_R_START_SERVICE
*r_u
)
496 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
498 /* perform access checks */
500 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
503 if ( !(info
->access_granted
& SC_RIGHT_SVC_START
) )
504 return WERR_ACCESS_DENIED
;
506 return info
->ops
->start_service();
509 /********************************************************************
510 ********************************************************************/
512 WERROR
_svcctl_control_service(pipes_struct
*p
, SVCCTL_Q_CONTROL_SERVICE
*q_u
, SVCCTL_R_CONTROL_SERVICE
*r_u
)
514 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
516 /* perform access checks */
517 /* we only support stop so don't get complicated */
519 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
522 if ( q_u
->control
!= SVCCTL_CONTROL_STOP
)
523 return WERR_ACCESS_DENIED
;
525 if ( !(info
->access_granted
& SC_RIGHT_SVC_STOP
) )
526 return WERR_ACCESS_DENIED
;
528 return info
->ops
->stop_service( &r_u
->svc_status
);
531 /********************************************************************
532 ********************************************************************/
534 WERROR
_svcctl_enum_dependent_services( pipes_struct
*p
, SVCCTL_Q_ENUM_DEPENDENT_SERVICES
*q_u
, SVCCTL_R_ENUM_DEPENDENT_SERVICES
*r_u
)
536 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
538 /* perform access checks */
540 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
543 if ( !(info
->access_granted
& SC_RIGHT_SVC_ENUMERATE_DEPENDENTS
) )
544 return WERR_ACCESS_DENIED
;
546 /* we have to set the outgoing buffer size to the same as the
547 incoming buffer size (even in the case of failure */
549 rpcbuf_init( &r_u
->buffer
, q_u
->buffer_size
, p
->mem_ctx
);
551 r_u
->needed
= q_u
->buffer_size
;
553 /* no dependent services...basically a stub function */
559 /********************************************************************
560 ********************************************************************/
562 WERROR
_svcctl_query_service_status_ex( pipes_struct
*p
, SVCCTL_Q_QUERY_SERVICE_STATUSEX
*q_u
, SVCCTL_R_QUERY_SERVICE_STATUSEX
*r_u
)
564 SERVICE_STATUS_PROCESS ssp
;
566 SERVICE_INFO
*service_info
;
568 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
570 /* perform access checks */
572 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
575 if ( !(info
->access_granted
& SC_RIGHT_SVC_QUERY_STATUS
) )
576 return WERR_ACCESS_DENIED
;
578 /* we have to set the outgoing buffer size to the same as the
579 incoming buffer size (even in the case of failure */
581 r_u
->needed
= q_u
->buffer_size
;
583 /* need to find the service name by the handle that is open */
584 handle
= &(q_u
->handle
);
587 /* get rid of the easy errors */
589 if (q_u
->info_level
!= SVC_STATUS_PROCESS_INFO
) {
590 DEBUG(10, ("_svcctl_query_service_status_ex : Invalid information level specified\n"));
591 return WERR_UNKNOWN_LEVEL
;
594 service_info
= find_service_info_by_hnd(p
, handle
);
597 DEBUG(10, ("_svcctl_query_service_status_ex : Can't find the service for the handle\n"));
601 if (r_u
->needed
< (sizeof(SERVICE_STATUS_PROCESS
)+sizeof(uint32
)+sizeof(uint32
))) {
602 DEBUG(10, ("_svcctl_query_service_status_ex : buffer size of [%d] is too small.\n",r_u
->needed
));
603 return WERR_INSUFFICIENT_BUFFER
;
609 if (!strwicmp(service_info
->servicetype
,"EXTERNAL"))
610 ssp
.type
= SVCCTL_WIN32_OWN_PROC
;
612 ssp
.type
= SVCCTL_WIN32_SHARED_PROC
;
615 /* Get the status of the service.. */
617 memset(command
, 0, sizeof(command
));
620 slprintf(command
, sizeof(command
)-1, "%s%s%s %s", dyn_LIBDIR
, SVCCTL_SCRIPT_DIR
, service_info
->filename
, "status");
622 DEBUG(10, ("_svcctl_query_service_status_ex: status command is [%s]\n", command
));
624 /* TODO - wrap in privilege check */
626 ret
= smbrun(command
, &fd
);
627 DEBUGADD(10, ("returned [%d]\n", ret
));
630 DEBUG(10, ("_svcctl_query_service_status_ex: Command returned [%d]\n", ret
));
632 /* SET all service_stats bits here... */
634 ssp
.state
= SVCCTL_RUNNING
;
635 ssp
.controls_accepted
= SVCCTL_CONTROL_SHUTDOWN
| SVCCTL_CONTROL_STOP
;
637 ssp
.state
= SVCCTL_STOPPED
;
638 ssp
.controls_accepted
= 0;
645 /********************************************************************
646 ********************************************************************/
648 WERROR
_svcctl_query_service_config( pipes_struct
*p
, SVCCTL_Q_QUERY_SERVICE_CONFIG
*q_u
, SVCCTL_R_QUERY_SERVICE_CONFIG
*r_u
)
651 SERVICE_INFO
*service_info
;
653 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
655 /* perform access checks */
657 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
660 if ( !(info
->access_granted
& SC_RIGHT_SVC_QUERY_CONFIG
) )
661 return WERR_ACCESS_DENIED
;
663 /* we have to set the outgoing buffer size to the same as the
664 incoming buffer size (even in the case of failure */
666 r_u
->needed
= q_u
->buffer_size
;
668 /* need to find the service name by the handle that is open */
669 handle
= &(q_u
->handle
);
671 service_info
= find_service_info_by_hnd(p
, handle
);
674 if (q_u
->buffer_size
< sizeof(Service_info
)) {
675 /* have to report need more... */
676 /* TODO worst case -- should actualy calc what we need here. */
677 r_u
->needed
= sizeof(Service_info
)+sizeof(pstring
)*5;
678 DEBUG(10, ("_svcctl_query_service_config: NOT ENOUGH BUFFER ALLOCATED FOR RETURN DATA -- provided %d wanted %d\n",
679 q_u
->buffer_size
,r_u
->needed
));
681 return WERR_INSUFFICIENT_BUFFER
;
685 DEBUG(10, ("_svcctl_query_service_config : Can't find the service for the handle\n"));
690 if ( !(service_config
= (SERVICE_CONFIG
*)TALLOC_ZERO_P(p
->mem_ctx
, SERVICE_CONFIG
)) )
694 r_u
->config
.service_type
= SVCCTL_WIN32_OWN_PROC
;
695 r_u
->config
.start_type
= SVCCTL_DEMAND_START
;
696 r_u
->config
.error_control
= SVCCTL_SVC_ERROR_IGNORE
;
697 r_u
->config
.tag_id
= 0x00000000;
699 /* Init the strings */
701 r_u
->config
.executablepath
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
702 r_u
->config
.loadordergroup
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
703 r_u
->config
.dependencies
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
704 r_u
->config
.startname
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
705 r_u
->config
.displayname
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
708 pstrcpy(fullpathinfo
,dyn_LIBDIR
);
709 pstrcat(fullpathinfo
,SVCCTL_SCRIPT_DIR
);
710 pstrcat(fullpathinfo
,service_info
->filename
);
711 /* Get and calculate the size of the fields. Note that we're still building the fields in the "too-small buffer case"
712 even though we throw it away. */
714 DEBUG(10, ("_svcctl_query_service_config: fullpath info [%s]\n",fullpathinfo
));
715 init_unistr2(r_u
->config
.executablepath
,fullpathinfo
,UNI_STR_TERMINATE
);
716 init_unistr2(r_u
->config
.loadordergroup
,"",UNI_STR_TERMINATE
);
717 init_unistr2(r_u
->config
.dependencies
,service_info
->dependencies
,UNI_STR_TERMINATE
);
719 /* TODO - if someone really cares, perhaps "LocalSystem" should be changed to something else here... */
721 init_unistr2(r_u
->config
.startname
,"LocalSystem",UNI_STR_TERMINATE
);
722 init_unistr2(r_u
->config
.displayname
,service_info
->servicename
,UNI_STR_TERMINATE
);
725 needed_size
= 0x04 + sizeof(SERVICE_CONFIG
)+ 2*(
726 r_u
->config
.executablepath
->uni_str_len
+
727 r_u
->config
.loadordergroup
->uni_str_len
+
728 r_u
->config
.dependencies
->uni_str_len
+
729 r_u
->config
.startname
->uni_str_len
+
730 r_u
->config
.displayname
->uni_str_len
);
732 DEBUG(10, ("_svcctl_query_service_config: ****** need to have a buffer of [%d], [%d] for struct \n",needed_size
,
733 sizeof(SERVICE_CONFIG
)));
734 DEBUG(10, ("\tsize of executable path : %d\n",r_u
->config
.executablepath
->uni_str_len
));
735 DEBUG(10, ("\tsize of loadordergroup : %d\n", r_u
->config
.loadordergroup
->uni_str_len
));
736 DEBUG(10, ("\tsize of dependencies : %d\n", r_u
->config
.dependencies
->uni_str_len
));
737 DEBUG(10, ("\tsize of startname : %d\n", r_u
->config
.startname
->uni_str_len
));
738 DEBUG(10, ("\tsize of displayname : %d\n", r_u
->config
.displayname
->uni_str_len
));
740 if (q_u
->buffer_size
< needed_size
) {
741 /* have to report need more...*/
742 r_u
->needed
= needed_size
;
743 DEBUG(10, ("_svcctl_query_service_config: ****** zeroing strings for return\n"));
744 memset(&r_u
->config
,0,sizeof(SERVICE_CONFIG
));
745 DEBUG(10, ("_svcctl_query_service_config: Not enouh buffer provided for return -- provided %d wanted %d\n",
746 q_u
->buffer_size
,needed_size
));
747 return WERR_INSUFFICIENT_BUFFER
;
753 /********************************************************************
754 ********************************************************************/
756 WERROR
_svcctl_query_service_config2( pipes_struct
*p
, SVCCTL_Q_QUERY_SERVICE_CONFIG2
*q_u
, SVCCTL_R_QUERY_SERVICE_CONFIG2
*r_u
)
759 SERVICE_INFO
*service_info
;
761 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
763 /* perform access checks */
765 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
768 if ( !(info
->access_granted
& SC_RIGHT_SVC_QUERY_CONFIG
) )
769 return WERR_ACCESS_DENIED
;
771 /* we have to set the outgoing buffer size to the same as the
772 incoming buffer size (even in the case of failure */
774 r_u
->needed
= q_u
->buffer_size
;
775 r_u
->description
= NULL
;
776 r_u
->returned
= q_u
->buffer_size
;
779 handle
= &(q_u
->handle
);
781 service_info
= find_service_info_by_hnd(p
, handle
);
784 DEBUG(10, ("_svcctl_query_service_config2 : Can't find the service for the handle\n"));
789 TODO - perhaps move the RPC_DATA_BLOB into the R_QUERY_SERVICE_CONFIG structure, and to the processing in here, vs
790 in the *r_query_config2 marshalling routine...
793 level
= q_u
->info_level
;
796 if (SERVICE_CONFIG_DESCRIPTION
== level
) {
797 if (service_info
&& service_info
->shortdescription
) {
798 /* length of the string, plus the terminator... */
799 string_buffer_size
= strlen(service_info
->shortdescription
)+1;
800 DEBUG(10, ("_svcctl_query_service_config: copying the description [%s] length [%d]\n",
801 service_info
->shortdescription
,string_buffer_size
));
803 if (q_u
->buffer_size
>= ((string_buffer_size
)*2+4)) {
804 r_u
->description
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
805 if (!r_u
->description
) return WERR_NOMEM
;
806 init_unistr2(r_u
->description
,service_info
->shortdescription
,UNI_STR_TERMINATE
);
810 string_buffer_size
= 0;
812 DEBUG(10, ("_svcctl_query_service_config2: buffer needed is [%x], return buffer size is [%x]\n",
813 string_buffer_size
,q_u
->buffer_size
));
814 if (((string_buffer_size
)*2+4) > q_u
->buffer_size
) {
815 r_u
->needed
= (string_buffer_size
+1)*2+4;
816 DEBUG(10, ("_svcctl_query_service_config2: INSUFFICIENT BUFFER\n"));
817 return WERR_INSUFFICIENT_BUFFER
;
819 DEBUG(10, ("_svcctl_query_service_config2: returning ok, needed is [%x], buffer size is [%x]\n",
820 r_u
->needed
,q_u
->buffer_size
));
826 return WERR_ACCESS_DENIED
;