sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-01-26 10:04:02 +03:00
Code

* got rid of UNISTR2 and everything that depends on it

Browse Source 
* removed a bunch of code that needs to be rewritten using the new
    interfaces
This commit is contained in:
Andrew Tridgell -
parent 829b87f30d
commit 9b02b486ef
15 changed files with 3 additions and 9592 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/Makefile.in
View File

@ -244,8 +244,6 @@ DEVEL_HELP_OBJ = modules/developer.o
GROUPDB_OBJ = groupdb/mapping.o
#PROFILE_OBJ = profile/profile.o
# OPLOCK_OBJ = smbd/oplock.o smbd/oplock_irix.o smbd/oplock_linux.o

223
source/auth/auth_util.c
View File

@ -862,228 +862,6 @@ NTSTATUS make_server_info_guest(auth_serversupplied_info **server_info)
return nt_status;
}
/***************************************************************************
Make a server_info struct from the info3 returned by a domain logon
***************************************************************************/
NTSTATUS make_server_info_info3(TALLOC_CTX *mem_ctx,
const char *internal_username,
const char *sent_nt_username,
const char *domain,
auth_serversupplied_info **server_info,
NET_USER_INFO_3 *info3)
{
NTSTATUS nt_status = NT_STATUS_OK;
const char *nt_domain;
const char *nt_username;
SAM_ACCOUNT *sam_account = NULL;
DOM_SID user_sid;
DOM_SID group_sid;
struct passwd *passwd;
uid_t uid;
gid_t gid;
int n_lgroupSIDs;
DOM_SID *lgroupSIDs = NULL;
gid_t *unix_groups = NULL;
NT_USER_TOKEN *token;
DOM_SID *all_group_SIDs;
size_t i;
/*
Here is where we should check the list of
trusted domains, and verify that the SID
matches.
*/
sid_copy(&user_sid, &info3->dom_sid.sid);
if (!sid_append_rid(&user_sid, info3->user_rid)) {
return NT_STATUS_INVALID_PARAMETER;
}
sid_copy(&group_sid, &info3->dom_sid.sid);
if (!sid_append_rid(&group_sid, info3->group_rid)) {
return NT_STATUS_INVALID_PARAMETER;
}
if (!(nt_username = unistr2_tdup(mem_ctx, &(info3->uni_user_name)))) {
/* If the server didn't give us one, just use the one we sent them */
nt_username = sent_nt_username;
}
if (!(nt_domain = unistr2_tdup(mem_ctx, &(info3->uni_logon_dom)))) {
/* If the server didn't give us one, just use the one we sent them */
domain = domain;
}
if (winbind_sid_to_uid(&uid, &user_sid)
&& winbind_sid_to_gid(&gid, &group_sid)
&& ((passwd = getpwuid_alloc(uid)))) {
nt_status = pdb_init_sam_pw(&sam_account, passwd);
passwd_free(&passwd);
} else {
char *dom_user;
dom_user = talloc_asprintf(mem_ctx, "%s%s%s",
nt_domain,
lp_winbind_separator(),
internal_username);
if (!dom_user) {
DEBUG(0, ("talloc_asprintf failed!\n"));
return NT_STATUS_NO_MEMORY;
} else {
if (!(passwd = Get_Pwnam(dom_user))
/* Only lookup local for the local
domain, we don't want this for
trusted domains */
&& strequal(nt_domain, lp_workgroup())) {
passwd = Get_Pwnam(internal_username);
}
if (!passwd) {
return NT_STATUS_NO_SUCH_USER;
} else {
nt_status = pdb_init_sam_pw(&sam_account, passwd);
}
}
}
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(0, ("make_server_info_info3: pdb_init_sam failed!\n"));
return nt_status;
}
if (!pdb_set_user_sid(sam_account, &user_sid, PDB_CHANGED)) {
pdb_free_sam(&sam_account);
return NT_STATUS_UNSUCCESSFUL;
}
if (!pdb_set_group_sid(sam_account, &group_sid, PDB_CHANGED)) {
pdb_free_sam(&sam_account);
return NT_STATUS_UNSUCCESSFUL;
}
if (!pdb_set_nt_username(sam_account, nt_username, PDB_CHANGED)) {
pdb_free_sam(&sam_account);
return NT_STATUS_NO_MEMORY;
}
if (!pdb_set_domain(sam_account, nt_domain, PDB_CHANGED)) {
pdb_free_sam(&sam_account);
return NT_STATUS_NO_MEMORY;
}
if (!pdb_set_fullname(sam_account, unistr2_static(mem_ctx, &(info3->uni_full_name)), PDB_CHANGED)) {
pdb_free_sam(&sam_account);
return NT_STATUS_NO_MEMORY;
}
if (!pdb_set_logon_script(sam_account, unistr2_static(mem_ctx, &(info3->uni_logon_script)), PDB_CHANGED)) {
pdb_free_sam(&sam_account);
return NT_STATUS_NO_MEMORY;
}
if (!pdb_set_profile_path(sam_account, unistr2_static(mem_ctx, &(info3->uni_profile_path)), PDB_CHANGED)) {
pdb_free_sam(&sam_account);
return NT_STATUS_NO_MEMORY;
}
if (!pdb_set_homedir(sam_account, unistr2_static(mem_ctx, &(info3->uni_home_dir)), PDB_CHANGED)) {
pdb_free_sam(&sam_account);
return NT_STATUS_NO_MEMORY;
}
if (!pdb_set_dir_drive(sam_account, unistr2_static(mem_ctx, &(info3->uni_dir_drive)), PDB_CHANGED)) {
pdb_free_sam(&sam_account);
return NT_STATUS_NO_MEMORY;
}
if (!NT_STATUS_IS_OK(nt_status = make_server_info(server_info, sam_account))) {
DEBUG(4, ("make_server_info failed!\n"));
pdb_free_sam(&sam_account);
return nt_status;
}
/* Store the user group information in the server_info
returned to the caller. */
if (!NT_STATUS_IS_OK(nt_status
= get_user_groups_from_local_sam(sam_account,
&n_lgroupSIDs,
&lgroupSIDs,
&unix_groups)))
{
DEBUG(4,("get_user_groups_from_local_sam failed\n"));
return nt_status;
}
(*server_info)->groups = unix_groups;
(*server_info)->n_groups = n_lgroupSIDs;
/* Create a 'combined' list of all SIDs we might want in the SD */
all_group_SIDs = malloc(sizeof(DOM_SID) *
(n_lgroupSIDs + info3->num_groups2 +
info3->num_other_sids));
if (!all_group_SIDs) {
DEBUG(0, ("create_nt_token_info3: malloc() failed for DOM_SID list!\n"));
SAFE_FREE(lgroupSIDs);
return NT_STATUS_NO_MEMORY;
}
/* Copy the 'local' sids */
memcpy(all_group_SIDs, lgroupSIDs, sizeof(DOM_SID) * n_lgroupSIDs);
SAFE_FREE(lgroupSIDs);
/* and create (by appending rids) the 'domain' sids */
for (i = 0; i < info3->num_groups2; i++) {
sid_copy(&all_group_SIDs[i+n_lgroupSIDs], &(info3->dom_sid.sid));
if (!sid_append_rid(&all_group_SIDs[i+n_lgroupSIDs], info3->gids[i].g_rid)) {
nt_status = NT_STATUS_INVALID_PARAMETER;
DEBUG(3,("create_nt_token_info3: could not append additional group rid 0x%x\n",
info3->gids[i].g_rid));
SAFE_FREE(lgroupSIDs);
return nt_status;
}
}
/* Copy 'other' sids. We need to do sid filtering here to
prevent possible elevation of privileges. See:
http://www.microsoft.com/windows2000/techinfo/administration/security/sidfilter.asp
*/
for (i = 0; i < info3->num_other_sids; i++)
sid_copy(&all_group_SIDs[
n_lgroupSIDs + info3->num_groups2 + i],
&info3->other_sids[i].sid);
/* Where are the 'global' sids... */
/* can the user be guest? if yes, where is it stored? */
if (!NT_STATUS_IS_OK(
nt_status = create_nt_user_token(
&user_sid, &group_sid,
n_lgroupSIDs + info3->num_groups2 + info3->num_other_sids,
all_group_SIDs, False, &token))) {
DEBUG(4,("create_nt_user_token failed\n"));
SAFE_FREE(all_group_SIDs);
return nt_status;
}
(*server_info)->ptok = token;
SAFE_FREE(all_group_SIDs);
return NT_STATUS_OK;
}
/***************************************************************************
Free a user_info struct
***************************************************************************/
@ -1102,7 +880,6 @@ void free_user_info(auth_usersupplied_info **user_info)
SAFE_FREE((*user_info)->wksta_name.str);
data_blob_free(&(*user_info)->lm_resp);
data_blob_free(&(*user_info)->nt_resp);
SAFE_FREE((*user_info)->interactive_password);
data_blob_clear_free(&(*user_info)->plaintext_password);
ZERO_STRUCT(**user_info);
}

1340
source/groupdb/mapping.c
View File

File diff suppressed because it is too large Load Diff

7
source/include/auth.h
View File

@ -34,12 +34,6 @@ typedef struct unicode_string
uchar *unistr;
} AUTH_UNISTR;
typedef struct interactive_password
{
OWF_INFO lm_owf; /* LM OWF Password */
OWF_INFO nt_owf; /* NT OWF Password */
} auth_interactive_password;
#define AUTH_FLAG_NONE 0x000000
#define AUTH_FLAG_PLAINTEXT 0x000001
#define AUTH_FLAG_LM_RESP 0x000002
@ -51,7 +45,6 @@ typedef struct auth_usersupplied_info
DATA_BLOB lm_resp;
DATA_BLOB nt_resp;
auth_interactive_password * interactive_password;
DATA_BLOB plaintext_password;
BOOL encrypted;

1
source/include/mapping.h
View File

