?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: Fix an uninitialized variable reference
[Samba.git] / source / services / services_db.c
blobfaeaf3bfe4e545a875c4f14a7df41f4090821d3d
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 size_t i = 0;
93 SEC_DESC *sd = NULL;
94 SEC_ACL *theacl = NULL;
95 size_t sd_size;
96
97 /* basic access for Everyone */
98
99 init_sec_ace(&ace[i++], &global_sid_World,
100 SEC_ACE_TYPE_ACCESS_ALLOWED, SERVICE_READ_ACCESS, 0);
101
102 init_sec_ace(&ace[i++], &global_sid_Builtin_Power_Users,
103 SEC_ACE_TYPE_ACCESS_ALLOWED, SERVICE_EXECUTE_ACCESS, 0);
104
105 init_sec_ace(&ace[i++], &global_sid_Builtin_Server_Operators,
106 SEC_ACE_TYPE_ACCESS_ALLOWED, SERVICE_ALL_ACCESS, 0);
107 init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
108 SEC_ACE_TYPE_ACCESS_ALLOWED, SERVICE_ALL_ACCESS, 0);
109
110 /* create the security descriptor */
111
112 if ( !(theacl = make_sec_acl(ctx, NT4_ACL_REVISION, i, ace)) )
113 return NULL;
114
115 if ( !(sd = make_sec_desc(ctx, SECURITY_DESCRIPTOR_REVISION_1,
116 SEC_DESC_SELF_RELATIVE, NULL, NULL, NULL,
117 theacl, &sd_size)) )
118 return NULL;
119
120 return sd;
121 }
122
123 /********************************************************************
124 This is where we do the dirty work of filling in things like the
125 Display name, Description, etc...
126 ********************************************************************/
127
128 static char *get_common_service_dispname( const char *servicename )
129 {
130 int i;
131
132 for ( i=0; common_unix_svcs[i].servicename; i++ ) {
133 if (strequal(servicename, common_unix_svcs[i].servicename)) {
134 char *dispname;
135 if (asprintf(&dispname,
136 "%s (%s)",
137 common_unix_svcs[i].dispname,
138 common_unix_svcs[i].servicename) < 0) {
139 return NULL;
140 }
141 return dispname;
142 }
143 }
144
145 return SMB_STRDUP(servicename );
146 }
147
148 /********************************************************************
149 ********************************************************************/
150
151 static char *cleanup_string( const char *string )
152 {
153 char *clean = NULL;
154 char *begin, *end;
155 TALLOC_CTX *ctx = talloc_tos();
156
157 clean = talloc_strdup(ctx, string);
158 if (!clean) {
159 return NULL;
160 }
161 begin = clean;
162
163 /* trim any beginning whilespace */
164
165 while (isspace(*begin)) {
166 begin++;
167 }
168
169 if (*begin == '\0') {
170 return NULL;
171 }
172
173 /* trim any trailing whitespace or carriage returns.
174 Start at the end and move backwards */
175
176 end = begin + strlen(begin) - 1;
177
178 while ( isspace(*end) || *end=='\n' || *end=='\r' ) {
179 *end = '\0';
180 end--;
181 }
182
183 return begin;
184 }
185
186 /********************************************************************
187 ********************************************************************/
188
189 static bool read_init_file( const char *servicename, struct rcinit_file_information **service_info )
190 {
191 struct rcinit_file_information *info = NULL;
192 char *filepath = NULL;
193 char str[1024];
194 XFILE *f = NULL;
195 char *p = NULL;
196
197 if ( !(info = TALLOC_ZERO_P( NULL, struct rcinit_file_information ) ) )
198 return False;
199
200 /* attempt the file open */
201
202 filepath = talloc_asprintf(info, "%s/%s/%s", get_dyn_MODULESDIR(),
203 SVCCTL_SCRIPT_DIR, servicename);
204 if (!filepath) {
205 TALLOC_FREE(info);
206 return false;
207 }
208 if (!(f = x_fopen( filepath, O_RDONLY, 0 ))) {
209 DEBUG(0,("read_init_file: failed to open [%s]\n", filepath));
210 TALLOC_FREE(info);
211 return false;
212 }
213
214 while ( (x_fgets( str, sizeof(str)-1, f )) != NULL ) {
215 /* ignore everything that is not a full line
216 comment starting with a '#' */
217
218 if ( str[0] != '#' )
219 continue;
220
221 /* Look for a line like '^#.*Description:' */
222
223 if ( (p = strstr( str, "Description:" )) != NULL ) {
224 char *desc;
225
226 p += strlen( "Description:" ) + 1;
227 if ( !p )
228 break;
229
230 if ( (desc = cleanup_string(p)) != NULL )
231 info->description = talloc_strdup( info, desc );
232 }
233 }
234
235 x_fclose( f );
236
237 if ( !info->description )
238 info->description = talloc_strdup( info, "External Unix Service" );
239
240 *service_info = info;
241 TALLOC_FREE(filepath);
242
243 return True;
244 }
245
246 /********************************************************************
247 This is where we do the dirty work of filling in things like the
248 Display name, Description, etc...
249 ********************************************************************/
250
251 static void fill_service_values( const char *name, REGVAL_CTR *values )
252 {
253 UNISTR2 data, dname, ipath, description;
254 uint32 dword;
255 int i;
256
257 /* These values are hardcoded in all QueryServiceConfig() replies.
258 I'm just storing them here for cosmetic purposes */
259
260 dword = SVCCTL_AUTO_START;
261 regval_ctr_addvalue( values, "Start", REG_DWORD, (char*)&dword, sizeof(uint32));
262
263 dword = SVCCTL_WIN32_OWN_PROC;
264 regval_ctr_addvalue( values, "Type", REG_DWORD, (char*)&dword, sizeof(uint32));
265
266 dword = SVCCTL_SVC_ERROR_NORMAL;
267 regval_ctr_addvalue( values, "ErrorControl", REG_DWORD, (char*)&dword, sizeof(uint32));
268
269 /* everything runs as LocalSystem */
270
271 init_unistr2( &data, "LocalSystem", UNI_STR_TERMINATE );
272 regval_ctr_addvalue( values, "ObjectName", REG_SZ, (char*)data.buffer, data.uni_str_len*2);
273
274 /* special considerations for internal services and the DisplayName value */
275
276 for ( i=0; builtin_svcs[i].servicename; i++ ) {
277 if ( strequal( name, builtin_svcs[i].servicename ) ) {
278 char *pstr = NULL;
279 if (asprintf(&pstr, "%s/%s/%s",
280 get_dyn_MODULESDIR(), SVCCTL_SCRIPT_DIR,
281 builtin_svcs[i].daemon) > 0) {
282 init_unistr2( &ipath, pstr, UNI_STR_TERMINATE );
283 SAFE_FREE(pstr);
284 } else {
285 init_unistr2( &ipath, "", UNI_STR_TERMINATE );
286 }
287 init_unistr2( &description, builtin_svcs[i].description, UNI_STR_TERMINATE );
288 init_unistr2( &dname, builtin_svcs[i].dispname, UNI_STR_TERMINATE );
289 break;
290 }
291 }
292
293 /* default to an external service if we haven't found a match */
294
295 if ( builtin_svcs[i].servicename == NULL ) {
296 char *pstr = NULL;
297 char *dispname = NULL;
298 struct rcinit_file_information *init_info = NULL;
299
300 if (asprintf(&pstr, "%s/%s/%s",get_dyn_MODULESDIR(),
301 SVCCTL_SCRIPT_DIR, name) > 0) {
302 init_unistr2( &ipath, pstr, UNI_STR_TERMINATE );
303 SAFE_FREE(pstr);
304 } else {
305 init_unistr2( &ipath, "", UNI_STR_TERMINATE );
306 }
307
308 /* lookup common unix display names */
309 dispname = get_common_service_dispname(name);
310 init_unistr2( &dname, dispname ? dispname : "", UNI_STR_TERMINATE );
311 SAFE_FREE(dispname);
312
313 /* get info from init file itself */
314 if ( read_init_file( name, &init_info ) ) {
315 init_unistr2( &description, init_info->description, UNI_STR_TERMINATE );
316 TALLOC_FREE( init_info );
317 }
318 else {
319 init_unistr2( &description, "External Unix Service", UNI_STR_TERMINATE );
320 }
321 }
322
323 /* add the new values */
324
325 regval_ctr_addvalue( values, "DisplayName", REG_SZ, (char*)dname.buffer, dname.uni_str_len*2);
326 regval_ctr_addvalue( values, "ImagePath", REG_SZ, (char*)ipath.buffer, ipath.uni_str_len*2);
327 regval_ctr_addvalue( values, "Description", REG_SZ, (char*)description.buffer, description.uni_str_len*2);
328
329 return;
330 }
331
332 /********************************************************************
333 ********************************************************************/
334
335 static void add_new_svc_name( REGISTRY_KEY *key_parent, struct regsubkey_ctr *subkeys,
336 const char *name )
337 {
338 REGISTRY_KEY *key_service = NULL, *key_secdesc = NULL;
339 WERROR wresult;
340 char *path = NULL;
341 REGVAL_CTR *values = NULL;
342 struct regsubkey_ctr *svc_subkeys = NULL;
343 SEC_DESC *sd = NULL;
344 DATA_BLOB sd_blob;
345 NTSTATUS status;
346
347 /* add to the list and create the subkey path */
348
349 regsubkey_ctr_addkey( subkeys, name );
350 store_reg_keys( key_parent, subkeys );
351
352 /* open the new service key */
353
354 if (asprintf(&path, "%s\\%s", KEY_SERVICES, name) < 0) {
355 return;
356 }
357 wresult = regkey_open_internal( NULL, &key_service, path,
358 get_root_nt_token(), REG_KEY_ALL );
359 if ( !W_ERROR_IS_OK(wresult) ) {
360 DEBUG(0,("add_new_svc_name: key lookup failed! [%s] (%s)\n",
361 path, dos_errstr(wresult)));
362 SAFE_FREE(path);
363 return;
364 }
365 SAFE_FREE(path);
366
367 /* add the 'Security' key */
368
369 wresult = regsubkey_ctr_init(key_service, &svc_subkeys);
370 if (!W_ERROR_IS_OK(wresult)) {
371 DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
372 TALLOC_FREE( key_service );
373 return;
374 }
375
376 fetch_reg_keys( key_service, svc_subkeys );
377 regsubkey_ctr_addkey( svc_subkeys, "Security" );
378 store_reg_keys( key_service, svc_subkeys );
379
380 /* now for the service values */
381
382 if ( !(values = TALLOC_ZERO_P( key_service, REGVAL_CTR )) ) {
383 DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
384 TALLOC_FREE( key_service );
385 return;
386 }
387
388 fill_service_values( name, values );
389 store_reg_values( key_service, values );
390
391 /* cleanup the service key*/
392
393 TALLOC_FREE( key_service );
394
395 /* now add the security descriptor */
396
397 if (asprintf(&path, "%s\\%s\\%s", KEY_SERVICES, name, "Security") < 0) {
398 return;
399 }
400 wresult = regkey_open_internal( NULL, &key_secdesc, path,
401 get_root_nt_token(), REG_KEY_ALL );
402 if ( !W_ERROR_IS_OK(wresult) ) {
403 DEBUG(0,("add_new_svc_name: key lookup failed! [%s] (%s)\n",
404 path, dos_errstr(wresult)));
405 TALLOC_FREE( key_secdesc );
406 SAFE_FREE(path);
407 return;
408 }
409 SAFE_FREE(path);
410
411 if ( !(values = TALLOC_ZERO_P( key_secdesc, REGVAL_CTR )) ) {
412 DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
413 TALLOC_FREE( key_secdesc );
414 return;
415 }
416
417 if ( !(sd = construct_service_sd(key_secdesc)) ) {
418 DEBUG(0,("add_new_svc_name: Failed to create default sec_desc!\n"));
419 TALLOC_FREE( key_secdesc );
420 return;
421 }
422
423 status = marshall_sec_desc(key_secdesc, sd, &sd_blob.data,
424 &sd_blob.length);
425 if (!NT_STATUS_IS_OK(status)) {
426 DEBUG(0, ("marshall_sec_desc failed: %s\n",
427 nt_errstr(status)));
428 TALLOC_FREE(key_secdesc);
429 return;
430 }
431
432 regval_ctr_addvalue(values, "Security", REG_BINARY,
433 (const char *)sd_blob.data, sd_blob.length);
434 store_reg_values( key_secdesc, values );
435
436 TALLOC_FREE( key_secdesc );
437
438 return;
439 }
440
441 /********************************************************************
442 ********************************************************************/
443
444 void svcctl_init_keys( void )
445 {
446 const char **service_list = lp_svcctl_list();
447 int i;
448 struct regsubkey_ctr *subkeys = NULL;
449 REGISTRY_KEY *key = NULL;
450 WERROR wresult;
451
452 /* bad mojo here if the lookup failed. Should not happen */
453
454 wresult = regkey_open_internal( NULL, &key, KEY_SERVICES,
455 get_root_nt_token(), REG_KEY_ALL );
456
457 if ( !W_ERROR_IS_OK(wresult) ) {
458 DEBUG(0,("svcctl_init_keys: key lookup failed! (%s)\n",
459 dos_errstr(wresult)));
460 return;
461 }
462
463 /* lookup the available subkeys */
464
465 wresult = regsubkey_ctr_init(key, &subkeys);
466 if (!W_ERROR_IS_OK(wresult)) {
467 DEBUG(0,("svcctl_init_keys: talloc() failed!\n"));
468 TALLOC_FREE( key );
469 return;
470 }
471
472 fetch_reg_keys( key, subkeys );
473
474 /* the builtin services exist */
475
476 for ( i=0; builtin_svcs[i].servicename; i++ )
477 add_new_svc_name( key, subkeys, builtin_svcs[i].servicename );
478
479 for ( i=0; service_list && service_list[i]; i++ ) {
480
481 /* only add new services */
482 if ( regsubkey_ctr_key_exists( subkeys, service_list[i] ) )
483 continue;
484
485 /* Add the new service key and initialize the appropriate values */
486
487 add_new_svc_name( key, subkeys, service_list[i] );
488 }
489
490 TALLOC_FREE( key );
491
492 /* initialize the control hooks */
493
494 init_service_op_table();
495
496 return;
497 }
498
499 /********************************************************************
500 This is where we do the dirty work of filling in things like the
501 Display name, Description, etc...Always return a default secdesc
502 in case of any failure.
503 ********************************************************************/
504
505 SEC_DESC *svcctl_get_secdesc( TALLOC_CTX *ctx, const char *name, NT_USER_TOKEN *token )
506 {
507 REGISTRY_KEY *key = NULL;
508 REGVAL_CTR *values = NULL;
509 REGISTRY_VALUE *val = NULL;
510 SEC_DESC *ret_sd = NULL;
511 char *path= NULL;
512 WERROR wresult;
513 NTSTATUS status;
514
515 /* now add the security descriptor */
516
517 if (asprintf(&path, "%s\\%s\\%s", KEY_SERVICES, name, "Security") < 0) {
518 return NULL;
519 }
520 wresult = regkey_open_internal( NULL, &key, path, token,
521 REG_KEY_ALL );
522 if ( !W_ERROR_IS_OK(wresult) ) {
523 DEBUG(0,("svcctl_get_secdesc: key lookup failed! [%s] (%s)\n",
524 path, dos_errstr(wresult)));
525 goto done;
526 }
527
528 if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
529 DEBUG(0,("svcctl_get_secdesc: talloc() failed!\n"));
530 goto done;
531 }
532
533 if (fetch_reg_values( key, values ) == -1) {
534 DEBUG(0, ("Error getting registry values\n"));
535 goto done;
536 }
537
538 if ( !(val = regval_ctr_getvalue( values, "Security" )) ) {
539 goto fallback_to_default_sd;
540 }
541
542 /* stream the service security descriptor */
543
544 status = unmarshall_sec_desc(ctx, regval_data_p(val),
545 regval_size(val), &ret_sd);
546
547 if (NT_STATUS_IS_OK(status)) {
548 goto done;
549 }
550
551 fallback_to_default_sd:
552 DEBUG(6, ("svcctl_get_secdesc: constructing default secdesc for "
553 "service [%s]\n", name));
554 ret_sd = construct_service_sd(ctx);
555
556 done:
557 SAFE_FREE(path);
558 TALLOC_FREE(key);
559 return ret_sd;
560 }
561
562 /********************************************************************
563 Wrapper to make storing a Service sd easier
564 ********************************************************************/
565
566 bool svcctl_set_secdesc( TALLOC_CTX *ctx, const char *name, SEC_DESC *sec_desc, NT_USER_TOKEN *token )
567 {
568 REGISTRY_KEY *key = NULL;
569 WERROR wresult;
570 char *path = NULL;
571 REGVAL_CTR *values = NULL;
572 prs_struct ps;
573 bool ret = False;
574
575 /* now add the security descriptor */
576
577 if (asprintf(&path, "%s\\%s\\%s", KEY_SERVICES, name, "Security") < 0) {
578 return false;
579 }
580 wresult = regkey_open_internal( NULL, &key, path, token,
581 REG_KEY_ALL );
582 if ( !W_ERROR_IS_OK(wresult) ) {
583 DEBUG(0,("svcctl_get_secdesc: key lookup failed! [%s] (%s)\n",
584 path, dos_errstr(wresult)));
585 SAFE_FREE(path);
586 return False;
587 }
588 SAFE_FREE(path);
589
590 if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
591 DEBUG(0,("svcctl_set_secdesc: talloc() failed!\n"));
592 TALLOC_FREE( key );
593 return False;
594 }
595
596 /* stream the printer security descriptor */
597
598 if (!prs_init( &ps, RPC_MAX_PDU_FRAG_LEN, key, MARSHALL)) {
599 DEBUG(0,("svcctl_set_secdesc: prs_init() failed!\n"));
600 TALLOC_FREE( key );
601 return False;
602 }
603
604 if ( sec_io_desc("sec_desc", &sec_desc, &ps, 0 ) ) {
605 uint32 offset = prs_offset( &ps );
606 regval_ctr_addvalue( values, "Security", REG_BINARY, prs_data_p(&ps), offset );
607 ret = store_reg_values( key, values );
608 }
609
610 /* cleanup */
611
612 prs_mem_free( &ps );
613 TALLOC_FREE( key);
614
615 return ret;
616 }
617
618 /********************************************************************
619 ********************************************************************/
620
621 const char *svcctl_lookup_dispname(TALLOC_CTX *ctx, const char *name, NT_USER_TOKEN *token )
622 {
623 char *display_name = NULL;
624 REGISTRY_KEY *key = NULL;
625 REGVAL_CTR *values = NULL;
626 REGISTRY_VALUE *val = NULL;
627 char *path = NULL;
628 WERROR wresult;
629
630 /* now add the security descriptor */
631
632 if (asprintf(&path, "%s\\%s", KEY_SERVICES, name) < 0) {
633 return NULL;
634 }
635 wresult = regkey_open_internal( NULL, &key, path, token,
636 REG_KEY_READ );
637 if ( !W_ERROR_IS_OK(wresult) ) {
638 DEBUG(0,("svcctl_lookup_dispname: key lookup failed! [%s] (%s)\n",
639 path, dos_errstr(wresult)));
640 SAFE_FREE(path);
641 goto fail;
642 }
643 SAFE_FREE(path);
644
645 if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
646 DEBUG(0,("svcctl_lookup_dispname: talloc() failed!\n"));
647 TALLOC_FREE( key );
648 goto fail;
649 }
650
651 fetch_reg_values( key, values );
652
653 if ( !(val = regval_ctr_getvalue( values, "DisplayName" )) )
654 goto fail;
655
656 rpcstr_pull_talloc(ctx, &display_name, regval_data_p(val), regval_size(val), 0 );
657
658 TALLOC_FREE( key );
659
660 return display_name;
661
662 fail:
663 /* default to returning the service name */
664 TALLOC_FREE( key );
665 return talloc_strdup(ctx, name);
666 }
667
668 /********************************************************************
669 ********************************************************************/
670
671 const char *svcctl_lookup_description(TALLOC_CTX *ctx, const char *name, NT_USER_TOKEN *token )
672 {
673 char *description = NULL;
674 REGISTRY_KEY *key = NULL;
675 REGVAL_CTR *values = NULL;
676 REGISTRY_VALUE *val = NULL;
677 char *path = NULL;
678 WERROR wresult;
679
680 /* now add the security descriptor */
681
682 if (asprintf(&path, "%s\\%s", KEY_SERVICES, name) < 0) {
683 return NULL;
684 }
685 wresult = regkey_open_internal( NULL, &key, path, token,
686 REG_KEY_READ );
687 if ( !W_ERROR_IS_OK(wresult) ) {
688 DEBUG(0,("svcctl_lookup_description: key lookup failed! [%s] (%s)\n",
689 path, dos_errstr(wresult)));
690 SAFE_FREE(path);
691 return NULL;
692 }
693 SAFE_FREE(path);
694
695 if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
696 DEBUG(0,("svcctl_lookup_description: talloc() failed!\n"));
697 TALLOC_FREE( key );
698 return NULL;
699 }
700
701 fetch_reg_values( key, values );
702
703 if ( !(val = regval_ctr_getvalue( values, "Description" )) ) {
704 TALLOC_FREE( key );
705 return "Unix Service";
706 }
707 rpcstr_pull_talloc(ctx, &description, regval_data_p(val), regval_size(val), 0 );
708 TALLOC_FREE(key);
709
710 return description;
711 }
712
713
714 /********************************************************************
715 ********************************************************************/
716
717 REGVAL_CTR *svcctl_fetch_regvalues( const char *name, NT_USER_TOKEN *token )
718 {
719 REGISTRY_KEY *key = NULL;
720 REGVAL_CTR *values = NULL;
721 char *path = NULL;
722 WERROR wresult;
723
724 /* now add the security descriptor */
725
726 if (asprintf(&path, "%s\\%s", KEY_SERVICES, name) < 0) {
727 return NULL;
728 }
729 wresult = regkey_open_internal( NULL, &key, path, token,
730 REG_KEY_READ );
731 if ( !W_ERROR_IS_OK(wresult) ) {
732 DEBUG(0,("svcctl_fetch_regvalues: key lookup failed! [%s] (%s)\n",
733 path, dos_errstr(wresult)));
734 SAFE_FREE(path);
735 return NULL;
736 }
737 SAFE_FREE(path);
738
739 if ( !(values = TALLOC_ZERO_P( NULL, REGVAL_CTR )) ) {
740 DEBUG(0,("svcctl_fetch_regvalues: talloc() failed!\n"));
741 TALLOC_FREE( key );
742 return NULL;
743 }
744 fetch_reg_values( key, values );
745
746 TALLOC_FREE( key );
747 return values;
748 }
Samba GIT mirror