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