@ -50,7 +50,6 @@ typedef struct _GROUP_MAP {
fstring nt_name;
fstring comment;
uint32 systemaccount;
PRIVILEGE_SET priv_set;
} GROUP_MAP;
typedef struct _PRIVS {

289
source/include/rpc_dce.h
View File

@ -26,295 +26,6 @@
#include "rpc_misc.h" /* this only pulls in STRHDR */
/* DCE/RPC packet types */
enum RPC_PKT_TYPE
{
RPC_REQUEST = 0x00,
RPC_RESPONSE = 0x02,
RPC_FAULT = 0x03,
RPC_BIND = 0x0B,
RPC_BINDACK = 0x0C,
RPC_BINDNACK = 0x0D,
RPC_ALTCONT = 0x0E,
RPC_ALTCONTRESP = 0x0F,
RPC_BINDRESP = 0x10 /* not the real name! this is undocumented! */
};
/* DCE/RPC flags */
#define RPC_FLG_FIRST 0x01
#define RPC_FLG_LAST 0x02
#define RPC_FLG_NOCALL 0x20
#define SMBD_NTLMSSP_NEG_FLAGS 0x000082b1 /* ALWAYS_SIGN|NEG_NTLM|NEG_LM|NEG_SEAL|NEG_SIGN|NEG_UNICODE */
/* NTLMSSP signature version */
#define NTLMSSP_SIGN_VERSION 0x01
/* NTLMSSP auth type and level. */
#define NTLMSSP_AUTH_TYPE 0xa
#define NTLMSSP_AUTH_LEVEL 0x6
/* Maximum PDU fragment size. */
#define MAX_PDU_FRAG_LEN 0x1630
/* #define MAX_PDU_FRAG_LEN 0x10b8 this is what w2k sets */
/*
* Actual structure of a DCE UUID
*/
typedef struct rpc_uuid
{
uint32 time_low;
uint16 time_mid;
uint16 time_hi_and_version;
uint8 remaining[8];
} RPC_UUID;
#define RPC_UUID_LEN 16
/* RPC_IFACE */
typedef struct rpc_iface_info
{
RPC_UUID uuid; /* 16 bytes of rpc interface identification */
uint32 version; /* the interface version number */
} RPC_IFACE;
#define RPC_IFACE_LEN (RPC_UUID_LEN + 4)
struct pipe_id_info
{
/* the names appear not to matter: the syntaxes _do_ matter */
const char *client_pipe;
RPC_IFACE abstr_syntax; /* this one is the abstract syntax id */
const char *server_pipe; /* this one is the secondary syntax name */
RPC_IFACE trans_syntax; /* this one is the primary syntax id */
};
/* RPC_HDR - dce rpc header */
typedef struct rpc_hdr_info
{
uint8 major; /* 5 - RPC major version */
uint8 minor; /* 0 - RPC minor version */
uint8 pkt_type; /* RPC_PKT_TYPE - RPC response packet */
uint8 flags; /* DCE/RPC flags */
uint8 pack_type[4]; /* 0x1000 0000 - little-endian packed data representation */
uint16 frag_len; /* fragment length - data size (bytes) inc header and tail. */
uint16 auth_len; /* 0 - authentication length */
uint32 call_id; /* call identifier. matches 12th uint32 of incoming RPC data. */
} RPC_HDR;
#define RPC_HEADER_LEN 16
/* RPC_HDR_REQ - ms request rpc header */
typedef struct rpc_hdr_req_info
{
uint32 alloc_hint; /* allocation hint - data size (bytes) minus header and tail. */
uint16 context_id; /* 0 - presentation context identifier */
uint16 opnum; /* opnum */
} RPC_HDR_REQ;
#define RPC_HDR_REQ_LEN 8
/* RPC_HDR_RESP - ms response rpc header */
typedef struct rpc_hdr_resp_info
{
uint32 alloc_hint; /* allocation hint - data size (bytes) minus header and tail. */
uint16 context_id; /* 0 - presentation context identifier */
uint8 cancel_count; /* 0 - cancel count */
uint8 reserved; /* 0 - reserved. */
} RPC_HDR_RESP;
#define RPC_HDR_RESP_LEN 8
/* RPC_HDR_FAULT - fault rpc header */
typedef struct rpc_hdr_fault_info
{
NTSTATUS status;
uint32 reserved; /* 0x0000 0000 */
} RPC_HDR_FAULT;
#define RPC_HDR_FAULT_LEN 8
/* this seems to be the same string name depending on the name of the pipe,
* but is more likely to be linked to the interface name
* "srvsvc", "\\PIPE\\ntsvcs"
* "samr", "\\PIPE\\lsass"
* "wkssvc", "\\PIPE\\wksvcs"
* "NETLOGON", "\\PIPE\\NETLOGON"
*/
/* RPC_ADDR_STR */
typedef struct rpc_addr_info
{
uint16 len; /* length of the string including null terminator */
fstring str; /* the string above in single byte, null terminated form */
} RPC_ADDR_STR;
/* RPC_HDR_BBA */
typedef struct rpc_hdr_bba_info
{
uint16 max_tsize; /* maximum transmission fragment size (0x1630) */
uint16 max_rsize; /* max receive fragment size (0x1630) */
uint32 assoc_gid; /* associated group id (0x0) */
} RPC_HDR_BBA;
#define RPC_HDR_BBA_LEN 8
/* RPC_HDR_AUTHA */
typedef struct rpc_hdr_autha_info
{
uint16 max_tsize; /* maximum transmission fragment size (0x1630) */
uint16 max_rsize; /* max receive fragment size (0x1630) */
uint8 auth_type; /* 0x0a */
uint8 auth_level; /* 0x06 */
uint8 stub_type_len; /* don't know */
uint8 padding; /* padding */
uint32 unknown; /* 0x0014a0c0 */
} RPC_HDR_AUTHA;
#define RPC_HDR_AUTHA_LEN 12
/* RPC_HDR_AUTH */
typedef struct rpc_hdr_auth_info
{
uint8 auth_type; /* 0x0a */
uint8 auth_level; /* 0x06 */
uint8 stub_type_len; /* don't know */
uint8 padding; /* padding */
uint32 unknown; /* pointer */
} RPC_HDR_AUTH;
#define RPC_HDR_AUTH_LEN 8
/* RPC_BIND_REQ - ms req bind */
typedef struct rpc_bind_req_info
{
RPC_HDR_BBA bba;
uint32 num_elements; /* the number of elements (0x1) */
uint16 context_id; /* presentation context identifier (0x0) */
uint8 num_syntaxes; /* the number of syntaxes (has always been 1?)(0x1) */
RPC_IFACE abstract; /* num and vers. of interface client is using */
RPC_IFACE transfer; /* num and vers. of interface to use for replies */
} RPC_HDR_RB;
/*
* The following length is 8 bytes RPC_HDR_BBA_LEN, 8 bytes internals
* (with 3 bytes padding), + 2 x RPC_IFACE_LEN bytes for RPC_IFACE structs.
*/
#define RPC_HDR_RB_LEN (RPC_HDR_BBA_LEN + 8 + (2*RPC_IFACE_LEN))
/* RPC_RESULTS - can only cope with one reason, right now... */
typedef struct rpc_results_info
{
/* uint8[] # 4-byte alignment padding, against SMB header */
uint8 num_results; /* the number of results (0x01) */
/* uint8[] # 4-byte alignment padding, against SMB header */
uint16 result; /* result (0x00 = accept) */
uint16 reason; /* reason (0x00 = no reason specified) */
} RPC_RESULTS;
/* RPC_HDR_BA */
typedef struct rpc_hdr_ba_info
{
RPC_HDR_BBA bba;
RPC_ADDR_STR addr ; /* the secondary address string, as described earlier */
RPC_RESULTS res ; /* results and reasons */
RPC_IFACE transfer; /* the transfer syntax from the request */
} RPC_HDR_BA;
/* RPC_AUTH_VERIFIER */
typedef struct rpc_auth_verif_info
{
fstring signature; /* "NTLMSSP" */
uint32 msg_type; /* NTLMSSP_MESSAGE_TYPE (1,2,3) */
} RPC_AUTH_VERIFIER;
/* this is TEMPORARILY coded up as a specific structure */
/* this structure comes after the bind request */
/* RPC_AUTH_NTLMSSP_NEG */
typedef struct rpc_auth_ntlmssp_neg_info
{
uint32 neg_flgs; /* 0x0000 b2b3 */
STRHDR hdr_myname; /* offset is against START of this structure */
STRHDR hdr_domain; /* offset is against START of this structure */
fstring myname; /* calling workstation's name */
fstring domain; /* calling workstations's domain */
} RPC_AUTH_NTLMSSP_NEG;
/* this is TEMPORARILY coded up as a specific structure */
/* this structure comes after the bind acknowledgement */
/* RPC_AUTH_NTLMSSP_CHAL */
typedef struct rpc_auth_ntlmssp_chal_info
{
uint32 unknown_1; /* 0x0000 0000 */
uint32 unknown_2; /* 0x0000 0028 */
uint32 neg_flags; /* 0x0000 82b1 */
uint8 challenge[8]; /* ntlm challenge */
uint8 reserved [8]; /* zeros */
} RPC_AUTH_NTLMSSP_CHAL;
/* RPC_AUTH_NTLMSSP_RESP */
typedef struct rpc_auth_ntlmssp_resp_info
{
STRHDR hdr_lm_resp; /* 24 byte response */
STRHDR hdr_nt_resp; /* 24 byte response */
STRHDR hdr_domain;
STRHDR hdr_usr;
STRHDR hdr_wks;
STRHDR hdr_sess_key; /* NULL unless negotiated */
uint32 neg_flags; /* 0x0000 82b1 */
fstring sess_key;
fstring wks;
fstring user;
fstring domain;
fstring nt_resp;
fstring lm_resp;
} RPC_AUTH_NTLMSSP_RESP;
/* attached to the end of encrypted rpc requests and responses */
/* RPC_AUTH_NTLMSSP_CHK */
typedef struct rpc_auth_ntlmssp_chk_info
{
uint32 ver; /* 0x0000 0001 */
uint32 reserved;
uint32 crc32; /* checksum using 0xEDB8 8320 as a polynomial */
uint32 seq_num;
} RPC_AUTH_NTLMSSP_CHK;
#define RPC_AUTH_NTLMSSP_CHK_LEN 16
#endif /* _DCE_RPC_H */

599
source/include/rpc_lsa.h
View File

@ -78,37 +78,6 @@
/* XXXX these are here to get a compile! */
#define LSA_LOOKUPRIDS 0xFD
/* DOM_QUERY - info class 3 and 5 LSA Query response */
typedef struct dom_query_info
{
uint16 uni_dom_max_len; /* domain name string length * 2 */
uint16 uni_dom_str_len; /* domain name string length * 2 */
uint32 buffer_dom_name; /* undocumented domain name string buffer pointer */
uint32 buffer_dom_sid; /* undocumented domain SID string buffer pointer */
UNISTR2 uni_domain_name; /* domain name (unicode string) */
DOM_SID2 dom_sid; /* domain SID */
} DOM_QUERY;
/* level 5 is same as level 3. */
typedef DOM_QUERY DOM_QUERY_3;
typedef DOM_QUERY DOM_QUERY_5;
/* level 2 is auditing settings */
typedef struct dom_query_2
{
uint32 auditing_enabled;
uint32 count1; /* usualy 7, at least on nt4sp4 */
uint32 count2; /* the same */
uint32 *auditsettings;
} DOM_QUERY_2;
/* level 6 is server role information */
typedef struct dom_query_6
{
uint16 server_role; /* 2=backup, 3=primary */
} DOM_QUERY_6;
typedef struct seq_qos_info
{
uint32 len; /* 12 */
@ -141,34 +110,6 @@ typedef struct lsa_q_open_pol_info
} LSA_Q_OPEN_POL;
/* LSA_R_OPEN_POL - response to LSA Open Policy */
typedef struct lsa_r_open_pol_info
{
POLICY_HND pol; /* policy handle */
NTSTATUS status; /* return code */
} LSA_R_OPEN_POL;
/* LSA_Q_OPEN_POL2 - LSA Query Open Policy */
typedef struct lsa_q_open_pol2_info
{
uint32 ptr; /* undocumented buffer pointer */
UNISTR2 uni_server_name; /* server name, starting with two '\'s */
LSA_OBJ_ATTR attr ; /* object attributes */
uint32 des_access; /* desired access attributes */
} LSA_Q_OPEN_POL2;
/* LSA_R_OPEN_POL2 - response to LSA Open Policy */
typedef struct lsa_r_open_pol2_info
{
POLICY_HND pol; /* policy handle */
NTSTATUS status; /* return code */
} LSA_R_OPEN_POL2;
#define POLICY_VIEW_LOCAL_INFORMATION 0x00000001
#define POLICY_VIEW_AUDIT_INFORMATION 0x00000002
#define POLICY_GET_PRIVATE_INFORMATION 0x00000004
@ -215,546 +156,6 @@ typedef struct lsa_r_open_pol2_info
POLICY_VIEW_LOCAL_INFORMATION |\
POLICY_LOOKUP_NAMES )
/* LSA_Q_QUERY_SEC_OBJ - LSA query security */
typedef struct lsa_query_sec_obj_info
{
POLICY_HND pol; /* policy handle */
uint32 sec_info;
} LSA_Q_QUERY_SEC_OBJ;
/* LSA_R_QUERY_SEC_OBJ - probably an open */
typedef struct r_lsa_query_sec_obj_info
{
uint32 ptr;
SEC_DESC_BUF *buf;
NTSTATUS status; /* return status */
} LSA_R_QUERY_SEC_OBJ;
/* LSA_Q_QUERY_INFO - LSA query info policy */
typedef struct lsa_query_info
{
POLICY_HND pol; /* policy handle */
uint16 info_class; /* info class */
} LSA_Q_QUERY_INFO;
/* LSA_INFO_UNION */
typedef union lsa_info_union
{
DOM_QUERY_2 id2;
DOM_QUERY_3 id3;
DOM_QUERY_5 id5;
DOM_QUERY_6 id6;
} LSA_INFO_UNION;
/* LSA_R_QUERY_INFO - response to LSA query info policy */
typedef struct lsa_r_query_info
{
uint32 undoc_buffer; /* undocumented buffer pointer */
uint16 info_class; /* info class (same as info class in request) */
LSA_INFO_UNION dom;
NTSTATUS status; /* return code */
} LSA_R_QUERY_INFO;
/* LSA_DNS_DOM_INFO - DNS domain info - info class 12*/
typedef struct lsa_dns_dom_info
{
UNIHDR hdr_nb_dom_name; /* netbios domain name */
UNIHDR hdr_dns_dom_name;
UNIHDR hdr_forest_name;
GUID dom_guid; /* domain GUID */
UNISTR2 uni_nb_dom_name;
UNISTR2 uni_dns_dom_name;
UNISTR2 uni_forest_name;
uint32 ptr_dom_sid;
DOM_SID2 dom_sid; /* domain SID */
} LSA_DNS_DOM_INFO;
typedef union lsa_info2_union
{
LSA_DNS_DOM_INFO dns_dom_info;
} LSA_INFO2_UNION;
/* LSA_Q_QUERY_INFO2 - LSA query info */
typedef struct lsa_q_query_info2
{
POLICY_HND pol; /* policy handle */
uint16 info_class; /* info class */
} LSA_Q_QUERY_INFO2;
typedef struct lsa_r_query_info2
{
uint32 ptr; /* pointer to info struct */
uint16 info_class;
LSA_INFO2_UNION info; /* so far the only one */
NTSTATUS status;
} LSA_R_QUERY_INFO2;
/* LSA_Q_ENUM_TRUST_DOM - LSA enumerate trusted domains */
typedef struct lsa_enum_trust_dom_info
{
POLICY_HND pol; /* policy handle */
uint32 enum_context; /* enumeration context handle */
uint32 preferred_len; /* preferred maximum length */
} LSA_Q_ENUM_TRUST_DOM;
/* LSA_R_ENUM_TRUST_DOM - response to LSA enumerate trusted domains */
typedef struct lsa_r_enum_trust_dom_info
{
uint32 enum_context; /* enumeration context handle */
uint32 num_domains; /* number of domains */
uint32 ptr_enum_domains; /* buffer pointer to num domains */
/* this lot is only added if ptr_enum_domains is non-NULL */
uint32 num_domains2; /* number of domains */
UNIHDR2 *hdr_domain_name;
UNISTR2 *uni_domain_name;
DOM_SID2 *domain_sid;
NTSTATUS status; /* return code */
} LSA_R_ENUM_TRUST_DOM;
/* LSA_Q_CLOSE */
typedef struct lsa_q_close_info
{
POLICY_HND pol; /* policy handle */
} LSA_Q_CLOSE;
/* LSA_R_CLOSE */
typedef struct lsa_r_close_info
{
POLICY_HND pol; /* policy handle. should be all zeros. */
NTSTATUS status; /* return code */
} LSA_R_CLOSE;
#define MAX_REF_DOMAINS 32
/* DOM_TRUST_HDR */
typedef struct dom_trust_hdr
{
UNIHDR hdr_dom_name; /* referenced domain unicode string headers */
uint32 ptr_dom_sid;
} DOM_TRUST_HDR;
/* DOM_TRUST_INFO */
typedef struct dom_trust_info
{
UNISTR2 uni_dom_name; /* domain name unicode string */
DOM_SID2 ref_dom ; /* referenced domain SID */
} DOM_TRUST_INFO;
/* DOM_R_REF */
typedef struct dom_ref_info
{
uint32 num_ref_doms_1; /* num referenced domains */
uint32 ptr_ref_dom; /* pointer to referenced domains */
uint32 max_entries; /* 32 - max number of entries */
uint32 num_ref_doms_2; /* num referenced domains */
DOM_TRUST_HDR hdr_ref_dom[MAX_REF_DOMAINS]; /* referenced domains */
DOM_TRUST_INFO ref_dom [MAX_REF_DOMAINS]; /* referenced domains */
} DOM_R_REF;
/* the domain_idx points to a SID associated with the name */
/* LSA_TRANS_NAME - translated name */
typedef struct lsa_trans_name_info
{
uint16 sid_name_use; /* value is 5 for a well-known group; 2 for a domain group; 1 for a user... */
UNIHDR hdr_name;
uint32 domain_idx; /* index into DOM_R_REF array of SIDs */
} LSA_TRANS_NAME;
/* This number purly arbitary - just to prevent a client from requesting large amounts of memory */
#define MAX_LOOKUP_SIDS 256
/* LSA_TRANS_NAME_ENUM - LSA Translated Name Enumeration container */
typedef struct lsa_trans_name_enum_info
{
uint32 num_entries;
uint32 ptr_trans_names;
uint32 num_entries2;
LSA_TRANS_NAME *name; /* translated names */
UNISTR2 *uni_name;
} LSA_TRANS_NAME_ENUM;
/* LSA_SID_ENUM - LSA SID enumeration container */
typedef struct lsa_sid_enum_info
{
uint32 num_entries;
uint32 ptr_sid_enum;
uint32 num_entries2;
uint32 *ptr_sid; /* domain SID pointers to be looked up. */
DOM_SID2 *sid; /* domain SIDs to be looked up. */
} LSA_SID_ENUM;
/* LSA_Q_LOOKUP_SIDS - LSA Lookup SIDs */
typedef struct lsa_q_lookup_sids
{
POLICY_HND pol; /* policy handle */
LSA_SID_ENUM sids;
LSA_TRANS_NAME_ENUM names;
LOOKUP_LEVEL level;
uint32 mapped_count;
} LSA_Q_LOOKUP_SIDS;
/* LSA_R_LOOKUP_SIDS - response to LSA Lookup SIDs */
typedef struct lsa_r_lookup_sids
{
uint32 ptr_dom_ref;
DOM_R_REF *dom_ref; /* domain reference info */
LSA_TRANS_NAME_ENUM *names;
uint32 mapped_count;
NTSTATUS status; /* return code */
} LSA_R_LOOKUP_SIDS;
/* LSA_Q_LOOKUP_NAMES - LSA Lookup NAMEs */
typedef struct lsa_q_lookup_names
{
POLICY_HND pol; /* policy handle */
uint32 num_entries;
uint32 num_entries2;
UNIHDR *hdr_name; /* name buffer pointers */
UNISTR2 *uni_name; /* names to be looked up */
uint32 num_trans_entries;
uint32 ptr_trans_sids; /* undocumented domain SID buffer pointer */
uint32 lookup_level;
uint32 mapped_count;
} LSA_Q_LOOKUP_NAMES;
/* LSA_R_LOOKUP_NAMES - response to LSA Lookup NAMEs by name */
typedef struct lsa_r_lookup_names
{
uint32 ptr_dom_ref;
DOM_R_REF *dom_ref; /* domain reference info */
uint32 num_entries;
uint32 ptr_entries;
uint32 num_entries2;
DOM_RID2 *dom_rid; /* domain RIDs being looked up */
uint32 mapped_count;
NTSTATUS status; /* return code */
} LSA_R_LOOKUP_NAMES;
/* This is probably a policy handle but at the moment we
never read it - so use a dummy struct. */
typedef struct lsa_q_open_secret
{
uint32 dummy;
} LSA_Q_OPEN_SECRET;
/* We always return "not found" at present - so just marshal the minimum. */
typedef struct lsa_r_open_secret
{
uint32 dummy1;
uint32 dummy2;
uint32 dummy3;
uint32 dummy4;
NTSTATUS status;
} LSA_R_OPEN_SECRET;
typedef struct lsa_enum_priv_entry
{
UNIHDR hdr_name;
uint32 luid_low;
uint32 luid_high;
UNISTR2 name;
} LSA_PRIV_ENTRY;
/* LSA_Q_ENUM_PRIVS - LSA enum privileges */
typedef struct lsa_q_enum_privs
{
POLICY_HND pol; /* policy handle */
uint32 enum_context;
uint32 pref_max_length;
} LSA_Q_ENUM_PRIVS;
typedef struct lsa_r_enum_privs
{
uint32 enum_context;
uint32 count;
uint32 ptr;
uint32 count1;
LSA_PRIV_ENTRY *privs;
NTSTATUS status;
} LSA_R_ENUM_PRIVS;
/* LSA_Q_ENUM_ACCT_RIGHTS - LSA enum account rights */
typedef struct
{
POLICY_HND pol; /* policy handle */
DOM_SID2 sid;
} LSA_Q_ENUM_ACCT_RIGHTS;
/* LSA_R_ENUM_ACCT_RIGHTS - LSA enum account rights */
typedef struct
{
uint32 count;
UNISTR2_ARRAY rights;
NTSTATUS status;
} LSA_R_ENUM_ACCT_RIGHTS;
/* LSA_Q_ADD_ACCT_RIGHTS - LSA add account rights */
typedef struct
{
POLICY_HND pol; /* policy handle */
DOM_SID2 sid;
UNISTR2_ARRAY rights;
} LSA_Q_ADD_ACCT_RIGHTS;
/* LSA_R_ADD_ACCT_RIGHTS - LSA add account rights */
typedef struct
{
NTSTATUS status;
} LSA_R_ADD_ACCT_RIGHTS;
/* LSA_Q_REMOVE_ACCT_RIGHTS - LSA remove account rights */
typedef struct
{
POLICY_HND pol; /* policy handle */
DOM_SID2 sid;
uint32 removeall;
UNISTR2_ARRAY rights;
} LSA_Q_REMOVE_ACCT_RIGHTS;
/* LSA_R_REMOVE_ACCT_RIGHTS - LSA remove account rights */
typedef struct
{
NTSTATUS status;
} LSA_R_REMOVE_ACCT_RIGHTS;
/* LSA_Q_ENUM_ACCT_WITH_RIGHT - LSA enum accounts with right */
typedef struct
{
POLICY_HND pol;
STRHDR right_hdr;
UNISTR2 right;
} LSA_Q_ENUM_ACCT_WITH_RIGHT;
/* LSA_R_ENUM_ACCT_WITH_RIGHT - LSA enum accounts with right */
typedef struct
{
uint32 count;
SID_ARRAY sids;
NTSTATUS status;
} LSA_R_ENUM_ACCT_WITH_RIGHT;
/* LSA_Q_PRIV_GET_DISPNAME - LSA get privilege display name */
typedef struct lsa_q_priv_get_dispname
{
POLICY_HND pol; /* policy handle */
UNIHDR hdr_name;
UNISTR2 name;
uint16 lang_id;
uint16 lang_id_sys;
} LSA_Q_PRIV_GET_DISPNAME;
typedef struct lsa_r_priv_get_dispname
{
uint32 ptr_info;
UNIHDR hdr_desc;
UNISTR2 desc;
/* Don't align ! */
uint16 lang_id;
/* align */
NTSTATUS status;
} LSA_R_PRIV_GET_DISPNAME;
/* LSA_Q_ENUM_ACCOUNTS */
typedef struct lsa_q_enum_accounts
{
POLICY_HND pol; /* policy handle */
uint32 enum_context;
uint32 pref_max_length;
} LSA_Q_ENUM_ACCOUNTS;
/* LSA_R_ENUM_ACCOUNTS */
typedef struct lsa_r_enum_accounts
{
uint32 enum_context;
LSA_SID_ENUM sids;
NTSTATUS status;
} LSA_R_ENUM_ACCOUNTS;
/* LSA_Q_UNK_GET_CONNUSER - gets username\domain of connected user
called when "Take Ownership" is clicked -SK */
typedef struct lsa_q_unk_get_connuser
{
uint32 ptr_srvname;
UNISTR2 uni2_srvname;
uint32 unk1; /* 3 unknown uint32's are seen right after uni2_srvname */
uint32 unk2; /* unk2 appears to be a ptr, unk1 = unk3 = 0 usually */
uint32 unk3;
} LSA_Q_UNK_GET_CONNUSER;
/* LSA_R_UNK_GET_CONNUSER */
typedef struct lsa_r_unk_get_connuser
{
uint32 ptr_user_name;
UNIHDR hdr_user_name;
UNISTR2 uni2_user_name;
uint32 unk1;
uint32 ptr_dom_name;
UNIHDR hdr_dom_name;
UNISTR2 uni2_dom_name;
NTSTATUS status;
} LSA_R_UNK_GET_CONNUSER;
typedef struct lsa_q_openaccount
{
POLICY_HND pol; /* policy handle */
DOM_SID2 sid;
uint32 access; /* desired access */
} LSA_Q_OPENACCOUNT;
typedef struct lsa_r_openaccount
{
POLICY_HND pol; /* policy handle */
NTSTATUS status;
} LSA_R_OPENACCOUNT;
typedef struct lsa_q_enumprivsaccount
{
POLICY_HND pol; /* policy handle */
} LSA_Q_ENUMPRIVSACCOUNT;
typedef struct LUID
{
uint32 low;
uint32 high;
} LUID;
typedef struct LUID_ATTR
{
LUID luid;
uint32 attr;
} LUID_ATTR ;
typedef struct privilege_set
{
uint32 count;
uint32 control;
LUID_ATTR *set;
} PRIVILEGE_SET;
typedef struct lsa_r_enumprivsaccount
{
uint32 ptr;
uint32 count;
PRIVILEGE_SET set;
NTSTATUS status;
} LSA_R_ENUMPRIVSACCOUNT;
typedef struct lsa_q_getsystemaccount
{
POLICY_HND pol; /* policy handle */
} LSA_Q_GETSYSTEMACCOUNT;
typedef struct lsa_r_getsystemaccount
{
uint32 access;
NTSTATUS status;
} LSA_R_GETSYSTEMACCOUNT;
typedef struct lsa_q_setsystemaccount
{
POLICY_HND pol; /* policy handle */
uint32 access;
} LSA_Q_SETSYSTEMACCOUNT;
typedef struct lsa_r_setsystemaccount
{
NTSTATUS status;
} LSA_R_SETSYSTEMACCOUNT;
typedef struct lsa_q_lookupprivvalue
{
POLICY_HND pol; /* policy handle */
UNIHDR hdr_right;
UNISTR2 uni2_right;
} LSA_Q_LOOKUPPRIVVALUE;
typedef struct lsa_r_lookupprivvalue
{
LUID luid;
NTSTATUS status;
} LSA_R_LOOKUPPRIVVALUE;
typedef struct lsa_q_addprivs
{
POLICY_HND pol; /* policy handle */
uint32 count;
PRIVILEGE_SET set;
} LSA_Q_ADDPRIVS;
typedef struct lsa_r_addprivs
{
NTSTATUS status;
} LSA_R_ADDPRIVS;
typedef struct lsa_q_removeprivs
{
POLICY_HND pol; /* policy handle */
uint32 allrights;
uint32 ptr;
uint32 count;
PRIVILEGE_SET set;
} LSA_Q_REMOVEPRIVS;
typedef struct lsa_r_removeprivs
{
NTSTATUS status;
} LSA_R_REMOVEPRIVS;
#endif /* _RPC_LSA_H */

