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
;
174 WERROR result
= WERR_OK
;
176 if ( !(info
= SMB_MALLOC_P( SERVICE_INFO
)) )
179 ZERO_STRUCTP( info
);
181 /* the Service Manager has a NULL name */
184 info
->type
= SVC_HANDLE_IS_SCM
;
188 info
->type
= SVC_HANDLE_IS_SERVICE
;
190 /* lookup the SERVICE_CONTROL_OPS */
192 for ( i
=0; svcctl_ops
[i
].name
; i
++ ) {
193 if ( strequal( svcctl_ops
[i
].name
, service
) ) {
194 info
->ops
= svcctl_ops
[i
].ops
;
199 if ( !svcctl_ops
[i
].name
) {
200 result
= WERR_NO_SUCH_SERVICE
;
204 if ( !(info
->name
= SMB_STRDUP( service
)) ) {
210 info
->access_granted
= access_granted
;
212 /* store the SERVICE_INFO and create an open handle */
214 if ( !create_policy_hnd( p
, handle
, free_service_handle_info
, info
) ) {
215 result
= WERR_ACCESS_DENIED
;
220 if ( !W_ERROR_IS_OK(result
) )
221 free_service_handle_info( info
);
226 /********************************************************************
227 ********************************************************************/
229 WERROR
_svcctl_open_scmanager(pipes_struct
*p
, SVCCTL_Q_OPEN_SCMANAGER
*q_u
, SVCCTL_R_OPEN_SCMANAGER
*r_u
)
232 uint32 access_granted
= 0;
235 /* perform access checks */
237 if ( !(sec_desc
= construct_scm_sd( p
->mem_ctx
)) )
240 status
= svcctl_access_check( sec_desc
, p
->pipe_user
.nt_user_token
, q_u
->access
, &access_granted
);
241 if ( !NT_STATUS_IS_OK(status
) )
242 return ntstatus_to_werror( status
);
244 return create_open_service_handle( p
, &r_u
->handle
, NULL
, access_granted
);
247 /********************************************************************
248 ********************************************************************/
250 WERROR
_svcctl_open_service(pipes_struct
*p
, SVCCTL_Q_OPEN_SERVICE
*q_u
, SVCCTL_R_OPEN_SERVICE
*r_u
)
253 uint32 access_granted
= 0;
256 SERVICE_INFO
*scm_info
;
258 rpcstr_pull(service
, q_u
->servicename
.buffer
, sizeof(service
), q_u
->servicename
.uni_str_len
*2, 0);
260 DEBUG(5, ("_svcctl_open_service: Attempting to open Service [%s], \n", service
));
263 /* based on my tests you can open a service if you have a valid scm handle */
265 if ( !(scm_info
= find_service_info_by_hnd( p
, &q_u
->handle
)) )
268 /* perform access checks */
270 if ( !(sec_desc
= construct_service_sd( p
->mem_ctx
)) )
273 status
= svcctl_access_check( sec_desc
, p
->pipe_user
.nt_user_token
, q_u
->access
, &access_granted
);
274 if ( !NT_STATUS_IS_OK(status
) )
275 return ntstatus_to_werror( status
);
278 if ( ! get_service_info(service_tdb
, service
, info
) ) {
279 return WERR_NO_SUCH_SERVICE
;
282 return create_open_service_handle( p
, &r_u
->handle
, service
, access_granted
);
285 /********************************************************************
286 ********************************************************************/
288 WERROR
_svcctl_close_service(pipes_struct
*p
, SVCCTL_Q_CLOSE_SERVICE
*q_u
, SVCCTL_R_CLOSE_SERVICE
*r_u
)
290 return close_policy_hnd( p
, &q_u
->handle
) ? WERR_OK
: WERR_BADFID
;
293 /********************************************************************
294 ********************************************************************/
296 WERROR
_svcctl_get_display_name(pipes_struct
*p
, SVCCTL_Q_GET_DISPLAY_NAME
*q_u
, SVCCTL_R_GET_DISPLAY_NAME
*r_u
)
300 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
302 /* can only use an SCM handle here */
304 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SCM
) )
307 rpcstr_pull(service
, q_u
->servicename
.buffer
, sizeof(service
), q_u
->servicename
.uni_str_len
*2, 0);
309 /* need a tdb lookup here or something */
311 fstrcpy( displayname
, "FIX ME!" );
313 init_svcctl_r_get_display_name( r_u
, displayname
);
318 /********************************************************************
319 ********************************************************************/
321 WERROR
_svcctl_query_status(pipes_struct
*p
, SVCCTL_Q_QUERY_STATUS
*q_u
, SVCCTL_R_QUERY_STATUS
*r_u
)
323 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
325 /* perform access checks */
327 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
330 if ( !(info
->access_granted
& SC_RIGHT_SVC_QUERY_STATUS
) )
331 return WERR_ACCESS_DENIED
;
333 /* try the service specific status call */
336 return info
->ops
->service_status( &r_u
->svc_status
);
338 /* default action for now */
340 r_u
->svc_status
.type
= 0x0020;
341 r_u
->svc_status
.state
= 0x0004;
342 r_u
->svc_status
.controls_accepted
= 0x0005;
348 /*********************************************************************
349 TODO - for internal services, do similar to external services, except
350 we have to call the right status routine...
351 **********************************************************************/
353 static WERROR
enum_internal_services(TALLOC_CTX
*tcx
,ENUM_SERVICES_STATUS
**svc_ptr
, int existing_services
, uint32
*added
)
355 int num_services
= 2;
357 ENUM_SERVICES_STATUS
*services
=NULL
;
359 if (!svc_ptr
|| !(*svc_ptr
))
365 /* *svc_ptr has the pointer to the array if there is one already. NULL if not. */
366 if ((existing_services
>0) && svc_ptr
&& *svc_ptr
) { /* reallocate vs. allocate */
367 DEBUG(8,("enum_internal_services: REALLOCing %d services\n", num_services
));
368 services
= TALLOC_REALLOC_ARRAY(tcx
,*svc_ptr
,ENUM_SERVICES_STATUS
,existing_services
+num_services
);
373 if ( !(services
= TALLOC_ARRAY( tcx
, ENUM_SERVICES_STATUS
, num_services
)) )
378 if (existing_services
> 0) {
379 i
+= existing_services
;
381 DEBUG(8,("enum_internal_services: Creating %d services, starting index %d\n", num_services
,existing_services
));
383 init_unistr( &services
[i
].servicename
, "Spooler" );
384 init_unistr( &services
[i
].displayname
, "Print Spooler" );
386 services
[i
].status
.type
= 0x110;
387 services
[i
].status
.controls_accepted
= 0x0;
388 services
[i
].status
.win32_exit_code
= 0x0;
389 services
[i
].status
.service_exit_code
= 0x0;
390 services
[i
].status
.check_point
= 0x0;
391 services
[i
].status
.wait_hint
= 0x0;
392 if ( !lp_disable_spoolss() )
393 services
[i
].status
.state
= SVCCTL_RUNNING
;
395 services
[i
].status
.state
= SVCCTL_STOPPED
;
399 init_unistr( &services
[i
].servicename
, "NETLOGON" );
400 init_unistr( &services
[i
].displayname
, "Net Logon" );
402 services
[i
].status
.type
= 0x20;
403 services
[i
].status
.controls_accepted
= 0x0;
404 services
[i
].status
.win32_exit_code
= 0x0;
405 services
[i
].status
.service_exit_code
= 0x0;
406 services
[i
].status
.check_point
= 0x0;
407 services
[i
].status
.wait_hint
= 0x0;
408 if ( lp_servicenumber("NETLOGON") != -1 )
409 services
[i
].status
.state
= SVCCTL_RUNNING
;
411 services
[i
].status
.state
= SVCCTL_STOPPED
;
413 *added
= num_services
;
418 /********************************************************************
419 ********************************************************************/
421 WERROR
_svcctl_enum_services_status(pipes_struct
*p
, SVCCTL_Q_ENUM_SERVICES_STATUS
*q_u
, SVCCTL_R_ENUM_SERVICES_STATUS
*r_u
)
423 ENUM_SERVICES_STATUS
*services
= NULL
;
424 uint32 num_int_services
= 0;
425 uint32 num_ext_services
= 0;
428 WERROR result
= WERR_OK
;
429 WERROR ext_result
= WERR_OK
;
430 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
432 /* perform access checks */
434 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SCM
) )
437 if ( !(info
->access_granted
& SC_RIGHT_MGR_ENUMERATE_SERVICE
) )
438 return WERR_ACCESS_DENIED
;
440 /* num_services = str_list_count( lp_enable_svcctl() ); */
442 /* here's where we'll read the db of external services */
443 /* _svcctl_read_LSB_data(NULL,NULL); */
444 /* init_svcctl_db(); */
446 /* num_int_services = num_internal_services(); */
448 /* num_ext_services = num_external_services(); */
450 if ( !(services
= TALLOC_ARRAY(p
->mem_ctx
, ENUM_SERVICES_STATUS
, num_int_services
+num_ext_services
)) )
453 result
= enum_internal_services(p
->mem_ctx
, &services
, 0, &num_int_services
);
455 if (W_ERROR_IS_OK(result
)) {
456 DEBUG(8,("_svcctl_enum_services_status: Got %d internal services\n", num_int_services
));
459 /* ext_result=enum_external_services(p->mem_ctx, &services, num_int_services, &num_ext_services); */
461 if (W_ERROR_IS_OK(ext_result
)) {
462 DEBUG(8,("_svcctl_enum_services_status: Got %d external services\n", num_ext_services
));
465 DEBUG(8,("_svcctl_enum_services_status: total of %d services\n", num_int_services
+num_ext_services
));
468 for (i
=0;i
<num_int_services
+num_ext_services
;i
++) {
469 buffer_size
+= svcctl_sizeof_enum_services_status(&services
[i
]);
473 buffer_size
+= buffer_size
% 4;
474 DEBUG(8,("_svcctl_enum_services_status: buffer size passed %d, we need %d\n",
475 q_u
->buffer_size
, buffer_size
));
477 if (buffer_size
> q_u
->buffer_size
) {
478 num_int_services
= 0;
479 num_ext_services
= 0;
480 result
= WERR_MORE_DATA
;
483 rpcbuf_init(&r_u
->buffer
, q_u
->buffer_size
, p
->mem_ctx
);
485 if ( W_ERROR_IS_OK(result
) ) {
486 for ( i
=0; i
<num_int_services
+num_ext_services
; i
++ )
487 svcctl_io_enum_services_status( "", &services
[i
], &r_u
->buffer
, 0 );
490 r_u
->needed
= (buffer_size
> q_u
->buffer_size
) ? buffer_size
: q_u
->buffer_size
;
491 r_u
->returned
= num_int_services
+num_ext_services
;
493 if ( !(r_u
->resume
= TALLOC_P( p
->mem_ctx
, uint32
)) )
501 /********************************************************************
502 ********************************************************************/
504 WERROR
_svcctl_start_service(pipes_struct
*p
, SVCCTL_Q_START_SERVICE
*q_u
, SVCCTL_R_START_SERVICE
*r_u
)
506 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
508 /* perform access checks */
510 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
513 if ( !(info
->access_granted
& SC_RIGHT_SVC_START
) )
514 return WERR_ACCESS_DENIED
;
516 return info
->ops
->start_service();
519 /********************************************************************
520 ********************************************************************/
522 WERROR
_svcctl_control_service(pipes_struct
*p
, SVCCTL_Q_CONTROL_SERVICE
*q_u
, SVCCTL_R_CONTROL_SERVICE
*r_u
)
524 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
526 /* perform access checks */
527 /* we only support stop so don't get complicated */
529 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
532 if ( q_u
->control
!= SVCCTL_CONTROL_STOP
)
533 return WERR_ACCESS_DENIED
;
535 if ( !(info
->access_granted
& SC_RIGHT_SVC_STOP
) )
536 return WERR_ACCESS_DENIED
;
538 return info
->ops
->stop_service( &r_u
->svc_status
);
541 /********************************************************************
542 ********************************************************************/
544 WERROR
_svcctl_enum_dependent_services( pipes_struct
*p
, SVCCTL_Q_ENUM_DEPENDENT_SERVICES
*q_u
, SVCCTL_R_ENUM_DEPENDENT_SERVICES
*r_u
)
546 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
548 /* perform access checks */
550 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
553 if ( !(info
->access_granted
& SC_RIGHT_SVC_ENUMERATE_DEPENDENTS
) )
554 return WERR_ACCESS_DENIED
;
556 /* we have to set the outgoing buffer size to the same as the
557 incoming buffer size (even in the case of failure */
559 rpcbuf_init( &r_u
->buffer
, q_u
->buffer_size
, p
->mem_ctx
);
561 r_u
->needed
= q_u
->buffer_size
;
563 /* no dependent services...basically a stub function */
569 /********************************************************************
570 ********************************************************************/
572 WERROR
_svcctl_query_service_status_ex( pipes_struct
*p
, SVCCTL_Q_QUERY_SERVICE_STATUSEX
*q_u
, SVCCTL_R_QUERY_SERVICE_STATUSEX
*r_u
)
574 SERVICE_STATUS_PROCESS ssp
;
576 SERVICE_INFO
*service_info
;
578 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
580 /* perform access checks */
582 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
585 if ( !(info
->access_granted
& SC_RIGHT_SVC_QUERY_STATUS
) )
586 return WERR_ACCESS_DENIED
;
588 /* we have to set the outgoing buffer size to the same as the
589 incoming buffer size (even in the case of failure */
591 r_u
->needed
= q_u
->buffer_size
;
593 /* need to find the service name by the handle that is open */
594 handle
= &(q_u
->handle
);
597 /* get rid of the easy errors */
599 if (q_u
->info_level
!= SVC_STATUS_PROCESS_INFO
) {
600 DEBUG(10, ("_svcctl_query_service_status_ex : Invalid information level specified\n"));
601 return WERR_UNKNOWN_LEVEL
;
604 service_info
= find_service_info_by_hnd(p
, handle
);
607 DEBUG(10, ("_svcctl_query_service_status_ex : Can't find the service for the handle\n"));
611 if (r_u
->needed
< (sizeof(SERVICE_STATUS_PROCESS
)+sizeof(uint32
)+sizeof(uint32
))) {
612 DEBUG(10, ("_svcctl_query_service_status_ex : buffer size of [%d] is too small.\n",r_u
->needed
));
613 return WERR_INSUFFICIENT_BUFFER
;
619 if (!strwicmp(service_info
->servicetype
,"EXTERNAL"))
620 ssp
.type
= SVCCTL_WIN32_OWN_PROC
;
622 ssp
.type
= SVCCTL_WIN32_SHARED_PROC
;
625 /* Get the status of the service.. */
627 memset(command
, 0, sizeof(command
));
630 slprintf(command
, sizeof(command
)-1, "%s%s%s %s", dyn_LIBDIR
, SVCCTL_SCRIPT_DIR
, service_info
->filename
, "status");
632 DEBUG(10, ("_svcctl_query_service_status_ex: status command is [%s]\n", command
));
634 /* TODO - wrap in privilege check */
636 ret
= smbrun(command
, &fd
);
637 DEBUGADD(10, ("returned [%d]\n", ret
));
640 DEBUG(10, ("_svcctl_query_service_status_ex: Command returned [%d]\n", ret
));
642 /* SET all service_stats bits here... */
644 ssp
.state
= SVCCTL_RUNNING
;
645 ssp
.controls_accepted
= SVCCTL_CONTROL_SHUTDOWN
| SVCCTL_CONTROL_STOP
;
647 ssp
.state
= SVCCTL_STOPPED
;
648 ssp
.controls_accepted
= 0;
655 /********************************************************************
656 ********************************************************************/
658 WERROR
_svcctl_query_service_config( pipes_struct
*p
, SVCCTL_Q_QUERY_SERVICE_CONFIG
*q_u
, SVCCTL_R_QUERY_SERVICE_CONFIG
*r_u
)
661 SERVICE_INFO
*service_info
;
663 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
665 /* perform access checks */
667 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
670 if ( !(info
->access_granted
& SC_RIGHT_SVC_QUERY_CONFIG
) )
671 return WERR_ACCESS_DENIED
;
673 /* we have to set the outgoing buffer size to the same as the
674 incoming buffer size (even in the case of failure */
676 r_u
->needed
= q_u
->buffer_size
;
678 /* need to find the service name by the handle that is open */
679 handle
= &(q_u
->handle
);
681 service_info
= find_service_info_by_hnd(p
, handle
);
684 if (q_u
->buffer_size
< sizeof(Service_info
)) {
685 /* have to report need more... */
686 /* TODO worst case -- should actualy calc what we need here. */
687 r_u
->needed
= sizeof(Service_info
)+sizeof(pstring
)*5;
688 DEBUG(10, ("_svcctl_query_service_config: NOT ENOUGH BUFFER ALLOCATED FOR RETURN DATA -- provided %d wanted %d\n",
689 q_u
->buffer_size
,r_u
->needed
));
691 return WERR_INSUFFICIENT_BUFFER
;
695 DEBUG(10, ("_svcctl_query_service_config : Can't find the service for the handle\n"));
700 if ( !(service_config
= (SERVICE_CONFIG
*)TALLOC_ZERO_P(p
->mem_ctx
, SERVICE_CONFIG
)) )
704 r_u
->config
.service_type
= SVCCTL_WIN32_OWN_PROC
;
705 r_u
->config
.start_type
= SVCCTL_DEMAND_START
;
706 r_u
->config
.error_control
= SVCCTL_SVC_ERROR_IGNORE
;
707 r_u
->config
.tag_id
= 0x00000000;
709 /* Init the strings */
711 r_u
->config
.executablepath
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
712 r_u
->config
.loadordergroup
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
713 r_u
->config
.dependencies
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
714 r_u
->config
.startname
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
715 r_u
->config
.displayname
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
718 pstrcpy(fullpathinfo
,dyn_LIBDIR
);
719 pstrcat(fullpathinfo
,SVCCTL_SCRIPT_DIR
);
720 pstrcat(fullpathinfo
,service_info
->filename
);
721 /* Get and calculate the size of the fields. Note that we're still building the fields in the "too-small buffer case"
722 even though we throw it away. */
724 DEBUG(10, ("_svcctl_query_service_config: fullpath info [%s]\n",fullpathinfo
));
725 init_unistr2(r_u
->config
.executablepath
,fullpathinfo
,UNI_STR_TERMINATE
);
726 init_unistr2(r_u
->config
.loadordergroup
,"",UNI_STR_TERMINATE
);
727 init_unistr2(r_u
->config
.dependencies
,service_info
->dependencies
,UNI_STR_TERMINATE
);
729 /* TODO - if someone really cares, perhaps "LocalSystem" should be changed to something else here... */
731 init_unistr2(r_u
->config
.startname
,"LocalSystem",UNI_STR_TERMINATE
);
732 init_unistr2(r_u
->config
.displayname
,service_info
->servicename
,UNI_STR_TERMINATE
);
735 needed_size
= 0x04 + sizeof(SERVICE_CONFIG
)+ 2*(
736 r_u
->config
.executablepath
->uni_str_len
+
737 r_u
->config
.loadordergroup
->uni_str_len
+
738 r_u
->config
.dependencies
->uni_str_len
+
739 r_u
->config
.startname
->uni_str_len
+
740 r_u
->config
.displayname
->uni_str_len
);
742 DEBUG(10, ("_svcctl_query_service_config: ****** need to have a buffer of [%d], [%d] for struct \n",needed_size
,
743 sizeof(SERVICE_CONFIG
)));
744 DEBUG(10, ("\tsize of executable path : %d\n",r_u
->config
.executablepath
->uni_str_len
));
745 DEBUG(10, ("\tsize of loadordergroup : %d\n", r_u
->config
.loadordergroup
->uni_str_len
));
746 DEBUG(10, ("\tsize of dependencies : %d\n", r_u
->config
.dependencies
->uni_str_len
));
747 DEBUG(10, ("\tsize of startname : %d\n", r_u
->config
.startname
->uni_str_len
));
748 DEBUG(10, ("\tsize of displayname : %d\n", r_u
->config
.displayname
->uni_str_len
));
750 if (q_u
->buffer_size
< needed_size
) {
751 /* have to report need more...*/
752 r_u
->needed
= needed_size
;
753 DEBUG(10, ("_svcctl_query_service_config: ****** zeroing strings for return\n"));
754 memset(&r_u
->config
,0,sizeof(SERVICE_CONFIG
));
755 DEBUG(10, ("_svcctl_query_service_config: Not enouh buffer provided for return -- provided %d wanted %d\n",
756 q_u
->buffer_size
,needed_size
));
757 return WERR_INSUFFICIENT_BUFFER
;
763 /********************************************************************
764 ********************************************************************/
766 WERROR
_svcctl_query_service_config2( pipes_struct
*p
, SVCCTL_Q_QUERY_SERVICE_CONFIG2
*q_u
, SVCCTL_R_QUERY_SERVICE_CONFIG2
*r_u
)
769 SERVICE_INFO
*service_info
;
771 SERVICE_INFO
*info
= find_service_info_by_hnd( p
, &q_u
->handle
);
773 /* perform access checks */
775 if ( !info
|| (info
->type
!= SVC_HANDLE_IS_SERVICE
) )
778 if ( !(info
->access_granted
& SC_RIGHT_SVC_QUERY_CONFIG
) )
779 return WERR_ACCESS_DENIED
;
781 /* we have to set the outgoing buffer size to the same as the
782 incoming buffer size (even in the case of failure */
784 r_u
->needed
= q_u
->buffer_size
;
785 r_u
->description
= NULL
;
786 r_u
->returned
= q_u
->buffer_size
;
789 handle
= &(q_u
->handle
);
791 service_info
= find_service_info_by_hnd(p
, handle
);
794 DEBUG(10, ("_svcctl_query_service_config2 : Can't find the service for the handle\n"));
799 TODO - perhaps move the RPC_DATA_BLOB into the R_QUERY_SERVICE_CONFIG structure, and to the processing in here, vs
800 in the *r_query_config2 marshalling routine...
803 level
= q_u
->info_level
;
806 if (SERVICE_CONFIG_DESCRIPTION
== level
) {
807 if (service_info
&& service_info
->shortdescription
) {
808 /* length of the string, plus the terminator... */
809 string_buffer_size
= strlen(service_info
->shortdescription
)+1;
810 DEBUG(10, ("_svcctl_query_service_config: copying the description [%s] length [%d]\n",
811 service_info
->shortdescription
,string_buffer_size
));
813 if (q_u
->buffer_size
>= ((string_buffer_size
)*2+4)) {
814 r_u
->description
= TALLOC_ZERO_P(p
->mem_ctx
, UNISTR2
);
815 if (!r_u
->description
) return WERR_NOMEM
;
816 init_unistr2(r_u
->description
,service_info
->shortdescription
,UNI_STR_TERMINATE
);
820 string_buffer_size
= 0;
822 DEBUG(10, ("_svcctl_query_service_config2: buffer needed is [%x], return buffer size is [%x]\n",
823 string_buffer_size
,q_u
->buffer_size
));
824 if (((string_buffer_size
)*2+4) > q_u
->buffer_size
) {
825 r_u
->needed
= (string_buffer_size
+1)*2+4;
826 DEBUG(10, ("_svcctl_query_service_config2: INSUFFICIENT BUFFER\n"));
827 return WERR_INSUFFICIENT_BUFFER
;
829 DEBUG(10, ("_svcctl_query_service_config2: returning ok, needed is [%x], buffer size is [%x]\n",
830 r_u
->needed
,q_u
->buffer_size
));
836 return WERR_ACCESS_DENIED
;