274136537306be8d6e84968cfa576016d6fe72c1
[nivanova/samba-autobuild/.git] / source3 / include / libmsrpc.h
1 /* 
2  *  Unix SMB/CIFS implementation.
3  *  MS-RPC client library API definitions/prototypes
4  *
5  *  Copyright (C) Chris Nicholls              2005.
6  *  
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; either version 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 uuid *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    struct {
1003    } out;
1004 };
1005
1006 /** 
1007  * Removes a _specific_ set of privileges from an account
1008  * @param hnd Initialized and connected server handle
1009  * @param mem_ctx Context for memory allocation
1010  * @param op Initialized Parameters
1011  * @return CAC_FAILURE the privileges could not be removed. hnd->status is set with NT_STATUS code
1012  * @return CAC_SUCCESS the privileges were removed 
1013  */
1014 int cac_LsaRemovePrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaRemovePrivileges *op);
1015
1016 struct LsaClearPrivileges {
1017    struct {
1018       /**An open handle to the LSA*/
1019       POLICY_HND *pol;
1020
1021       /**(Optional) The user's SID (must specify at least sid or name)*/
1022       DOM_SID *sid;
1023
1024       /**(Optional) The user's name (must specify at least sid or name)*/
1025       char *name;
1026    } in;
1027
1028    struct {
1029    } out;
1030 };
1031
1032 /** 
1033  * Removes ALL privileges from an account
1034  * @param hnd Initialized and connected server handle
1035  * @param mem_ctx Context for memory allocation
1036  * @param op Initialized Parameters
1037  * @return CAC_FAILURE the operation was not successful, hnd->status set with NT_STATUS code
1038  * @return CAC_SUCCESS the opeartion was successful.
1039  */
1040 int cac_LsaClearPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaClearPrivileges *op);
1041
1042 /** 
1043  * Sets an accounts priviliges. Removes all privileges and then adds specified privileges.
1044  * @param hnd Initialized and connected server handle
1045  * @param mem_ctx Context for memory allocation
1046  * @param op Initialized Parameters 
1047  * @return CAC_FAILURE The operation could not complete successfully
1048  * @return CAC_SUCCESS The operation completed successfully
1049  */
1050 int cac_LsaSetPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaAddPrivileges *op);
1051
1052 struct LsaGetSecurityObject {
1053    struct {
1054       /**Open LSA policy handle*/
1055       POLICY_HND *pol;
1056    } in;
1057
1058    struct {
1059       /**Returned security descriptor information*/
1060       SEC_DESC_BUF *sec;
1061    } out;
1062 };
1063
1064 /**
1065  * Retrieves Security Descriptor information about the LSA
1066  * @param hnd Initialized and connected server handle
1067  * @param mem_ctx Context for memory allocation
1068  * @param op Initialized Parameters 
1069  * @return CAC_FAILURE The operation could not complete successfully
1070  * @return CAC_SUCCESS The operation completed successfully
1071  */
1072 int cac_LsaGetSecurityObject(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaGetSecurityObject *op);
1073
1074
1075 /**@}*/ /*LSA_Functions*/
1076       
1077 /**********************
1078  * Registry Functions *
1079  *********************/
1080
1081 /**@addtogroup Reg_Functions
1082  * @{
1083  */
1084
1085 struct RegConnect {
1086    struct {
1087       /** must be one of : 
1088        *    HKEY_CLASSES_ROOT, 
1089        *    HKEY_LOCAL_MACHINE, 
1090        *    HKEY_USERS, 
1091        *    HKEY_PERFORMANCE_DATA,
1092        */
1093       int root;
1094
1095       /**desired access on the root key
1096        * combination of: 
1097        * REG_KEY_READ,
1098        * REG_KEY_WRITE,
1099        * REG_KEY_EXECUTE,
1100        * REG_KEY_ALL,
1101        * found in include/rpc_secdes.h*/
1102       uint32 access;
1103    } in;
1104
1105    struct {
1106       POLICY_HND *key;
1107    } out;
1108 };
1109
1110 /** 
1111  * Opens a handle to the registry on the server
1112  * @param hnd Initialized and connected server handle
1113  * @param mem_ctx Context for memory allocation
1114  * @param op Initialized Parameters 
1115  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1116  * @return CAC_SUCCESS The operation completed successfully
1117  */
1118 int cac_RegConnect(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegConnect *op);
1119
1120 /**
1121  * Closes an open registry handle
1122  * @param hnd Initialized and connected server handle
1123  * @param mem_ctx Context for memory allocation
1124  * @param key The Key/Handle to close 
1125  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1126  * @return CAC_SUCCESS The operation completed successfully
1127  */
1128 int cac_RegClose(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *key);
1129
1130 struct RegOpenKey {
1131    struct {
1132       /**(Optional)parent key. 
1133        * If this is NULL, then cac_RegOpenKey() will attempt to connect to the registry, name MUST start with something like:<br>
1134        *  HKEY_LOCAL_MACHINE\  or an abbreviation like HKCR\
1135        *
1136        *  supported root names:
1137        *   - HKEY_LOCAL_MACHINE\ or HKLM\
1138        *   - HKEY_CLASSES_ROOT\ or HKCR\
1139        *   - HKEY_USERS\ or HKU\
1140        *   - HKEY_PERFORMANCE_DATA or HKPD\
1141        */
1142       POLICY_HND *parent_key;
1143
1144       /**name/path of key*/
1145       char *name;
1146
1147       /**desired access on this key*/
1148       uint32 access;
1149    } in;
1150
1151    struct {
1152       POLICY_HND *key;
1153    } out;
1154 };
1155       
1156 /**
1157  * Opens a registry key
1158  * @param hnd Initialized and connected server handle
1159  * @param mem_ctx Context for memory allocation
1160  * @param op Initialized parameters
1161  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1162  * @return CAC_SUCCESS The operation completed successfully
1163  */
1164
1165 int cac_RegOpenKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegOpenKey *op);
1166
1167 struct RegEnumKeys {
1168    struct {
1169       /**enumerate subkeys of this key*/
1170       POLICY_HND *key;
1171
1172       /**maximum number of keys to enumerate each call*/
1173       uint32 max_keys;
1174    } in;
1175
1176    struct {
1177       /**keeps track of the index to resume enumerating*/
1178       uint32 resume_idx;
1179
1180       /**the number of keys returned this call*/
1181       uint32 num_keys;
1182
1183       /**array of key names*/
1184       char **key_names;
1185
1186       /**class names of the keys*/
1187       char **class_names;
1188
1189       /**last modification time of the key*/
1190       time_t *mod_times;
1191    } out;
1192 };
1193
1194 /**
1195  * Enumerates Subkeys of a given key. Can be run in a loop. Example: while(cac_RegEnumKeys(hnd, mem_ctx, op)) { ... }
1196  * @param hnd Initialized and connected server handle
1197  * @param mem_ctx Context for memory allocation
1198  * @param op Initialized Parameters
1199  * @see CAC_OP_FAILED()
1200  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1201  * @return CAC_SUCCESS The operation completed successfully
1202  */
1203 int cac_RegEnumKeys(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegEnumKeys *op);
1204
1205
1206 struct RegCreateKey {
1207    struct {
1208       /**create a subkey of parent_key*/
1209       POLICY_HND *parent_key;
1210
1211       /**name of the key to create*/
1212       char *key_name;
1213
1214       /**class of the key*/
1215       char *class_name;
1216
1217       /**Access mask to open the key with. See REG_KEY_* in include/rpc_secdes.h*/
1218       uint32 access;
1219    } in;
1220
1221    struct {
1222       /**Open handle to the key*/
1223       POLICY_HND *key;
1224    } out;
1225 };
1226
1227 /**
1228  * Creates a registry key, if the key already exists, it will be opened __Creating keys is not currently working__.
1229  * @param hnd Initialized and connected server handle
1230  * @param mem_ctx Context for memory allocation
1231  * @param op Initialized Parmeters
1232  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1233  * @return CAC_SUCCESS The operation completed successfully
1234  */
1235 int cac_RegCreateKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegCreateKey *op);
1236
1237 struct RegDeleteKey {
1238    struct {
1239       /**handle to open registry key*/
1240       POLICY_HND *parent_key;
1241
1242       /**name of the key to delete*/
1243       char *name;
1244
1245       /**delete recursively. WARNING: this might not always work as planned*/
1246       BOOL recursive;
1247    } in;
1248
1249 };
1250
1251 /**
1252  * 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.
1253  * @param hnd Initialized and connected server handle
1254  * @param mem_ctx Context for memory allocation
1255  * @param op Initialized parameters
1256  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1257  * @return CAC_SUCCESS The operation completed successfully
1258  */
1259
1260 int cac_RegDeleteKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegDeleteKey *op);
1261
1262 struct RegDeleteValue {
1263    struct {
1264       /**handle to open registry key*/
1265       POLICY_HND *parent_key;
1266
1267       /**name of the value to delete*/
1268       char *name;
1269    } in;
1270 };
1271
1272 /**
1273  * Deletes a registry value.
1274  * @param hnd Initialized and connected server handle
1275  * @param mem_ctx Context for memory allocation
1276  * @param op Initialized Parameters
1277  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1278  * @return CAC_SUCCESS The operation completed successfully
1279  */
1280 int cac_RegDeleteValue(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegDeleteValue *op);
1281
1282 struct RegQueryKeyInfo {
1283    struct {
1284       /**Open handle to the key to query*/
1285       POLICY_HND *key;
1286    } in;
1287
1288    struct {
1289       /**name of the key class*/
1290       char *class_name;
1291
1292       /**number of subkeys of the key*/
1293       uint32 num_subkeys;
1294
1295       /**length (in characters) of the longest subkey name*/
1296       uint32 longest_subkey;
1297
1298       /**length (in characters) of the longest class name*/
1299       uint32 longest_class;
1300
1301       /**number of values in this key*/
1302       uint32 num_values;
1303
1304       /**length (in characters) of the longest value name*/
1305       uint32 longest_value_name;
1306
1307       /**length (in bytes) of the biggest value data*/
1308       uint32 longest_value_data;
1309
1310       /**size (in bytes) of the security descriptor*/
1311       uint32 security_desc_size;
1312
1313       /**time of the last write*/
1314       time_t last_write_time;
1315    } out;
1316 };
1317
1318 /**
1319  * Retrieves information about an open key
1320  * @param hnd Initialized and connected server handle
1321  * @param mem_ctx Context for memory allocation
1322  * @param op Initialized parameters
1323  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1324  * @return CAC_SUCCESS The operation completed successfully
1325  */
1326
1327 int cac_RegQueryKeyInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegQueryKeyInfo *op);
1328
1329 struct RegSaveKey {
1330    struct {
1331       /**Open key to be saved*/
1332       POLICY_HND *key;
1333
1334       /**The path (on the remote computer) to save the file to*/
1335       char *filename;
1336    } in;
1337 };
1338
1339 /**
1340  * Saves a key to a file on the remote machine __Not currently working__.
1341  * @param hnd Initialized and connected server handle
1342  * @param mem_ctx Context for memory allocation
1343  * @param op Initialized parameters
1344  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1345  * @return CAC_SUCCESS The operation completed successfully
1346  */
1347
1348 int cac_RegSaveKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSaveKey *op);
1349
1350 struct RegQueryValue {
1351    struct {
1352       /**handle to open registry key*/
1353       POLICY_HND *key;
1354
1355       /**name of the value to query*/
1356       char *val_name;
1357    } in;
1358
1359    struct {
1360       /**Value type.
1361        * One of:
1362        *  - REG_DWORD (equivalent to REG_DWORD_LE)
1363        *  - REG_DWORD_BE
1364        *  - REG_SZ
1365        *  - REG_EXPAND_SZ
1366        *  - REG_MULTI_SZ
1367        *  - REG_BINARY
1368        */
1369       uint32 type;
1370
1371       /**The value*/
1372       REG_VALUE_DATA *data;
1373    } out;
1374 };
1375
1376 /**
1377  * Retrieves a value (type and data) _not currently working_.
1378  * @param hnd Initialized and connected server handle
1379  * @param mem_ctx Context for memory allocation
1380  * @param op Initialized parameters
1381  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1382  * @return CAC_SUCCESS The operation completed successfully
1383  */
1384
1385 int cac_RegQueryValue(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegQueryValue *op);
1386
1387 struct RegEnumValues {
1388    struct {
1389       /**handle to open key*/
1390       POLICY_HND *key;
1391
1392       /**max number of values returned per call*/
1393       uint32 max_values;
1394
1395    } in;
1396
1397    struct {
1398       /**keeps track of the index to resume from - used over multiple calls*/
1399       uint32 resume_idx;
1400
1401       /**the number of values that were returned this call*/
1402       uint32 num_values;
1403
1404       /**Array of value types. A type can be one of:
1405        *  - REG_DWORD (equivalent to REG_DWORD_LE)
1406        *  - REG_DWORD_BE
1407        *  - REG_SZ
1408        *  - REG_EXPAND_SZ
1409        *  - REG_MULTI_SZ
1410        *  - REG_BINARY
1411        */
1412       uint32 *types;
1413
1414       /**array of strings storing the names of the values*/
1415       char **value_names;
1416
1417       /**array of pointers to the value data returned*/
1418       REG_VALUE_DATA **values;
1419    } out;
1420 };
1421
1422 /**
1423  * Enumerates a number of Registry values in an open registry key.
1424  * Can be run in a loop. Example: while(cac_RegEnumValues(hnd, mem_ctx, op)) { ... }
1425  * @param hnd Initialized and connected server handle
1426  * @param mem_ctx Context for memory allocation
1427  * @param op Initialized Parameters
1428  * @see CAC_OP_FAILED()
1429  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1430  * @return CAC_SUCCESS The operation completed successfully
1431  */
1432 int cac_RegEnumValues(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegEnumValues *op);
1433
1434 struct RegSetValue {
1435    struct {
1436       /**Handle to open registry key*/
1437       POLICY_HND *key;
1438
1439       /**Name of the value*/
1440       char *val_name;
1441
1442       /**Value type.
1443        * One of:
1444        *  - REG_DWORD (equivalent to REG_DWORD_LE)
1445        *  - REG_DWORD_BE
1446        *  - REG_SZ
1447        *  - REG_EXPAND_SZ
1448        *  - REG_MULTI_SZ
1449        *  - REG_BINARY
1450        */
1451       uint32 type;
1452
1453       /**the value*/
1454       REG_VALUE_DATA value;
1455    } in;
1456 };
1457
1458 /**
1459  * Sets or creates value (type and data).
1460  * @param hnd Initialized and connected server handle
1461  * @param mem_ctx Context for memory allocation
1462  * @param op Initialized parameters
1463  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1464  * @return CAC_SUCCESS The operation completed successfully
1465  */
1466 int cac_RegSetValue(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSetValue *op);
1467
1468 struct RegGetVersion {
1469    struct {
1470       /**open registry key*/
1471       POLICY_HND *key;
1472    } in;
1473
1474    struct {
1475       /**version number*/
1476       uint32 version;
1477    } out;
1478 };
1479
1480 /**
1481  * Retrieves the registry version number
1482  * @param hnd Initialized and connected server handle
1483  * @param mem_ctx Context for memory allocation
1484  * @param op Initialized parameters
1485  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1486  * @return CAC_SUCCESS The operation completed successfully
1487  */
1488 int cac_RegGetVersion(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegGetVersion *op);
1489
1490 struct RegGetKeySecurity {
1491    struct {
1492       /**Handle to key to query*/
1493       POLICY_HND *key;
1494
1495       /**Info that you want. Should be a combination of (1 or more or'd):
1496        * - OWNER_SECURITY_INFORMATION
1497        * - GROUP_SECURITY_INFORMATION
1498        * - DACL_SECURITY_INFORMATION
1499        * - SACL_SECURITY_INFORMATION
1500        * - UNPROTECTED_SACL_SECURITY_INFORMATION
1501        * - UNPROTECTED_DACL_SECURITY_INFORMATION
1502        * - PROTECTED_SACL_SECURITY_INFORMATION
1503        * - PROTECTED_DACL_SECURITY_INFORMATION
1504        *
1505        * or use:
1506        * - ALL_SECURITY_INFORMATION
1507        *
1508        * all definitions from include/rpc_secdes.h
1509        */
1510       uint32 info_type;
1511    } in;
1512
1513    struct {
1514       /**size of the data returned*/
1515       uint32 size;
1516
1517       /**Security descriptor*/
1518       SEC_DESC *descriptor;
1519    } out;
1520 };
1521
1522 /**
1523  * Retrieves a key security descriptor.
1524  * @param hnd Initialized and connected server handle
1525  * @param mem_ctx Context for memory allocation
1526  * @param op Initialized parameters
1527  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1528  * @return CAC_SUCCESS The operation completed successfully
1529  */
1530
1531 int cac_RegGetKeySecurity(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegGetKeySecurity *op);
1532
1533 struct RegSetKeySecurity {
1534    struct {
1535       /**Handle to key to query*/
1536       POLICY_HND *key;
1537
1538       /**Info that you want. Should be a combination of (1 or more or'd):
1539        * - OWNER_SECURITY_INFORMATION
1540        * - GROUP_SECURITY_INFORMATION
1541        * - DACL_SECURITY_INFORMATION
1542        * - SACL_SECURITY_INFORMATION
1543        * - UNPROTECTED_SACL_SECURITY_INFORMATION
1544        * - UNPROTECTED_DACL_SECURITY_INFORMATION
1545        * - PROTECTED_SACL_SECURITY_INFORMATION
1546        * - PROTECTED_DACL_SECURITY_INFORMATION
1547        *
1548        * or use:
1549        * - ALL_SECURITY_INFORMATION
1550        *
1551        * all definitions from include/rpc_secdes.h
1552        */
1553       uint32 info_type;
1554       
1555       /**size of the descriptor*/
1556       size_t size;
1557
1558       /**Security descriptor*/
1559       SEC_DESC *descriptor;
1560    } in;
1561 };
1562
1563 /**
1564  * Sets the key security descriptor.
1565  * @param hnd Initialized and connected server handle
1566  * @param mem_ctx Context for memory allocation
1567  * @param op Initialized parameters
1568  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1569  * @return CAC_SUCCESS The operation completed successfully
1570  */
1571 int cac_RegSetKeySecurity(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSetKeySecurity *op);
1572
1573 /**@}*/ /*Reg_Functions*/
1574
1575 struct Shutdown {
1576    struct {
1577       /**the message to display (can be NULL)*/
1578       char *message;
1579
1580       /**timeout in seconds*/
1581       uint32 timeout;
1582
1583       /**False = shutdown, True = reboot*/
1584       BOOL reboot;
1585       
1586       /**force the*/
1587       BOOL force;
1588
1589       /*FIXME: make this useful*/
1590       uint32 reason;
1591    } in;
1592 };
1593
1594
1595 /**
1596  * Shutdown the server _not currently working_. 
1597  * @param hnd Initialized and connected server handle
1598  * @param mem_ctx Context for memory allocation
1599  * @param op Initialized parameters
1600  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1601  * @return CAC_SUCCESS The operation completed successfully
1602  */
1603 int cac_Shutdown(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct Shutdown *op);
1604
1605 /**
1606  * Attempt to abort initiated shutdown on the server _not currently working_. 
1607  * @param hnd Initialized and connected server handle
1608  * @param mem_ctx Context for memory allocation
1609  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1610  * @return CAC_SUCCESS The operation completed successfully
1611  */
1612 int cac_AbortShutdown(CacServerHandle *hnd, TALLOC_CTX *mem_ctx);
1613
1614 /*****************
1615  * SAM Functions *
1616  *****************/
1617
1618 /**@addtogroup SAM_Functions
1619  * @{
1620  */
1621 struct SamConnect {
1622    struct {
1623       /**Access mask to open with
1624        * see generic access masks in include/smb.h*/
1625       uint32 access;
1626    } in;
1627
1628    struct {
1629       POLICY_HND *sam;
1630    } out;
1631 };
1632
1633 /** 
1634  * Connects to the SAM. This can be skipped by just calling cac_SamOpenDomain()
1635  * @param hnd Initialized and connected server handle
1636  * @param mem_ctx Context for memory allocation
1637  * @param op Initialized parameters
1638  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1639  * @return CAC_SUCCESS The operation completed successfully
1640  */
1641
1642 int cac_SamConnect(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamConnect *op);
1643
1644
1645 /** 
1646  * Closes any (SAM, domain, user, group, etc.) SAM handle. 
1647  * @param hnd Initialized and connected server handle
1648  * @param mem_ctx Context for memory allocation
1649  * @param sam Handle to close
1650  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1651  * @return CAC_SUCCESS The operation completed successfully
1652  */
1653
1654 int cac_SamClose(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *sam);
1655
1656 struct SamOpenDomain {
1657    struct {
1658       /**The desired access. See generic access masks - include/smb.h*/
1659       uint32 access;
1660
1661       /**(Optional) An open handle to the SAM. If it is NULL, the function will connect to the SAM with the access mask above*/
1662       POLICY_HND *sam;
1663
1664       /**(Optional) The SID of the domain to open. 
1665        *  If this this is NULL, the function will attempt to open the domain specified in hnd->domain */
1666       DOM_SID *sid;
1667    } in;
1668
1669    struct {
1670       /**handle to the open domain*/
1671       POLICY_HND *dom_hnd;
1672
1673       /**Handle to the open SAM*/
1674       POLICY_HND *sam;
1675    } out;
1676 };
1677
1678 /** 
1679  * Opens a handle to a domain. This must be called before any other SAM functions 
1680  * @param hnd Initialized and connected server handle
1681  * @param mem_ctx Context for memory allocation
1682  * @param op Initialized parameters
1683  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1684  * @return CAC_SUCCESS The operation completed successfully
1685  */
1686 int cac_SamOpenDomain(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenDomain *op);
1687
1688 struct SamCreateUser {
1689    struct {
1690       /**Open domain handle*/
1691       POLICY_HND *dom_hnd;
1692
1693       /**Username*/
1694       char *name;
1695
1696       /**See Allowable account control bits in include/smb.h*/
1697       uint32 acb_mask;
1698    } in;
1699
1700    struct {
1701       /**handle to the user*/
1702       POLICY_HND *user_hnd;
1703
1704       /**rid of the user*/
1705       uint32 rid;
1706    } out;
1707 };
1708
1709 /** 
1710  * Creates a new domain user, if the account already exists it will _not_ be opened and hnd->status will be NT_STATUS_USER_EXISTS
1711  * @param hnd Initialized and connected server handle
1712  * @param mem_ctx Context for memory allocation
1713  * @param op Initialized parameters
1714  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1715  * @return CAC_SUCCESS The operation completed successfully
1716  */
1717
1718 int cac_SamCreateUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamCreateUser *op);
1719
1720 struct SamOpenUser {
1721    struct {
1722       /**Handle to open SAM connection*/
1723       POLICY_HND *dom_hnd;
1724
1725       /**desired access - see generic access masks in include/smb.h*/
1726       uint32 access;
1727
1728       /**RID of the user*/
1729       uint32 rid;
1730
1731       /**(Optional) name of the user - must supply either RID or user name*/
1732       char *name;
1733    } in;
1734
1735    struct {
1736       /**Handle to the user*/
1737       POLICY_HND *user_hnd;
1738    } out;    
1739 };
1740
1741 /** 
1742  * Opens a domain user.
1743  * @param hnd Initialized and connected server handle
1744  * @param mem_ctx Context for memory allocation
1745  * @param op Initialized parameters
1746  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1747  * @return CAC_SUCCESS The operation completed successfully
1748  */
1749 int cac_SamOpenUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenUser *op);
1750
1751 /** 
1752  * Deletes a domain user.  
1753  * @param hnd Initialized and connected server handle
1754  * @param mem_ctx Context for memory allocation
1755  * @param user_hnd Open handle to the user
1756  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1757  * @return CAC_SUCCESS The operation completed successfully
1758  */
1759 int cac_SamDeleteUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *user_hnd);
1760
1761
1762 struct SamEnumUsers {
1763    struct {
1764       /**Open handle to a domain*/
1765       POLICY_HND *dom_hnd;
1766
1767       /**Enumerate users with specific ACB. If 0, all users will be enumerated*/
1768       uint16 acb_mask;
1769    } in;
1770
1771    struct {
1772       /**where to resume from. Used over multiple calls*/
1773       uint32 resume_idx;
1774
1775       /**the number of users returned this call*/
1776       uint32 num_users;
1777
1778       /**Array storing the rids of the returned users*/
1779       uint32 *rids;
1780
1781       /**Array storing the names of all the users returned*/
1782       char **names;
1783
1784       BOOL done;
1785    } out;
1786 };
1787
1788 /** 
1789  * Enumerates domain users. Can be used as a loop condition. Example: while(cac_SamEnumUsers(hnd, mem_ctx, op)) { ... }
1790  * @param hnd Initialized and connected server handle
1791  * @param mem_ctx Context for memory allocation
1792  * @param op Initialized parameters
1793  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1794  * @return CAC_SUCCESS The operation completed successfully
1795  */
1796 int cac_SamEnumUsers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamEnumUsers *op);
1797
1798 struct SamGetNamesFromRids {
1799    struct {
1800       /**An open handle to the domain SAM from cac_SamOpenDomain()*/
1801       POLICY_HND *dom_hnd;
1802
1803       /**Number of RIDs to resolve*/
1804       uint32 num_rids;
1805
1806       /**Array of RIDs to resolve*/
1807       uint32 *rids;
1808    } in;
1809
1810    struct {
1811       /**the number of names returned - if this is 0, the map is NULL*/
1812       uint32 num_names;
1813
1814       /**array contiaing the Names and RIDs*/
1815       CacLookupRidsRecord *map;
1816    } out;
1817 };
1818
1819 /** 
1820  * Returns a list of names which map to a list of RIDs.
1821  * @param hnd Initialized and connected server handle
1822  * @param mem_ctx Context for memory allocation
1823  * @param op Initialized parameters
1824  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1825  * @return CAC_SUCCESS The operation completed successfully
1826  */
1827 int cac_SamGetNamesFromRids(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetNamesFromRids *op);
1828
1829 struct SamGetRidsFromNames {
1830    struct {
1831       /**An open handle to the domain SAM from cac_SamOpenDomain()*/
1832       POLICY_HND *dom_hnd;
1833
1834       /**Number of names to resolve*/
1835       uint32 num_names;
1836
1837       /**Array of names to resolve*/
1838       char **names;
1839    } in;
1840
1841    struct {
1842       /**the number of names returned - if this is 0, then map is NULL*/
1843       uint32 num_rids;
1844
1845       /**array contiaing the Names and RIDs*/
1846       CacLookupRidsRecord *map;
1847    } out;
1848 };
1849
1850 /** 
1851  * Returns a list of RIDs which map to a list of names.
1852  * @param hnd Initialized and connected server handle
1853  * @param mem_ctx Context for memory allocation
1854  * @param op Initialized parameters
1855  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1856  * @return CAC_SUCCESS The operation completed successfully
1857  */
1858 int cac_SamGetRidsFromNames(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetRidsFromNames *op);
1859
1860 struct SamGetGroupsForUser {
1861    struct {
1862       /**An open handle to the user*/
1863       POLICY_HND *user_hnd;
1864    } in;
1865
1866    struct {
1867       /**The number of groups the user is a member of*/
1868       uint32 num_groups;
1869
1870       /**The RIDs of the groups*/
1871       uint32 *rids;
1872
1873       /**The attributes of the groups*/ 
1874       uint32 *attributes;
1875    } out;
1876 };
1877 /** 
1878  * Retrieves a list of groups that a user is a member of.
1879  * @param hnd Initialized and connected server handle
1880  * @param mem_ctx Context for memory allocation
1881  * @param op Initialized parameters
1882  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1883  * @return CAC_SUCCESS The operation completed successfully
1884  */
1885 int cac_SamGetGroupsForUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetGroupsForUser *op);
1886
1887 struct SamOpenGroup {
1888    struct {
1889       /**Open handle to the domain SAM*/
1890       POLICY_HND *dom_hnd;
1891
1892       /**Desired access to open the group with. See Generic access masks in include/smb.h*/
1893       uint32 access;
1894
1895       /**rid of the group*/
1896       uint32 rid;
1897    } in;
1898
1899    struct {
1900       /**Handle to the group*/
1901       POLICY_HND *group_hnd;
1902    } out;
1903 };
1904
1905 /** 
1906  * Opens a domain group.
1907  * @param hnd Initialized and connected server handle
1908  * @param mem_ctx Context for memory allocation
1909  * @param op Initialized parameters
1910  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1911  * @return CAC_SUCCESS The operation completed successfully
1912  */
1913 int cac_SamOpenGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenGroup *op);
1914
1915 struct SamCreateGroup {
1916    struct {
1917       /**Open handle to the domain SAM*/
1918       POLICY_HND *dom_hnd;
1919
1920       /**Desired access to open the group with. See Generic access masks in include/smb.h*/
1921       uint32 access;
1922
1923       /**The name of the group*/
1924       char *name;
1925    } in;
1926
1927    struct {
1928       /**Handle to the group*/
1929       POLICY_HND *group_hnd;
1930    } out;
1931 };
1932
1933 /** 
1934  * Creates a group. If the group already exists it will not be opened.
1935  * @param hnd Initialized and connected server handle
1936  * @param mem_ctx Context for memory allocation
1937  * @param op Initialized parameters
1938  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1939  * @return CAC_SUCCESS The operation completed successfully
1940  */
1941 int cac_SamCreateGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamCreateGroup *op);
1942
1943 /** 
1944  * Deletes a domain group.  
1945  * @param hnd Initialized and connected server handle
1946  * @param mem_ctx Context for memory allocation
1947  * @param group_hnd Open handle to the group.
1948  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1949  * @return CAC_SUCCESS The operation completed successfully
1950  */
1951 int cac_SamDeleteGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *group_hnd);
1952
1953 struct SamGetGroupMembers {
1954    struct {
1955       /**Open handle to a group*/
1956       POLICY_HND *group_hnd;
1957    } in;
1958
1959    struct {
1960       /**The number of members in the group*/
1961       uint32 num_members;
1962
1963       /**An array storing the RIDs of the users*/
1964       uint32 *rids;
1965
1966       /**The attributes*/
1967       uint32 *attributes;
1968    } out;
1969 };
1970
1971 /** 
1972  * Retrives a list of users in a group.
1973  * @param hnd Initialized and connected server handle
1974  * @param mem_ctx Context for memory allocation
1975  * @param op Initialized parameters
1976  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1977  * @return CAC_SUCCESS The operation completed successfully
1978  */
1979 int cac_SamGetGroupMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetGroupMembers *op);
1980
1981 struct SamAddGroupMember {
1982    struct {
1983       /**Open handle to a group*/
1984       POLICY_HND *group_hnd;
1985
1986       /**RID of new member*/
1987       uint32 rid;
1988    } in;
1989 };
1990
1991 /** 
1992  * Adds a user to a group.
1993  * @param hnd Initialized and connected server handle
1994  * @param mem_ctx Context for memory allocation
1995  * @param op Initialized parameters
1996  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
1997  * @return CAC_SUCCESS The operation completed successfully
1998  */
1999 int cac_SamAddGroupMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamAddGroupMember *op);
2000
2001 struct SamRemoveGroupMember {
2002    struct {
2003       /**Open handle to a group*/
2004       POLICY_HND *group_hnd;
2005
2006       /**RID of member to remove*/
2007       uint32 rid;
2008    } in;
2009 };
2010
2011 /** 
2012  * Removes a user from a group.
2013  * @param hnd Initialized and connected server handle
2014  * @param mem_ctx Context for memory allocation
2015  * @param op Initialized parameters
2016  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2017  * @return CAC_SUCCESS The operation completed successfully
2018  */
2019 int cac_SamRemoveGroupMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRemoveGroupMember *op);
2020
2021 /**
2022  * Removes all the members of a group - warning: if this function fails is is possible that some but not all members were removed
2023  * @param hnd Initialized and connected server handle
2024  * @param mem_ctx Context for memory allocation
2025  * @param group_hnd Open handle to the group to clear
2026  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2027  * @return CAC_SUCCESS The operation completed successfully
2028  */
2029 int cac_SamClearGroupMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *group_hnd);
2030
2031 struct SamSetGroupMembers {
2032    struct {
2033       /**Open handle to the group*/
2034       POLICY_HND *group_hnd;
2035
2036       /**Number of members in the group - if this is 0, all members of the group will be removed*/
2037       uint32 num_members;
2038
2039       /**The RIDs of the users to add*/
2040       uint32 *rids;
2041    } in;
2042 };
2043
2044 /**
2045  * Clears the members of a group and adds a list of members to the group
2046  * @param hnd Initialized and connected server handle
2047  * @param mem_ctx Context for memory allocation
2048  * @param op Initialized parameters
2049  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2050  * @return CAC_SUCCESS The operation completed successfully
2051  */
2052 int cac_SamSetGroupMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetGroupMembers *op);
2053
2054 struct SamEnumGroups {
2055    struct {
2056       /**Open handle to a domain*/
2057       POLICY_HND *dom_hnd;
2058    } in;
2059
2060    struct {
2061       /**Where to resume from _do not_ modify this value. Used over multiple calls.*/
2062       uint32 resume_idx;
2063
2064       /**the number of users returned this call*/
2065       uint32 num_groups;
2066
2067       /**Array storing the rids of the returned groups*/
2068       uint32 *rids;
2069
2070       /**Array storing the names of all the groups returned*/
2071       char **names;
2072
2073       /**Array storing the descriptions of all the groups returned*/
2074       char **descriptions;
2075
2076       BOOL done;
2077    } out;
2078 };
2079
2080 /** 
2081  * Enumerates domain groups. Can be used as a loop condition. Example: while(cac_SamEnumGroups(hnd, mem_ctx, op)) { ... }
2082  * @param hnd Initialized and connected server handle
2083  * @param mem_ctx Context for memory allocation
2084  * @param op Initialized parameters
2085  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2086  * @return CAC_SUCCESS The operation completed successfully
2087  */
2088 int cac_SamEnumGroups(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamEnumGroups *op);
2089
2090 struct SamEnumAliases {
2091    struct {
2092       /**Open handle to a domain*/
2093       POLICY_HND *dom_hnd;
2094    } in;
2095
2096    struct {
2097       /**where to resume from. Used over multiple calls*/
2098       uint32 resume_idx;
2099
2100       /**the number of users returned this call*/
2101       uint32 num_aliases;
2102
2103       /**Array storing the rids of the returned groups*/
2104       uint32 *rids;
2105
2106       /**Array storing the names of all the groups returned*/
2107       char **names;
2108
2109       /**Array storing the descriptions of all the groups returned*/
2110       char **descriptions;
2111
2112       BOOL done;
2113    } out;
2114 };
2115
2116 /** 
2117  * Enumerates domain aliases. Can be used as a loop condition. Example: while(cac_SamEnumAliases(hnd, mem_ctx, op)) { ... }
2118  * @param hnd Initialized and connected server handle
2119  * @param mem_ctx Context for memory allocation
2120  * @param op Initialized parameters
2121  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2122  * @return CAC_SUCCESS The operation completed successfully
2123  */
2124 int cac_SamEnumAliases(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamEnumAliases *op);
2125
2126 struct SamCreateAlias {
2127    struct {
2128       /**Open handle to the domain SAM*/
2129       POLICY_HND *dom_hnd;
2130
2131       /**The name of the alias*/
2132       char *name;
2133    } in;
2134
2135    struct {
2136       /**Handle to the group*/
2137       POLICY_HND *alias_hnd;
2138    } out;
2139 };
2140
2141 /** 
2142  * Creates an alias. If the alias already exists it will not be opened.
2143  * @param hnd Initialized and connected server handle
2144  * @param mem_ctx Context for memory allocation
2145  * @param op Initialized parameters
2146  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2147  * @return CAC_SUCCESS The operation completed successfully
2148  */
2149
2150 int cac_SamCreateAlias(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamCreateAlias *op);
2151
2152 struct SamOpenAlias {
2153    struct {
2154       /**Open handle to the domain SAM*/
2155       POLICY_HND *dom_hnd;
2156
2157       /**Desired access to open the group with. See Generic access masks in include/smb.h*/
2158       uint32 access;
2159
2160       /**rid of the alias*/
2161       uint32 rid;
2162    } in;
2163
2164    struct {
2165       /**Handle to the alias*/
2166       POLICY_HND *alias_hnd;
2167    } out;
2168 };
2169
2170 /** 
2171  * Opens a handle to an alias.
2172  * @param hnd Initialized and connected server handle
2173  * @param mem_ctx Context for memory allocation
2174  * @param op Initialized parameters
2175  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2176  * @return CAC_SUCCESS The operation completed successfully
2177  */
2178 int cac_SamOpenAlias(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenAlias *op);
2179
2180 /** 
2181  * Deletes an alias.
2182  * @param hnd Initialized and connected server handle
2183  * @param mem_ctx Context for memory allocation
2184  * @param alias_hnd Open handle to the alias
2185  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2186  * @return CAC_SUCCESS The operation completed successfully
2187  */
2188 int cac_SamDeleteAlias(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *alias_hnd);
2189
2190 struct SamAddAliasMember {
2191    struct {
2192       /**Open handle to a alias*/
2193       POLICY_HND *alias_hnd;
2194
2195       /**SID of new member*/
2196       DOM_SID *sid;
2197    } in;
2198 };
2199
2200 /** 
2201  * Adds an account to an alias.
2202  * @param hnd Initialized and connected server handle
2203  * @param mem_ctx Context for memory allocation
2204  * @param op Initialized parameters
2205  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2206  * @return CAC_SUCCESS The operation completed successfully
2207  */
2208 int cac_SamAddAliasMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamAddAliasMember *op);
2209
2210 struct SamRemoveAliasMember {
2211    struct {
2212       /**Open handle to the alias*/
2213       POLICY_HND *alias_hnd;
2214
2215       /**The SID of the member*/
2216       DOM_SID *sid;
2217    } in;
2218 };
2219
2220 /** 
2221  * Removes an account from an alias.
2222  * @param hnd Initialized and connected server handle
2223  * @param mem_ctx Context for memory allocation
2224  * @param op Initialized parameters
2225  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2226  * @return CAC_SUCCESS The operation completed successfully
2227  */
2228 int cac_SamRemoveAliasMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRemoveAliasMember *op);
2229
2230 struct SamGetAliasMembers {
2231    struct {
2232       /**Open handle to the alias*/
2233       POLICY_HND *alias_hnd;
2234    } in;
2235
2236    struct {
2237       /**The number of members*/
2238       uint32 num_members;
2239
2240       /**An array storing the SIDs of the accounts*/
2241       DOM_SID *sids;
2242    } out;
2243 };
2244
2245 /** 
2246  * Retrieves a list of all accounts in an alias.
2247  * @param hnd Initialized and connected server handle
2248  * @param mem_ctx Context for memory allocation
2249  * @param op Initialized parameters
2250  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2251  * @return CAC_SUCCESS The operation completed successfully
2252  */
2253 int cac_SamGetAliasMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetAliasMembers *op);
2254
2255 /**
2256  * Removes all the members of an alias  - warning: if this function fails is is possible that some but not all members were removed
2257  * @param hnd Initialized and connected server handle
2258  * @param mem_ctx Context for memory allocation
2259  * @param alias_hnd Handle to the alias to clear
2260  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2261  * @return CAC_SUCCESS The operation completed successfully
2262  */
2263
2264 int cac_SamClearAliasMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *alias_hnd);
2265
2266 struct SamSetAliasMembers {
2267    struct {
2268       /**Open handle to the group*/
2269       POLICY_HND *alias_hnd;
2270
2271       /**Number of members in the group - if this is 0, all members of the group will be removed*/
2272       uint32 num_members;
2273
2274       /**The SIDs of the accounts to add*/
2275       DOM_SID *sids;
2276    } in;
2277 };
2278
2279 /**
2280  * Clears the members of an alias and adds a list of members to the alias
2281  * @param hnd Initialized and connected server handle
2282  * @param mem_ctx Context for memory allocation
2283  * @param op Initialized parameters
2284  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2285  * @return CAC_SUCCESS The operation completed successfully
2286  */
2287 int cac_SamSetAliasMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetAliasMembers *op);
2288
2289
2290 struct SamUserChangePasswd {
2291    struct {
2292       /**The username*/
2293       char *username;
2294
2295       /**The current password*/
2296       char *password;
2297
2298       /**The new password*/
2299       char *new_password;
2300    } in;
2301 };
2302 /**Used by a user to change their password*/
2303 int cac_SamUserChangePasswd(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamUserChangePasswd *op);
2304
2305 /**
2306  * Enables a user
2307  * @param hnd Initialized and connected server handle
2308  * @param mem_ctx Context for memory allocation
2309  * @param user_hnd Open handle to the user to enable
2310  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2311  * @return CAC_SUCCESS The operation completed successfully
2312  */
2313 int cac_SamEnableUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *user_hnd);
2314
2315 /**
2316  * Disables a user
2317  * @param hnd Initialized and connected server handle
2318  * @param mem_ctx Context for memory allocation
2319  * @param user_hnd Open handle to the user to disables
2320  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2321  * @return CAC_SUCCESS The operation completed successfully
2322  */
2323 int cac_SamDisableUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *user_hnd);
2324
2325 struct SamSetPassword {
2326    struct {
2327       /**Open handle to a user*/
2328       POLICY_HND *user_hnd;
2329
2330       /**The new password*/
2331       char *password;
2332    } in;
2333 };
2334
2335 /**
2336  * Sets a user's password
2337  * @param hnd Initialized and connected server handle
2338  * @param mem_ctx Context for memory allocation
2339  * @param op Initialized parameters
2340  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2341  * @return CAC_SUCCESS The operation completed successfully
2342  */
2343
2344 int cac_SamSetPassword(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetPassword *op);
2345
2346 struct SamGetUserInfo {
2347    struct {
2348       /**Open Handle to a user*/
2349       POLICY_HND *user_hnd;
2350    } in;
2351
2352    struct {
2353       CacUserInfo *info;
2354    } out;
2355 };
2356
2357 /**
2358  * Retrieves user information using a CacUserInfo structure. If you would like to use a SAM_USERINFO_CTR directly, use cac_SamGetUserInfoCtr()
2359  * @param hnd Initialized and connected server handle
2360  * @param mem_ctx Context for memory allocation
2361  * @param op Initialized parameters
2362  * @see cac_SamGetUserInfoCtr()
2363  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2364  * @return CAC_SUCCESS The operation completed successfully
2365  */
2366 int cac_SamGetUserInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetUserInfo *op);
2367
2368 struct SamSetUserInfo {
2369    struct {
2370       /**Open handle to a user*/
2371       POLICY_HND *user_hnd;
2372
2373       /**Structure containing the data you would like to set*/
2374       CacUserInfo *info;
2375    } in;
2376 };
2377
2378 /**
2379  * Sets the user info using a CacUserInfo structure. If you would like to use a SAM_USERINFO_CTR directly use cac_SamSetUserInfoCtr().
2380  * @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().
2381  * @note When calling this, you _must_ set the user's password.
2382  * @param hnd Initialized and connected server handle
2383  * @param mem_ctx Context for memory allocation
2384  * @param op Initialized parameters
2385  * @see cac_SamSetUserInfoCtr()
2386  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2387  * @return CAC_SUCCESS The operation completed successfully
2388  */
2389 int cac_SamSetUserInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetUserInfo *op);
2390
2391 struct SamGetUserInfoCtr {
2392    struct {
2393       /**Open handle to a user*/
2394       POLICY_HND *user_hnd;
2395
2396       /**What USER_INFO structure you want. See include/rpc_samr.h*/
2397       uint16 info_class;
2398    } in;
2399
2400    struct {
2401       /**returned user info*/
2402       SAM_USERINFO_CTR *ctr;
2403    } out;
2404 };
2405
2406 /**
2407  * Retrieves user information using a SAM_USERINFO_CTR structure. If you don't want to use this structure, user SamGetUserInfo()
2408  * @param hnd Initialized and connected server handle
2409  * @param mem_ctx Context for memory allocation
2410  * @param op Initialized parameters
2411  * @see cac_SamGetUserInfo()
2412  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2413  * @return CAC_SUCCESS The operation completed successfully
2414  */
2415 int cac_SamGetUserInfoCtr(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetUserInfoCtr *op);
2416
2417 struct SamSetUserInfoCtr {
2418    struct {
2419       /**Open handle to a user*/
2420       POLICY_HND *user_hnd;
2421
2422       /**user info - make sure ctr->switch_value is set properly*/
2423       SAM_USERINFO_CTR *ctr;
2424    } in;
2425 };
2426
2427 /**
2428  * Sets the user info using a SAM_USERINFO_CTR structure. If you don't want to use this structure, use cac_SamSetUserInfo()
2429  * @param hnd Initialized and connected server handle
2430  * @param mem_ctx Context for memory allocation
2431  * @param op Initialized parameters
2432  * @see cac_SamSetUserInfo()
2433  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2434  * @return CAC_SUCCESS The operation completed successfully
2435  */
2436
2437 int cac_SamSetUserInfoCtr(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetUserInfoCtr *op);
2438
2439 struct SamRenameUser {
2440    struct {
2441       /**Open handle to user*/
2442       POLICY_HND *user_hnd;
2443
2444       /**New user name*/
2445       char *new_name;
2446    } in;
2447 };
2448
2449 /**
2450  * Changes the name of a user.
2451  * @param hnd Initialized and connected server handle
2452  * @param mem_ctx Context for memory allocation
2453  * @param op Initialized parameters
2454  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2455  * @return CAC_SUCCESS The operation completed successfully
2456  */
2457 int cac_SamRenameUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRenameUser *op);
2458
2459 struct SamGetGroupInfo {
2460    struct {
2461       /**Open handle to a group*/
2462       POLICY_HND *group_hnd;
2463    } in;
2464
2465    struct {
2466       /**Returned info about the group*/
2467       CacGroupInfo *info;
2468    } out;
2469 };
2470
2471 /**
2472  * Retrieves information about a group.
2473  * @param hnd Initialized and connected server handle
2474  * @param mem_ctx Context for memory allocation
2475  * @param op Initialized parameters
2476  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2477  * @return CAC_SUCCESS The operation completed successfully
2478  */
2479 int cac_SamGetGroupInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetGroupInfo *op);
2480
2481 struct SamSetGroupInfo {
2482    struct {
2483       /**Open handle to a group*/
2484       POLICY_HND *group_hnd;
2485
2486       /**group info*/
2487       CacGroupInfo *info;
2488    } in;
2489 };
2490
2491 /**
2492  * Sets information about a group.
2493  * @param hnd Initialized and connected server handle
2494  * @param mem_ctx Context for memory allocation
2495  * @param op Initialized parameters
2496  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2497  * @return CAC_SUCCESS The operation completed successfully
2498  */
2499 int cac_SamSetGroupInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetGroupInfo *op);
2500
2501 struct SamRenameGroup {
2502    struct {
2503       /**Open handle to a group*/
2504       POLICY_HND *group_hnd;
2505
2506       /**New name*/
2507       char *new_name;
2508    } in;
2509 };
2510
2511 /**
2512  * Changes the name of a group
2513  * @param hnd Initialized and connected server handle
2514  * @param mem_ctx Context for memory allocation
2515  * @param op Initialized parameters
2516  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2517  * @return CAC_SUCCESS The operation completed successfully
2518  */
2519
2520 int cac_SamRenameGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRenameGroup *op);
2521
2522 struct SamGetAliasInfo {
2523    struct {
2524       /**Open handle to an alias*/
2525       POLICY_HND *alias_hnd;
2526    } in;
2527
2528    struct {
2529       /**Returned alias info*/
2530       CacAliasInfo *info;
2531    } out;
2532 };
2533
2534 /**
2535  * Retrieves information about an alias.
2536  * @param hnd Initialized and connected server handle
2537  * @param mem_ctx Context for memory allocation
2538  * @param op Initialized parameters
2539  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2540  * @return CAC_SUCCESS The operation completed successfully
2541  */
2542 int cac_SamGetAliasInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetAliasInfo *op);
2543
2544 struct SamSetAliasInfo {
2545    struct {
2546       /**Open handle to an alias*/
2547       POLICY_HND *alias_hnd;
2548       
2549       /**Returned alias info*/
2550       CacAliasInfo *info;
2551    } in;
2552 };
2553
2554 /**
2555  * Sets information about an alias.
2556  * @param hnd Initialized and connected server handle
2557  * @param mem_ctx Context for memory allocation
2558  * @param op Initialized parameters
2559  * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
2560  * @return CAC_SUCCESS The operation completed successfully
2561  */
2562 int cac_SamSetAliasInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetAliasInfo *op);
2563
2564 struct SamGetDomainInfo {
2565    struct {
2566       /**Open handle to the domain SAM*/
2567       POLICY_HND *dom_hnd;
2568    } in;
2569
2570    struct {
2571       /**Returned domain info*/
2572       CacDomainInfo *info;
2573    } out;
2574 };
2575
2576 /**
2577  * Gets domain information in the form of a CacDomainInfo structure. 
2578  * @param hnd Initialized and connected server handle
2579  * @param mem_ctx Context for memory allocation
2580  * @param op Initialized parameters
2581  * @see SamGetDomainInfoCtr()
2582  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2583  * @return CAC_SUCCESS - the operation was successful
2584  * @return CAC_PARTIAL_SUCCESS - This function makes 3 rpc calls, if one or two fail and the rest succeed, 
2585  *                                  not all fields in the CacDomainInfo structure will be filled
2586  */
2587 int cac_SamGetDomainInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetDomainInfo *op);
2588
2589 struct SamGetDomainInfoCtr {
2590    struct {
2591       /**Open handle to domain*/
2592       POLICY_HND *dom_hnd;
2593
2594       /**What info level you want*/
2595       uint16 info_class;
2596    } in;
2597
2598    struct {
2599       SAM_UNK_CTR *info;
2600    } out;
2601 };
2602
2603 /**
2604  * Gets domain information in the form of a SAM_UNK_CTR structure. 
2605  * @param hnd Initialized and connected server handle
2606  * @param mem_ctx Context for memory allocation
2607  * @param op Initialized parameters
2608  * @see SamGetDomainInfo()
2609  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2610  * @return CAC_SUCCESS - the operation was successful
2611  */
2612 int cac_SamGetDomainInfoCtr(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetDomainInfoCtr *op);
2613
2614 struct SamGetDisplayInfo {
2615    struct {
2616       /**Open handle to domain*/
2617       POLICY_HND *dom_hnd;
2618
2619       /**What type of data*/
2620       uint16 info_class;
2621
2622       /**(Optional)If 0, max_entries and max_size will be filled in by the function*/
2623       uint32 max_entries;
2624       
2625       /**(Optional)If 0, max_entries and max_size will be filled in by the function*/
2626       uint32 max_size;
2627    } in;
2628
2629    struct {
2630       /**Do not modify this value, use the same value between multiple calls (ie in while loop)*/
2631       uint32 resume_idx;
2632
2633       /**Number of entries returned*/
2634       uint32 num_entries;
2635
2636       /**Returned display info*/
2637       SAM_DISPINFO_CTR ctr;
2638
2639       /**Internal value. Do not modify.*/
2640       uint32 loop_count;
2641
2642       BOOL done;
2643    } out;
2644 };
2645
2646 /**
2647  * Gets dislpay information using a SAM_DISPINFO_CTR.
2648  * @param hnd Initialized and connected server handle
2649  * @param mem_ctx Context for memory allocation
2650  * @param op Initialized parameters
2651  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2652  * @return CAC_SUCCESS - the operation was successful
2653  */
2654 int cac_SamGetDisplayInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetDisplayInfo *op);
2655
2656 struct SamLookupDomain {
2657    struct {
2658       /**Open handle to the sam (opened with cac_SamConnect() or cac_SamOpenDomain()*/
2659       POLICY_HND *sam;
2660
2661       /**Name of the domain to lookup*/
2662       char *name;
2663    } in;
2664
2665    struct {
2666       /**SID of the domain*/
2667       DOM_SID *sid;
2668    } out;
2669 };
2670
2671 /**
2672  * Looks up a Domain SID given it's name.
2673  * @param hnd Initialized and connected server handle
2674  * @param mem_ctx Context for memory allocation
2675  * @param op Initialized parameters
2676  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2677  * @return CAC_SUCCESS - the operation was successful
2678  */
2679 int cac_SamLookupDomain(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamLookupDomain *op);
2680
2681 struct SamGetSecurityObject {
2682    struct {
2683       /**An open handle (SAM, domain or user)*/
2684       POLICY_HND *pol;
2685    } in;
2686
2687    struct {
2688       SEC_DESC_BUF *sec;
2689    } out;
2690 };
2691
2692 /**
2693  * Retrievies Security descriptor information for a SAM/Domain/user
2694  * @param hnd Initialized and connected server handle
2695  * @param mem_ctx Context for memory allocation
2696  * @param op Initialized parameters
2697  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2698  * @return CAC_SUCCESS - the operation was successful
2699  */
2700 int cac_SamGetSecurityObject(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetSecurityObject *op);
2701
2702 struct SamFlush {
2703    struct {
2704       /**Open handle to the domain SAM*/
2705       POLICY_HND *dom_hnd;
2706
2707       /**(Optional)Domain SID. If NULL, the domain in hnd->domain will be opened*/
2708       DOM_SID *sid;
2709
2710       /**(Optional)Desired access to re-open the domain with. If 0, MAXIMUM_ALLOWED_ACCESS is used.*/
2711       uint32 access;
2712    } in;
2713 };
2714
2715 /**
2716  * Closes the domain handle, then re-opens it - effectively flushing any changes made.
2717  * WARNING: if this fails you will no longer have an open handle to the domain SAM.
2718  * @param hnd Initialized and connected server handle
2719  * @param mem_ctx Context for memory allocation
2720  * @param op Initialized Parameters
2721  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2722  * @return CAC_SUCCESS - the operation was successful
2723  */
2724 int cac_SamFlush(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamFlush *op);
2725
2726 /**@}*/ /*SAM_Functions*/
2727
2728 /**@addtogroup SCM_Functions
2729  * @{
2730  */
2731
2732 struct SvcOpenScm {
2733    struct {
2734       /**Desired access to open the Handle with. See SC_RIGHT_MGR_* or SC_MANAGER_* in include/rpc_secdes.h*/
2735       uint32 access;
2736    } in;
2737
2738    struct {
2739       /**Handle to the SCM*/
2740       POLICY_HND *scm_hnd;
2741    } out;
2742 };
2743
2744 /**
2745  * Opens a handle to the SCM on the remote machine.
2746  * @param hnd Initialized and connected server handle
2747  * @param mem_ctx Context for memory allocation
2748  * @param op Initialized parameters
2749  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2750  * @return CAC_SUCCESS - the operation was successful
2751  */
2752 int cac_SvcOpenScm(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcOpenScm *op);
2753
2754 /**
2755  * Closes an Svc handle (SCM or Service)
2756  * @param hnd Initialized and connected server handle
2757  * @param mem_ctx Context for memory allocation
2758  * @param scm_hnd The handle to close
2759  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2760  * @return CAC_SUCCESS - the operation was successful
2761  */
2762 int cac_SvcClose(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *scm_hnd);
2763
2764 struct SvcEnumServices {
2765    struct {
2766       /**Open handle to the SCM*/
2767       POLICY_HND *scm_hnd;
2768
2769       /**(Optional)Type of service to enumerate. Possible values:
2770        *  - SVCCTL_TYPE_WIN32
2771        *  - SVCCTL_TYPE_DRIVER
2772        *  If this is 0, (SVCCTL_TYPE_DRIVER | SVCCTL_TYPE_WIN32) is assumed.
2773        */
2774       uint32 type;
2775
2776       /**(Optional)State of service to enumerate. Possible values:
2777        *  - SVCCTL_STATE_ACTIVE
2778        *  - SVCCTL_STATE_INACTIVE
2779        *  - SVCCTL_STATE_ALL
2780        *  If this is 0, SVCCTL_STATE_ALL is assumed.
2781        */
2782       uint32 state;
2783    } in;
2784    
2785    struct {
2786       /**Number of services returned*/
2787       uint32 num_services;
2788
2789       /**Array of service structures*/
2790       CacService *services;
2791    } out;
2792 };
2793
2794 /**
2795  * Enumerates services on the remote machine.
2796  * @param hnd Initialized and connected server handle
2797  * @param mem_ctx Context for memory allocation
2798  * @param op Initialized parameters
2799  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2800  * @return CAC_SUCCESS - the operation was successful
2801  */
2802 int cac_SvcEnumServices(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcEnumServices *op);
2803
2804 struct SvcOpenService {
2805    struct {
2806       /**Handle to the Service Control Manager*/
2807       POLICY_HND *scm_hnd;
2808
2809       /**Access mask to open service with see SERVICE_* or SC_RIGHT_SVC_* in include/rpc_secdes.h*/
2810       uint32 access;
2811
2812       /**The name of the service. _not_ the display name*/
2813       char *name;
2814    } in;
2815
2816    struct {
2817       /**Handle to the open service*/
2818       POLICY_HND *svc_hnd;
2819    } out;
2820 };
2821
2822 /**
2823  * Opens a handle to a service.
2824  * @param hnd Initialized and connected server handle
2825  * @param mem_ctx Context for memory allocation
2826  * @param op Initialized Parameters
2827  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2828  * @return CAC_SUCCESS - the operation was successful
2829  */
2830
2831 int cac_SvcOpenService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcOpenService *op);
2832
2833 struct SvcGetStatus {
2834    struct {
2835       /**Open handle to the service to query*/
2836       POLICY_HND *svc_hnd;
2837    } in;
2838
2839    struct {
2840       /**The status of the service. See include/rpc_svcctl.h for SERVICE_STATUS definition.*/
2841       SERVICE_STATUS status;
2842    } out;
2843 };
2844
2845 /**
2846  * Retrieves the status of a service.
2847  * @param hnd Initialized and connected server handle
2848  * @param mem_ctx Context for memory allocation
2849  * @param op Initialized Parameters
2850  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2851  * @return CAC_SUCCESS - the operation was successful
2852  */
2853 int cac_SvcGetStatus(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcGetStatus *op);
2854
2855 struct SvcStartService {
2856    struct {
2857       /**open handle to the service*/
2858       POLICY_HND *svc_hnd;
2859
2860       /**Array of parameters to start the service with. Can be NULL if num_parms is 0*/
2861       char **parms;
2862
2863       /**Number of parameters in the parms array*/
2864       uint32 num_parms;
2865
2866       /**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*/
2867       uint32 timeout;
2868    } in;
2869 };
2870
2871 /**
2872  * Attempts to start a service.
2873  * @param hnd Initialized and connected server handle
2874  * @param mem_ctx Context for memory allocation
2875  * @param op Initialized Parameters
2876  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2877  * @return CAC_SUCCESS - the operation was successful
2878  */
2879
2880 int cac_SvcStartService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcStartService *op);
2881
2882 struct SvcControlService {
2883    struct {
2884       /**Open handle to the service to control*/
2885       POLICY_HND *svc_hnd;
2886
2887       /**The control operation to perform. Possible values (from include/rpc_svcctl.h):
2888        * - SVCCTL_CONTROL_STOP
2889        * - SVCCTL_CONTROL_PAUSE
2890        * - SVCCTL_CONTROL_CONTINUE
2891        * - SVCCTL_CONTROL_SHUTDOWN
2892        */
2893       uint32 control;
2894    } in;
2895
2896    struct {
2897       /**The returned status of the service, _immediately_ after the call*/
2898       SERVICE_STATUS *status;
2899    } out;
2900 };
2901
2902 /**
2903  * Performs a control operation on a service and _immediately_ returns.
2904  * @see cac_SvcStopService()
2905  * @see cac_SvcPauseService()
2906  * @see cac_SvcContinueService()
2907  * @see cac_SvcShutdownService()
2908  * @param hnd Initialized and connected server handle
2909  * @param mem_ctx Context for memory allocation
2910  * @param op Initialized Parameters
2911  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
2912  * @return CAC_SUCCESS - the operation was successful
2913  */
2914 int cac_SvcControlService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcControlService *op);
2915
2916 struct SvcStopService {
2917    struct {
2918       /**Open handle to the service*/
2919       POLICY_HND *svc_hnd;
2920
2921       /**Number of seconds to wait for the service to actually start. 
2922        * 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
2923        */
2924       uint32 timeout;
2925    } in;
2926
2927    struct {
2928       /**Status of the service after the operation*/
2929       SERVICE_STATUS status;
2930    } out;
2931 };
2932
2933 /**
2934  * Attempts to stop a service.
2935  * @see cacSvcControlService()
2936  * @param hnd Initialized and connected server handle
2937  * @param mem_ctx Context for memory allocation
2938  * @param op Initialized Parameters
2939  * @return CAC_FAILURE - the operation was not successful. If hnd->status is NT_STATUS_OK, then a timeout occured.
2940  * @return CAC_SUCCESS - the operation was successful
2941  */
2942 int cac_SvcStopService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcStopService *op);
2943
2944 struct SvcPauseService {
2945    struct {
2946       /**Open handle to the service*/
2947       POLICY_HND *svc_hnd;
2948
2949       /**Number of seconds to wait for the service to actually start. 
2950        * 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
2951        */
2952       uint32 timeout;
2953    } in;
2954
2955    struct {
2956       /**Status of the service after the operation*/
2957       SERVICE_STATUS status;
2958    } out;
2959 };
2960
2961 /**
2962  * Attempts to pause a service.
2963  * @see cacSvcControlService()
2964  * @param hnd Initialized and connected server handle
2965  * @param mem_ctx Context for memory allocation
2966  * @param op Initialized Parameters
2967  * @return CAC_FAILURE - the operation was not successful. If hnd->status is NT_STATUS_OK, then a timeout occured.
2968  * @return CAC_SUCCESS - the operation was successful
2969  */
2970 int cac_SvcPauseService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcPauseService *op);
2971
2972 struct SvcContinueService {
2973    struct {
2974       /**Open handle to the service*/
2975       POLICY_HND *svc_hnd;
2976
2977       /**Number of seconds to wait for the service to actually start. 
2978        * 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
2979        */
2980       uint32 timeout;
2981    } in;
2982
2983    struct {
2984       /**Status of the service after the operation*/
2985       SERVICE_STATUS status;
2986    } out;
2987 };
2988
2989 /**
2990  * Attempts to continue a paused service.
2991  * @see cacSvcControlService()
2992  * @param hnd Initialized and connected server handle
2993  * @param mem_ctx Context for memory allocation
2994  * @param op Initialized Parameters
2995  * @return CAC_FAILURE - the operation was not successful. If hnd->status is NT_STATUS_OK, then a timeout occured.
2996  * @return CAC_SUCCESS - the operation was successful
2997  */
2998 int cac_SvcContinueService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcContinueService *op);
2999
3000 struct SvcGetDisplayName {
3001    struct {
3002       /**Open handle to the service*/
3003       POLICY_HND *svc_hnd;
3004    } in;
3005
3006    struct {
3007       /**The returned display name of the service*/
3008       char *display_name;
3009    } out;
3010 };
3011
3012 /**
3013  * Retrieves the display name of a service _not currently working_
3014  * @param hnd Initialized and connected server handle
3015  * @param mem_ctx Context for memory allocation
3016  * @param op Initialized Parameters
3017  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
3018  * @return CAC_SUCCESS - the operation was successful
3019  */
3020 int cac_SvcGetDisplayName(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcGetDisplayName *op);
3021
3022 struct SvcGetServiceConfig {
3023    struct {
3024       /**Open handle to the service*/
3025       POLICY_HND *svc_hnd;
3026    } in;
3027
3028    struct {
3029       /**Returned Configuration information*/
3030       CacServiceConfig config;
3031    } out;
3032 };
3033
3034 /**
3035  * Retrieves configuration information about a service.
3036  * @param hnd Initialized and connected server handle
3037  * @param mem_ctx Context for memory allocation
3038  * @param op Initialized Parameters
3039  * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
3040  * @return CAC_SUCCESS - the operation was successful
3041  */
3042 int cac_SvcGetServiceConfig(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcGetServiceConfig *op);
3043
3044 /**@}*/ /*SCM_Functions*/
3045
3046 struct rpc_pipe_client *cac_GetPipe(CacServerHandle *hnd, int pi_idx);
3047
3048 #endif /* LIBMSRPC_H */
3049
3050