335
source/include/rpc_misc.h
View File

@ -80,21 +80,6 @@
#define USER_RID_TYPE 0
#define GROUP_RID_TYPE 1
/* ENUM_HND */
typedef struct enum_hnd_info
{
uint32 ptr_hnd; /* pointer to enumeration handle */
uint32 handle; /* enumeration handle */
} ENUM_HND;
/* LOOKUP_LEVEL - switch value */
typedef struct lookup_level_info
{
uint16 value;
} LOOKUP_LEVEL;
/* DOM_SID2 - security id */
typedef struct sid_info_2
{
@ -104,326 +89,6 @@ typedef struct sid_info_2
} DOM_SID2;
/* STRHDR - string header */
typedef struct header_info
{
uint16 str_str_len;
uint16 str_max_len;
uint32 buffer; /* non-zero */
} STRHDR;
/* UNIHDR - unicode string header */
typedef struct unihdr_info
{
uint16 uni_str_len;
uint16 uni_max_len;
uint32 buffer; /* usually has a value of 4 */
} UNIHDR;
/* UNIHDR2 - unicode string header and undocumented buffer */
typedef struct unihdr2_info
{
UNIHDR unihdr;
uint32 buffer; /* 32 bit buffer pointer */
} UNIHDR2;
/* clueless as to what maximum length should be */
#define MAX_UNISTRLEN 256
#define MAX_STRINGLEN 256
#define MAX_BUFFERLEN 512
/* UNISTR - unicode string size and buffer */
typedef struct unistr_info
{
/* unicode characters. ***MUST*** be little-endian. ***MUST*** be null-terminated */
uint16 *buffer;
} UNISTR;
/* BUFHDR - buffer header */
typedef struct bufhdr_info
{
uint32 buf_max_len;
uint32 buf_len;
} BUFHDR;
/* BUFFER2 - unicode string, size (in uint8 ascii chars) and buffer */
/* pathetic. some stupid team of \PIPE\winreg writers got the concept */
/* of a unicode string different from the other \PIPE\ writers */
typedef struct buffer2_info
{
uint32 buf_max_len;
uint32 undoc;
uint32 buf_len;
/* unicode characters. ***MUST*** be little-endian. **NOT** necessarily null-terminated */
uint16 *buffer;
} BUFFER2;
/* BUFFER3 */
typedef struct buffer3_info
{
uint32 buf_max_len;
uint8 *buffer; /* Data */
uint32 buf_len;
} BUFFER3;
/* BUFFER5 */
typedef struct buffer5_info
{
uint32 buf_len;
uint16 *buffer; /* data */
} BUFFER5;
/* UNISTR2 - unicode string size (in uint16 unicode chars) and buffer */
typedef struct unistr2_info
{
uint32 uni_max_len;
uint32 undoc;
uint32 uni_str_len;
/* unicode characters. ***MUST*** be little-endian.
**must** be null-terminated and the uni_str_len should include
the NULL character */
uint16 *buffer;
} UNISTR2;
/* STRING2 - string size (in uint8 chars) and buffer */
typedef struct string2_info
{
uint32 str_max_len;
uint32 undoc;
uint32 str_str_len;
uint8 *buffer; /* uint8 characters. **NOT** necessarily null-terminated */
} STRING2;
/* UNISTR3 - XXXX not sure about this structure */
typedef struct unistr3_info
{
uint32 uni_str_len;
UNISTR str;
} UNISTR3;
/* an element in a unicode string array */
typedef struct
{
uint16 length;
uint16 size;
uint32 ref_id;
UNISTR2 string;
} UNISTR2_ARRAY_EL;
/* an array of unicode strings */
typedef struct
{
uint32 ref_id;
uint32 count;
UNISTR2_ARRAY_EL *strings;
} UNISTR2_ARRAY;
/* an element in a sid array */
typedef struct
{
uint32 ref_id;
DOM_SID2 sid;
} SID_ARRAY_EL;
/* an array of sids */
typedef struct
{
uint32 ref_id;
uint32 count;
SID_ARRAY_EL *sids;
} SID_ARRAY;
/* DOM_RID2 - domain RID structure for ntlsa pipe */
typedef struct domrid2_info
{
uint8 type; /* value is SID_NAME_USE enum */
uint32 rid;
uint32 rid_idx; /* referenced domain index */
} DOM_RID2;
/* DOM_RID3 - domain RID structure for samr pipe */
typedef struct domrid3_info
{
uint32 rid; /* domain-relative (to a SID) id */
uint32 type1; /* value is 0x1 */
uint32 ptr_type; /* undocumented pointer */
uint32 type2; /* value is 0x1 */
uint32 unk; /* value is 0x2 */
} DOM_RID3;
/* DOM_RID4 - rid + user attributes */
typedef struct domrid4_info
{
uint32 unknown;
uint16 attr;
uint32 rid; /* user RID */
} DOM_RID4;
/* DOM_CLNT_SRV - client / server names */
typedef struct clnt_srv_info
{
uint32 undoc_buffer; /* undocumented 32 bit buffer pointer */
UNISTR2 uni_logon_srv; /* logon server name */
uint32 undoc_buffer2; /* undocumented 32 bit buffer pointer */
UNISTR2 uni_comp_name; /* client machine name */
} DOM_CLNT_SRV;
/* DOM_LOG_INFO - login info */
typedef struct log_info
{
uint32 undoc_buffer; /* undocumented 32 bit buffer pointer */
UNISTR2 uni_logon_srv; /* logon server name */
UNISTR2 uni_acct_name; /* account name */
uint16 sec_chan; /* secure channel type */
UNISTR2 uni_comp_name; /* client machine name */
} DOM_LOG_INFO;
/* DOM_CHAL - challenge info */
typedef struct chal_info
{
uchar data[8]; /* credentials */
} DOM_CHAL;
/* DOM_CREDs - timestamped client or server credentials */
typedef struct cred_info
{
DOM_CHAL challenge; /* credentials */
UTIME timestamp; /* credential time-stamp */
} DOM_CRED;
/* DOM_CLNT_INFO - client info */
typedef struct clnt_info
{
DOM_LOG_INFO login;
DOM_CRED cred;
} DOM_CLNT_INFO;
/* DOM_CLNT_INFO2 - client info */
typedef struct clnt_info2
{
DOM_CLNT_SRV login;
uint32 ptr_cred;
DOM_CRED cred;
} DOM_CLNT_INFO2;
/* DOM_LOGON_ID - logon id */
typedef struct logon_info
{
uint32 low;
uint32 high;
} DOM_LOGON_ID;
/* OWF INFO */
typedef struct owf_info
{
uint8 data[16];
} OWF_INFO;
/* DOM_GID - group id + user attributes */
typedef struct gid_info
{
uint32 g_rid; /* a group RID */
uint32 attr;
} DOM_GID;
/* POLICY_HND */
typedef struct lsa_policy_info
{
uint32 data1;
uint32 data2;
uint16 data3;
uint16 data4;
uint8 data5[8];
#ifdef __INSURE__
/* To prevent the leakage of policy handles mallocate a bit of
memory when a policy handle is created and free it when the
handle is closed. This should cause Insure to flag an error
when policy handles are overwritten or fall out of scope without
being freed. */
char *marker;
#endif
} POLICY_HND;
/*
* A client connection's state, pipe name,
* user credentials, etc...
*/
typedef struct _cli_auth_fns cli_auth_fns;
struct user_creds;
struct cli_connection {
char *srv_name;
char *pipe_name;
struct user_creds usr_creds;
struct cli_state *pCli_state;
cli_auth_fns *auth;
void *auth_info;
void *auth_creds;
};
/*
* Associate a POLICY_HND with a cli_connection
*/
typedef struct rpc_hnd_node {
POLICY_HND hnd;
struct cli_connection *cli;
} RPC_HND_NODE;
typedef struct uint64_s
{
uint32 low;
uint32 high;
} UINT64_S;
/* BUFHDR2 - another buffer header, with info level */
typedef struct bufhdr2_info
{
uint32 info_level;
uint32 length; /* uint8 chars */
uint32 buffer;
}
BUFHDR2;
/* BUFFER4 - simple length and buffer */
typedef struct buffer4_info
{
uint32 buf_len;
uint8 buffer[MAX_BUFFERLEN];
}
BUFFER4;
#endif /* _RPC_MISC_H */

