RIP BOOL. Convert BOOL -> bool. I found a few interesting
[nivanova/samba-autobuild/.git] / source3 / services / services_db.c
1 /* 
2  *  Unix SMB/CIFS implementation.
3  *  Service Control API Implementation
4  * 
5  *  Copyright (C) Marcin Krzysztof Porwit         2005.
6  *  Largely Rewritten by:
7  *  Copyright (C) Gerald (Jerry) Carter           2005.
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 3 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, see <http://www.gnu.org/licenses/>.
21  */
22
23 #include "includes.h"
24
25 struct rcinit_file_information {
26         char *description;
27 };
28
29 struct service_display_info {
30         const char *servicename;
31         const char *daemon;
32         const char *dispname;
33         const char *description;
34 };
35
36 struct service_display_info builtin_svcs[] = {  
37   { "Spooler",        "smbd",   "Print Spooler", "Internal service for spooling files to print devices" },
38   { "NETLOGON",       "smbd",   "Net Logon", "File service providing access to policy and profile data (not remotely manageable)" },
39   { "RemoteRegistry", "smbd",   "Remote Registry Service", "Internal service providing remote access to "
40                                 "the Samba registry" },
41   { "WINS",           "nmbd",   "Windows Internet Name Service (WINS)", "Internal service providing a "
42                                 "NetBIOS point-to-point name server (not remotely manageable)" },
43   { NULL, NULL, NULL, NULL }
44 };
45
46 struct service_display_info common_unix_svcs[] = {  
47   { "cups",          NULL, "Common Unix Printing System","Provides unified printing support for all operating systems" },
48   { "postfix",       NULL, "Internet Mail Service",     "Provides support for sending and receiving electonic mail" },
49   { "sendmail",      NULL, "Internet Mail Service",     "Provides support for sending and receiving electonic mail" },
50   { "portmap",       NULL, "TCP Port to RPC PortMapper",NULL },
51   { "xinetd",        NULL, "Internet Meta-Daemon",      NULL },
52   { "inet",          NULL, "Internet Meta-Daemon",      NULL },
53   { "xntpd",         NULL, "Network Time Service",      NULL },
54   { "ntpd",          NULL, "Network Time Service",      NULL },
55   { "lpd",           NULL, "BSD Print Spooler",         NULL },
56   { "nfsserver",     NULL, "Network File Service",      NULL },
57   { "cron",          NULL, "Scheduling Service",        NULL },
58   { "at",            NULL, "Scheduling Service",        NULL },
59   { "nscd",          NULL, "Name Service Cache Daemon", NULL },
60   { "slapd",         NULL, "LDAP Directory Service",    NULL },
61   { "ldap",          NULL, "LDAP DIrectory Service",    NULL },
62   { "ypbind",        NULL, "NIS Directory Service",     NULL },
63   { "courier-imap",  NULL, "IMAP4 Mail Service",        NULL },
64   { "courier-pop3",  NULL, "POP3 Mail Service",         NULL },
65   { "named",         NULL, "Domain Name Service",       NULL },
66   { "bind",          NULL, "Domain Name Service",       NULL },
67   { "httpd",         NULL, "HTTP Server",               NULL },
68   { "apache",        NULL, "HTTP Server",               "Provides s highly scalable and flexible web server "
69                                                         "capable of implementing various protocols incluing "
70                                                         "but not limited to HTTP" },
71   { "autofs",        NULL, "Automounter",               NULL },
72   { "squid",         NULL, "Web Cache Proxy ",          NULL },
73   { "perfcountd",    NULL, "Performance Monitoring Daemon", NULL },
74   { "pgsql",         NULL, "PgSQL Database Server",     "Provides service for SQL database from Postgresql.org" },
75   { "arpwatch",      NULL, "ARP Tables watcher",        "Provides service for monitoring ARP tables for changes" },
76   { "dhcpd",         NULL, "DHCP Server",               "Provides service for dynamic host configuration and IP assignment" },
77   { "nwserv",        NULL, "NetWare Server Emulator",   "Provides service for emulating Novell NetWare 3.12 server" },
78   { "proftpd",       NULL, "Professional FTP Server",   "Provides high configurable service for FTP connection and "
79                                                         "file transferring" },
80   { "ssh2",          NULL, "SSH Secure Shell",          "Provides service for secure connection for remote administration" },
81   { "sshd",          NULL, "SSH Secure Shell",          "Provides service for secure connection for remote administration" },
82   { NULL, NULL, NULL, NULL }
83 };
84
85
86 /********************************************************************
87 ********************************************************************/
88
89 static SEC_DESC* construct_service_sd( TALLOC_CTX *ctx )
90 {
91         SEC_ACE ace[4]; 
92         SEC_ACCESS mask;
93         size_t i = 0;
94         SEC_DESC *sd;
95         SEC_ACL *acl;
96         size_t sd_size;
97         
98         /* basic access for Everyone */
99         
100         init_sec_access(&mask, SERVICE_READ_ACCESS );
101         init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
102                 
103         init_sec_access(&mask,SERVICE_EXECUTE_ACCESS );
104         init_sec_ace(&ace[i++], &global_sid_Builtin_Power_Users, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
105         
106         init_sec_access(&mask,SERVICE_ALL_ACCESS );
107         init_sec_ace(&ace[i++], &global_sid_Builtin_Server_Operators, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
108         init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
109         
110         /* create the security descriptor */
111         
112         if ( !(acl = make_sec_acl(ctx, NT4_ACL_REVISION, i, ace)) )
113                 return NULL;
114
115         if ( !(sd = make_sec_desc(ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE, NULL, NULL, NULL, acl, &sd_size)) )
116                 return NULL;
117
118         return sd;
119 }
120
121 /********************************************************************
122  This is where we do the dirty work of filling in things like the
123  Display name, Description, etc...
124 ********************************************************************/
125
126 static char *get_common_service_dispname( const char *servicename )
127 {
128         static fstring dispname;
129         int i;
130         
131         for ( i=0; common_unix_svcs[i].servicename; i++ ) {
132                 if ( strequal( servicename, common_unix_svcs[i].servicename ) ) {
133                         fstr_sprintf( dispname, "%s (%s)", 
134                                 common_unix_svcs[i].dispname,
135                                 common_unix_svcs[i].servicename );
136                                 
137                         return dispname;
138                 }
139         } 
140         
141         fstrcpy( dispname, servicename );
142         
143         return dispname;
144 }
145
146 /********************************************************************
147 ********************************************************************/
148
149 static char* cleanup_string( const char *string )
150 {
151         pstring clean;
152         char *begin, *end;
153
154         pstrcpy( clean, string );
155         begin = clean;
156         
157         /* trim any beginning whilespace */
158         
159         while ( isspace(*begin) )
160                 begin++;
161
162         if ( *begin == '\0' )
163                 return NULL;
164                         
165         /* trim any trailing whitespace or carriage returns.
166            Start at the end and move backwards */
167                         
168         end = begin + strlen(begin) - 1;
169                         
170         while ( isspace(*end) || *end=='\n' || *end=='\r' ) {
171                 *end = '\0';
172                 end--;
173         }
174
175         return talloc_strdup(talloc_tos(), begin);
176 }
177
178 /********************************************************************
179 ********************************************************************/
180
181 static bool read_init_file( const char *servicename, struct rcinit_file_information **service_info )
182 {
183         struct rcinit_file_information *info;
184         pstring filepath, str;
185         XFILE *f;
186         char *p;
187                 
188         if ( !(info = TALLOC_ZERO_P( NULL, struct rcinit_file_information ) ) )
189                 return False;
190         
191         /* attempt the file open */
192                 
193         pstr_sprintf( filepath, "%s/%s/%s", dyn_LIBDIR, SVCCTL_SCRIPT_DIR, servicename );
194         if ( !(f = x_fopen( filepath, O_RDONLY, 0 )) ) {
195                 DEBUG(0,("read_init_file: failed to open [%s]\n", filepath));
196                 TALLOC_FREE(info);
197                 return False;
198         }
199         
200         while ( (x_fgets( str, sizeof(str)-1, f )) != NULL ) {
201                 /* ignore everything that is not a full line 
202                    comment starting with a '#' */
203                    
204                 if ( str[0] != '#' )
205                         continue;
206                 
207                 /* Look for a line like '^#.*Description:' */
208                 
209                 if ( (p = strstr( str, "Description:" )) != NULL ) {
210                         char *desc;
211
212                         p += strlen( "Description:" ) + 1;
213                         if ( !p ) 
214                                 break;
215                                 
216                         if ( (desc = cleanup_string(p)) != NULL )
217                                 info->description = talloc_strdup( info, desc );
218                 }
219         }
220         
221         x_fclose( f );
222         
223         if ( !info->description )
224                 info->description = talloc_strdup( info, "External Unix Service" );
225         
226         *service_info = info;
227         
228         return True;
229 }
230
231 /********************************************************************
232  This is where we do the dirty work of filling in things like the
233  Display name, Description, etc...
234 ********************************************************************/
235
236 static void fill_service_values( const char *name, REGVAL_CTR *values )
237 {
238         UNISTR2 data, dname, ipath, description;
239         uint32 dword;
240         pstring pstr;
241         int i;
242         
243         /* These values are hardcoded in all QueryServiceConfig() replies.
244            I'm just storing them here for cosmetic purposes */
245         
246         dword = SVCCTL_AUTO_START;
247         regval_ctr_addvalue( values, "Start", REG_DWORD, (char*)&dword, sizeof(uint32));
248         
249         dword = SVCCTL_WIN32_OWN_PROC;
250         regval_ctr_addvalue( values, "Type", REG_DWORD, (char*)&dword, sizeof(uint32));
251
252         dword = SVCCTL_SVC_ERROR_NORMAL;
253         regval_ctr_addvalue( values, "ErrorControl", REG_DWORD, (char*)&dword, sizeof(uint32));
254         
255         /* everything runs as LocalSystem */
256         
257         init_unistr2( &data, "LocalSystem", UNI_STR_TERMINATE );
258         regval_ctr_addvalue( values, "ObjectName", REG_SZ, (char*)data.buffer, data.uni_str_len*2);
259         
260         /* special considerations for internal services and the DisplayName value */
261         
262         for ( i=0; builtin_svcs[i].servicename; i++ ) {
263                 if ( strequal( name, builtin_svcs[i].servicename ) ) {
264                         pstr_sprintf( pstr, "%s/%s/%s",dyn_LIBDIR, SVCCTL_SCRIPT_DIR, builtin_svcs[i].daemon );
265                         init_unistr2( &ipath, pstr, UNI_STR_TERMINATE );
266                         init_unistr2( &description, builtin_svcs[i].description, UNI_STR_TERMINATE );
267                         init_unistr2( &dname, builtin_svcs[i].dispname, UNI_STR_TERMINATE );
268                         break;
269                 }
270         } 
271         
272         /* default to an external service if we haven't found a match */
273         
274         if ( builtin_svcs[i].servicename == NULL ) {
275                 struct rcinit_file_information *init_info = NULL;
276
277                 pstr_sprintf( pstr, "%s/%s/%s",dyn_LIBDIR, SVCCTL_SCRIPT_DIR, name );
278                 init_unistr2( &ipath, pstr, UNI_STR_TERMINATE );
279                 
280                 /* lookup common unix display names */
281                 init_unistr2( &dname, get_common_service_dispname( name ), UNI_STR_TERMINATE );
282
283                 /* get info from init file itself */            
284                 if ( read_init_file( name, &init_info ) ) {
285                         init_unistr2( &description, init_info->description, UNI_STR_TERMINATE );
286                         TALLOC_FREE( init_info );
287                 }
288                 else {
289                         init_unistr2( &description, "External Unix Service", UNI_STR_TERMINATE );
290                 }
291         }
292         
293         /* add the new values */
294         
295         regval_ctr_addvalue( values, "DisplayName", REG_SZ, (char*)dname.buffer, dname.uni_str_len*2);
296         regval_ctr_addvalue( values, "ImagePath", REG_SZ, (char*)ipath.buffer, ipath.uni_str_len*2);
297         regval_ctr_addvalue( values, "Description", REG_SZ, (char*)description.buffer, description.uni_str_len*2);
298         
299         return;
300 }
301
302 /********************************************************************
303 ********************************************************************/
304
305 static void add_new_svc_name( REGISTRY_KEY *key_parent, REGSUBKEY_CTR *subkeys, 
306                               const char *name )
307 {
308         REGISTRY_KEY *key_service, *key_secdesc;
309         WERROR wresult;
310         pstring path;
311         REGVAL_CTR *values;
312         REGSUBKEY_CTR *svc_subkeys;
313         SEC_DESC *sd;
314         DATA_BLOB sd_blob;
315         NTSTATUS status;
316
317         /* add to the list and create the subkey path */
318
319         regsubkey_ctr_addkey( subkeys, name );
320         store_reg_keys( key_parent, subkeys );
321
322         /* open the new service key */
323
324         pstr_sprintf( path, "%s\\%s", KEY_SERVICES, name );
325         wresult = regkey_open_internal( NULL, &key_service, path,
326                                         get_root_nt_token(), REG_KEY_ALL );
327         if ( !W_ERROR_IS_OK(wresult) ) {
328                 DEBUG(0,("add_new_svc_name: key lookup failed! [%s] (%s)\n", 
329                         path, dos_errstr(wresult)));
330                 return;
331         }
332         
333         /* add the 'Security' key */
334
335         if ( !(svc_subkeys = TALLOC_ZERO_P( key_service, REGSUBKEY_CTR )) ) {
336                 DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
337                 TALLOC_FREE( key_service );
338                 return;
339         }
340         
341         fetch_reg_keys( key_service, svc_subkeys );
342         regsubkey_ctr_addkey( svc_subkeys, "Security" );
343         store_reg_keys( key_service, svc_subkeys );
344
345         /* now for the service values */
346         
347         if ( !(values = TALLOC_ZERO_P( key_service, REGVAL_CTR )) ) {
348                 DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
349                 TALLOC_FREE( key_service );
350                 return;
351         }
352
353         fill_service_values( name, values );
354         store_reg_values( key_service, values );
355
356         /* cleanup the service key*/
357
358         TALLOC_FREE( key_service );
359
360         /* now add the security descriptor */
361
362         pstr_sprintf( path, "%s\\%s\\%s", KEY_SERVICES, name, "Security" );
363         wresult = regkey_open_internal( NULL, &key_secdesc, path,
364                                         get_root_nt_token(), REG_KEY_ALL );
365         if ( !W_ERROR_IS_OK(wresult) ) {
366                 DEBUG(0,("add_new_svc_name: key lookup failed! [%s] (%s)\n", 
367                         path, dos_errstr(wresult)));
368                 TALLOC_FREE( key_secdesc );
369                 return;
370         }
371
372         if ( !(values = TALLOC_ZERO_P( key_secdesc, REGVAL_CTR )) ) {
373                 DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
374                 TALLOC_FREE( key_secdesc );
375                 return;
376         }
377
378         if ( !(sd = construct_service_sd(key_secdesc)) ) {
379                 DEBUG(0,("add_new_svc_name: Failed to create default sec_desc!\n"));
380                 TALLOC_FREE( key_secdesc );
381                 return;
382         }
383
384         status = marshall_sec_desc(key_secdesc, sd, &sd_blob.data,
385                                    &sd_blob.length);
386         if (!NT_STATUS_IS_OK(status)) {
387                 DEBUG(0, ("marshall_sec_desc failed: %s\n",
388                           nt_errstr(status)));
389                 TALLOC_FREE(key_secdesc);
390                 return;
391         }
392         
393         regval_ctr_addvalue(values, "Security", REG_BINARY,
394                             (const char *)sd_blob.data, sd_blob.length);
395         store_reg_values( key_secdesc, values );
396         
397         TALLOC_FREE( key_secdesc );
398
399         return;
400 }
401
402 /********************************************************************
403 ********************************************************************/
404
405 void svcctl_init_keys( void )
406 {
407         const char **service_list = lp_svcctl_list();
408         int i;
409         REGSUBKEY_CTR *subkeys;
410         REGISTRY_KEY *key = NULL;
411         WERROR wresult;
412         
413         /* bad mojo here if the lookup failed.  Should not happen */
414         
415         wresult = regkey_open_internal( NULL, &key, KEY_SERVICES,
416                                         get_root_nt_token(), REG_KEY_ALL );
417
418         if ( !W_ERROR_IS_OK(wresult) ) {
419                 DEBUG(0,("svcctl_init_keys: key lookup failed! (%s)\n", 
420                         dos_errstr(wresult)));
421                 return;
422         }
423         
424         /* lookup the available subkeys */      
425         
426         if ( !(subkeys = TALLOC_ZERO_P( key, REGSUBKEY_CTR )) ) {
427                 DEBUG(0,("svcctl_init_keys: talloc() failed!\n"));
428                 TALLOC_FREE( key );
429                 return;
430         }
431         
432         fetch_reg_keys( key, subkeys );
433         
434         /* the builting services exist */
435         
436         for ( i=0; builtin_svcs[i].servicename; i++ )
437                 add_new_svc_name( key, subkeys, builtin_svcs[i].servicename );
438                 
439         for ( i=0; service_list && service_list[i]; i++ ) {
440         
441                 /* only add new services */
442                 if ( regsubkey_ctr_key_exists( subkeys, service_list[i] ) )
443                         continue;
444
445                 /* Add the new service key and initialize the appropriate values */
446
447                 add_new_svc_name( key, subkeys, service_list[i] );
448         }
449
450         TALLOC_FREE( key );
451
452         /* initialize the control hooks */
453
454         init_service_op_table();
455
456         return;
457 }
458
459 /********************************************************************
460  This is where we do the dirty work of filling in things like the
461  Display name, Description, etc...Always return a default secdesc 
462  in case of any failure.
463 ********************************************************************/
464
465 SEC_DESC* svcctl_get_secdesc( TALLOC_CTX *ctx, const char *name, NT_USER_TOKEN *token )
466 {
467         REGISTRY_KEY *key;
468         REGVAL_CTR *values;
469         REGISTRY_VALUE *val;
470         SEC_DESC *ret_sd = NULL;
471         pstring path;
472         WERROR wresult;
473         NTSTATUS status;
474         
475         /* now add the security descriptor */
476
477         pstr_sprintf( path, "%s\\%s\\%s", KEY_SERVICES, name, "Security" );
478         wresult = regkey_open_internal( NULL, &key, path, token,
479                                         REG_KEY_ALL );
480         if ( !W_ERROR_IS_OK(wresult) ) {
481                 DEBUG(0,("svcctl_get_secdesc: key lookup failed! [%s] (%s)\n", 
482                         path, dos_errstr(wresult)));
483                 return NULL;
484         }
485
486         if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
487                 DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
488                 TALLOC_FREE( key );
489                 return NULL;
490         }
491
492         fetch_reg_values( key, values );
493
494         TALLOC_FREE(key);
495         
496         if ( !(val = regval_ctr_getvalue( values, "Security" )) ) {
497                 DEBUG(6,("svcctl_get_secdesc: constructing default secdesc for service [%s]\n", 
498                         name));
499                 return construct_service_sd( ctx );
500         }
501         
502
503         /* stream the service security descriptor */
504
505         status = unmarshall_sec_desc(ctx, regval_data_p(val),
506                                      regval_size(val), &ret_sd);
507
508         if (!NT_STATUS_IS_OK(status)) {
509                 return construct_service_sd( ctx );
510         }
511
512         return ret_sd;
513 }
514
515 /********************************************************************
516  Wrapper to make storing a Service sd easier
517 ********************************************************************/
518
519 bool svcctl_set_secdesc( TALLOC_CTX *ctx, const char *name, SEC_DESC *sec_desc, NT_USER_TOKEN *token )
520 {
521         REGISTRY_KEY *key;
522         WERROR wresult;
523         pstring path;
524         REGVAL_CTR *values;
525         prs_struct ps;
526         bool ret = False;
527         
528         /* now add the security descriptor */
529
530         pstr_sprintf( path, "%s\\%s\\%s", KEY_SERVICES, name, "Security" );
531         wresult = regkey_open_internal( NULL, &key, path, token,
532                                         REG_KEY_ALL );
533         if ( !W_ERROR_IS_OK(wresult) ) {
534                 DEBUG(0,("svcctl_get_secdesc: key lookup failed! [%s] (%s)\n", 
535                         path, dos_errstr(wresult)));
536                 return False;
537         }
538
539         if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
540                 DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
541                 TALLOC_FREE( key );
542                 return False;
543         }
544         
545         /* stream the printer security descriptor */
546         
547         prs_init( &ps, RPC_MAX_PDU_FRAG_LEN, key, MARSHALL);
548         
549         if ( sec_io_desc("sec_desc", &sec_desc, &ps, 0 ) ) {
550                 uint32 offset = prs_offset( &ps );
551                 regval_ctr_addvalue( values, "Security", REG_BINARY, prs_data_p(&ps), offset );
552                 ret = store_reg_values( key, values );
553         }
554         
555         /* cleanup */
556         
557         prs_mem_free( &ps );
558         TALLOC_FREE( key);
559
560         return ret;
561 }
562
563 /********************************************************************
564 ********************************************************************/
565
566 char* svcctl_lookup_dispname( const char *name, NT_USER_TOKEN *token )
567 {
568         static fstring display_name;
569         REGISTRY_KEY *key;
570         REGVAL_CTR *values;
571         REGISTRY_VALUE *val;
572         pstring path;
573         WERROR wresult;
574         
575         /* now add the security descriptor */
576
577         pstr_sprintf( path, "%s\\%s", KEY_SERVICES, name );
578         wresult = regkey_open_internal( NULL, &key, path, token,
579                                         REG_KEY_READ );
580         if ( !W_ERROR_IS_OK(wresult) ) {
581                 DEBUG(0,("svcctl_lookup_dispname: key lookup failed! [%s] (%s)\n", 
582                         path, dos_errstr(wresult)));
583                 goto fail;
584         }
585
586         if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
587                 DEBUG(0,("svcctl_lookup_dispname: talloc() failed!\n"));
588                 TALLOC_FREE( key );
589                 goto fail;
590         }
591
592         fetch_reg_values( key, values );
593         
594         if ( !(val = regval_ctr_getvalue( values, "DisplayName" )) )
595                 goto fail;
596
597         rpcstr_pull( display_name, regval_data_p(val), sizeof(display_name), regval_size(val), 0 );
598
599         TALLOC_FREE( key );
600         
601         return display_name;
602
603 fail:
604         /* default to returning the service name */
605         TALLOC_FREE( key );
606         fstrcpy( display_name, name );
607         return display_name;
608 }
609
610 /********************************************************************
611 ********************************************************************/
612
613 char* svcctl_lookup_description( const char *name, NT_USER_TOKEN *token )
614 {
615         static fstring description;
616         REGISTRY_KEY *key;
617         REGVAL_CTR *values;
618         REGISTRY_VALUE *val;
619         pstring path;
620         WERROR wresult;
621         
622         /* now add the security descriptor */
623
624         pstr_sprintf( path, "%s\\%s", KEY_SERVICES, name );
625         wresult = regkey_open_internal( NULL, &key, path, token,
626                                         REG_KEY_READ );
627         if ( !W_ERROR_IS_OK(wresult) ) {
628                 DEBUG(0,("svcctl_lookup_dispname: key lookup failed! [%s] (%s)\n", 
629                         path, dos_errstr(wresult)));
630                 return NULL;
631         }
632
633         if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
634                 DEBUG(0,("svcctl_lookup_dispname: talloc() failed!\n"));
635                 TALLOC_FREE( key );
636                 return NULL;
637         }
638
639         fetch_reg_values( key, values );
640         
641         if ( !(val = regval_ctr_getvalue( values, "Description" )) )
642                 fstrcpy( description, "Unix Service");
643         else
644                 rpcstr_pull( description, regval_data_p(val), sizeof(description), regval_size(val), 0 );
645
646         TALLOC_FREE( key );
647         
648         return description;
649 }
650
651
652 /********************************************************************
653 ********************************************************************/
654
655 REGVAL_CTR* svcctl_fetch_regvalues( const char *name, NT_USER_TOKEN *token )
656 {
657         REGISTRY_KEY *key;
658         REGVAL_CTR *values;
659         pstring path;
660         WERROR wresult;
661         
662         /* now add the security descriptor */
663
664         pstr_sprintf( path, "%s\\%s", KEY_SERVICES, name );
665         wresult = regkey_open_internal( NULL, &key, path, token,
666                                         REG_KEY_READ );
667         if ( !W_ERROR_IS_OK(wresult) ) {
668                 DEBUG(0,("svcctl_fetch_regvalues: key lookup failed! [%s] (%s)\n", 
669                         path, dos_errstr(wresult)));
670                 return NULL;
671         }
672
673         if ( !(values = TALLOC_ZERO_P( NULL, REGVAL_CTR )) ) {
674                 DEBUG(0,("svcctl_fetch_regvalues: talloc() failed!\n"));
675                 TALLOC_FREE( key );
676                 return NULL;
677         }
678         
679         fetch_reg_values( key, values );
680
681         TALLOC_FREE( key );
682         
683         return values;
684 }
685