source3/include/libmsrpc.h

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  MS-RPC client library API definitions/prototypes
   4  *
   5  *  Copyright (C) Chris Nicholls              2005.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #ifndef LIBMSRPC_H
  23 #define LIBMSRPC_H
  24
  25
  26 #include "includes.h"
  27 #include "libsmbclient.h"
  28 #include "libsmb_internal.h"
  29
  30 /*server capability levels*/
  31 #define SRV_WIN_NT4     1
  32 #define SRV_WIN_2K      2
  33 #define SRV_WIN_2K_SP3  3
  34 #define SRV_WIN_2K3     4
  35
  36 /**@defgroup handle Server Handle*/
  37 /**@defgroup Library_Functions Library/Utility Functions*/
  38 /**@defgroup lsa_defs LSA Definitions*/
  39 /**@defgroup LSA_Functions LSA Functions*/
  40 /**@defgroup reg_defs Registry Definitions*/
  41 /**@defgroup Reg_Functions Registry Functions*/
  42 /**@defgroup sam_defs SAM Definitions*/
  43 /**@defgroup SAM_Functions SAM Functions*/
  44 /**@defgroup svc_defs Service Control Definitions*/
  45 /**@defgroup SCM_Functions Service Control Functions*/
  46
  47 /**Operation was unsuccessful*/
  48 #define CAC_FAILURE           0
  49 /**Operation was successful*/
  50 #define CAC_SUCCESS           1
  51 /**Operation was only partially successful
  52  *  an example of this is if you try to lookup a list of accounts to SIDs and not all accounts can be resolved*/
  53 #define CAC_PARTIAL_SUCCESS   2
  54
  55 /**@ingroup CAC_errors Use this to see if the last operation failed - useful for enumeration functions that use multiple calls*/
  56 #define CAC_OP_FAILED(status) !NT_STATUS_IS_OK(status) && \
  57                               NT_STATUS_V(status) != NT_STATUS_V(STATUS_SOME_UNMAPPED) && \
  58                               NT_STATUS_V(status) != NT_STATUS_V(STATUS_NO_MORE_FILES) && \
  59                               NT_STATUS_V(status) != NT_STATUS_V(NT_STATUS_NO_MORE_ENTRIES) && \
  60                               NT_STATUS_V(status) != NT_STATUS_V(NT_STATUS_NONE_MAPPED) && \
  61                               NT_STATUS_V(status) != NT_STATUS_V(NT_STATUS_GUIDS_EXHAUSTED)
  62
  63
  64 /**Privilege string constants*/
  65 #define CAC_SE_CREATE_TOKEN            "SeCreateTokenPrivilege"
  66 #define CAC_SE_ASSIGN_PRIMARY_TOKEN    "SeAssignPrimaryTokenPrivilege"
  67 #define CAC_SE_LOCK_MEMORY             "SeLockMemoryPrivilege"
  68 #define CAC_SE_INCREASE_QUOTA          "SeIncreaseQuotaPrivilege"
  69 #define CAC_SE_MACHINE_ACCOUNT         "SeMachineAccountPrivilege"
  70 #define CAC_SE_TCB                     "SeTcbPrivilege"
  71 #define CAC_SE_SECURITY                "SeSecurityPrivilege"
  72 #define CAC_SE_TAKE_OWNERSHIP          "SeTakeOwnershipPrivilege"
  73 #define CAC_SE_LOAD_DRIVER             "SeLoadDriverPrivilege"
  74 #define CAC_SE_SYSTEM_PROFILE          "SeSystemProfilePrivilege"
  75 #define CAC_SE_SYSTEM_TIME             "SeSystemtimePrivilege"
  76 #define CAC_SE_PROFILE_SINGLE_PROC     "SeProfileSingleProcessPrivilege"
  77 #define CAC_SE_INCREASE_BASE_PRIORITY  "SeIncreaseBasePriorityPrivilege"
  78 #define CAC_SE_CREATE_PAGEFILE         "SeCreatePagefilePrivilege"
  79 #define CAC_SE_CREATE_PERMANENT        "SeCreatePermanentPrivilege"
  80 #define CAC_SE_BACKUP                  "SeBackupPrivilege"
  81 #define CAC_SE_RESTORE                 "SeRestorePrivilege"
  82 #define CAC_SE_SHUTDOWN                "SeShutdownPrivilege"
  83 #define CAC_SE_DEBUG                   "SeDebugPrivilege"
  84 #define CAC_SE_AUDIT                   "SeAuditPrivilege"
  85 #define CAC_SE_SYSTEM_ENV              "SeSystemEnvironmentPrivilege"
  86 #define CAC_SE_CHANGE_NOTIFY           "SeChangeNotifyPrivilege"
  87 #define CAC_SE_REMOTE_SHUTDOWN         "SeRemoteShutdownPrivilege"
  88 #define CAC_SE_UNDOCK                  "SeUndockPrivilege"
  89 #define CAC_SE_SYNC_AGENT              "SeSyncAgentPrivilege"
  90 #define CAC_SE_ENABLE_DELEGATION       "SeEnableDelegationPrivilege"
  91 #define CAC_SE_MANAGE_VOLUME           "SeManageVolumePrivilege"
  92 #define CAC_SE_IMPERSONATE             "SeImpersonatePrivilege"
  93 #define CAC_SE_CREATE_GLOBAL           "SeCreateGlobalPrivilege"
  94 #define CAC_SE_PRINT_OPERATOR          "SePrintOperatorPrivilege"
  95 #define CAC_SE_NETWORK_LOGON           "SeNetworkLogonRight"
  96 #define CAC_SE_INTERACTIVE_LOGON       "SeInteractiveLogonRight"
  97 #define CAC_SE_BATCH_LOGON             "SeBatchLogonRight"
  98 #define CAC_SE_SERVICE_LOGON           "SeServiceLogonRight"
  99 #define CAC_SE_ADD_USERS               "SeAddUsersPrivilege"
 100 #define CAC_SE_DISK_OPERATOR           "SeDiskOperatorPrivilege"
 101
 102 /**
 103  * @addtogroup lsa_defs
 104  * @{
 105  */
 106 /**used to specify what data to retrieve using cac_LsaQueryTrustedDomainInformation*/
 107 #define CAC_INFO_TRUSTED_DOMAIN_NAME         0x1
 108 #define CAC_INFO_TRUSTED_DOMAIN_POSIX_OFFSET 0x3
 109 #define CAC_INFO_TRUSTED_DOMAIN_PASSWORD     0x4
 110
 111 /**Used when requesting machine domain information*/
 112 #define CAC_DOMAIN_INFO 0x0003
 113
 114 /**Used when requesting machine local information*/
 115 #define CAC_LOCAL_INFO  0x0005
 116
 117 /**Stores information about a SID*/
 118 typedef struct _CACSIDINFO {
 119    /**The actual SID*/
 120    DOM_SID sid;
 121
 122    /**The name of the object which maps to this SID*/
 123    char *name;
 124
 125    /**The domain the SID belongs to*/
 126    char *domain;
 127 } CacSidInfo;
 128 /* @} */
 129
 130 /**
 131  * @addtogroup reg_defs
 132  * @{
 133  */
 134 /**Null terminated string*/
 135 typedef char*  REG_SZ_DATA;
 136
 137 /**Null terminated string with windows environment variables that should be expanded*/
 138 typedef char*  REG_EXPAND_SZ_DATA;
 139
 140 /**Binary data of some kind*/
 141 typedef struct _REGBINARYDATA {
 142    uint32 data_length;
 143    uint8 * data;
 144 } REG_BINARY_DATA;
 145
 146 /**32-bit (little endian) number*/
 147 typedef uint32 REG_DWORD_DATA;
 148
 149 /**32-bit big endian number*/
 150 typedef uint32 REG_DWORD_BE_DATA;
 151
 152 /**array of strings*/
 153 typedef struct _REGMULTISZDATA {
 154    uint32 num_strings;
 155
 156    char **strings;
 157 } REG_MULTI_SZ_DATA;
 158
 159 typedef union _REGVALUEDATA {
 160    REG_SZ_DATA          reg_sz;
 161    REG_EXPAND_SZ_DATA   reg_expand_sz;
 162    REG_BINARY_DATA      reg_binary;
 163    REG_DWORD_DATA       reg_dword;
 164    REG_DWORD_BE_DATA    reg_dword_be;
 165    REG_MULTI_SZ_DATA    reg_multi_sz;
 166 } REG_VALUE_DATA;
 167 /**@}*/
 168
 169 /**
 170  * @addtogroup sam_defs
 171  * @{
 172  */
 173
 174 #define CAC_USER_RID  0x1
 175 #define CAC_GROUP_RID 0x2
 176
 177 typedef struct _CACLOOKUPRIDSRECORD {
 178    char *name;
 179    uint32 rid;
 180
 181    /**If found, this will be one of:
 182     * - CAC_USER_RID
 183     * - CAC_GROUP_RID
 184     */
 185    uint32 type;
 186
 187    /*if the name or RID was looked up, then found = True*/
 188    BOOL found;
 189 } CacLookupRidsRecord;
 190
 191 typedef struct _CACUSERINFO {
 192    /**Last logon time*/
 193    time_t logon_time;
 194
 195    /**Last logoff time*/
 196    time_t logoff_time;
 197
 198    /**Last kickoff time*/
 199    time_t kickoff_time;
 200
 201    /**Last password set time*/
 202    time_t pass_last_set_time;
 203
 204    /**Time password can change*/
 205    time_t pass_can_change_time;
 206
 207    /**Time password must change*/
 208    time_t pass_must_change_time;
 209
 210    /**LM user password*/
 211    uint8 lm_password[8];
 212
 213    /**NT user password*/
 214    uint8 nt_password[8];
 215
 216    /**User's RID*/
 217    uint32 rid;
 218
 219    /**RID of primary group*/
 220    uint32 group_rid;
 221
 222    /**User's ACB mask*/
 223    uint32 acb_mask;
 224
 225    /**Bad password count*/
 226    uint16 bad_passwd_count;
 227
 228    /**Number of logons*/
 229    uint16 logon_count;
 230
 231    /**Change password at next logon?*/
 232    BOOL pass_must_change;
 233
 234    /**Username*/
 235    char *username;
 236
 237    /**User's full name*/
 238    char *full_name;
 239
 240    /**User's home directory*/
 241    char *home_dir;
 242
 243    /**Home directory drive*/
 244    char *home_drive;
 245
 246    /**Logon script*/
 247    char *logon_script;
 248
 249    /**Path to profile*/
 250    char *profile_path;
 251
 252    /**Account description*/
 253    char *description;
 254
 255    /**Login from workstations*/
 256    char *workstations;
 257
 258    char *dial;
 259
 260    /**Possible logon hours*/
 261    LOGON_HRS *logon_hours;
 262
 263 } CacUserInfo;
 264
 265 typedef struct _CACGROUPINFO {
 266    /**Group name*/
 267    char *name;
 268
 269    /**Description*/
 270    char *description;
 271
 272    /**Number of members*/
 273    uint32 num_members;
 274 } CacGroupInfo, CacAliasInfo;
 275
 276 /**Represents a period (duration) of time*/
 277 typedef struct _CACTIME {
 278    /**Number of days*/
 279    uint32 days;
 280
 281    /**Number of hours*/
 282    uint32 hours;
 283
 284    /**Number of minutes*/
 285    uint32 minutes;
 286
 287    /**number of seconds*/
 288    uint32 seconds;
 289 } CacTime;
 290
 291
 292 typedef struct _CACDOMINFO {
 293    /**The server role. Should be one of:
 294     *   ROLE_STANDALONE
 295     *   ROLE_DOMAIN_MEMBER
 296     *   ROLE_DOMAIN_BDC
 297     *   ROLE_DOMAIN_PDC
 298     *   see include/smb.h
 299     */
 300    uint32 server_role;
 301
 302    /**Number of domain users*/
 303    uint32 num_users;
 304
 305    /**Number of domain groups*/
 306    uint32 num_domain_groups;
 307
 308    /**Number of local groups*/
 309    uint32 num_local_groups;
 310
 311    /**Comment*/
 312    char *comment;
 313
 314    /**Domain name*/
 315    char *domain_name;
 316
 317    /**Server name*/
 318    char *server_name;
 319
 320    /**Minimum password length*/
 321    uint16 min_pass_length;
 322
 323    /**How many previous passwords to remember - ie, password cannot be the same as N previous passwords*/
 324    uint16 pass_history;
 325
 326    /**How long (from now) before passwords expire*/
 327    CacTime expire;
 328
 329    /**How long (from now) before passwords can be changed*/
 330    CacTime min_pass_age;
 331
 332    /**How long users are locked out for too many bad password attempts*/
 333    CacTime lockout_duration;
 334
 335    /**How long before lockouts are reset*/
 336    CacTime lockout_reset;
 337
 338    /**How many bad password attempts before lockout occurs*/
 339    uint16 num_bad_attempts;
 340 } CacDomainInfo;
 341
 342 /**@}*/ /*sam_defs*/
 343
 344 /**@addtogroup svc_defs
 345  * @{
 346  */
 347 typedef struct _CACSERVICE {
 348    /**The service name*/
 349    char *service_name;
 350
 351    /**The display name of the service*/
 352    char *display_name;
 353
 354    /**Current status of the service - see include/rpc_svcctl.h for SERVICE_STATUS definition*/
 355    SERVICE_STATUS status;
 356 } CacService;
 357
 358 typedef struct __CACSERVICECONFIG {
 359    /**The service type*/
 360    uint32 type;
 361
 362    /**The start type. Should be one of:
 363     * - SVCCTL_BOOT_START
 364     * - SVCCTL_SYSTEM_START
 365     * - SVCCTL_AUTO_START
 366     * - SVCCTL_DEMAND_START
 367     */
 368    uint32 start_type;
 369
 370    uint32 error_control;
 371
 372    /**Path to executable*/
 373    char *exe_path;
 374
 375    /***/
 376    char *load_order_group;
 377
 378    uint32 tag_id;
 379
 380    /**Any dependencies for the service*/
 381    char *dependencies;
 382
 383    /**Run as...*/
 384    char *start_name;
 385
 386    /**Service display name*/
 387    char *display_name;
 388
 389 } CacServiceConfig;
 390 /**@}*/ /*svc_defs*/
 391
 392 #include "libmsrpc_internal.h"
 393
 394 /**
 395  * @addtogroup handle
 396  * @{
 397  */
 398
 399 /**
 400  * Server handle used to keep track of client/server/pipe information. Use cac_NewServerHandle() to allocate.
 401  * Initiliaze as many values as possible before calling cac_Connect().
 402  *
 403  * @note When allocating memory for the fields, use SMB_MALLOC() (or equivalent) instead of talloc() (or equivalent) -
 404  * If memory is not allocated for a field, cac_Connect will allocate sizeof(fstring) bytes for it.
 405  *
 406  * @note It may be wise to allocate large buffers for these fields and strcpy data into them.
 407  *
 408  * @see cac_NewServerHandle()
 409  * @see cac_FreeHandle()
 410  */
 411 typedef struct _CACSERVERHANDLE {
 412    /** debug level
 413     */
 414    int debug;
 415
 416    /** netbios name used to make connections
 417     */
 418    char *netbios_name;
 419
 420    /** domain name used to make connections
 421     */
 422    char *domain;
 423
 424    /** username used to make connections
 425     */
 426    char *username;
 427
 428    /** user's password plain text string
 429     */
 430    char *password;
 431
 432    /** name or IP address of server we are currently working with
 433     */
 434    char *server;
 435
 436    /**stores the latest NTSTATUS code
 437     */
 438    NTSTATUS status;
 439
 440    /** internal. do not modify!
 441     */
 442    struct CacServerHandleInternal _internal;
 443
 444 } CacServerHandle;
 445
 446 /*@}*/
 447
 448 /**internal function. do not call this function*/
 449 SMBCSRV *cac_GetServer(CacServerHandle *hnd);
 450
 451
 452 /** @addtogroup Library_Functions
 453  * @{
 454  */
 455 /**
 456  * Initializes the library - do not need to call this function.  Open's smb.conf as well as initializes logging.
 457  * @param debug Debug level for library to use
 458  */
 459
 460 void cac_Init(int debug);
 461
 462 /**
 463  * Creates an un-initialized CacServerHandle
 464  * @param allocate_fields If True, the function will allocate sizeof(fstring) bytes for all char * fields in the handle
 465  * @return - un-initialized server handle
 466  *         - NULL if no memory could be allocated
 467  */
 468 CacServerHandle * cac_NewServerHandle(BOOL allocate_fields);
 469
 470 /**
 471  * Specifies the smbc_get_auth_data_fn to use if you do not want to use the default.
 472  * @param hnd non-NULL server handle
 473  * @param auth_fn  auth_data_fn to set in server handle
 474  */
 475
 476 void cac_SetAuthDataFn(CacServerHandle *hnd, smbc_get_auth_data_fn auth_fn);
 477
 478 /** Use your own libsmbclient context - not necessary.
 479  * @note You must still call cac_Connect() after specifying your own libsmbclient context
 480  * @param hnd Initialized, but not connected CacServerHandle
 481  * @param ctx The libsmbclient context you would like to use.
 482  */
 483 void cac_SetSmbcContext(CacServerHandle *hnd, SMBCCTX *ctx);
 484
 485 /** Connects to a specified server.  If there is already a connection to a different server,
 486  *    it will be cleaned up before connecting to the new server.
 487  * @param hnd   Pre-initialized CacServerHandle
 488  * @param srv   (Optional) Name or IP of the server to connect to.  If NULL, server from the CacServerHandle will be used.
 489  *
 490  * @return CAC_FAILURE if the operation could not be completed successfully (hnd->status will also be set with a NTSTATUS code)
 491  * @return CAC_SUCCESS if the operation succeeded
 492  */
 493 int cac_Connect(CacServerHandle *hnd, const char *srv);
 494
 495
 496 /**
 497  * Cleans up any data used by the CacServerHandle. If the libsmbclient context was set using cac_SetSmbcContext(), it will not be free'd.
 498  * @param hnd the CacServerHandle to destroy
 499  */
 500 void cac_FreeHandle(CacServerHandle * hnd);
 501
 502 /**
 503  * Initializes a CacTime structure based on an NTTIME structure
 504  *  If the function fails, then the CacTime structure will be zero'd out
 505  */
 506 void cac_InitCacTime(CacTime *cactime, NTTIME nttime);
 507
 508 /**
 509  * Called by cac_NewServerHandle() if allocate_fields = True. You can call this if you want to, allocates sizeof(fstring) char's for every char * field
 510  * @param hnd Uninitialized server handle
 511  * @return CAC_FAILURE Memory could not be allocated
 512  * @return CAC_SUCCESS Memory was allocated
 513  */
 514 int cac_InitHandleMem(CacServerHandle *hnd);
 515
 516 /**
 517  * Default smbc_get_auth_data_fn for libmsrpc. This function is called when libmsrpc needs to get more information about the
 518  * client (username/password, workgroup).
 519  * This function provides simple prompts to the user to enter the information. This description his here so you know how to re-define this function.
 520  * @see cac_SetAuthDataFn()
 521  * @param pServer Name/IP of the server to connect to.
 522  * @param pShare Share name to connect to
 523  * @param pWorkgroup libmsrpc passes in the workgroup/domain name from hnd->domain. It can be modified in the function.
 524  * @param maxLenWorkgroup The maximum length of a string pWogroup can hold.
 525  * @param pUsername libmsrpc passes in the username from hnd->username. It can be modified in the function.
 526  * @param maxLenUsername The maximum length of a string pUsername can hold.
 527  * @param pPassword libmsrpc pass in the password from hnd->password. It can be modified in the function.
 528  * @param maxLenPassword The maximum length  of a string pPassword can hold.
 529  */
 530 void cac_GetAuthDataFn(const char * pServer,
 531                  const char * pShare,
 532                  char * pWorkgroup,
 533                  int maxLenWorkgroup,
 534                  char * pUsername,
 535                  int maxLenUsername,
 536                  char * pPassword,
 537                  int maxLenPassword);
 538
 539
 540 /**@}*/
 541
 542 /*****************
 543  * LSA Functions *
 544  *****************/
 545
 546 /** @addtogroup LSA_Functions
 547  * @{
 548  */
 549
 550 struct LsaOpenPolicy {
 551    /**Inputs*/
 552    struct {
 553       /**Access Mask. Refer to Security Access Masks in include/rpc_secdes.h*/
 554       uint32 access;
 555
 556       /**Use security quality of service? (True/False)*/
 557       BOOL security_qos;
 558    } in;
 559
 560    /**Outputs*/
 561    struct {
 562       /**Handle to the open policy (needed for all other operations)*/
 563       POLICY_HND *pol;
 564    } out;
 565 };
 566
 567 /**
 568  * Opens a policy handle on a remote machine.
 569  * @param hnd fully initialized CacServerHandle for remote machine
 570  * @param mem_ctx Talloc context for memory allocation
 571  * @param op Initialized parameters
 572  * @return CAC_FAILURE if the policy could not be opened. hnd->status set with appropriate NTSTATUS
 573  * @return CAC_SUCCESS if the policy could be opened, the policy handle can be found
 574  */
 575 int cac_LsaOpenPolicy(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaOpenPolicy *op);
 576
 577
 578 /**
 579  * Closes an  LSA policy handle (Retrieved using cac_LsaOpenPolicy).
 580  *   If successful, the handle will be closed on the server, and memory for pol will be freed
 581  * @param hnd - An initialized and connected server handle
 582  * @param mem_ctx Talloc context for memory allocation
 583  * @param pol - the policy handle to close
 584  * @return CAC_FAILURE could not close the policy handle, hnd->status is set to the appropriate NTSTATUS error code
 585  * @return CAC_SUCCESS the policy handle was closed
 586  */
 587 int cac_LsaClosePolicy(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *pol);
 588
 589
 590 struct LsaGetNamesFromSids {
 591    struct {
 592       /**handle to and open LSA policy*/
 593       POLICY_HND *pol;
 594
 595       /**the number of SIDs to lookup*/
 596       uint32 num_sids;
 597
 598       /**array of SIDs to lookup*/
 599       DOM_SID *sids;
 600    } in;
 601
 602    struct {
 603       /**The number of names returned (in case of CAC_PARTIAL_SUCCESS)*/
 604       uint32 num_found;
 605
 606       /**array of SID info each index is one sid */
 607       CacSidInfo *sids;
 608
 609       /**in case of partial success, an array of SIDs that could not be looked up (NULL if all sids were looked up)*/
 610       DOM_SID *unknown;
 611    } out;
 612 };
 613
 614 /**
 615  * Looks up the names for a list of SIDS
 616  * @param hnd initialized and connected server handle
 617  * @param mem_ctx Talloc context for memory allocation
 618  * @param op  input and output parameters
 619  * @return CAC_FAILURE none of the SIDs could be looked up hnd->status is set with appropriate NTSTATUS error code
 620  * @return CAC_SUCCESS all of the SIDs were translated and a list of names has been output
 621  * @return CAC_PARTIAL_SUCCESS not all of the SIDs were translated, as a result the number of returned names is less than the original list of SIDs
 622  */
 623 int cac_LsaGetNamesFromSids(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaGetNamesFromSids *op);
 624
 625 struct LsaGetSidsFromNames {
 626    struct {
 627       /**handle to an open LSA policy*/
 628       POLICY_HND *pol;
 629
 630       /**number of SIDs to lookup*/
 631       uint32 num_names;
 632
 633       /**array of strings listing the names*/
 634       char **names;
 635    } in;
 636
 637    struct {
 638       /**The number of SIDs returned (in case of partial success*/
 639       uint32 num_found;
 640
 641       /**array of SID info for the looked up names*/
 642       CacSidInfo *sids;
 643
 644       /**in case of partial success, the names that were not looked up*/
 645       char **unknown;
 646    } out;
 647 };
 648
 649 /**
 650  * Looks up the SIDs for a list of names
 651  * @param hnd initialized and connected server handle
 652  * @param mem_ctx Talloc context for memory allocation
 653  * @param op  input and output parameters
 654  * @return CAC_FAILURE none of the SIDs could be looked up hnd->status is set with appropriate NTSTATUS error code
 655  * @return CAC_SUCCESS all of the SIDs were translated and a list of names has been output
 656  * @return CAC_PARTIAL_SUCCESS not all of the SIDs were translated, as a result the number of returned names is less than the original list of SIDs
 657  */
 658 int cac_LsaGetSidsFromNames(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaGetSidsFromNames *op);
 659
 660 struct LsaFetchSid {
 661    struct {
 662       /**handle to an open LSA policy*/
 663       POLICY_HND *pol;
 664
 665       /**can be CAC_LOCAL_INFO, CAC_DOMAIN_INFO, or (CAC_LOCAL_INFO | CAC_DOMAIN_INFO)*/
 666       uint16 info_class;
 667    } in;
 668
 669    struct {
 670       /**the machine's local SID and domain name (NULL if not asked for)*/
 671       CacSidInfo *local_sid;
 672
 673       /**the machine's domain SID and name (NULL if not asked for)*/
 674       CacSidInfo *domain_sid;
 675
 676    } out;
 677 };
 678
 679 /**
 680  * Looks up the domain or local sid of a machine with an open LSA policy handle
 681  * @param hnd initialized and connected server handle
 682  * @param mem_ctx Talloc context for memory allocation
 683  * @param op input and output parameters
 684  * @return CAC_FAILURE if the SID could not be fetched
 685  * @return CAC_SUCCESS if the SID was fetched
 686  * @return CAC_PARTIAL_SUCCESS if you asked for both local and domain sids but only one was returned
 687  */
 688 int cac_LsaFetchSid(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaFetchSid *op);
 689
 690 struct LsaQueryInfoPolicy {
 691    struct {
 692       /**Open LSA policy handle on remote server*/
 693       POLICY_HND *pol;
 694    } in;
 695
 696    struct {
 697       /**remote server's domain name*/
 698       char *domain_name;
 699
 700       /**remote server's dns name*/
 701       char *dns_name;
 702
 703       /**remote server's forest name*/
 704       char *forest_name;
 705
 706       /**remote server's domain guid*/
 707       struct GUID *domain_guid;
 708
 709       /**remote server's domain SID*/
 710       DOM_SID *domain_sid;
 711    } out;
 712 };
 713
 714 /**
 715  * Retrieves information about the LSA machine/domain
 716  * @param hnd initialized and connected server handle
 717  * @param mem_ctx Talloc context for memory allocation
 718  * @param op input and output parameters
 719  *           Note: for pre-Windows 2000 machines, only op->out.SID and op->out.domain will be set. @see cac_LsaFetchSid
 720  * @return - CAC_FAILURE if the operation was not successful. hnd->status will be set with an accurate NT_STATUS code
 721  * @return CAC_SUCCESS the operation was successful.
 722  */
 723 int cac_LsaQueryInfoPolicy(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaQueryInfoPolicy *op);
 724
 725 struct LsaEnumSids {
 726    struct {
 727       /**Open LSA Policy handle*/
 728       POLICY_HND *pol;
 729
 730       /**The prefered maximum number of SIDs returned per call*/
 731       uint32 pref_max_sids;
 732    } in;
 733
 734    struct {
 735       /**used to keep track of how many sids have been retrieved over multiple calls
 736        *  should be set to zero via ZERO_STRUCT() befrore the first call. Use the same struct LsaEnumSids for multiple calls*/
 737       uint32 resume_idx;
 738
 739       /**The number of sids returned this call*/
 740       uint32 num_sids;
 741
 742       /**Array of sids returned*/
 743       DOM_SID *sids;
 744
 745    } out;
 746 };
 747
 748 /**
 749  * Enumerates the SIDs in the LSA.  Can be enumerated in blocks by calling the function multiple times.
 750  *  Example: while(cac_LsaEnumSids(hnd, mem_ctx, op) { ... }
 751  * @param hnd - An initialized and connected server handle
 752  * @param mem_ctx Talloc context for memory allocation
 753  * @param op Initialized parameters
 754  * @return CAC_FAILURE there was an error during operations OR there are no more results
 755  * @return CAC_SUCCESS the operation completed and results were returned
 756  */
 757 int cac_LsaEnumSids(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaEnumSids *op);
 758
 759 struct LsaEnumAccountRights {
 760    struct {
 761       /**Open LSA Policy handle*/
 762       POLICY_HND *pol;
 763
 764       /**(Optional) SID of the account - must supply either sid or name*/
 765       DOM_SID *sid;
 766
 767       /**(Optional) name of the account - must supply either sid or name*/
 768       char *name;
 769    } in;
 770
 771    struct {
 772       /**Count of rights for this account*/
 773       uint32 num_privs;
 774
 775       /**array of privilege names*/
 776       char **priv_names;
 777    } out;
 778 };
 779
 780 /**
 781  * Enumerates rights assigned to a given account. Takes a SID instead of account handle as input
 782  * @param hnd Initialized and connected server handle
 783  * @param mem_ctx Context for memory allocation
 784  * @param op Initialized Parameters
 785  * @return CAC_FAILURE the rights could not be retrieved. hnd->status is set with NT_STATUS code
 786  * @return CAC_SUCCESS the operation was successful.
 787  */
 788
 789 int cac_LsaEnumAccountRights(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaEnumAccountRights *op);
 790
 791 struct LsaEnumTrustedDomains {
 792    struct {
 793       /**Open LSA policy handle*/
 794       POLICY_HND *pol;
 795    } in;
 796
 797    struct {
 798       /**used to keep track of how many domains have been retrieved over multiple calls
 799        *  should be set to zero via ZERO_STRUCT() before the first call. Use the same struct LsaEnumSids for multiple calls*/
 800       uint32 resume_idx;
 801
 802       /**The number of domains returned by the remote server this call*/
 803       uint32 num_domains;
 804
 805       /**array of trusted domain names returned by the remote server*/
 806       char **domain_names;
 807
 808       /**array of trusted domain sids returned by the remote server*/
 809       DOM_SID *domain_sids;
 810    } out;
 811 };
 812
 813 /**
 814  * Enumerates the trusted domains in the LSA.
 815  * @param hnd - An initialized and connected server handle
 816  * @param mem_ctx Talloc context for memory allocation
 817  * @param op - initialized parameters
 818  * @return CAC_FAILURE there was an error during operations OR there are no more results
 819  * @return CAC_SUCCESS the operation completed and results were returned
 820  */
 821 int cac_LsaEnumTrustedDomains(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaEnumTrustedDomains *op);
 822
 823 struct LsaOpenTrustedDomain {
 824    struct {
 825       /**an open LSA policy handle*/
 826       POLICY_HND *pol;
 827
 828       /**SID of the trusted domain to open*/
 829       DOM_SID *domain_sid;
 830
 831       /**Desired access on the open domain*/
 832       uint32 access;
 833    } in;
 834
 835    struct {
 836       /**A handle to the policy that is opened*/
 837       POLICY_HND *domain_pol;
 838    } out;
 839 };
 840
 841 /**
 842  * Opens a trusted domain by SID.
 843  * @param hnd An initialized and connected server handle
 844  * @param mem_ctx Talloc context for memory allocation
 845  * @param op initialized I/O parameters
 846  * @return CAC_FAILURE a handle to the domain could not be opened. hnd->status is set with approriate NT_STATUS code
 847  * @return CAC_SUCCESS the domain was opened successfully
 848  */
 849 int cac_LsaOpenTrustedDomain(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaOpenTrustedDomain *op);
 850
 851 struct LsaQueryTrustedDomainInfo {
 852    struct {
 853       /**Open LSA policy handle*/
 854       POLICY_HND *pol;
 855
 856       /**Info class of returned data*/
 857       uint16 info_class;
 858
 859       /**(Optional)SID of trusted domain to query (must specify either SID or name of trusted domain)*/
 860       DOM_SID *domain_sid;
 861
 862       /**(Optional)Name of trusted domain to query (must specify either SID or name of trusted domain)*/
 863       char *domain_name;
 864    } in;
 865
 866    struct {
 867       /**information about the trusted domain*/
 868       LSA_TRUSTED_DOMAIN_INFO *info;
 869    } out;
 870 };
 871
 872 /**
 873  * Retrieves information a trusted domain.
 874  * @param hnd An initialized and connected server handle
 875  * @param mem_ctx Talloc context for memory allocation
 876  * @param op initialized I/O parameters
 877  * @return CAC_FAILURE a handle to the domain could not be opened. hnd->status is set with approriate NT_STATUS code
 878  * @return CAC_SUCCESS the domain was opened successfully
 879  */
 880
 881 int cac_LsaQueryTrustedDomainInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaQueryTrustedDomainInfo *op);
 882
 883 struct LsaEnumPrivileges {
 884    struct {
 885       /**An open LSA policy handle*/
 886       POLICY_HND *pol;
 887
 888       /**The _preferred_ maxinum number of privileges returned per call*/
 889       uint32 pref_max_privs;
 890    } in;
 891
 892    struct {
 893       /**Used to keep track of how many privileges have been retrieved over multiple calls. Do not modify this value between calls*/
 894       uint32 resume_idx;
 895
 896       /**The number of privileges returned this call*/
 897       uint32 num_privs;
 898
 899       /**Array of privilege names*/
 900       char **priv_names;
 901
 902       /**Array of high bits for privilege LUID*/
 903       uint32 *high_bits;
 904
 905       /**Array of low bits for privilege LUID*/
 906       uint32 *low_bits;
 907    } out;
 908 };
 909
 910 /**
 911  * Enumerates the Privileges supported by the LSA.  Can be enumerated in blocks by calling the function multiple times.
 912  *  Example: while(cac_LsaEnumPrivileges(hnd, mem_ctx, op) { ... }
 913  * @param hnd An initialized and connected server handle
 914  * @param mem_ctx Talloc context for memory allocation
 915  * @param op Initialized parameters
 916  * @return CAC_FAILURE there was an error during operations OR there are no more results
 917  * @return CAC_SUCCESS the operation completed and results were returned
 918  * @see CAC_OP_FAILED()
 919  */
 920 int cac_LsaEnumPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaEnumPrivileges *op);
 921
 922 struct LsaOpenAccount {
 923    struct {
 924       /**An open LSA policy handle*/
 925       POLICY_HND *pol;
 926
 927       /**(Optional) account SID - must supply either sid or name*/
 928       DOM_SID *sid;
 929
 930       /**(Optional) account name - must supply either sid or name*/
 931       char *name;
 932
 933       /**desired access for the handle*/
 934       uint32 access;
 935    } in;
 936
 937    struct {
 938       /**A handle to the opened user*/
 939       POLICY_HND *user;
 940    } out;
 941 };
 942
 943 /**
 944  * Opens a handle to an account in the LSA
 945  * @param hnd Initialized and connected server handle
 946  * @param mem_ctx Context for memory allocation
 947  * @param op Initialized Parameters
 948  * @return CAC_FAILURE the account could not be opened. hnd->status has appropriate NT_STATUS code
 949  * @return CAC_SUCCESS the account was opened
 950  */
 951 int cac_LsaOpenAccount(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaOpenAccount *op);
 952
 953 struct LsaAddPrivileges {
 954    struct {
 955       /**An open LSA policy handle*/
 956       POLICY_HND *pol;
 957
 958       /**(Optional) The user's SID (must specify at least sid or name)*/
 959       DOM_SID *sid;
 960
 961       /**(Optional) The user's name (must specify at least sid or name)*/
 962       char *name;
 963
 964       /**The privilege names of the privileges to add for the account*/
 965       char **priv_names;
 966
 967       /**The number of privileges in the priv_names array*/
 968       uint32 num_privs;
 969
 970    } in;
 971 };
 972
 973 /**
 974  * Adds Privileges an account.
 975  * @param hnd Initialized and connected server handle
 976  * @param mem_ctx Context for memory allocation
 977  * @param op Initialized Parameters
 978  * @return CAC_FAILURE the privileges could not be set. hnd->status has appropriate NT_STATUS code
 979  * @return CAC_SUCCESS the privileges were set.
 980  */
 981 int cac_LsaAddPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaAddPrivileges *op);
 982
 983 struct LsaRemovePrivileges {
 984    struct {
 985       /**An open handle to the LSA*/
 986       POLICY_HND *pol;
 987
 988       /**(Optional) The account SID (must specify at least sid or name)*/
 989       DOM_SID *sid;
 990
 991       /**(Optional) The account name (must specify at least sid or name)*/
 992       char *name;
 993
 994       /**The privilege names of the privileges to remove from the account*/
 995       char **priv_names;
 996
 997       /**The number of privileges in the priv_names array*/
 998       uint32 num_privs;
 999
1000    } in;
1001
1002 };
1003
1004 /**
1005  * Removes a _specific_ set of privileges from an account
1006  * @param hnd Initialized and connected server handle
1007  * @param mem_ctx Context for memory allocation
1008  * @param op Initialized Parameters
1009  * @return CAC_FAILURE the privileges could not be removed. hnd->status is set with NT_STATUS code
1010  * @return CAC_SUCCESS the privileges were removed
1011  */
1012 int cac_LsaRemovePrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaRemovePrivileges *op);
1013
1014 struct LsaClearPrivileges {
1015    struct {
1016       /**An open handle to the LSA*/
1017       POLICY_HND *pol;
1018
1019       /**(Optional) The user's SID (must specify at least sid or name)*/
1020       DOM_SID *sid;
1021
1022       /**(Optional) The user's name (must specify at least sid or name)*/
1023       char *name;
1024    } in;
1025
1026 };
1027
1028 /**
1029  * Removes ALL privileges from an account
1030  * @param hnd Initialized and connected server handle
1031  * @param mem_ctx Context for memory allocation
1032  * @param op Initialized Parameters
1033  * @return CAC_FAILURE the operation was not successful, hnd->status set with NT_STATUS code
1034  * @return CAC_SUCCESS the opeartion was successful.
1035  */
1036 int cac_LsaClearPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaClearPrivileges *op);
1037
1038 /**
1039  * Sets an accounts priviliges. Removes all privileges and then adds specified privileges.
1040  * @param hnd Initialized and connected server handle
1041  * @param mem_ctx Context for memory allocation
1042  * @param op Initialized Parameters
1043  * @return CAC_FAILURE The operation could not complete successfully
1044  * @return CAC_SUCCESS The operation completed successfully
1045  */
1046 int cac_LsaSetPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaAddPrivileges *op);
1047
1048 struct LsaGetSecurityObject {
1049    struct {
1050       /**Open LSA policy handle*/
1051       POLICY_HND *pol;
1052    } in;
1053
1054    struct {
1055       /**Returned security descriptor information*/
1056       SEC_DESC_BUF *sec;
1057    } out;
1058 };
1059
1060 /**
1061  * Retrieves Security Descriptor information about the LSA
1062  * @param hnd Initialized and connected server handle
1063  * @param mem_ctx Context for memory allocation
1064  * @param op Initialized Parameters
1065  * @return CAC_FAILURE The operation could not complete successfully
1066  * @return CAC_SUCCESS The operation completed successfully
1067  */
1068 int cac_LsaGetSecurityObject(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaGetSecurityObject *op);
1069
1070
1071 /**@}*/ /*LSA_Functions*/
1072
1073 /**********************
1074  * Registry Functions *
1075  *********************/
1076
1077 /**@addtogroup Reg_Functions
1078  * @{
1079  */
1080
1081 struct RegConnect {
1082    struct {
1083       /** must be one of :
1084        *    HKEY_CLASSES_ROOT,
1085        *    HKEY_LOCAL_MACHINE,
1086        *    HKEY_USERS,
1087        *    HKEY_PERFORMANCE_DATA,
1088        */
1089       int root;
1090
1091       /**desired access on the root key
1092        * combination of:
1093        * REG_KEY_READ,
1094        * REG_KEY_WRITE,
1095        * REG_KEY_EXECUTE,
1096        * REG_KEY_ALL,
1097        * found in include/rpc_secdes.h*/
1098       uint32 access;
1099    } in;
1100
1101    struct {
1102       POLICY_HND *key;
1103    } out;
1104 };
1105
1106 /**
1107  * Opens a handle to the registry on the server
1108  * @param hnd Initialized and connected server handle
1109  * @param mem_ctx Context for memory allocation
1110  * @param op Initialized Parameters
1111  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1112  * @return CAC_SUCCESS The operation completed successfully
1113  */
1114 int cac_RegConnect(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegConnect *op);
1115
1116 /**
1117  * Closes an open registry handle
1118  * @param hnd Initialized and connected server handle
1119  * @param mem_ctx Context for memory allocation
1120  * @param key The Key/Handle to close
1121  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1122  * @return CAC_SUCCESS The operation completed successfully
1123  */
1124 int cac_RegClose(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *key);
1125
1126 struct RegOpenKey {
1127    struct {
1128       /**(Optional)parent key.
1129        * If this is NULL, then cac_RegOpenKey() will attempt to connect to the registry, name MUST start with something like:<br>
1130        *  HKEY_LOCAL_MACHINE\  or an abbreviation like HKCR\
1131        *
1132        *  supported root names:
1133        *   - HKEY_LOCAL_MACHINE\ or HKLM\
1134        *   - HKEY_CLASSES_ROOT\ or HKCR\
1135        *   - HKEY_USERS\ or HKU\
1136        *   - HKEY_PERFORMANCE_DATA or HKPD\
1137        */
1138       POLICY_HND *parent_key;
1139
1140       /**name/path of key*/
1141       char *name;
1142
1143       /**desired access on this key*/
1144       uint32 access;
1145    } in;
1146
1147    struct {
1148       POLICY_HND *key;
1149    } out;
1150 };
1151
1152 /**
1153  * Opens a registry key
1154  * @param hnd Initialized and connected server handle
1155  * @param mem_ctx Context for memory allocation
1156  * @param op Initialized parameters
1157  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1158  * @return CAC_SUCCESS The operation completed successfully
1159  */
1160
1161 int cac_RegOpenKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegOpenKey *op);
1162
1163 struct RegEnumKeys {
1164    struct {
1165       /**enumerate subkeys of this key*/
1166       POLICY_HND *key;
1167
1168       /**maximum number of keys to enumerate each call*/
1169       uint32 max_keys;
1170    } in;
1171
1172    struct {
1173       /**keeps track of the index to resume enumerating*/
1174       uint32 resume_idx;
1175
1176       /**the number of keys returned this call*/
1177       uint32 num_keys;
1178
1179       /**array of key names*/
1180       char **key_names;
1181
1182       /**class names of the keys*/
1183       char **class_names;
1184
1185       /**last modification time of the key*/
1186       time_t *mod_times;
1187    } out;
1188 };
1189
1190 /**
1191  * Enumerates Subkeys of a given key. Can be run in a loop. Example: while(cac_RegEnumKeys(hnd, mem_ctx, op)) { ... }
1192  * @param hnd Initialized and connected server handle
1193  * @param mem_ctx Context for memory allocation
1194  * @param op Initialized Parameters
1195  * @see CAC_OP_FAILED()
1196  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1197  * @return CAC_SUCCESS The operation completed successfully
1198  */
1199 int cac_RegEnumKeys(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegEnumKeys *op);
1200
1201
1202 struct RegCreateKey {
1203    struct {
1204       /**create a subkey of parent_key*/
1205       POLICY_HND *parent_key;
1206
1207       /**name of the key to create*/
1208       char *key_name;
1209
1210       /**class of the key*/
1211       char *class_name;
1212
1213       /**Access mask to open the key with. See REG_KEY_* in include/rpc_secdes.h*/
1214       uint32 access;
1215    } in;
1216
1217    struct {
1218       /**Open handle to the key*/
1219       POLICY_HND *key;
1220    } out;
1221 };
1222
1223 /**
1224  * Creates a registry key, if the key already exists, it will be opened __Creating keys is not currently working__.
1225  * @param hnd Initialized and connected server handle
1226  * @param mem_ctx Context for memory allocation
1227  * @param op Initialized Parmeters
1228  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1229  * @return CAC_SUCCESS The operation completed successfully
1230  */
1231 int cac_RegCreateKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegCreateKey *op);
1232
1233 struct RegDeleteKey {
1234    struct {
1235       /**handle to open registry key*/
1236       POLICY_HND *parent_key;
1237
1238       /**name of the key to delete*/
1239       char *name;
1240
1241       /**delete recursively. WARNING: this might not always work as planned*/
1242       BOOL recursive;
1243    } in;
1244
1245 };
1246
1247 /**
1248  * Deletes a subkey of an open key. Note: if you run this with op->in.recursive == True, and the operation fails, it may leave the key in an inconsistent state.
1249  * @param hnd Initialized and connected server handle
1250  * @param mem_ctx Context for memory allocation
1251  * @param op Initialized parameters
1252  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1253  * @return CAC_SUCCESS The operation completed successfully
1254  */
1255
1256 int cac_RegDeleteKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegDeleteKey *op);
1257
1258 struct RegDeleteValue {
1259    struct {
1260       /**handle to open registry key*/
1261       POLICY_HND *parent_key;
1262
1263       /**name of the value to delete*/
1264       char *name;
1265    } in;
1266 };
1267
1268 /**
1269  * Deletes a registry value.
1270  * @param hnd Initialized and connected server handle
1271  * @param mem_ctx Context for memory allocation
1272  * @param op Initialized Parameters
1273  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1274  * @return CAC_SUCCESS The operation completed successfully
1275  */
1276 int cac_RegDeleteValue(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegDeleteValue *op);
1277
1278 struct RegQueryKeyInfo {
1279    struct {
1280       /**Open handle to the key to query*/
1281       POLICY_HND *key;
1282    } in;
1283
1284    struct {
1285       /**name of the key class*/
1286       char *class_name;
1287
1288       /**number of subkeys of the key*/
1289       uint32 num_subkeys;
1290
1291       /**length (in characters) of the longest subkey name*/
1292       uint32 longest_subkey;
1293
1294       /**length (in characters) of the longest class name*/
1295       uint32 longest_class;
1296
1297       /**number of values in this key*/
1298       uint32 num_values;
1299
1300       /**length (in characters) of the longest value name*/
1301       uint32 longest_value_name;
1302
1303       /**length (in bytes) of the biggest value data*/
1304       uint32 longest_value_data;
1305
1306       /**size (in bytes) of the security descriptor*/
1307       uint32 security_desc_size;
1308
1309       /**time of the last write*/
1310       time_t last_write_time;
1311    } out;
1312 };
1313
1314 /**
1315  * Retrieves information about an open key
1316  * @param hnd Initialized and connected server handle
1317  * @param mem_ctx Context for memory allocation
1318  * @param op Initialized parameters
1319  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1320  * @return CAC_SUCCESS The operation completed successfully
1321  */
1322
1323 int cac_RegQueryKeyInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegQueryKeyInfo *op);
1324
1325 struct RegSaveKey {
1326    struct {
1327       /**Open key to be saved*/
1328       POLICY_HND *key;
1329
1330       /**The path (on the remote computer) to save the file to*/
1331       char *filename;
1332    } in;
1333 };
1334
1335 /**
1336  * Saves a key to a file on the remote machine __Not currently working__.
1337  * @param hnd Initialized and connected server handle
1338  * @param mem_ctx Context for memory allocation
1339  * @param op Initialized parameters
1340  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1341  * @return CAC_SUCCESS The operation completed successfully
1342  */
1343
1344 int cac_RegSaveKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSaveKey *op);
1345
1346 struct RegQueryValue {
1347    struct {
1348       /**handle to open registry key*/
1349       POLICY_HND *key;
1350
1351       /**name of the value to query*/
1352       char *val_name;
1353    } in;
1354
1355    struct {
1356       /**Value type.
1357        * One of:
1358        *  - REG_DWORD (equivalent to REG_DWORD_LE)
1359        *  - REG_DWORD_BE
1360        *  - REG_SZ
1361        *  - REG_EXPAND_SZ
1362        *  - REG_MULTI_SZ
1363        *  - REG_BINARY
1364        */
1365       uint32 type;
1366
1367       /**The value*/
1368       REG_VALUE_DATA *data;
1369    } out;
1370 };
1371
1372 /**
1373  * Retrieves a value (type and data) _not currently working_.
1374  * @param hnd Initialized and connected server handle
1375  * @param mem_ctx Context for memory allocation
1376  * @param op Initialized parameters
1377  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1378  * @return CAC_SUCCESS The operation completed successfully
1379  */
1380
1381 int cac_RegQueryValue(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegQueryValue *op);
1382
1383 struct RegEnumValues {
1384    struct {
1385       /**handle to open key*/
1386       POLICY_HND *key;
1387
1388       /**max number of values returned per call*/
1389       uint32 max_values;
1390
1391    } in;
1392
1393    struct {
1394       /**keeps track of the index to resume from - used over multiple calls*/
1395       uint32 resume_idx;
1396
1397       /**the number of values that were returned this call*/
1398       uint32 num_values;
1399
1400       /**Array of value types. A type can be one of:
1401        *  - REG_DWORD (equivalent to REG_DWORD_LE)
1402        *  - REG_DWORD_BE
1403        *  - REG_SZ
1404        *  - REG_EXPAND_SZ
1405        *  - REG_MULTI_SZ
1406        *  - REG_BINARY
1407        */
1408       uint32 *types;
1409
1410       /**array of strings storing the names of the values*/
1411       char **value_names;
1412
1413       /**array of pointers to the value data returned*/
1414       REG_VALUE_DATA **values;
1415    } out;
1416 };
1417
1418 /**
1419  * Enumerates a number of Registry values in an open registry key.
1420  * Can be run in a loop. Example: while(cac_RegEnumValues(hnd, mem_ctx, op)) { ... }
1421  * @param hnd Initialized and connected server handle
1422  * @param mem_ctx Context for memory allocation
1423  * @param op Initialized Parameters
1424  * @see CAC_OP_FAILED()
1425  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1426  * @return CAC_SUCCESS The operation completed successfully
1427  */
1428 int cac_RegEnumValues(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegEnumValues *op);
1429
1430 struct RegSetValue {
1431    struct {
1432       /**Handle to open registry key*/
1433       POLICY_HND *key;
1434
1435       /**Name of the value*/
1436       char *val_name;
1437
1438       /**Value type.
1439        * One of:
1440        *  - REG_DWORD (equivalent to REG_DWORD_LE)
1441        *  - REG_DWORD_BE
1442        *  - REG_SZ
1443        *  - REG_EXPAND_SZ
1444        *  - REG_MULTI_SZ
1445        *  - REG_BINARY
1446        */
1447       uint32 type;
1448
1449       /**the value*/
1450       REG_VALUE_DATA value;
1451    } in;
1452 };
1453
1454 /**
1455  * Sets or creates value (type and data).
1456  * @param hnd Initialized and connected server handle
1457  * @param mem_ctx Context for memory allocation
1458  * @param op Initialized parameters
1459  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1460  * @return CAC_SUCCESS The operation completed successfully
1461  */
1462 int cac_RegSetValue(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSetValue *op);
1463
1464 struct RegGetVersion {
1465    struct {
1466       /**open registry key*/
1467       POLICY_HND *key;
1468    } in;
1469
1470    struct {
1471       /**version number*/
1472       uint32 version;
1473    } out;
1474 };
1475
1476 /**
1477  * Retrieves the registry version number
1478  * @param hnd Initialized and connected server handle
1479  * @param mem_ctx Context for memory allocation
1480  * @param op Initialized parameters
1481  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1482  * @return CAC_SUCCESS The operation completed successfully
1483  */
1484 int cac_RegGetVersion(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegGetVersion *op);
1485
1486 struct RegGetKeySecurity {
1487    struct {
1488       /**Handle to key to query*/
1489       POLICY_HND *key;
1490
1491       /**Info that you want. Should be a combination of (1 or more or'd):
1492        * - OWNER_SECURITY_INFORMATION
1493        * - GROUP_SECURITY_INFORMATION
1494        * - DACL_SECURITY_INFORMATION
1495        * - SACL_SECURITY_INFORMATION
1496        * - UNPROTECTED_SACL_SECURITY_INFORMATION
1497        * - UNPROTECTED_DACL_SECURITY_INFORMATION
1498        * - PROTECTED_SACL_SECURITY_INFORMATION
1499        * - PROTECTED_DACL_SECURITY_INFORMATION
1500        *
1501        * or use:
1502        * - ALL_SECURITY_INFORMATION
1503        *
1504        * all definitions from include/rpc_secdes.h
1505        */
1506       uint32 info_type;
1507    } in;
1508
1509    struct {
1510       /**size of the data returned*/
1511       uint32 size;
1512
1513       /**Security descriptor*/
1514       SEC_DESC *descriptor;
1515    } out;
1516 };
1517
1518 /**
1519  * Retrieves a key security descriptor.
1520  * @param hnd Initialized and connected server handle
1521  * @param mem_ctx Context for memory allocation
1522  * @param op Initialized parameters
1523  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1524  * @return CAC_SUCCESS The operation completed successfully
1525  */
1526
1527 int cac_RegGetKeySecurity(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegGetKeySecurity *op);
1528
1529 struct RegSetKeySecurity {
1530    struct {
1531       /**Handle to key to query*/
1532       POLICY_HND *key;
1533
1534       /**Info that you want. Should be a combination of (1 or more or'd):
1535        * - OWNER_SECURITY_INFORMATION
1536        * - GROUP_SECURITY_INFORMATION
1537        * - DACL_SECURITY_INFORMATION
1538        * - SACL_SECURITY_INFORMATION
1539        * - UNPROTECTED_SACL_SECURITY_INFORMATION
1540        * - UNPROTECTED_DACL_SECURITY_INFORMATION
1541        * - PROTECTED_SACL_SECURITY_INFORMATION
1542        * - PROTECTED_DACL_SECURITY_INFORMATION
1543        *
1544        * or use:
1545        * - ALL_SECURITY_INFORMATION
1546        *
1547        * all definitions from include/rpc_secdes.h
1548        */
1549       uint32 info_type;
1550
1551       /**size of the descriptor*/
1552       size_t size;
1553
1554       /**Security descriptor*/
1555       SEC_DESC *descriptor;
1556    } in;
1557 };
1558
1559 /**
1560  * Sets the key security descriptor.
1561  * @param hnd Initialized and connected server handle
1562  * @param mem_ctx Context for memory allocation
1563  * @param op Initialized parameters
1564  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1565  * @return CAC_SUCCESS The operation completed successfully
1566  */
1567 int cac_RegSetKeySecurity(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSetKeySecurity *op);
1568
1569 /**@}*/ /*Reg_Functions*/
1570
1571 struct Shutdown {
1572    struct {
1573       /**the message to display (can be NULL)*/
1574       char *message;
1575
1576       /**timeout in seconds*/
1577       uint32 timeout;
1578
1579       /**False = shutdown, True = reboot*/
1580       BOOL reboot;
1581
1582       /**force the*/
1583       BOOL force;
1584
1585       /*FIXME: make this useful*/
1586       uint32 reason;
1587    } in;
1588 };
1589
1590
1591 /**
1592  * Shutdown the server _not currently working_.
1593  * @param hnd Initialized and connected server handle
1594  * @param mem_ctx Context for memory allocation
1595  * @param op Initialized parameters
1596  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1597  * @return CAC_SUCCESS The operation completed successfully
1598  */
1599 int cac_Shutdown(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct Shutdown *op);
1600
1601 /**
1602  * Attempt to abort initiated shutdown on the server _not currently working_.
1603  * @param hnd Initialized and connected server handle
1604  * @param mem_ctx Context for memory allocation
1605  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1606  * @return CAC_SUCCESS The operation completed successfully
1607  */
1608 int cac_AbortShutdown(CacServerHandle *hnd, TALLOC_CTX *mem_ctx);
1609
1610 /*****************
1611  * SAM Functions *
1612  *****************/
1613
1614 /**@addtogroup SAM_Functions
1615  * @{
1616  */
1617 struct SamConnect {
1618    struct {
1619       /**Access mask to open with
1620        * see generic access masks in include/smb.h*/
1621       uint32 access;
1622    } in;
1623
1624    struct {
1625       POLICY_HND *sam;
1626    } out;
1627 };
1628
1629 /**
1630  * Connects to the SAM. This can be skipped by just calling cac_SamOpenDomain()
1631  * @param hnd Initialized and connected server handle
1632  * @param mem_ctx Context for memory allocation
1633  * @param op Initialized parameters
1634  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1635  * @return CAC_SUCCESS The operation completed successfully
1636  */
1637
1638 int cac_SamConnect(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamConnect *op);
1639
1640
1641 /**
1642  * Closes any (SAM, domain, user, group, etc.) SAM handle.
1643  * @param hnd Initialized and connected server handle
1644  * @param mem_ctx Context for memory allocation
1645  * @param sam Handle to close
1646  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1647  * @return CAC_SUCCESS The operation completed successfully
1648  */
1649
1650 int cac_SamClose(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *sam);
1651
1652 struct SamOpenDomain {
1653    struct {
1654       /**The desired access. See generic access masks - include/smb.h*/
1655       uint32 access;
1656
1657       /**(Optional) An open handle to the SAM. If it is NULL, the function will connect to the SAM with the access mask above*/
1658       POLICY_HND *sam;
1659
1660       /**(Optional) The SID of the domain to open.
1661        *  If this this is NULL, the function will attempt to open the domain specified in hnd->domain */
1662       DOM_SID *sid;
1663    } in;
1664
1665    struct {
1666       /**handle to the open domain*/
1667       POLICY_HND *dom_hnd;
1668
1669       /**Handle to the open SAM*/
1670       POLICY_HND *sam;
1671    } out;
1672 };
1673
1674 /**
1675  * Opens a handle to a domain. This must be called before any other SAM functions
1676  * @param hnd Initialized and connected server handle
1677  * @param mem_ctx Context for memory allocation
1678  * @param op Initialized parameters
1679  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1680  * @return CAC_SUCCESS The operation completed successfully
1681  */
1682 int cac_SamOpenDomain(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenDomain *op);
1683
1684 struct SamCreateUser {
1685    struct {
1686       /**Open domain handle*/
1687       POLICY_HND *dom_hnd;
1688
1689       /**Username*/
1690       char *name;
1691
1692       /**See Allowable account control bits in include/smb.h*/
1693       uint32 acb_mask;
1694    } in;
1695
1696    struct {
1697       /**handle to the user*/
1698       POLICY_HND *user_hnd;
1699
1700       /**rid of the user*/
1701       uint32 rid;
1702    } out;
1703 };
1704
1705 /**
1706  * Creates a new domain user, if the account already exists it will _not_ be opened and hnd->status will be NT_STATUS_USER_EXISTS
1707  * @param hnd Initialized and connected server handle
1708  * @param mem_ctx Context for memory allocation
1709  * @param op Initialized parameters
1710  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1711  * @return CAC_SUCCESS The operation completed successfully
1712  */
1713
1714 int cac_SamCreateUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamCreateUser *op);
1715
1716 struct SamOpenUser {
1717    struct {
1718       /**Handle to open SAM connection*/
1719       POLICY_HND *dom_hnd;
1720
1721       /**desired access - see generic access masks in include/smb.h*/
1722       uint32 access;
1723
1724       /**RID of the user*/
1725       uint32 rid;
1726
1727       /**(Optional) name of the user - must supply either RID or user name*/
1728       char *name;
1729    } in;
1730
1731    struct {
1732       /**Handle to the user*/
1733       POLICY_HND *user_hnd;
1734    } out;
1735 };
1736
1737 /**
1738  * Opens a domain user.
1739  * @param hnd Initialized and connected server handle
1740  * @param mem_ctx Context for memory allocation
1741  * @param op Initialized parameters
1742  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1743  * @return CAC_SUCCESS The operation completed successfully
1744  */
1745 int cac_SamOpenUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenUser *op);
1746
1747 /**
1748  * Deletes a domain user.
1749  * @param hnd Initialized and connected server handle
1750  * @param mem_ctx Context for memory allocation
1751  * @param user_hnd Open handle to the user
1752  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1753  * @return CAC_SUCCESS The operation completed successfully
1754  */
1755 int cac_SamDeleteUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *user_hnd);
1756
1757
1758 struct SamEnumUsers {
1759    struct {
1760       /**Open handle to a domain*/
1761       POLICY_HND *dom_hnd;
1762
1763       /**Enumerate users with specific ACB. If 0, all users will be enumerated*/
1764       uint32 acb_mask;
1765    } in;
1766
1767    struct {
1768       /**where to resume from. Used over multiple calls*/
1769       uint32 resume_idx;
1770
1771       /**the number of users returned this call*/
1772       uint32 num_users;
1773
1774       /**Array storing the rids of the returned users*/
1775       uint32 *rids;
1776
1777       /**Array storing the names of all the users returned*/
1778       char **names;
1779
1780       BOOL done;
1781    } out;
1782 };
1783
1784 /**
1785  * Enumerates domain users. Can be used as a loop condition. Example: while(cac_SamEnumUsers(hnd, mem_ctx, op)) { ... }
1786  * @param hnd Initialized and connected server handle
1787  * @param mem_ctx Context for memory allocation
1788  * @param op Initialized parameters
1789  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1790  * @return CAC_SUCCESS The operation completed successfully
1791  */
1792 int cac_SamEnumUsers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamEnumUsers *op);
1793
1794 struct SamGetNamesFromRids {
1795    struct {
1796       /**An open handle to the domain SAM from cac_SamOpenDomain()*/
1797       POLICY_HND *dom_hnd;
1798
1799       /**Number of RIDs to resolve*/
1800       uint32 num_rids;
1801
1802       /**Array of RIDs to resolve*/
1803       uint32 *rids;
1804    } in;
1805
1806    struct {
1807       /**the number of names returned - if this is 0, the map is NULL*/
1808       uint32 num_names;
1809
1810       /**array contiaing the Names and RIDs*/
1811       CacLookupRidsRecord *map;
1812    } out;
1813 };
1814
1815 /**
1816  * Returns a list of names which map to a list of RIDs.
1817  * @param hnd Initialized and connected server handle
1818  * @param mem_ctx Context for memory allocation
1819  * @param op Initialized parameters
1820  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1821  * @return CAC_SUCCESS The operation completed successfully
1822  */
1823 int cac_SamGetNamesFromRids(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetNamesFromRids *op);
1824
1825 struct SamGetRidsFromNames {
1826    struct {
1827       /**An open handle to the domain SAM from cac_SamOpenDomain()*/
1828       POLICY_HND *dom_hnd;
1829
1830       /**Number of names to resolve*/
1831       uint32 num_names;
1832
1833       /**Array of names to resolve*/
1834       char **names;
1835    } in;
1836
1837    struct {
1838       /**the number of names returned - if this is 0, then map is NULL*/
1839       uint32 num_rids;
1840
1841       /**array contiaing the Names and RIDs*/
1842       CacLookupRidsRecord *map;
1843    } out;
1844 };
1845
1846 /**
1847  * Returns a list of RIDs which map to a list of names.
1848  * @param hnd Initialized and connected server handle
1849  * @param mem_ctx Context for memory allocation
1850  * @param op Initialized parameters
1851  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1852  * @return CAC_SUCCESS The operation completed successfully
1853  */
1854 int cac_SamGetRidsFromNames(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetRidsFromNames *op);
1855
1856 struct SamGetGroupsForUser {
1857    struct {
1858       /**An open handle to the user*/
1859       POLICY_HND *user_hnd;
1860    } in;
1861
1862    struct {
1863       /**The number of groups the user is a member of*/
1864       uint32 num_groups;
1865
1866       /**The RIDs of the groups*/
1867       uint32 *rids;
1868
1869       /**The attributes of the groups*/
1870       uint32 *attributes;
1871    } out;
1872 };
1873 /**
1874  * Retrieves a list of groups that a user is a member of.
1875  * @param hnd Initialized and connected server handle
1876  * @param mem_ctx Context for memory allocation
1877  * @param op Initialized parameters
1878  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1879  * @return CAC_SUCCESS The operation completed successfully
1880  */
1881 int cac_SamGetGroupsForUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetGroupsForUser *op);
1882
1883 struct SamOpenGroup {
1884    struct {
1885       /**Open handle to the domain SAM*/
1886       POLICY_HND *dom_hnd;
1887
1888       /**Desired access to open the group with. See Generic access masks in include/smb.h*/
1889       uint32 access;
1890
1891       /**rid of the group*/
1892       uint32 rid;
1893    } in;
1894
1895    struct {
1896       /**Handle to the group*/
1897       POLICY_HND *group_hnd;
1898    } out;
1899 };
1900
1901 /**
1902  * Opens a domain group.
1903  * @param hnd Initialized and connected server handle
1904  * @param mem_ctx Context for memory allocation
1905  * @param op Initialized parameters
1906  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1907  * @return CAC_SUCCESS The operation completed successfully
1908  */
1909 int cac_SamOpenGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenGroup *op);
1910
1911 struct SamCreateGroup {
1912    struct {
1913       /**Open handle to the domain SAM*/
1914       POLICY_HND *dom_hnd;
1915
1916       /**Desired access to open the group with. See Generic access masks in include/smb.h*/
1917       uint32 access;
1918
1919       /**The name of the group*/
1920       char *name;
1921    } in;
1922
1923    struct {
1924       /**Handle to the group*/
1925       POLICY_HND *group_hnd;
1926    } out;
1927 };
1928
1929 /**
1930  * Creates a group. If the group already exists it will not be opened.
1931  * @param hnd Initialized and connected server handle
1932  * @param mem_ctx Context for memory allocation
1933  * @param op Initialized parameters
1934  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1935  * @return CAC_SUCCESS The operation completed successfully
1936  */
1937 int cac_SamCreateGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamCreateGroup *op);
1938
1939 /**
1940  * Deletes a domain group.
1941  * @param hnd Initialized and connected server handle
1942  * @param mem_ctx Context for memory allocation
1943  * @param group_hnd Open handle to the group.
1944  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1945  * @return CAC_SUCCESS The operation completed successfully
1946  */
1947 int cac_SamDeleteGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *group_hnd);
1948
1949 struct SamGetGroupMembers {
1950    struct {
1951       /**Open handle to a group*/
1952       POLICY_HND *group_hnd;
1953    } in;
1954
1955    struct {
1956       /**The number of members in the group*/
1957       uint32 num_members;
1958
1959       /**An array storing the RIDs of the users*/
1960       uint32 *rids;
1961
1962       /**The attributes*/
1963       uint32 *attributes;
1964    } out;
1965 };
1966
1967 /**
1968  * Retrives a list of users in a group.
1969  * @param hnd Initialized and connected server handle
1970  * @param mem_ctx Context for memory allocation
1971  * @param op Initialized parameters
1972  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1973  * @return CAC_SUCCESS The operation completed successfully
1974  */
1975 int cac_SamGetGroupMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetGroupMembers *op);
1976
1977 struct SamAddGroupMember {
1978    struct {
1979       /**Open handle to a group*/
1980       POLICY_HND *group_hnd;
1981
1982       /**RID of new member*/
1983       uint32 rid;
1984    } in;
1985 };
1986
1987 /**
1988  * Adds a user to a group.
1989  * @param hnd Initialized and connected server handle
1990  * @param mem_ctx Context for memory allocation
1991  * @param op Initialized parameters
1992  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1993  * @return CAC_SUCCESS The operation completed successfully
1994  */
1995 int cac_SamAddGroupMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamAddGroupMember *op);
1996
1997 struct SamRemoveGroupMember {
1998    struct {
1999       /**Open handle to a group*/
2000       POLICY_HND *group_hnd;
2001
2002       /**RID of member to remove*/
2003       uint32 rid;
2004    } in;
2005 };
2006
2007 /**
2008  * Removes a user from a group.
2009  * @param hnd Initialized and connected server handle
2010  * @param mem_ctx Context for memory allocation
2011  * @param op Initialized parameters
2012  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2013  * @return CAC_SUCCESS The operation completed successfully
2014  */
2015 int cac_SamRemoveGroupMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRemoveGroupMember *op);
2016
2017 /**
2018  * Removes all the members of a group - warning: if this function fails is is possible that some but not all members were removed
2019  * @param hnd Initialized and connected server handle
2020  * @param mem_ctx Context for memory allocation
2021  * @param group_hnd Open handle to the group to clear
2022  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2023  * @return CAC_SUCCESS The operation completed successfully
2024  */
2025 int cac_SamClearGroupMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *group_hnd);
2026
2027 struct SamSetGroupMembers {
2028    struct {
2029       /**Open handle to the group*/
2030       POLICY_HND *group_hnd;
2031
2032       /**Number of members in the group - if this is 0, all members of the group will be removed*/
2033       uint32 num_members;
2034
2035       /**The RIDs of the users to add*/
2036       uint32 *rids;
2037    } in;
2038 };
2039
2040 /**
2041  * Clears the members of a group and adds a list of members to the group
2042  * @param hnd Initialized and connected server handle
2043  * @param mem_ctx Context for memory allocation
2044  * @param op Initialized parameters
2045  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2046  * @return CAC_SUCCESS The operation completed successfully
2047  */
2048 int cac_SamSetGroupMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetGroupMembers *op);
2049
2050 struct SamEnumGroups {
2051    struct {
2052       /**Open handle to a domain*/
2053       POLICY_HND *dom_hnd;
2054    } in;
2055
2056    struct {
2057       /**Where to resume from _do not_ modify this value. Used over multiple calls.*/
2058       uint32 resume_idx;
2059
2060       /**the number of users returned this call*/
2061       uint32 num_groups;
2062
2063       /**Array storing the rids of the returned groups*/
2064       uint32 *rids;
2065
2066       /**Array storing the names of all the groups returned*/
2067       char **names;
2068
2069       /**Array storing the descriptions of all the groups returned*/
2070       char **descriptions;
2071
2072       BOOL done;
2073    } out;
2074 };
2075
2076 /**
2077  * Enumerates domain groups. Can be used as a loop condition. Example: while(cac_SamEnumGroups(hnd, mem_ctx, op)) { ... }
2078  * @param hnd Initialized and connected server handle
2079  * @param mem_ctx Context for memory allocation
2080  * @param op Initialized parameters
2081  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2082  * @return CAC_SUCCESS The operation completed successfully
2083  */
2084 int cac_SamEnumGroups(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamEnumGroups *op);
2085
2086 struct SamEnumAliases {
2087    struct {
2088       /**Open handle to a domain*/
2089       POLICY_HND *dom_hnd;
2090    } in;
2091
2092    struct {
2093       /**where to resume from. Used over multiple calls*/
2094       uint32 resume_idx;
2095
2096       /**the number of users returned this call*/
2097       uint32 num_aliases;
2098
2099       /**Array storing the rids of the returned groups*/
2100       uint32 *rids;
2101
2102       /**Array storing the names of all the groups returned*/
2103       char **names;
2104
2105       /**Array storing the descriptions of all the groups returned*/
2106       char **descriptions;
2107
2108       BOOL done;
2109    } out;
2110 };
2111
2112 /**
2113  * Enumerates domain aliases. Can be used as a loop condition. Example: while(cac_SamEnumAliases(hnd, mem_ctx, op)) { ... }
2114  * @param hnd Initialized and connected server handle
2115  * @param mem_ctx Context for memory allocation
2116  * @param op Initialized parameters
2117  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2118  * @return CAC_SUCCESS The operation completed successfully
2119  */
2120 int cac_SamEnumAliases(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamEnumAliases *op);
2121
2122 struct SamCreateAlias {
2123    struct {
2124       /**Open handle to the domain SAM*/
2125       POLICY_HND *dom_hnd;
2126
2127       /**The name of the alias*/
2128       char *name;
2129    } in;
2130
2131    struct {
2132       /**Handle to the group*/
2133       POLICY_HND *alias_hnd;
2134    } out;
2135 };
2136
2137 /**
2138  * Creates an alias. If the alias already exists it will not be opened.
2139  * @param hnd Initialized and connected server handle
2140  * @param mem_ctx Context for memory allocation
2141  * @param op Initialized parameters
2142  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2143  * @return CAC_SUCCESS The operation completed successfully
2144  */
2145
2146 int cac_SamCreateAlias(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamCreateAlias *op);
2147
2148 struct SamOpenAlias {
2149    struct {
2150       /**Open handle to the domain SAM*/
2151       POLICY_HND *dom_hnd;
2152
2153       /**Desired access to open the group with. See Generic access masks in include/smb.h*/
2154       uint32 access;
2155
2156       /**rid of the alias*/
2157       uint32 rid;
2158    } in;
2159
2160    struct {
2161       /**Handle to the alias*/
2162       POLICY_HND *alias_hnd;
2163    } out;
2164 };
2165
2166 /**
2167  * Opens a handle to an alias.
2168  * @param hnd Initialized and connected server handle
2169  * @param mem_ctx Context for memory allocation
2170  * @param op Initialized parameters
2171  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2172  * @return CAC_SUCCESS The operation completed successfully
2173  */
2174 int cac_SamOpenAlias(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenAlias *op);
2175
2176 /**
2177  * Deletes an alias.
2178  * @param hnd Initialized and connected server handle
2179  * @param mem_ctx Context for memory allocation
2180  * @param alias_hnd Open handle to the alias
2181  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2182  * @return CAC_SUCCESS The operation completed successfully
2183  */
2184 int cac_SamDeleteAlias(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *alias_hnd);
2185
2186 struct SamAddAliasMember {
2187    struct {
2188       /**Open handle to a alias*/
2189       POLICY_HND *alias_hnd;
2190
2191       /**SID of new member*/
2192       DOM_SID *sid;
2193    } in;
2194 };
2195
2196 /**
2197  * Adds an account to an alias.
2198  * @param hnd Initialized and connected server handle
2199  * @param mem_ctx Context for memory allocation
2200  * @param op Initialized parameters
2201  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2202  * @return CAC_SUCCESS The operation completed successfully
2203  */
2204 int cac_SamAddAliasMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamAddAliasMember *op);
2205
2206 struct SamRemoveAliasMember {
2207    struct {
2208       /**Open handle to the alias*/
2209       POLICY_HND *alias_hnd;
2210
2211       /**The SID of the member*/
2212       DOM_SID *sid;
2213    } in;
2214 };
2215
2216 /**
2217  * Removes an account from an alias.
2218  * @param hnd Initialized and connected server handle
2219  * @param mem_ctx Context for memory allocation
2220  * @param op Initialized parameters
2221  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2222  * @return CAC_SUCCESS The operation completed successfully
2223  */
2224 int cac_SamRemoveAliasMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRemoveAliasMember *op);
2225
2226 struct SamGetAliasMembers {
2227    struct {
2228       /**Open handle to the alias*/
2229       POLICY_HND *alias_hnd;
2230    } in;
2231
2232    struct {
2233       /**The number of members*/
2234       uint32 num_members;
2235
2236       /**An array storing the SIDs of the accounts*/
2237       DOM_SID *sids;
2238    } out;
2239 };
2240
2241 /**
2242  * Retrieves a list of all accounts in an alias.
2243  * @param hnd Initialized and connected server handle
2244  * @param mem_ctx Context for memory allocation
2245  * @param op Initialized parameters
2246  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2247  * @return CAC_SUCCESS The operation completed successfully
2248  */
2249 int cac_SamGetAliasMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetAliasMembers *op);
2250
2251 /**
2252  * Removes all the members of an alias  - warning: if this function fails is is possible that some but not all members were removed
2253  * @param hnd Initialized and connected server handle
2254  * @param mem_ctx Context for memory allocation
2255  * @param alias_hnd Handle to the alias to clear
2256  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2257  * @return CAC_SUCCESS The operation completed successfully
2258  */
2259
2260 int cac_SamClearAliasMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *alias_hnd);
2261
2262 struct SamSetAliasMembers {
2263    struct {
2264       /**Open handle to the group*/
2265       POLICY_HND *alias_hnd;
2266
2267       /**Number of members in the group - if this is 0, all members of the group will be removed*/
2268       uint32 num_members;
2269
2270       /**The SIDs of the accounts to add*/
2271       DOM_SID *sids;
2272    } in;
2273 };
2274
2275 /**
2276  * Clears the members of an alias and adds a list of members to the alias
2277  * @param hnd Initialized and connected server handle
2278  * @param mem_ctx Context for memory allocation
2279  * @param op Initialized parameters
2280  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2281  * @return CAC_SUCCESS The operation completed successfully
2282  */
2283 int cac_SamSetAliasMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetAliasMembers *op);
2284
2285
2286 struct SamUserChangePasswd {
2287    struct {
2288       /**The username*/
2289       char *username;
2290
2291       /**The current password*/
2292       char *password;
2293
2294       /**The new password*/
2295       char *new_password;
2296    } in;
2297 };
2298 /**Used by a user to change their password*/
2299 int cac_SamUserChangePasswd(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamUserChangePasswd *op);
2300
2301 /**
2302  * Enables a user
2303  * @param hnd Initialized and connected server handle
2304  * @param mem_ctx Context for memory allocation
2305  * @param user_hnd Open handle to the user to enable
2306  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2307  * @return CAC_SUCCESS The operation completed successfully
2308  */
2309 int cac_SamEnableUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *user_hnd);
2310
2311 /**
2312  * Disables a user
2313  * @param hnd Initialized and connected server handle
2314  * @param mem_ctx Context for memory allocation
2315  * @param user_hnd Open handle to the user to disables
2316  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2317  * @return CAC_SUCCESS The operation completed successfully
2318  */
2319 int cac_SamDisableUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *user_hnd);
2320
2321 struct SamSetPassword {
2322    struct {
2323       /**Open handle to a user*/
2324       POLICY_HND *user_hnd;
2325
2326       /**The new password*/
2327       char *password;
2328    } in;
2329 };
2330
2331 /**
2332  * Sets a user's password
2333  * @param hnd Initialized and connected server handle
2334  * @param mem_ctx Context for memory allocation
2335  * @param op Initialized parameters
2336  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2337  * @return CAC_SUCCESS The operation completed successfully
2338  */
2339
2340 int cac_SamSetPassword(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetPassword *op);
2341
2342 struct SamGetUserInfo {
2343    struct {
2344       /**Open Handle to a user*/
2345       POLICY_HND *user_hnd;
2346    } in;
2347
2348    struct {
2349       CacUserInfo *info;
2350    } out;
2351 };
2352
2353 /**
2354  * Retrieves user information using a CacUserInfo structure. If you would like to use a SAM_USERINFO_CTR directly, use cac_SamGetUserInfoCtr()
2355  * @param hnd Initialized and connected server handle
2356  * @param mem_ctx Context for memory allocation
2357  * @param op Initialized parameters
2358  * @see cac_SamGetUserInfoCtr()
2359  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2360  * @return CAC_SUCCESS The operation completed successfully
2361  */
2362 int cac_SamGetUserInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetUserInfo *op);
2363
2364 struct SamSetUserInfo {
2365    struct {
2366       /**Open handle to a user*/
2367       POLICY_HND *user_hnd;
2368
2369       /**Structure containing the data you would like to set*/
2370       CacUserInfo *info;
2371    } in;
2372 };
2373
2374 /**
2375  * Sets the user info using a CacUserInfo structure. If you would like to use a SAM_USERINFO_CTR directly use cac_SamSetUserInfoCtr().
2376  * @note All fields in the CacUserInfo structure will be set. Best to call cac_GetUserInfo() modify fields that you want, and then call cac_SetUserInfo().
2377  * @note When calling this, you _must_ set the user's password.
2378  * @param hnd Initialized and connected server handle
2379  * @param mem_ctx Context for memory allocation
2380  * @param op Initialized parameters
2381  * @see cac_SamSetUserInfoCtr()
2382  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2383  * @return CAC_SUCCESS The operation completed successfully
2384  */
2385 int cac_SamSetUserInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetUserInfo *op);
2386
2387 struct SamGetUserInfoCtr {
2388    struct {
2389       /**Open handle to a user*/
2390       POLICY_HND *user_hnd;
2391
2392       /**What USER_INFO structure you want. See include/rpc_samr.h*/
2393       uint16 info_class;
2394    } in;
2395
2396    struct {
2397       /**returned user info*/
2398       SAM_USERINFO_CTR *ctr;
2399    } out;
2400 };
2401
2402 /**
2403  * Retrieves user information using a SAM_USERINFO_CTR structure. If you don't want to use this structure, user SamGetUserInfo()
2404  * @param hnd Initialized and connected server handle
2405  * @param mem_ctx Context for memory allocation
2406  * @param op Initialized parameters
2407  * @see cac_SamGetUserInfo()
2408  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2409  * @return CAC_SUCCESS The operation completed successfully
2410  */
2411 int cac_SamGetUserInfoCtr(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetUserInfoCtr *op);
2412
2413 struct SamSetUserInfoCtr {
2414    struct {
2415       /**Open handle to a user*/
2416       POLICY_HND *user_hnd;
2417
2418       /**user info - make sure ctr->switch_value is set properly*/
2419       SAM_USERINFO_CTR *ctr;
2420    } in;
2421 };
2422
2423 /**
2424  * Sets the user info using a SAM_USERINFO_CTR structure. If you don't want to use this structure, use cac_SamSetUserInfo()
2425  * @param hnd Initialized and connected server handle
2426  * @param mem_ctx Context for memory allocation
2427  * @param op Initialized parameters
2428  * @see cac_SamSetUserInfo()
2429  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2430  * @return CAC_SUCCESS The operation completed successfully
2431  */
2432
2433 int cac_SamSetUserInfoCtr(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetUserInfoCtr *op);
2434
2435 struct SamRenameUser {
2436    struct {
2437       /**Open handle to user*/
2438       POLICY_HND *user_hnd;
2439
2440       /**New user name*/
2441       char *new_name;
2442    } in;
2443 };
2444
2445 /**
2446  * Changes the name of a user.
2447  * @param hnd Initialized and connected server handle
2448  * @param mem_ctx Context for memory allocation
2449  * @param op Initialized parameters
2450  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2451  * @return CAC_SUCCESS The operation completed successfully
2452  */
2453 int cac_SamRenameUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRenameUser *op);
2454
2455 struct SamGetGroupInfo {
2456    struct {
2457       /**Open handle to a group*/
2458       POLICY_HND *group_hnd;
2459    } in;
2460
2461    struct {
2462       /**Returned info about the group*/
2463       CacGroupInfo *info;
2464    } out;
2465 };
2466
2467 /**
2468  * Retrieves information about a group.
2469  * @param hnd Initialized and connected server handle
2470  * @param mem_ctx Context for memory allocation
2471  * @param op Initialized parameters
2472  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2473  * @return CAC_SUCCESS The operation completed successfully
2474  */
2475 int cac_SamGetGroupInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetGroupInfo *op);
2476
2477 struct SamSetGroupInfo {
2478    struct {
2479       /**Open handle to a group*/
2480       POLICY_HND *group_hnd;
2481
2482       /**group info*/
2483       CacGroupInfo *info;
2484    } in;
2485 };
2486
2487 /**
2488  * Sets information about a group.
2489  * @param hnd Initialized and connected server handle
2490  * @param mem_ctx Context for memory allocation
2491  * @param op Initialized parameters
2492  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2493  * @return CAC_SUCCESS The operation completed successfully
2494  */
2495 int cac_SamSetGroupInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetGroupInfo *op);
2496
2497 struct SamRenameGroup {
2498    struct {
2499       /**Open handle to a group*/
2500       POLICY_HND *group_hnd;
2501
2502       /**New name*/
2503       char *new_name;
2504    } in;
2505 };
2506
2507 /**
2508  * Changes the name of a group
2509  * @param hnd Initialized and connected server handle
2510  * @param mem_ctx Context for memory allocation
2511  * @param op Initialized parameters
2512  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2513  * @return CAC_SUCCESS The operation completed successfully
2514  */
2515
2516 int cac_SamRenameGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRenameGroup *op);
2517
2518 struct SamGetAliasInfo {
2519    struct {
2520       /**Open handle to an alias*/
2521       POLICY_HND *alias_hnd;
2522    } in;
2523
2524    struct {
2525       /**Returned alias info*/
2526       CacAliasInfo *info;
2527    } out;
2528 };
2529
2530 /**
2531  * Retrieves information about an alias.
2532  * @param hnd Initialized and connected server handle
2533  * @param mem_ctx Context for memory allocation
2534  * @param op Initialized parameters
2535  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2536  * @return CAC_SUCCESS The operation completed successfully
2537  */
2538 int cac_SamGetAliasInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetAliasInfo *op);
2539
2540 struct SamSetAliasInfo {
2541    struct {
2542       /**Open handle to an alias*/
2543       POLICY_HND *alias_hnd;
2544
2545       /**Returned alias info*/
2546       CacAliasInfo *info;
2547    } in;
2548 };
2549
2550 /**
2551  * Sets information about an alias.
2552  * @param hnd Initialized and connected server handle
2553  * @param mem_ctx Context for memory allocation
2554  * @param op Initialized parameters
2555  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2556  * @return CAC_SUCCESS The operation completed successfully
2557  */
2558 int cac_SamSetAliasInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetAliasInfo *op);
2559
2560 struct SamGetDomainInfo {
2561    struct {
2562       /**Open handle to the domain SAM*/
2563       POLICY_HND *dom_hnd;
2564    } in;
2565
2566    struct {
2567       /**Returned domain info*/
2568       CacDomainInfo *info;
2569    } out;
2570 };
2571
2572 /**
2573  * Gets domain information in the form of a CacDomainInfo structure.
2574  * @param hnd Initialized and connected server handle
2575  * @param mem_ctx Context for memory allocation
2576  * @param op Initialized parameters
2577  * @see SamGetDomainInfoCtr()
2578  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2579  * @return CAC_SUCCESS - the operation was successful
2580  * @return CAC_PARTIAL_SUCCESS - This function makes 3 rpc calls, if one or two fail and the rest succeed,
2581  *                                  not all fields in the CacDomainInfo structure will be filled
2582  */
2583 int cac_SamGetDomainInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetDomainInfo *op);
2584
2585 struct SamGetDomainInfoCtr {
2586    struct {
2587       /**Open handle to domain*/
2588       POLICY_HND *dom_hnd;
2589
2590       /**What info level you want*/
2591       uint16 info_class;
2592    } in;
2593
2594    struct {
2595       SAM_UNK_CTR *info;
2596    } out;
2597 };
2598
2599 /**
2600  * Gets domain information in the form of a SAM_UNK_CTR structure.
2601  * @param hnd Initialized and connected server handle
2602  * @param mem_ctx Context for memory allocation
2603  * @param op Initialized parameters
2604  * @see SamGetDomainInfo()
2605  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2606  * @return CAC_SUCCESS - the operation was successful
2607  */
2608 int cac_SamGetDomainInfoCtr(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetDomainInfoCtr *op);
2609
2610 struct SamGetDisplayInfo {
2611    struct {
2612       /**Open handle to domain*/
2613       POLICY_HND *dom_hnd;
2614
2615       /**What type of data*/
2616       uint16 info_class;
2617
2618       /**(Optional)If 0, max_entries and max_size will be filled in by the function*/
2619       uint32 max_entries;
2620
2621       /**(Optional)If 0, max_entries and max_size will be filled in by the function*/
2622       uint32 max_size;
2623    } in;
2624
2625    struct {
2626       /**Do not modify this value, use the same value between multiple calls (ie in while loop)*/
2627       uint32 resume_idx;
2628
2629       /**Number of entries returned*/
2630       uint32 num_entries;
2631
2632       /**Returned display info*/
2633       SAM_DISPINFO_CTR ctr;
2634
2635       /**Internal value. Do not modify.*/
2636       uint32 loop_count;
2637
2638       BOOL done;
2639    } out;
2640 };
2641
2642 /**
2643  * Gets dislpay information using a SAM_DISPINFO_CTR.
2644  * @param hnd Initialized and connected server handle
2645  * @param mem_ctx Context for memory allocation
2646  * @param op Initialized parameters
2647  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2648  * @return CAC_SUCCESS - the operation was successful
2649  */
2650 int cac_SamGetDisplayInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetDisplayInfo *op);
2651
2652 struct SamLookupDomain {
2653    struct {
2654       /**Open handle to the sam (opened with cac_SamConnect() or cac_SamOpenDomain()*/
2655       POLICY_HND *sam;
2656
2657       /**Name of the domain to lookup*/
2658       char *name;
2659    } in;
2660
2661    struct {
2662       /**SID of the domain*/
2663       DOM_SID *sid;
2664    } out;
2665 };
2666
2667 /**
2668  * Looks up a Domain SID given it's name.
2669  * @param hnd Initialized and connected server handle
2670  * @param mem_ctx Context for memory allocation
2671  * @param op Initialized parameters
2672  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2673  * @return CAC_SUCCESS - the operation was successful
2674  */
2675 int cac_SamLookupDomain(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamLookupDomain *op);
2676
2677 struct SamGetSecurityObject {
2678    struct {
2679       /**An open handle (SAM, domain or user)*/
2680       POLICY_HND *pol;
2681    } in;
2682
2683    struct {
2684       SEC_DESC_BUF *sec;
2685    } out;
2686 };
2687
2688 /**
2689  * Retrievies Security descriptor information for a SAM/Domain/user
2690  * @param hnd Initialized and connected server handle
2691  * @param mem_ctx Context for memory allocation
2692  * @param op Initialized parameters
2693  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2694  * @return CAC_SUCCESS - the operation was successful
2695  */
2696 int cac_SamGetSecurityObject(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetSecurityObject *op);
2697
2698 struct SamFlush {
2699    struct {
2700       /**Open handle to the domain SAM*/
2701       POLICY_HND *dom_hnd;
2702
2703       /**(Optional)Domain SID. If NULL, the domain in hnd->domain will be opened*/
2704       DOM_SID *sid;
2705
2706       /**(Optional)Desired access to re-open the domain with. If 0, MAXIMUM_ALLOWED_ACCESS is used.*/
2707       uint32 access;
2708    } in;
2709 };
2710
2711 /**
2712  * Closes the domain handle, then re-opens it - effectively flushing any changes made.
2713  * WARNING: if this fails you will no longer have an open handle to the domain SAM.
2714  * @param hnd Initialized and connected server handle
2715  * @param mem_ctx Context for memory allocation
2716  * @param op Initialized Parameters
2717  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2718  * @return CAC_SUCCESS - the operation was successful
2719  */
2720 int cac_SamFlush(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamFlush *op);
2721
2722 /**@}*/ /*SAM_Functions*/
2723
2724 /**@addtogroup SCM_Functions
2725  * @{
2726  */
2727
2728 struct SvcOpenScm {
2729    struct {
2730       /**Desired access to open the Handle with. See SC_RIGHT_MGR_* or SC_MANAGER_* in include/rpc_secdes.h*/
2731       uint32 access;
2732    } in;
2733
2734    struct {
2735       /**Handle to the SCM*/
2736       POLICY_HND *scm_hnd;
2737    } out;
2738 };
2739
2740 /**
2741  * Opens a handle to the SCM on the remote machine.
2742  * @param hnd Initialized and connected server handle
2743  * @param mem_ctx Context for memory allocation
2744  * @param op Initialized parameters
2745  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2746  * @return CAC_SUCCESS - the operation was successful
2747  */
2748 int cac_SvcOpenScm(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcOpenScm *op);
2749
2750 /**
2751  * Closes an Svc handle (SCM or Service)
2752  * @param hnd Initialized and connected server handle
2753  * @param mem_ctx Context for memory allocation
2754  * @param scm_hnd The handle to close
2755  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2756  * @return CAC_SUCCESS - the operation was successful
2757  */
2758 int cac_SvcClose(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *scm_hnd);
2759
2760 struct SvcEnumServices {
2761    struct {
2762       /**Open handle to the SCM*/
2763       POLICY_HND *scm_hnd;
2764
2765       /**(Optional)Type of service to enumerate. Possible values:
2766        *  - SVCCTL_TYPE_WIN32
2767        *  - SVCCTL_TYPE_DRIVER
2768        *  If this is 0, (SVCCTL_TYPE_DRIVER | SVCCTL_TYPE_WIN32) is assumed.
2769        */
2770       uint32 type;
2771
2772       /**(Optional)State of service to enumerate. Possible values:
2773        *  - SVCCTL_STATE_ACTIVE
2774        *  - SVCCTL_STATE_INACTIVE
2775        *  - SVCCTL_STATE_ALL
2776        *  If this is 0, SVCCTL_STATE_ALL is assumed.
2777        */
2778       uint32 state;
2779    } in;
2780
2781    struct {
2782       /**Number of services returned*/
2783       uint32 num_services;
2784
2785       /**Array of service structures*/
2786       CacService *services;
2787    } out;
2788 };
2789
2790 /**
2791  * Enumerates services on the remote machine.
2792  * @param hnd Initialized and connected server handle
2793  * @param mem_ctx Context for memory allocation
2794  * @param op Initialized parameters
2795  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2796  * @return CAC_SUCCESS - the operation was successful
2797  */
2798 int cac_SvcEnumServices(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcEnumServices *op);
2799
2800 struct SvcOpenService {
2801    struct {
2802       /**Handle to the Service Control Manager*/
2803       POLICY_HND *scm_hnd;
2804
2805       /**Access mask to open service with see SERVICE_* or SC_RIGHT_SVC_* in include/rpc_secdes.h*/
2806       uint32 access;
2807
2808       /**The name of the service. _not_ the display name*/
2809       char *name;
2810    } in;
2811
2812    struct {
2813       /**Handle to the open service*/
2814       POLICY_HND *svc_hnd;
2815    } out;
2816 };
2817
2818 /**
2819  * Opens a handle to a service.
2820  * @param hnd Initialized and connected server handle
2821  * @param mem_ctx Context for memory allocation
2822  * @param op Initialized Parameters
2823  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2824  * @return CAC_SUCCESS - the operation was successful
2825  */
2826
2827 int cac_SvcOpenService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcOpenService *op);
2828
2829 struct SvcGetStatus {
2830    struct {
2831       /**Open handle to the service to query*/
2832       POLICY_HND *svc_hnd;
2833    } in;
2834
2835    struct {
2836       /**The status of the service. See include/rpc_svcctl.h for SERVICE_STATUS definition.*/
2837       SERVICE_STATUS status;
2838    } out;
2839 };
2840
2841 /**
2842  * Retrieves the status of a service.
2843  * @param hnd Initialized and connected server handle
2844  * @param mem_ctx Context for memory allocation
2845  * @param op Initialized Parameters
2846  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2847  * @return CAC_SUCCESS - the operation was successful
2848  */
2849 int cac_SvcGetStatus(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcGetStatus *op);
2850
2851 struct SvcStartService {
2852    struct {
2853       /**open handle to the service*/
2854       POLICY_HND *svc_hnd;
2855
2856       /**Array of parameters to start the service with. Can be NULL if num_parms is 0*/
2857       char **parms;
2858
2859       /**Number of parameters in the parms array*/
2860       uint32 num_parms;
2861
2862       /**Number of seconds to wait for the service to actually start. If this is 0, then the status will not be checked after the initial call*/
2863       uint32 timeout;
2864    } in;
2865 };
2866
2867 /**
2868  * Attempts to start a service.
2869  * @param hnd Initialized and connected server handle
2870  * @param mem_ctx Context for memory allocation
2871  * @param op Initialized Parameters
2872  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2873  * @return CAC_SUCCESS - the operation was successful
2874  */
2875
2876 int cac_SvcStartService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcStartService *op);
2877
2878 struct SvcControlService {
2879    struct {
2880       /**Open handle to the service to control*/
2881       POLICY_HND *svc_hnd;
2882
2883       /**The control operation to perform. Possible values (from include/rpc_svcctl.h):
2884        * - SVCCTL_CONTROL_STOP
2885        * - SVCCTL_CONTROL_PAUSE
2886        * - SVCCTL_CONTROL_CONTINUE
2887        * - SVCCTL_CONTROL_SHUTDOWN
2888        */
2889       uint32 control;
2890    } in;
2891
2892    struct {
2893       /**The returned status of the service, _immediately_ after the call*/
2894       SERVICE_STATUS *status;
2895    } out;
2896 };
2897
2898 /**
2899  * Performs a control operation on a service and _immediately_ returns.
2900  * @see cac_SvcStopService()
2901  * @see cac_SvcPauseService()
2902  * @see cac_SvcContinueService()
2903  * @see cac_SvcShutdownService()
2904  * @param hnd Initialized and connected server handle
2905  * @param mem_ctx Context for memory allocation
2906  * @param op Initialized Parameters
2907  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2908  * @return CAC_SUCCESS - the operation was successful
2909  */
2910 int cac_SvcControlService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcControlService *op);
2911
2912 struct SvcStopService {
2913    struct {
2914       /**Open handle to the service*/
2915       POLICY_HND *svc_hnd;
2916
2917       /**Number of seconds to wait for the service to actually start.
2918        * If this is 0, then the status will not be checked after the initial call and CAC_SUCCESS might be returned if the status isn't actually started
2919        */
2920       uint32 timeout;
2921    } in;
2922
2923    struct {
2924       /**Status of the service after the operation*/
2925       SERVICE_STATUS status;
2926    } out;
2927 };
2928
2929 /**
2930  * Attempts to stop a service.
2931  * @see cacSvcControlService()
2932  * @param hnd Initialized and connected server handle
2933  * @param mem_ctx Context for memory allocation
2934  * @param op Initialized Parameters
2935  * @return CAC_FAILURE - the operation was not successful. If hnd->status is NT_STATUS_OK, then a timeout occured.
2936  * @return CAC_SUCCESS - the operation was successful
2937  */
2938 int cac_SvcStopService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcStopService *op);
2939
2940 struct SvcPauseService {
2941    struct {
2942       /**Open handle to the service*/
2943       POLICY_HND *svc_hnd;
2944
2945       /**Number of seconds to wait for the service to actually start.
2946        * If this is 0, then the status will not be checked after the initial call and CAC_SUCCESS might be returned if the status isn't actually started
2947        */
2948       uint32 timeout;
2949    } in;
2950
2951    struct {
2952       /**Status of the service after the operation*/
2953       SERVICE_STATUS status;
2954    } out;
2955 };
2956
2957 /**
2958  * Attempts to pause a service.
2959  * @see cacSvcControlService()
2960  * @param hnd Initialized and connected server handle
2961  * @param mem_ctx Context for memory allocation
2962  * @param op Initialized Parameters
2963  * @return CAC_FAILURE - the operation was not successful. If hnd->status is NT_STATUS_OK, then a timeout occured.
2964  * @return CAC_SUCCESS - the operation was successful
2965  */
2966 int cac_SvcPauseService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcPauseService *op);
2967
2968 struct SvcContinueService {
2969    struct {
2970       /**Open handle to the service*/
2971       POLICY_HND *svc_hnd;
2972
2973       /**Number of seconds to wait for the service to actually start.
2974        * If this is 0, then the status will not be checked after the initial call and CAC_SUCCESS might be returned if the status isn't actually started
2975        */
2976       uint32 timeout;
2977    } in;
2978
2979    struct {
2980       /**Status of the service after the operation*/
2981       SERVICE_STATUS status;
2982    } out;
2983 };
2984
2985 /**
2986  * Attempts to continue a paused service.
2987  * @see cacSvcControlService()
2988  * @param hnd Initialized and connected server handle
2989  * @param mem_ctx Context for memory allocation
2990  * @param op Initialized Parameters
2991  * @return CAC_FAILURE - the operation was not successful. If hnd->status is NT_STATUS_OK, then a timeout occured.
2992  * @return CAC_SUCCESS - the operation was successful
2993  */
2994 int cac_SvcContinueService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcContinueService *op);
2995
2996 struct SvcGetDisplayName {
2997    struct {
2998       /**Open handle to the service*/
2999       POLICY_HND *svc_hnd;
3000    } in;
3001
3002    struct {
3003       /**The returned display name of the service*/
3004       char *display_name;
3005    } out;
3006 };
3007
3008 /**
3009  * Retrieves the display name of a service _not currently working_
3010  * @param hnd Initialized and connected server handle
3011  * @param mem_ctx Context for memory allocation
3012  * @param op Initialized Parameters
3013  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
3014  * @return CAC_SUCCESS - the operation was successful
3015  */
3016 int cac_SvcGetDisplayName(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcGetDisplayName *op);
3017
3018 struct SvcGetServiceConfig {
3019    struct {
3020       /**Open handle to the service*/
3021       POLICY_HND *svc_hnd;
3022    } in;
3023
3024    struct {
3025       /**Returned Configuration information*/
3026       CacServiceConfig config;
3027    } out;
3028 };
3029
3030 /**
3031  * Retrieves configuration information about a service.
3032  * @param hnd Initialized and connected server handle
3033  * @param mem_ctx Context for memory allocation
3034  * @param op Initialized Parameters
3035  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
3036  * @return CAC_SUCCESS - the operation was successful
3037  */
3038 int cac_SvcGetServiceConfig(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcGetServiceConfig *op);
3039
3040 /**@}*/ /*SCM_Functions*/
3041
3042 struct rpc_pipe_client *cac_GetPipe(CacServerHandle *hnd, int pi_idx);
3043
3044 #endif /* LIBMSRPC_H */
3045
3046