838
source/include/rpc_netlogon.h
View File

@ -67,844 +67,6 @@
#define SAM_DATABASE_BUILTIN 0x01 /* BUILTIN users and groups */
#define SAM_DATABASE_PRIVS 0x02 /* Privileges */
#if 0
/* I think this is correct - it's what gets parsed on the wire. JRA. */
/* NET_USER_INFO_2 */
typedef struct net_user_info_2
{
uint32 ptr_user_info;
NTTIME logon_time; /* logon time */
NTTIME logoff_time; /* logoff time */
NTTIME kickoff_time; /* kickoff time */
NTTIME pass_last_set_time; /* password last set time */
NTTIME pass_can_change_time; /* password can change time */
NTTIME pass_must_change_time; /* password must change time */
UNIHDR hdr_user_name; /* username unicode string header */
UNIHDR hdr_full_name; /* user's full name unicode string header */
UNIHDR hdr_logon_script; /* logon script unicode string header */
UNIHDR hdr_profile_path; /* profile path unicode string header */
UNIHDR hdr_home_dir; /* home directory unicode string header */
UNIHDR hdr_dir_drive; /* home directory drive unicode string header */
uint16 logon_count; /* logon count */
uint16 bad_pw_count; /* bad password count */
uint32 user_id; /* User ID */
uint32 group_id; /* Group ID */
uint32 num_groups; /* num groups */
uint32 buffer_groups; /* undocumented buffer pointer to groups. */
uint32 user_flgs; /* user flags */
uint8 user_sess_key[16]; /* unused user session key */
UNIHDR hdr_logon_srv; /* logon server unicode string header */
UNIHDR hdr_logon_dom; /* logon domain unicode string header */
uint32 buffer_dom_id; /* undocumented logon domain id pointer */
uint8 padding[40]; /* unused padding bytes. expansion room */
UNISTR2 uni_user_name; /* username unicode string */
UNISTR2 uni_full_name; /* user's full name unicode string */
UNISTR2 uni_logon_script; /* logon script unicode string */
UNISTR2 uni_profile_path; /* profile path unicode string */
UNISTR2 uni_home_dir; /* home directory unicode string */
UNISTR2 uni_dir_drive; /* home directory drive unicode string */
uint32 num_groups2; /* num groups */
DOM_GID *gids; /* group info */
UNISTR2 uni_logon_srv; /* logon server unicode string */
UNISTR2 uni_logon_dom; /* logon domain unicode string */
DOM_SID2 dom_sid; /* domain SID */
uint32 num_other_groups; /* other groups */
DOM_GID *other_gids; /* group info */
DOM_SID2 *other_sids; /* undocumented - domain SIDs */
} NET_USER_INFO_2;
#endif
/* NET_USER_INFO_3 */
typedef struct net_user_info_3
{
uint32 ptr_user_info;
NTTIME logon_time; /* logon time */
NTTIME logoff_time; /* logoff time */
NTTIME kickoff_time; /* kickoff time */
NTTIME pass_last_set_time; /* password last set time */
NTTIME pass_can_change_time; /* password can change time */
NTTIME pass_must_change_time; /* password must change time */
UNIHDR hdr_user_name; /* username unicode string header */
UNIHDR hdr_full_name; /* user's full name unicode string header */
UNIHDR hdr_logon_script; /* logon script unicode string header */
UNIHDR hdr_profile_path; /* profile path unicode string header */
UNIHDR hdr_home_dir; /* home directory unicode string header */
UNIHDR hdr_dir_drive; /* home directory drive unicode string header */
uint16 logon_count; /* logon count */
uint16 bad_pw_count; /* bad password count */
uint32 user_rid; /* User RID */
uint32 group_rid; /* Group RID */
uint32 num_groups; /* num groups */
uint32 buffer_groups; /* undocumented buffer pointer to groups. */
uint32 user_flgs; /* user flags */
uint8 user_sess_key[16]; /* unused user session key */
UNIHDR hdr_logon_srv; /* logon server unicode string header */
UNIHDR hdr_logon_dom; /* logon domain unicode string header */
uint32 buffer_dom_id; /* undocumented logon domain id pointer */
uint8 padding[40]; /* unused padding bytes. expansion room */
uint32 num_other_sids; /* number of foreign/trusted domain sids */
uint32 buffer_other_sids;
UNISTR2 uni_user_name; /* username unicode string */
UNISTR2 uni_full_name; /* user's full name unicode string */
UNISTR2 uni_logon_script; /* logon script unicode string */
UNISTR2 uni_profile_path; /* profile path unicode string */
UNISTR2 uni_home_dir; /* home directory unicode string */
UNISTR2 uni_dir_drive; /* home directory drive unicode string */
uint32 num_groups2; /* num groups */
DOM_GID *gids; /* group info */
UNISTR2 uni_logon_srv; /* logon server unicode string */
UNISTR2 uni_logon_dom; /* logon domain unicode string */
DOM_SID2 dom_sid; /* domain SID */
uint32 num_other_groups; /* other groups */
DOM_GID *other_gids; /* group info */
DOM_SID2 *other_sids; /* foreign/trusted domain SIDs */
} NET_USER_INFO_3;
/* NETLOGON_INFO_1 - pdc status info, i presume */
typedef struct netlogon_1_info
{
uint32 flags; /* 0x0 - undocumented */
uint32 pdc_status; /* 0x0 - undocumented */
} NETLOGON_INFO_1;
/* NETLOGON_INFO_2 - pdc status info, plus trusted domain info */
typedef struct netlogon_2_info
{
uint32 flags; /* 0x0 - undocumented */
uint32 pdc_status; /* 0x0 - undocumented */
uint32 ptr_trusted_dc_name; /* pointer to trusted domain controller name */
uint32 tc_status; /* 0x051f - ERROR_NO_LOGON_SERVERS */
UNISTR2 uni_trusted_dc_name; /* unicode string - trusted dc name */
} NETLOGON_INFO_2;
/* NETLOGON_INFO_3 - logon status info, i presume */
typedef struct netlogon_3_info
{
uint32 flags; /* 0x0 - undocumented */
uint32 logon_attempts; /* number of logon attempts */
uint32 reserved_1; /* 0x0 - undocumented */
uint32 reserved_2; /* 0x0 - undocumented */
uint32 reserved_3; /* 0x0 - undocumented */
uint32 reserved_4; /* 0x0 - undocumented */
uint32 reserved_5; /* 0x0 - undocumented */
} NETLOGON_INFO_3;
/********************************************************
Logon Control Query
This is generated by a nltest /bdc_query:DOMAIN
query_level 0x1, function_code 0x1
********************************************************/
/* NET_Q_LOGON_CTRL - LSA Netr Logon Control */
typedef struct net_q_logon_ctrl_info
{
uint32 ptr;
UNISTR2 uni_server_name;
uint32 function_code;
uint32 query_level;
} NET_Q_LOGON_CTRL;
/* NET_R_LOGON_CTRL - LSA Netr Logon Control */
typedef struct net_r_logon_ctrl_info
{
uint32 switch_value;
uint32 ptr;
union {
NETLOGON_INFO_1 info1;
} logon;
NTSTATUS status;
} NET_R_LOGON_CTRL;
/********************************************************
Logon Control2 Query
query_level 0x1 - pdc status
query_level 0x3 - number of logon attempts.
********************************************************/
/* NET_Q_LOGON_CTRL2 - LSA Netr Logon Control 2 */
typedef struct net_q_logon_ctrl2_info
{
uint32 ptr; /* undocumented buffer pointer */
UNISTR2 uni_server_name; /* server name, starting with two '\'s */
uint32 function_code; /* 0x1 */
uint32 query_level; /* 0x1, 0x3 */
uint32 switch_value; /* 0x1 */
} NET_Q_LOGON_CTRL2;
/*******************************************************
Logon Control Response
switch_value is same as query_level in request
*******************************************************/
/* NET_R_LOGON_CTRL2 - response to LSA Logon Control2 */
typedef struct net_r_logon_ctrl2_info
{
uint32 switch_value; /* 0x1, 0x3 */
uint32 ptr;
union
{
NETLOGON_INFO_1 info1;
NETLOGON_INFO_2 info2;
NETLOGON_INFO_3 info3;
} logon;
NTSTATUS status; /* return code */
} NET_R_LOGON_CTRL2;
/* NET_Q_TRUST_DOM_LIST - LSA Query Trusted Domains */
typedef struct net_q_trust_dom_info
{
uint32 ptr; /* undocumented buffer pointer */
UNISTR2 uni_server_name; /* server name, starting with two '\'s */
} NET_Q_TRUST_DOM_LIST;
#define MAX_TRUST_DOMS 1
/* NET_R_TRUST_DOM_LIST - response to LSA Trusted Domains */
typedef struct net_r_trust_dom_info
{
UNISTR2 uni_trust_dom_name[MAX_TRUST_DOMS];
NTSTATUS status; /* return code */
} NET_R_TRUST_DOM_LIST;
/* NEG_FLAGS */
typedef struct neg_flags_info
{
uint32 neg_flags; /* negotiated flags */
} NEG_FLAGS;
/* NET_Q_REQ_CHAL */
typedef struct net_q_req_chal_info
{
uint32 undoc_buffer; /* undocumented buffer pointer */
UNISTR2 uni_logon_srv; /* logon server unicode string */
UNISTR2 uni_logon_clnt; /* logon client unicode string */
DOM_CHAL clnt_chal; /* client challenge */
} NET_Q_REQ_CHAL;
/* NET_R_REQ_CHAL */
typedef struct net_r_req_chal_info
{
DOM_CHAL srv_chal; /* server challenge */
NTSTATUS status; /* return code */
} NET_R_REQ_CHAL;
/* NET_Q_AUTH */
typedef struct net_q_auth_info
{
DOM_LOG_INFO clnt_id; /* client identification info */
DOM_CHAL clnt_chal; /* client-calculated credentials */
} NET_Q_AUTH;
/* NET_R_AUTH */
typedef struct net_r_auth_info
{
DOM_CHAL srv_chal; /* server-calculated credentials */
NTSTATUS status; /* return code */
} NET_R_AUTH;
/* NET_Q_AUTH_2 */
typedef struct net_q_auth2_info
{
DOM_LOG_INFO clnt_id; /* client identification info */
DOM_CHAL clnt_chal; /* client-calculated credentials */
NEG_FLAGS clnt_flgs; /* usually 0x0000 01ff */
} NET_Q_AUTH_2;
/* NET_R_AUTH_2 */
typedef struct net_r_auth2_info
{
DOM_CHAL srv_chal; /* server-calculated credentials */
NEG_FLAGS srv_flgs; /* usually 0x0000 01ff */
NTSTATUS status; /* return code */
} NET_R_AUTH_2;
/* NET_Q_AUTH_3 */
typedef struct net_q_auth3_info
{
DOM_LOG_INFO clnt_id; /* client identification info */
DOM_CHAL clnt_chal; /* client-calculated credentials */
NEG_FLAGS clnt_flgs; /* usually 0x6007 ffff */
} NET_Q_AUTH_3;
/* NET_R_AUTH_3 */
typedef struct net_r_auth3_info
{
DOM_CHAL srv_chal; /* server-calculated credentials */
NEG_FLAGS srv_flgs; /* usually 0x6007 ffff */
uint32 unknown; /* 0x0000045b */
NTSTATUS status; /* return code */
} NET_R_AUTH_3;
/* NET_Q_SRV_PWSET */
typedef struct net_q_srv_pwset_info
{
DOM_CLNT_INFO clnt_id; /* client identification/authentication info */
uint8 pwd[16]; /* new password - undocumented. */
} NET_Q_SRV_PWSET;
/* NET_R_SRV_PWSET */
typedef struct net_r_srv_pwset_info
{
DOM_CRED srv_cred; /* server-calculated credentials */
NTSTATUS status; /* return code */
} NET_R_SRV_PWSET;
/* NET_ID_INFO_2 */
typedef struct net_network_info_2
{
uint32 ptr_id_info2; /* pointer to id_info_2 */
UNIHDR hdr_domain_name; /* domain name unicode header */
uint32 param_ctrl; /* param control (0x2) */
DOM_LOGON_ID logon_id; /* logon ID */
UNIHDR hdr_user_name; /* user name unicode header */
UNIHDR hdr_wksta_name; /* workstation name unicode header */
uint8 lm_chal[8]; /* lan manager 8 byte challenge */
STRHDR hdr_nt_chal_resp; /* nt challenge response */
STRHDR hdr_lm_chal_resp; /* lm challenge response */
UNISTR2 uni_domain_name; /* domain name unicode string */
UNISTR2 uni_user_name; /* user name unicode string */
UNISTR2 uni_wksta_name; /* workgroup name unicode string */
STRING2 nt_chal_resp; /* nt challenge response */
STRING2 lm_chal_resp; /* lm challenge response */
} NET_ID_INFO_2;
/* NET_ID_INFO_1 */
typedef struct id_info_1
{
uint32 ptr_id_info1; /* pointer to id_info_1 */
UNIHDR hdr_domain_name; /* domain name unicode header */
uint32 param_ctrl; /* param control */
DOM_LOGON_ID logon_id; /* logon ID */
UNIHDR hdr_user_name; /* user name unicode header */
UNIHDR hdr_wksta_name; /* workstation name unicode header */
OWF_INFO lm_owf; /* LM OWF Password */
OWF_INFO nt_owf; /* NT OWF Password */
UNISTR2 uni_domain_name; /* domain name unicode string */
UNISTR2 uni_user_name; /* user name unicode string */
UNISTR2 uni_wksta_name; /* workgroup name unicode string */
} NET_ID_INFO_1;
#define INTERACTIVE_LOGON_TYPE 1
#define NET_LOGON_TYPE 2
/* NET_ID_INFO_CTR */
typedef struct net_id_info_ctr_info
{
uint16 switch_value;
union
{
NET_ID_INFO_1 id1; /* auth-level 1 - interactive user login */
NET_ID_INFO_2 id2; /* auth-level 2 - workstation referred login */
} auth;
} NET_ID_INFO_CTR;
/* SAM_INFO - sam logon/off id structure */
typedef struct sam_info
{
DOM_CLNT_INFO2 client;
uint32 ptr_rtn_cred; /* pointer to return credentials */
DOM_CRED rtn_cred; /* return credentials */
uint16 logon_level;
NET_ID_INFO_CTR *ctr;
} DOM_SAM_INFO;
/* NET_Q_SAM_LOGON */
typedef struct net_q_sam_logon_info
{
DOM_SAM_INFO sam_id;
uint16 validation_level;
} NET_Q_SAM_LOGON;
/* NET_R_SAM_LOGON */
typedef struct net_r_sam_logon_info
{
uint32 buffer_creds; /* undocumented buffer pointer */
DOM_CRED srv_creds; /* server credentials. server time stamp appears to be ignored. */
uint16 switch_value; /* 3 - indicates type of USER INFO */
NET_USER_INFO_3 *user;
uint32 auth_resp; /* 1 - Authoritative response; 0 - Non-Auth? */
NTSTATUS status; /* return code */
} NET_R_SAM_LOGON;
/* NET_Q_SAM_LOGOFF */
typedef struct net_q_sam_logoff_info
{
DOM_SAM_INFO sam_id;
} NET_Q_SAM_LOGOFF;
/* NET_R_SAM_LOGOFF */
typedef struct net_r_sam_logoff_info
{
uint32 buffer_creds; /* undocumented buffer pointer */
DOM_CRED srv_creds; /* server credentials. server time stamp appears to be ignored. */
NTSTATUS status; /* return code */
} NET_R_SAM_LOGOFF;
/* NET_Q_SAM_SYNC */
typedef struct net_q_sam_sync_info
{
UNISTR2 uni_srv_name; /* \\PDC */
UNISTR2 uni_cli_name; /* BDC */
DOM_CRED cli_creds;
DOM_CRED ret_creds;
uint32 database_id;
uint32 restart_state;
uint32 sync_context;
uint32 max_size; /* preferred maximum length */
} NET_Q_SAM_SYNC;
/* SAM_DELTA_HDR */
typedef struct sam_delta_hdr_info
{
uint16 type; /* type of structure attached */
uint16 type2;
uint32 target_rid;
uint32 type3;
uint32 ptr_delta;
} SAM_DELTA_HDR;
/* SAM_DOMAIN_INFO (0x1) */
typedef struct sam_domain_info_info
{
UNIHDR hdr_dom_name;
UNIHDR hdr_oem_info;
UINT64_S force_logoff;
uint16 min_pwd_len;
uint16 pwd_history_len;
UINT64_S max_pwd_age;
UINT64_S min_pwd_age;
UINT64_S dom_mod_count;
NTTIME creation_time;
BUFHDR2 hdr_sec_desc; /* security descriptor */
UNIHDR hdr_unknown;
uint8 reserved[40];
UNISTR2 uni_dom_name;
UNISTR2 buf_oem_info; /* never seen */
BUFFER4 buf_sec_desc;
UNISTR2 buf_unknown;
} SAM_DOMAIN_INFO;
/* SAM_GROUP_INFO (0x2) */
typedef struct sam_group_info_info
{
UNIHDR hdr_grp_name;
DOM_GID gid;
UNIHDR hdr_grp_desc;
BUFHDR2 hdr_sec_desc; /* security descriptor */
uint8 reserved[48];
UNISTR2 uni_grp_name;
UNISTR2 uni_grp_desc;
BUFFER4 buf_sec_desc;
} SAM_GROUP_INFO;
/* SAM_PWD */
typedef struct sam_passwd_info
{
/* this structure probably contains password history */
/* this is probably a count of lm/nt pairs */
uint32 unk_0; /* 0x0000 0002 */
UNIHDR hdr_lm_pwd;
uint8 buf_lm_pwd[16];
UNIHDR hdr_nt_pwd;
uint8 buf_nt_pwd[16];
UNIHDR hdr_empty_lm;
UNIHDR hdr_empty_nt;
} SAM_PWD;
/* SAM_ACCOUNT_INFO (0x5) */
typedef struct sam_account_info_info
{
UNIHDR hdr_acct_name;
UNIHDR hdr_full_name;
uint32 user_rid;
uint32 group_rid;
UNIHDR hdr_home_dir;
UNIHDR hdr_dir_drive;
UNIHDR hdr_logon_script;
UNIHDR hdr_acct_desc;
UNIHDR hdr_workstations;
NTTIME logon_time;
NTTIME logoff_time;
uint32 logon_divs; /* 0xA8 */
uint32 ptr_logon_hrs;
uint16 bad_pwd_count;
uint16 logon_count;
NTTIME pwd_last_set_time;
NTTIME acct_expiry_time;
uint32 acb_info;
uint8 nt_pwd[16];
uint8 lm_pwd[16];
uint8 nt_pwd_present;
uint8 lm_pwd_present;
uint8 pwd_expired;
UNIHDR hdr_comment;
UNIHDR hdr_parameters;
uint16 country;
uint16 codepage;
BUFHDR2 hdr_sec_desc; /* security descriptor */
UNIHDR hdr_profile;
UNIHDR hdr_reserved[3]; /* space for more strings */
uint32 dw_reserved[4]; /* space for more data - first two seem to
be an NTTIME */
UNISTR2 uni_acct_name;
UNISTR2 uni_full_name;
UNISTR2 uni_home_dir;
UNISTR2 uni_dir_drive;
UNISTR2 uni_logon_script;
UNISTR2 uni_acct_desc;
UNISTR2 uni_workstations;
uint32 unknown1; /* 0x4EC */
uint32 unknown2; /* 0 */
BUFFER4 buf_logon_hrs;
UNISTR2 uni_comment;
UNISTR2 uni_parameters;
SAM_PWD pass;
BUFFER4 buf_sec_desc;
UNISTR2 uni_profile;
} SAM_ACCOUNT_INFO;
/* SAM_GROUP_MEM_INFO (0x8) */
typedef struct sam_group_mem_info_info
{
uint32 ptr_rids;
uint32 ptr_attribs;
uint32 num_members;
uint8 unknown[16];
uint32 num_members2;
uint32 *rids;
uint32 num_members3;
uint32 *attribs;
} SAM_GROUP_MEM_INFO;
/* SAM_ALIAS_INFO (0x9) */
typedef struct sam_alias_info_info
{
UNIHDR hdr_als_name;
uint32 als_rid;
BUFHDR2 hdr_sec_desc; /* security descriptor */
UNIHDR hdr_als_desc;
uint8 reserved[40];
UNISTR2 uni_als_name;
BUFFER4 buf_sec_desc;
UNISTR2 uni_als_desc;
} SAM_ALIAS_INFO;
/* SAM_ALIAS_MEM_INFO (0xC) */
typedef struct sam_alias_mem_info_info
{
uint32 num_members;
uint32 ptr_members;
uint8 unknown[16];
uint32 num_sids;
uint32 *ptr_sids;
DOM_SID2 *sids;
} SAM_ALIAS_MEM_INFO;
/* SAM_DELTA_POLICY (0x0D) */
typedef struct
{
uint32 max_log_size; /* 0x5000 */
UINT64_S audit_retention_period; /* 0 */
uint32 auditing_mode; /* 0 */
uint32 num_events;
uint32 ptr_events;
UNIHDR hdr_dom_name;
uint32 sid_ptr;
uint32 paged_pool_limit; /* 0x02000000 */
uint32 non_paged_pool_limit; /* 0x00100000 */
uint32 min_workset_size; /* 0x00010000 */
uint32 max_workset_size; /* 0x0f000000 */
uint32 page_file_limit; /* 0 */
UINT64_S time_limit; /* 0 */
NTTIME modify_time; /* 0x3c*/
NTTIME create_time; /* a7080110 */
BUFHDR2 hdr_sec_desc;
uint32 num_event_audit_options;
uint32 event_audit_option;
UNISTR2 domain_name;
DOM_SID2 domain_sid;
BUFFER4 buf_sec_desc;
} SAM_DELTA_POLICY;
/* SAM_DELTA_TRUST_DOMS */
typedef struct
{
uint32 buf_size;
SEC_DESC *sec_desc;
DOM_SID2 sid;
UNIHDR hdr_domain;
uint32 unknown0;
uint32 unknown1;
uint32 unknown2;
uint32 buf_size2;
uint32 ptr;
uint32 unknown3;
UNISTR2 domain;
} SAM_DELTA_TRUSTDOMS;
/* SAM_DELTA_PRIVS (0x10) */
typedef struct
{
DOM_SID2 sid;
uint32 priv_count;
uint32 priv_control;
uint32 priv_attr_ptr;
uint32 priv_name_ptr;
uint32 paged_pool_limit; /* 0x02000000 */
uint32 non_paged_pool_limit; /* 0x00100000 */
uint32 min_workset_size; /* 0x00010000 */
uint32 max_workset_size; /* 0x0f000000 */
uint32 page_file_limit; /* 0 */
UINT64_S time_limit; /* 0 */
uint32 system_flags; /* 1 */
BUFHDR2 hdr_sec_desc;
uint32 buf_size2;
uint32 attribute_count;
uint32 *attributes;
uint32 privlist_count;
UNIHDR *hdr_privslist;
UNISTR2 *uni_privslist;
BUFFER4 buf_sec_desc;
} SAM_DELTA_PRIVS;
/* SAM_DELTA_SECRET */
typedef struct
{
uint32 buf_size;
SEC_DESC *sec_desc;
UNISTR2 secret;
uint32 count1;
uint32 count2;
uint32 ptr;
NTTIME time1;
uint32 count3;
uint32 count4;
uint32 ptr2;
NTTIME time2;
uint32 unknow1;
uint32 buf_size2;
uint32 ptr3;
uint32 unknow2; /* 0x0 12 times */
uint32 chal_len;
uint32 reserved1; /* 0 */
uint32 chal_len2;
uint8 chal[16];
uint32 key_len;
uint32 reserved2; /* 0 */
uint32 key_len2;
uint8 key[8];
uint32 buf_size3;
SEC_DESC *sec_desc2;
} SAM_DELTA_SECRET;
/* SAM_DELTA_MOD_COUNT (0x16) */
typedef struct
{
uint32 seqnum;
uint32 dom_mod_count_ptr;
UINT64_S dom_mod_count; /* domain mod count at last sync */
} SAM_DELTA_MOD_COUNT;
typedef union sam_delta_ctr_info
{
SAM_DOMAIN_INFO domain_info ;
SAM_GROUP_INFO group_info ;
SAM_ACCOUNT_INFO account_info;
SAM_GROUP_MEM_INFO grp_mem_info;
SAM_ALIAS_INFO alias_info ;
SAM_ALIAS_MEM_INFO als_mem_info;
SAM_DELTA_POLICY policy_info;
SAM_DELTA_PRIVS privs_info;
SAM_DELTA_MOD_COUNT mod_count;
SAM_DELTA_TRUSTDOMS trustdoms_info;
SAM_DELTA_SECRET secret_info;
} SAM_DELTA_CTR;
/* NET_R_SAM_SYNC */
typedef struct net_r_sam_sync_info
{
DOM_CRED srv_creds;
uint32 sync_context;
uint32 ptr_deltas;
uint32 num_deltas;
uint32 ptr_deltas2;
uint32 num_deltas2;
SAM_DELTA_HDR *hdr_deltas;
SAM_DELTA_CTR *deltas;
NTSTATUS status;
} NET_R_SAM_SYNC;
/* NET_Q_SAM_DELTAS */
typedef struct net_q_sam_deltas_info
{
UNISTR2 uni_srv_name;
UNISTR2 uni_cli_name;
DOM_CRED cli_creds;
DOM_CRED ret_creds;
uint32 database_id;
UINT64_S dom_mod_count; /* domain mod count at last sync */
uint32 max_size; /* preferred maximum length */
} NET_Q_SAM_DELTAS;
/* NET_R_SAM_DELTAS */
typedef struct net_r_sam_deltas_info
{
DOM_CRED srv_creds;
UINT64_S dom_mod_count; /* new domain mod count */
uint32 ptr_deltas;
uint32 num_deltas;
uint32 num_deltas2;
SAM_DELTA_HDR *hdr_deltas;
SAM_DELTA_CTR *deltas;
NTSTATUS status;
} NET_R_SAM_DELTAS;
#endif /* _RPC_NETLOGON_H */

