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