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