40
source/lib/util_unistr.c
View File

@ -158,46 +158,6 @@ void init_valid_table(void)
}
/*******************************************************************
Convert a (little-endian) UNISTR2 structure to an ASCII string
********************************************************************/
static void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen)
{
if (str == NULL) {
*dest='\0';
return;
}
pull_ucs2(NULL, dest, str->buffer, maxlen, str->uni_str_len*2, STR_NOALIGN);
}
/*******************************************************************
give a static string for displaying a UNISTR2
********************************************************************/
const char *unistr2_static(TALLOC_CTX *mem_ctx, const UNISTR2 *str)
{
pstring ret;
unistr2_to_ascii(ret, str, sizeof(ret));
return talloc_strdup(mem_ctx, ret);
}
/*******************************************************************
duplicate a UNISTR2 string into a null terminated char*
using a talloc context
********************************************************************/
char *unistr2_tdup(TALLOC_CTX *ctx, const UNISTR2 *str)
{
char *s;
int maxlen = (str->uni_str_len+1)*4;
if (!str->buffer) return NULL;
s = (char *)talloc(ctx, maxlen); /* convervative */
if (!s) return NULL;
pull_ucs2(NULL, s, str->buffer, maxlen, str->uni_str_len*2,
STR_NOALIGN);
return s;
}
/*******************************************************************
Convert a wchar to upper case.
********************************************************************/

