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