3
source/libcli/auth/ntlmssp.h
View File

@ -68,6 +68,9 @@ enum NTLM_MESSAGE_TYPE
#define NTLMSSP_NAME_TYPE_SERVER_DNS 0x03
#define NTLMSSP_NAME_TYPE_DOMAIN_DNS 0x04
#define NTLMSSP_SIGN_VERSION 0xa
typedef struct ntlmssp_state
{
TALLOC_CTX *mem_ctx;

194
source/libcli/util/credentials.c
View File

@ -19,197 +19,3 @@
*/
#include "includes.h"
/****************************************************************************
represent a credential as a string
****************************************************************************/
char *credstr(const uchar *cred)
{
static fstring buf;
slprintf(buf, sizeof(buf) - 1, "%02X%02X%02X%02X%02X%02X%02X%02X",
cred[0], cred[1], cred[2], cred[3],
cred[4], cred[5], cred[6], cred[7]);
return buf;
}
/****************************************************************************
setup the session key.
Input: 8 byte challenge block
8 byte server challenge block
16 byte md4 encrypted password
Output:
8 byte session key
****************************************************************************/
void cred_session_key(const DOM_CHAL *clnt_chal, const DOM_CHAL *srv_chal, const uchar *pass,
uchar session_key[8])
{
uint32 sum[2];
unsigned char sum2[8];
sum[0] = IVAL(clnt_chal->data, 0) + IVAL(srv_chal->data, 0);
sum[1] = IVAL(clnt_chal->data, 4) + IVAL(srv_chal->data, 4);
SIVAL(sum2,0,sum[0]);
SIVAL(sum2,4,sum[1]);
cred_hash1(session_key, sum2, pass);
/* debug output */
DEBUG(4,("cred_session_key\n"));
DEBUG(5,(" clnt_chal: %s\n", credstr(clnt_chal->data)));
DEBUG(5,(" srv_chal : %s\n", credstr(srv_chal->data)));
DEBUG(5,(" clnt+srv : %s\n", credstr(sum2)));
DEBUG(5,(" sess_key : %s\n", credstr(session_key)));
}
/****************************************************************************
create a credential
Input:
8 byte sesssion key
8 byte stored credential
4 byte timestamp
Output:
8 byte credential
****************************************************************************/
void cred_create(uchar session_key[8], DOM_CHAL *stor_cred, UTIME timestamp,
DOM_CHAL *cred)
{
DOM_CHAL time_cred;
SIVAL(time_cred.data, 0, IVAL(stor_cred->data, 0) + timestamp.time);
SIVAL(time_cred.data, 4, IVAL(stor_cred->data, 4));
cred_hash2(cred->data, time_cred.data, session_key);
/* debug output*/
DEBUG(4,("cred_create\n"));
DEBUG(5,(" sess_key : %s\n", credstr(session_key)));
DEBUG(5,(" stor_cred: %s\n", credstr(stor_cred->data)));
DEBUG(5,(" timestamp: %x\n" , timestamp.time));
DEBUG(5,(" timecred : %s\n", credstr(time_cred.data)));
DEBUG(5,(" calc_cred: %s\n", credstr(cred->data)));
}
/****************************************************************************
check a supplied credential
Input:
8 byte received credential
8 byte sesssion key
8 byte stored credential
4 byte timestamp
Output:
returns 1 if computed credential matches received credential
returns 0 otherwise
****************************************************************************/
int cred_assert(DOM_CHAL *cred, uchar session_key[8], DOM_CHAL *stored_cred,
UTIME timestamp)
{
DOM_CHAL cred2;
cred_create(session_key, stored_cred, timestamp, &cred2);
/* debug output*/
DEBUG(4,("cred_assert\n"));
DEBUG(5,(" challenge : %s\n", credstr(cred->data)));
DEBUG(5,(" calculated: %s\n", credstr(cred2.data)));
if (memcmp(cred->data, cred2.data, 8) == 0)
{
DEBUG(5, ("credentials check ok\n"));
return True;
}
else
{
DEBUG(5, ("credentials check wrong\n"));
return False;
}
}
/****************************************************************************
checks credentials; generates next step in the credential chain
****************************************************************************/
BOOL clnt_deal_with_creds(uchar sess_key[8],
DOM_CRED *sto_clnt_cred, DOM_CRED *rcv_srv_cred)
{
UTIME new_clnt_time;
uint32 new_cred;
DEBUG(5,("clnt_deal_with_creds: %d\n", __LINE__));
/* increment client time by one second */
new_clnt_time.time = sto_clnt_cred->timestamp.time + 1;
/* check that the received server credentials are valid */
if (!cred_assert(&rcv_srv_cred->challenge, sess_key,
&sto_clnt_cred->challenge, new_clnt_time))
{
return False;
}
/* first 4 bytes of the new seed is old client 4 bytes + clnt time + 1 */
new_cred = IVAL(sto_clnt_cred->challenge.data, 0);
new_cred += new_clnt_time.time;
/* store new seed in client credentials */
SIVAL(sto_clnt_cred->challenge.data, 0, new_cred);
DEBUG(5,(" new clnt cred: %s\n", credstr(sto_clnt_cred->challenge.data)));
return True;
}
/****************************************************************************
checks credentials; generates next step in the credential chain
****************************************************************************/
BOOL deal_with_creds(uchar sess_key[8],
DOM_CRED *sto_clnt_cred,
DOM_CRED *rcv_clnt_cred, DOM_CRED *rtn_srv_cred)
{
UTIME new_clnt_time;
uint32 new_cred;
DEBUG(5,("deal_with_creds: %d\n", __LINE__));
/* check that the received client credentials are valid */
if (!cred_assert(&rcv_clnt_cred->challenge, sess_key,
&sto_clnt_cred->challenge, rcv_clnt_cred->timestamp))
{
return False;
}
/* increment client time by one second */
new_clnt_time.time = rcv_clnt_cred->timestamp.time + 1;
/* first 4 bytes of the new seed is old client 4 bytes + clnt time + 1 */
new_cred = IVAL(sto_clnt_cred->challenge.data, 0);
new_cred += new_clnt_time.time;
DEBUG(5,("deal_with_creds: new_cred[0]=%x\n", new_cred));
/* doesn't matter that server time is 0 */
rtn_srv_cred->timestamp.time = 0;
DEBUG(5,("deal_with_creds: new_clnt_time=%x\n", new_clnt_time.time));
/* create return credentials for inclusion in the reply */
cred_create(sess_key, &sto_clnt_cred->challenge, new_clnt_time,
&rtn_srv_cred->challenge);
DEBUG(5,("deal_with_creds: clnt_cred=%s\n", credstr(sto_clnt_cred->challenge.data)));
/* store new seed in client credentials */
SIVAL(sto_clnt_cred->challenge.data, 0, new_cred);
return True;
}

8
source/passdb/pdb_interface.c
View File

@ -837,13 +837,5 @@ NTSTATUS make_pdb_methods(TALLOC_CTX *mem_ctx, PDB_METHODS **methods)
(*methods)->update_sam_account = pdb_default_update_sam_account;
(*methods)->delete_sam_account = pdb_default_delete_sam_account;
(*methods)->getgrsid = pdb_default_getgrsid;
(*methods)->getgrgid = pdb_default_getgrgid;
(*methods)->getgrnam = pdb_default_getgrnam;
(*methods)->add_group_mapping_entry = pdb_default_add_group_mapping_entry;
(*methods)->update_group_mapping_entry = pdb_default_update_group_mapping_entry;
(*methods)->delete_group_mapping_entry = pdb_default_delete_group_mapping_entry;
(*methods)->enum_group_mapping = pdb_default_enum_group_mapping;
return NT_STATUS_OK;
}

4887
source/printing/nt_printing.c
View File

File diff suppressed because it is too large Load Diff

829
source/registry/reg_printing.c
View File

@ -1,829 +0,0 @@
/*
* Unix SMB/CIFS implementation.
* RPC Pipe client / server routines
* Copyright (C) Gerald Carter 2002.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* Implementation of registry virtual views for printing information */
#include "includes.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
#define MAX_TOP_LEVEL_KEYS 3
/* some symbolic indexes into the top_level_keys */
#define KEY_INDEX_ENVIR 0
#define KEY_INDEX_FORMS 1
#define KEY_INDEX_PRINTER 2
static char *top_level_keys[MAX_TOP_LEVEL_KEYS] = {
"Environments",
"Forms",
"Printers"
};
/**********************************************************************
It is safe to assume that every registry path passed into on of
the exported functions here begins with KEY_PRINTING else
these functions would have never been called. This is a small utility
function to strip the beginning of the path and make a copy that the
caller can modify. Note that the caller is responsible for releasing
the memory allocated here.
**********************************************************************/
static char* trim_reg_path( char *path )
{
char *p;
uint16 key_len = strlen(KEY_PRINTING);
/*
* sanity check...this really should never be True.
* It is only here to prevent us from accessing outside
* the path buffer in the extreme case.
*/
if ( strlen(path) < key_len ) {
DEBUG(0,("trim_reg_path: Registry path too short! [%s]\n", path));
DEBUG(0,("trim_reg_path: KEY_PRINTING => [%s]!\n", KEY_PRINTING));
return NULL;
}
p = path + strlen( KEY_PRINTING );
if ( *p == '\\' )
p++;
if ( *p )
return strdup(p);
else
return NULL;
}
/**********************************************************************
handle enumeration of subkeys below KEY_PRINTING\Environments
*********************************************************************/
static int print_subpath_environments( char *key, REGSUBKEY_CTR *subkeys )
{
const char *environments[] = {
"Windows 4.0",
"Windows NT x86",
"Windows NT R4000",
"Windows NT Alpha_AXP",
"Windows NT PowerPC",
NULL };
fstring *drivers = NULL;
int i, env_index, num_drivers;
BOOL valid_env = False;
char *base, *new_path;
char *keystr;
char *key2 = NULL;
int num_subkeys = -1;
DEBUG(10,("print_subpath_environments: key=>[%s]\n", key ? key : "NULL" ));
/* listed architectures of installed drivers */
if ( !key )
{
/* Windows 9x drivers */
if ( get_ntdrivers( &drivers, environments[0], 0 ) )
regsubkey_ctr_addkey( subkeys, environments[0] );
SAFE_FREE( drivers );
/* Windows NT/2k intel drivers */
if ( get_ntdrivers( &drivers, environments[1], 2 )
|| get_ntdrivers( &drivers, environments[1], 3 ) )
{
regsubkey_ctr_addkey( subkeys, environments[1] );
}
SAFE_FREE( drivers );
/* Windows NT 4.0; non-intel drivers */
for ( i=2; environments[i]; i++ ) {
if ( get_ntdrivers( &drivers, environments[i], 2 ) )
regsubkey_ctr_addkey( subkeys, environments[i] );
}
SAFE_FREE( drivers );
num_subkeys = regsubkey_ctr_numkeys( subkeys );
goto done;
}
/* we are dealing with a subkey of "Environments */
key2 = strdup( key );
keystr = key2;
reg_split_path( keystr, &base, &new_path );
/* sanity check */
for ( env_index=0; environments[env_index]; env_index++ ) {
if ( StrCaseCmp( environments[env_index], base ) == 0 ) {
valid_env = True;
break;
}
}
if ( !valid_env )
return -1;
/* enumerate driver versions; environment is environments[env_index] */
if ( !new_path ) {
switch ( env_index ) {
case 0: /* Win9x */
if ( get_ntdrivers( &drivers, environments[0], 0 ) ) {
regsubkey_ctr_addkey( subkeys, "0" );
SAFE_FREE( drivers );
}
break;
case 1: /* Windows NT/2k - intel */
if ( get_ntdrivers( &drivers, environments[1], 2 ) ) {
regsubkey_ctr_addkey( subkeys, "2" );
SAFE_FREE( drivers );
}
if ( get_ntdrivers( &drivers, environments[1], 3 ) ) {
regsubkey_ctr_addkey( subkeys, "3" );
SAFE_FREE( drivers );
}
break;
default: /* Windows NT - nonintel */
if ( get_ntdrivers( &drivers, environments[env_index], 2 ) ) {
regsubkey_ctr_addkey( subkeys, "2" );
SAFE_FREE( drivers );
}
}
num_subkeys = regsubkey_ctr_numkeys( subkeys );
goto done;
}
/* we finally get to enumerate the drivers */
keystr = new_path;
reg_split_path( keystr, &base, &new_path );
if ( !new_path ) {
num_drivers = get_ntdrivers( &drivers, environments[env_index], atoi(base) );
for ( i=0; i<num_drivers; i++ )
regsubkey_ctr_addkey( subkeys, drivers[i] );
num_subkeys = regsubkey_ctr_numkeys( subkeys );
goto done;
}
done:
SAFE_FREE( key2 );
return num_subkeys;
}
/***********************************************************************
simple function to prune a pathname down to the basename of a file
**********************************************************************/
static char* dos_basename ( char *path )
{
char *p;
p = strrchr( path, '\\' );
if ( p )
p++;
else
p = path;
return p;
}
/**********************************************************************
handle enumeration of values below
KEY_PRINTING\Environments\<arch>\<version>\<drivername>
*********************************************************************/
static int print_subpath_values_environments( char *key, REGVAL_CTR *val )
{
char *keystr;
char *key2 = NULL;
char *base, *new_path;
fstring env;
fstring driver;
int version;
NT_PRINTER_DRIVER_INFO_LEVEL driver_ctr;
NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
WERROR w_result;
char *buffer = NULL;
char *buffer2 = NULL;
int buffer_size = 0;
int i, length;
char *filename;
UNISTR2 data;;
DEBUG(8,("print_subpath_values_environments: Enter key => [%s]\n", key ? key : "NULL"));
if ( !key )
return 0;
/*
* The only key below KEY_PRINTING\Environments that
* posseses values is each specific printer driver
* First get the arch, version, & driver name
*/
/* env */
key2 = strdup( key );
keystr = key2;
reg_split_path( keystr, &base, &new_path );
if ( !base || !new_path )
return 0;
fstrcpy( env, base );
/* version */
keystr = new_path;
reg_split_path( keystr, &base, &new_path );
if ( !base || !new_path )
return 0;
version = atoi( base );
/* printer driver name */
keystr = new_path;
reg_split_path( keystr, &base, &new_path );
/* new_path should be NULL here since this must be the last key */
if ( !base || new_path )
return 0;
fstrcpy( driver, base );
w_result = get_a_printer_driver( &driver_ctr, 3, driver, env, version );
if ( !W_ERROR_IS_OK(w_result) )
return -1;
/* build the values out of the driver information */
info3 = driver_ctr.info_3;
filename = dos_basename( info3->driverpath );
init_unistr2( &data, filename, strlen(filename)+1 );
regval_ctr_addvalue( val, "Driver", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
filename = dos_basename( info3->configfile );
init_unistr2( &data, filename, strlen(filename)+1 );
regval_ctr_addvalue( val, "Configuration File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
filename = dos_basename( info3->datafile );
init_unistr2( &data, filename, strlen(filename)+1 );
regval_ctr_addvalue( val, "Data File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
filename = dos_basename( info3->helpfile );
init_unistr2( &data, filename, strlen(filename)+1 );
regval_ctr_addvalue( val, "Help File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info3->defaultdatatype, strlen(info3->defaultdatatype)+1 );
regval_ctr_addvalue( val, "Data Type", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
regval_ctr_addvalue( val, "Version", REG_DWORD, (char*)&info3->cversion, sizeof(info3->cversion) );
if ( info3->dependentfiles )
{
/* place the list of dependent files in a single
character buffer, separating each file name by
a NULL */
for ( i=0; strcmp(info3->dependentfiles[i], ""); i++ )
{
/* strip the path to only the file's base name */
filename = dos_basename( info3->dependentfiles[i] );
length = strlen(filename);
buffer2 = Realloc( buffer, buffer_size + (length + 1)*sizeof(uint16) );
if ( !buffer2 )
break;
buffer = buffer2;
init_unistr2( &data, filename, length+1 );
memcpy( buffer+buffer_size, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
buffer_size += (length + 1)*sizeof(uint16);
}
/* terminated by double NULL. Add the final one here */
buffer2 = Realloc( buffer, buffer_size + 2 );
if ( !buffer2 ) {
SAFE_FREE( buffer );
buffer_size = 0;
}
else {
buffer = buffer2;
buffer[buffer_size++] = '\0';
buffer[buffer_size++] = '\0';
}
}
regval_ctr_addvalue( val, "Dependent Files", REG_MULTI_SZ, buffer, buffer_size );
free_a_printer_driver( driver_ctr, 3 );
SAFE_FREE( key2 );
SAFE_FREE( buffer );
DEBUG(8,("print_subpath_values_environments: Exit\n"));
return regval_ctr_numvals( val );
}
/**********************************************************************
handle enumeration of subkeys below KEY_PRINTING\Forms
Really just a stub function, but left here in case it needs to
be expanded later on
*********************************************************************/
static int print_subpath_forms( char *key, REGSUBKEY_CTR *subkeys )
{
DEBUG(10,("print_subpath_forms: key=>[%s]\n", key ? key : "NULL" ));
/* there are no subkeys */
if ( key )
return -1;
return 0;
}
/**********************************************************************
handle enumeration of values below KEY_PRINTING\Forms
*********************************************************************/
static int print_subpath_values_forms( char *key, REGVAL_CTR *val )
{
int num_values = 0;
uint32 data[8];
int form_index = 1;
DEBUG(10,("print_values_forms: key=>[%s]\n", key ? key : "NULL" ));
/* handle ..\Forms\ */
if ( !key )
{
nt_forms_struct *forms_list = NULL;
nt_forms_struct *form = NULL;
int i;
if ( (num_values = get_ntforms( &forms_list )) == 0 )
return 0;
DEBUG(10,("print_subpath_values_forms: [%d] user defined forms returned\n",
num_values));
/* handle user defined forms */
for ( i=0; i<num_values; i++ )
{
form = &forms_list[i];
data[0] = form->width;
data[1] = form->length;
data[2] = form->left;
data[3] = form->top;
data[4] = form->right;
data[5] = form->bottom;
data[6] = form_index++;
data[7] = form->flag;
regval_ctr_addvalue( val, form->name, REG_BINARY, (char*)data, sizeof(data) );
}
SAFE_FREE( forms_list );
forms_list = NULL;
/* handle built-on forms */
if ( (num_values = get_builtin_ntforms( &forms_list )) == 0 )
return 0;
DEBUG(10,("print_subpath_values_forms: [%d] built-in forms returned\n",
num_values));
for ( i=0; i<num_values; i++ )
{
form = &forms_list[i];
data[0] = form->width;
data[1] = form->length;
data[2] = form->left;
data[3] = form->top;
data[4] = form->right;
data[5] = form->bottom;
data[6] = form_index++;
data[7] = form->flag;
regval_ctr_addvalue( val, form->name, REG_BINARY, (char*)data, sizeof(data) );
}
SAFE_FREE( forms_list );
}
return num_values;
}
/**********************************************************************
handle enumeration of subkeys below KEY_PRINTING\Printers
*********************************************************************/
static int print_subpath_printers( char *key, REGSUBKEY_CTR *subkeys )
{
int n_services = lp_numservices();
int snum;
fstring sname;
int i;
int num_subkeys = 0;
char *keystr, *key2 = NULL;
char *base, *new_path;
NT_PRINTER_INFO_LEVEL *printer = NULL;
fstring *subkey_names = NULL;
DEBUG(10,("print_subpath_printers: key=>[%s]\n", key ? key : "NULL" ));
if ( !key )
{
/* enumerate all printers */
for (snum=0; snum<n_services; snum++) {
if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
continue;
fstrcpy( sname, lp_servicename(snum) );
regsubkey_ctr_addkey( subkeys, sname );
}
num_subkeys = regsubkey_ctr_numkeys( subkeys );
goto done;
}
/* get information for a specific printer */
key2 = strdup( key );
keystr = key2;
reg_split_path( keystr, &base, &new_path );
if ( !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, base) ) )
goto done;
num_subkeys = get_printer_subkeys( &printer->info_2->data, new_path?new_path:"", &subkey_names );
for ( i=0; i<num_subkeys; i++ )
regsubkey_ctr_addkey( subkeys, subkey_names[i] );
free_a_printer( &printer, 2 );
/* no other subkeys below here */
done:
SAFE_FREE( key2 );
SAFE_FREE( subkey_names );
return num_subkeys;
}
/**********************************************************************
handle enumeration of values below KEY_PRINTING\Printers
*********************************************************************/
static int print_subpath_values_printers( char *key, REGVAL_CTR *val )
{
int num_values = 0;
char *keystr, *key2 = NULL;
char *base, *new_path;
NT_PRINTER_INFO_LEVEL *printer = NULL;
NT_PRINTER_INFO_LEVEL_2 *info2;
DEVICEMODE *devmode;
prs_struct prs;
uint32 offset;
int snum;
fstring printername;
NT_PRINTER_DATA *p_data;
int i, key_index;
UNISTR2 data;
/*
* Theres are tw cases to deal with here
* (1) enumeration of printer_info_2 values
* (2) enumeration of the PrinterDriverData subney
*/
if ( !key ) {
/* top level key has no values */
goto done;
}
key2 = strdup( key );
keystr = key2;
reg_split_path( keystr, &base, &new_path );
fstrcpy( printername, base );
if ( !new_path )
{
/* we are dealing with the printer itself */
if ( !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, printername) ) )
goto done;
info2 = printer->info_2;
regval_ctr_addvalue( val, "Attributes", REG_DWORD, (char*)&info2->attributes, sizeof(info2->attributes) );
regval_ctr_addvalue( val, "Priority", REG_DWORD, (char*)&info2->priority, sizeof(info2->attributes) );
regval_ctr_addvalue( val, "ChangeID", REG_DWORD, (char*)&info2->changeid, sizeof(info2->changeid) );
regval_ctr_addvalue( val, "Default Priority", REG_DWORD, (char*)&info2->default_priority, sizeof(info2->default_priority) );
regval_ctr_addvalue( val, "Status", REG_DWORD, (char*)&info2->status, sizeof(info2->status) );
regval_ctr_addvalue( val, "StartTime", REG_DWORD, (char*)&info2->starttime, sizeof(info2->starttime) );
regval_ctr_addvalue( val, "UntilTime", REG_DWORD, (char*)&info2->untiltime, sizeof(info2->untiltime) );
regval_ctr_addvalue( val, "cjobs", REG_DWORD, (char*)&info2->cjobs, sizeof(info2->cjobs) );
regval_ctr_addvalue( val, "AveragePPM", REG_DWORD, (char*)&info2->averageppm, sizeof(info2->averageppm) );
init_unistr2( &data, info2->printername, strlen(info2->printername)+1 );
regval_ctr_addvalue( val, "Name", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info2->location, strlen(info2->location)+1 );
regval_ctr_addvalue( val, "Location", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info2->comment, strlen(info2->comment)+1 );
regval_ctr_addvalue( val, "Comment", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info2->parameters, strlen(info2->parameters)+1 );
regval_ctr_addvalue( val, "Parameters", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info2->portname, strlen(info2->portname)+1 );
regval_ctr_addvalue( val, "Port", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info2->servername, strlen(info2->servername)+1 );
regval_ctr_addvalue( val, "Server", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info2->sharename, strlen(info2->sharename)+1 );
regval_ctr_addvalue( val, "Share", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info2->drivername, strlen(info2->drivername)+1 );
regval_ctr_addvalue( val, "Driver", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info2->sepfile, strlen(info2->sepfile)+1 );
regval_ctr_addvalue( val, "Separator File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, "winprint", strlen("winprint")+1 );
regval_ctr_addvalue( val, "Print Processor", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
/* use a prs_struct for converting the devmode and security
descriptor to REG_BIARY */
prs_init( &prs, MAX_PDU_FRAG_LEN, regval_ctr_getctx(val), MARSHALL);
/* stream the device mode */
snum = lp_servicenumber(info2->sharename);
if ( (devmode = construct_dev_mode( snum )) != NULL )
{
if ( spoolss_io_devmode( "devmode", &prs, 0, devmode ) ) {
offset = prs_offset( &prs );
regval_ctr_addvalue( val, "Default Devmode", REG_BINARY, prs_data_p(&prs), offset );
}
}
prs_mem_clear( &prs );
prs_set_offset( &prs, 0 );
if ( info2->secdesc_buf && info2->secdesc_buf->len )
{
if ( sec_io_desc("sec_desc", &info2->secdesc_buf->sec, &prs, 0 ) ) {
offset = prs_offset( &prs );
regval_ctr_addvalue( val, "Security", REG_BINARY, prs_data_p(&prs), offset );
}
}
prs_mem_free( &prs );
num_values = regval_ctr_numvals( val );
goto done;
}
/* now enumerate the key */
if ( !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, printername) ) )
goto done;
/* iterate over all printer data and fill the regval container */
p_data = &printer->info_2->data;
if ( (key_index = lookup_printerkey( p_data, new_path )) == -1 ) {
DEBUG(10,("print_subpath_values_printer: Unknown keyname [%s]\n", new_path));
goto done;
}
num_values = regval_ctr_numvals( &p_data->keys[key_index].values );
for ( i=0; i<num_values; i++ )
regval_ctr_copyvalue( val, regval_ctr_specific_value(&p_data->keys[key_index].values, i) );
done:
if ( printer )
free_a_printer( &printer, 2 );
SAFE_FREE( key2 );
return num_values;
}
/**********************************************************************
Routine to handle enumeration of subkeys and values
below KEY_PRINTING (depending on whether or not subkeys/val are
valid pointers.
*********************************************************************/
static int handle_printing_subpath( char *key, REGSUBKEY_CTR *subkeys, REGVAL_CTR *val )
{
int result = 0;
char *p, *base;
int i;
DEBUG(10,("handle_printing_subpath: key=>[%s]\n", key ));
/*
* break off the first part of the path
* topmost base **must** be one of the strings
* in top_level_keys[]
*/
reg_split_path( key, &base, &p);
for ( i=0; i<MAX_TOP_LEVEL_KEYS; i++ ) {
if ( StrCaseCmp( top_level_keys[i], base ) == 0 )
break;
}
DEBUG(10,("handle_printing_subpath: base=>[%s], i==[%d]\n", base, i));
if ( !(i < MAX_TOP_LEVEL_KEYS) )
return -1;
/* Call routine to handle each top level key */
switch ( i )
{
case KEY_INDEX_ENVIR:
if ( subkeys )
print_subpath_environments( p, subkeys );
if ( val )
print_subpath_values_environments( p, val );
break;
case KEY_INDEX_FORMS:
if ( subkeys )
print_subpath_forms( p, subkeys );
if ( val )
print_subpath_values_forms( p, val );
break;
case KEY_INDEX_PRINTER:
if ( subkeys )
print_subpath_printers( p, subkeys );
if ( val )
print_subpath_values_printers( p, val );
break;
/* default case for top level key that has no handler */
default:
break;
}
return result;
}
/**********************************************************************
Enumerate registry subkey names given a registry path.
Caller is responsible for freeing memory to **subkeys
*********************************************************************/
int printing_subkey_info( char *key, REGSUBKEY_CTR *subkey_ctr )
{
char *path;
BOOL top_level = False;
int num_subkeys = 0;
DEBUG(10,("printing_subkey_info: key=>[%s]\n", key));
path = trim_reg_path( key );
/* check to see if we are dealing with the top level key */
if ( !path )
top_level = True;
if ( top_level ) {
for ( num_subkeys=0; num_subkeys<MAX_TOP_LEVEL_KEYS; num_subkeys++ )
regsubkey_ctr_addkey( subkey_ctr, top_level_keys[num_subkeys] );
}
else
num_subkeys = handle_printing_subpath( path, subkey_ctr, NULL );
SAFE_FREE( path );
return num_subkeys;
}
/**********************************************************************
Enumerate registry values given a registry path.
Caller is responsible for freeing memory
*********************************************************************/
int printing_value_info( char *key, REGVAL_CTR *val )
{
char *path;
BOOL top_level = False;
int num_values = 0;
DEBUG(10,("printing_value_info: key=>[%s]\n", key));
path = trim_reg_path( key );
/* check to see if we are dealing with the top level key */
if ( !path )
top_level = True;
/* fill in values from the getprinterdata_printer_server() */
if ( top_level )
num_values = 0;
else
num_values = handle_printing_subpath( path, NULL, val );
return num_values;
}
/**********************************************************************
Stub function which always returns failure since we don't want
people storing printing information directly via regostry calls
(for now at least)
*********************************************************************/
BOOL printing_store_subkey( char *key, REGSUBKEY_CTR *subkeys )
{
return False;
}
/**********************************************************************
Stub function which always returns failure since we don't want
people storing printing information directly via regostry calls
(for now at least)
*********************************************************************/
BOOL printing_store_value( char *key, REGVAL_CTR *val )
{
return False;
}
/*
* Table of function pointers for accessing printing data
*/
REGISTRY_OPS printing_ops = {
printing_subkey_info,
printing_value_info,
printing_store_subkey,
printing_store_value
};