/* cache for bad password lockout data, to be used on replicated SAMs */
struct login_cache {
time_t entry_timestamp;
- uint32 acct_ctrl;
- uint16 bad_password_count;
+ uint32_t acct_ctrl;
+ uint16_t bad_password_count;
time_t bad_password_time;
};
DATA_BLOB nt_pw_his; /* nt hashed password history .data is Null if not available */
char* plaintext_pw; /* is Null if not available */
- uint32 acct_ctrl; /* account info (ACB_xxxx bit-mask) */
- uint32 fields_present; /* 0x00ff ffff */
+ uint32_t acct_ctrl; /* account info (ACB_xxxx bit-mask) */
+ uint32_t fields_present; /* 0x00ff ffff */
- uint16 logon_divs; /* 168 - number of hours in a week */
- uint32 hours_len; /* normally 21 bytes */
- uint8 hours[MAX_HOURS_LEN];
+ uint16_t logon_divs; /* 168 - number of hours in a week */
+ uint32_t hours_len; /* normally 21 bytes */
+ uint8_t hours[MAX_HOURS_LEN];
/* Was unknown_5. */
- uint16 bad_password_count;
- uint16 logon_count;
+ uint16_t bad_password_count;
+ uint16_t logon_count;
- uint32 unknown_6; /* 0x0000 04ec */
+ uint32_t unknown_6; /* 0x0000 04ec */
/* a tag for who added the private methods */
struct acct_info {
fstring acct_name; /* account name */
fstring acct_desc; /* account name */
- uint32 rid; /* domain-relative RID */
+ uint32_t rid; /* domain-relative RID */
};
struct samr_displayentry {
- uint32 idx;
- uint32 rid;
- uint32 acct_flags;
+ uint32_t idx;
+ uint32_t rid;
+ uint32_t acct_flags;
const char *account_name;
const char *fullname;
const char *description;
struct pdb_search {
enum pdb_search_type type;
struct samr_displayentry *cache;
- uint32 num_entries;
+ uint32_t num_entries;
ssize_t cache_size;
bool search_ended;
void *private_data;
* samr_lookup_rids twice. It was done in the srv_samr_nt.c code as well as in
* the pdb module. Remove the latter, this might happen more often. VL.
* changed to version 14 to move lookup_rids and lookup_names to return
- * enum lsa_SidType rather than uint32.
+ * enum lsa_SidType rather than uint32_t.
* Changed to 16 for access to the trusted domain passwords (obnox).
* Changed to 17, the sampwent interface is gone.
* Changed to 18, pdb_rid_algorithm -> pdb_capabilities
NTSTATUS (*getsampwsid)(struct pdb_methods *, struct samu *sam_acct, const DOM_SID *sid);
NTSTATUS (*create_user)(struct pdb_methods *, TALLOC_CTX *tmp_ctx,
- const char *name, uint32 acct_flags,
- uint32 *rid);
+ const char *name, uint32_t acct_flags,
+ uint32_t *rid);
NTSTATUS (*delete_user)(struct pdb_methods *, TALLOC_CTX *tmp_ctx,
struct samu *sam_acct);
NTSTATUS (*create_dom_group)(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx, const char *name,
- uint32 *rid);
+ uint32_t *rid);
NTSTATUS (*delete_dom_group)(struct pdb_methods *methods,
- TALLOC_CTX *mem_ctx, uint32 rid);
+ TALLOC_CTX *mem_ctx, uint32_t rid);
NTSTATUS (*add_group_mapping_entry)(struct pdb_methods *methods,
GROUP_MAP *map);
NTSTATUS (*enum_group_members)(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
const DOM_SID *group,
- uint32 **pp_member_rids,
+ uint32_t **pp_member_rids,
size_t *p_num_members);
NTSTATUS (*enum_group_memberships)(struct pdb_methods *methods,
NTSTATUS (*add_groupmem)(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
- uint32 group_rid, uint32 member_rid);
+ uint32_t group_rid, uint32_t member_rid);
NTSTATUS (*del_groupmem)(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
- uint32 group_rid, uint32 member_rid);
+ uint32_t group_rid, uint32_t member_rid);
NTSTATUS (*create_alias)(struct pdb_methods *methods,
- const char *name, uint32 *rid);
+ const char *name, uint32_t *rid);
NTSTATUS (*delete_alias)(struct pdb_methods *methods,
const DOM_SID *sid);
const DOM_SID *domain_sid,
const DOM_SID *members,
size_t num_members,
- uint32 **pp_alias_rids,
+ uint32_t **pp_alias_rids,
size_t *p_num_alias_rids);
NTSTATUS (*lookup_rids)(struct pdb_methods *methods,
const DOM_SID *domain_sid,
int num_rids,
- uint32 *rids,
+ uint32_t *rids,
const char **pp_names,
enum lsa_SidType *attrs);
const DOM_SID *domain_sid,
int num_names,
const char **pp_names,
- uint32 *rids,
+ uint32_t *rids,
enum lsa_SidType *attrs);
NTSTATUS (*get_account_policy)(struct pdb_methods *methods,
bool (*search_users)(struct pdb_methods *methods,
struct pdb_search *search,
- uint32 acct_flags);
+ uint32_t acct_flags);
bool (*search_groups)(struct pdb_methods *methods,
struct pdb_search *search);
bool (*search_aliases)(struct pdb_methods *methods,
union unid_t *id, enum lsa_SidType *type);
uint32_t (*capabilities)(struct pdb_methods *methods);
- bool (*new_rid)(struct pdb_methods *methods, uint32 *rid);
+ bool (*new_rid)(struct pdb_methods *methods, uint32_t *rid);
bool (*get_trusteddom_pw)(struct pdb_methods *methods,
bool (*del_trusteddom_pw)(struct pdb_methods *methods,
const char *domain);
NTSTATUS (*enum_trusteddoms)(struct pdb_methods *methods,
- TALLOC_CTX *mem_ctx, uint32 *num_domains,
+ TALLOC_CTX *mem_ctx, uint32_t *num_domains,
struct trustdom_info ***domains);
void *private_data; /* Private data of some kind */
time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset);
time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset);
time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset);
-uint32 convert_time_t_to_uint32(time_t t);
-time_t convert_uint32_to_time_t(uint32 u);
+uint32_t convert_time_t_to_uint32_t(time_t t);
+time_t convert_uint32_t_to_time_t(uint32_t u);
bool nt_time_is_zero(const NTTIME *nt);
time_t generalized_to_unix_time(const char *str);
int get_server_zone_offset(void);
struct samu *samu_new( TALLOC_CTX *ctx );
NTSTATUS samu_set_unix(struct samu *user, const struct passwd *pwd);
NTSTATUS samu_alloc_rid_unix(struct samu *user, const struct passwd *pwd);
-char *pdb_encode_acct_ctrl(uint32 acct_ctrl, size_t length);
-uint32 pdb_decode_acct_ctrl(const char *p);
-void pdb_sethexpwd(char p[33], const unsigned char *pwd, uint32 acct_ctrl);
+char *pdb_encode_acct_ctrl(uint32_t acct_ctrl, size_t length);
+uint32_t pdb_decode_acct_ctrl(const char *p);
+void pdb_sethexpwd(char p[33], const unsigned char *pwd, uint32_t acct_ctrl);
bool pdb_gethexpwd(const char *p, unsigned char *pwd);
void pdb_sethexhours(char *p, const unsigned char *hours);
bool pdb_gethexhours(const char *p, unsigned char *hours);
int algorithmic_rid_base(void);
-uid_t algorithmic_pdb_user_rid_to_uid(uint32 user_rid);
+uid_t algorithmic_pdb_user_rid_to_uid(uint32_t user_rid);
uid_t max_algorithmic_uid(void);
-uint32 algorithmic_pdb_uid_to_user_rid(uid_t uid);
-gid_t pdb_group_rid_to_gid(uint32 group_rid);
+uint32_t algorithmic_pdb_uid_to_user_rid(uid_t uid);
+gid_t pdb_group_rid_to_gid(uint32_t group_rid);
gid_t max_algorithmic_gid(void);
-uint32 algorithmic_pdb_gid_to_group_rid(gid_t gid);
-bool algorithmic_pdb_rid_is_user(uint32 rid);
+uint32_t algorithmic_pdb_gid_to_group_rid(gid_t gid);
+bool algorithmic_pdb_rid_is_user(uint32_t rid);
bool lookup_global_sam_name(const char *name, int flags, uint32_t *rid,
enum lsa_SidType *type);
NTSTATUS local_password_change(const char *user_name,
char **pp_err_str,
char **pp_msg_str);
bool init_samu_from_buffer(struct samu *sampass, uint32_t level,
- uint8 *buf, uint32 buflen);
-uint32 init_buffer_from_samu (uint8 **buf, struct samu *sampass, bool size_only);
+ uint8_t *buf, uint32_t buflen);
+uint32_t init_buffer_from_samu (uint8_t **buf, struct samu *sampass, bool size_only);
bool pdb_copy_sam_account(struct samu *dst, struct samu *src );
bool pdb_update_bad_password_count(struct samu *sampass, bool *updated);
bool pdb_update_autolock_flag(struct samu *sampass, bool *updated);
bool get_trust_pw_clear(const char *domain, char **ret_pwd,
const char **account_name,
enum netr_SchannelType *channel);
-bool get_trust_pw_hash(const char *domain, uint8 ret_pwd[16],
+bool get_trust_pw_hash(const char *domain, uint8_t ret_pwd[16],
const char **account_name,
enum netr_SchannelType *channel);
/* The following definitions come from passdb/pdb_compat.c */
-uint32 pdb_get_user_rid (const struct samu *sampass);
-uint32 pdb_get_group_rid (struct samu *sampass);
-bool pdb_set_user_sid_from_rid (struct samu *sampass, uint32 rid, enum pdb_value_state flag);
-bool pdb_set_group_sid_from_rid (struct samu *sampass, uint32 grid, enum pdb_value_state flag);
+uint32_t pdb_get_user_rid (const struct samu *sampass);
+uint32_t pdb_get_group_rid (struct samu *sampass);
+bool pdb_set_user_sid_from_rid (struct samu *sampass, uint32_t rid, enum pdb_value_state flag);
+bool pdb_set_group_sid_from_rid (struct samu *sampass, uint32_t grid, enum pdb_value_state flag);
/* The following definitions come from passdb/pdb_get_set.c */
-uint32 pdb_get_acct_ctrl(const struct samu *sampass);
+uint32_t pdb_get_acct_ctrl(const struct samu *sampass);
time_t pdb_get_logon_time(const struct samu *sampass);
time_t pdb_get_logoff_time(const struct samu *sampass);
time_t pdb_get_kickoff_time(const struct samu *sampass);
time_t pdb_get_pass_can_change_time_noncalc(const struct samu *sampass);
time_t pdb_get_pass_must_change_time(const struct samu *sampass);
bool pdb_get_pass_can_change(const struct samu *sampass);
-uint16 pdb_get_logon_divs(const struct samu *sampass);
-uint32 pdb_get_hours_len(const struct samu *sampass);
-const uint8 *pdb_get_hours(const struct samu *sampass);
-const uint8 *pdb_get_nt_passwd(const struct samu *sampass);
-const uint8 *pdb_get_lanman_passwd(const struct samu *sampass);
-const uint8 *pdb_get_pw_history(const struct samu *sampass, uint32 *current_hist_len);
+uint16_t pdb_get_logon_divs(const struct samu *sampass);
+uint32_t pdb_get_hours_len(const struct samu *sampass);
+const uint8_t *pdb_get_hours(const struct samu *sampass);
+const uint8_t *pdb_get_nt_passwd(const struct samu *sampass);
+const uint8_t *pdb_get_lanman_passwd(const struct samu *sampass);
+const uint8_t *pdb_get_pw_history(const struct samu *sampass, uint32_t *current_hist_len);
const char *pdb_get_plaintext_passwd(const struct samu *sampass);
const DOM_SID *pdb_get_user_sid(const struct samu *sampass);
const DOM_SID *pdb_get_group_sid(struct samu *sampass);
const char *pdb_get_workstations(const struct samu *sampass);
const char *pdb_get_comment(const struct samu *sampass);
const char *pdb_get_munged_dial(const struct samu *sampass);
-uint16 pdb_get_bad_password_count(const struct samu *sampass);
-uint16 pdb_get_logon_count(const struct samu *sampass);
-uint32 pdb_get_unknown_6(const struct samu *sampass);
+uint16_t pdb_get_bad_password_count(const struct samu *sampass);
+uint16_t pdb_get_logon_count(const struct samu *sampass);
+uint32_t pdb_get_unknown_6(const struct samu *sampass);
void *pdb_get_backend_private_data(const struct samu *sampass, const struct pdb_methods *my_methods);
-bool pdb_set_acct_ctrl(struct samu *sampass, uint32 acct_ctrl, enum pdb_value_state flag);
+bool pdb_set_acct_ctrl(struct samu *sampass, uint32_t acct_ctrl, enum pdb_value_state flag);
bool pdb_set_logon_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag);
bool pdb_set_logoff_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag);
bool pdb_set_kickoff_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag);
bool pdb_set_pass_can_change_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag);
bool pdb_set_pass_must_change_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag);
bool pdb_set_pass_last_set_time(struct samu *sampass, time_t mytime, enum pdb_value_state flag);
-bool pdb_set_hours_len(struct samu *sampass, uint32 len, enum pdb_value_state flag);
-bool pdb_set_logon_divs(struct samu *sampass, uint16 hours, enum pdb_value_state flag);
+bool pdb_set_hours_len(struct samu *sampass, uint32_t len, enum pdb_value_state flag);
+bool pdb_set_logon_divs(struct samu *sampass, uint16_t hours, enum pdb_value_state flag);
bool pdb_set_init_flags(struct samu *sampass, enum pdb_elements element, enum pdb_value_state value_flag);
bool pdb_set_user_sid(struct samu *sampass, const DOM_SID *u_sid, enum pdb_value_state flag);
bool pdb_set_user_sid_from_string(struct samu *sampass, fstring u_sid, enum pdb_value_state flag);
bool pdb_set_workstations(struct samu *sampass, const char *workstations, enum pdb_value_state flag);
bool pdb_set_comment(struct samu *sampass, const char *comment, enum pdb_value_state flag);
bool pdb_set_munged_dial(struct samu *sampass, const char *munged_dial, enum pdb_value_state flag);
-bool pdb_set_nt_passwd(struct samu *sampass, const uint8 pwd[NT_HASH_LEN], enum pdb_value_state flag);
-bool pdb_set_lanman_passwd(struct samu *sampass, const uint8 pwd[LM_HASH_LEN], enum pdb_value_state flag);
-bool pdb_set_pw_history(struct samu *sampass, const uint8 *pwd, uint32 historyLen, enum pdb_value_state flag);
+bool pdb_set_nt_passwd(struct samu *sampass, const uint8_t pwd[NT_HASH_LEN], enum pdb_value_state flag);
+bool pdb_set_lanman_passwd(struct samu *sampass, const uint8_t pwd[LM_HASH_LEN], enum pdb_value_state flag);
+bool pdb_set_pw_history(struct samu *sampass, const uint8_t *pwd, uint32_t historyLen, enum pdb_value_state flag);
bool pdb_set_plaintext_pw_only(struct samu *sampass, const char *password, enum pdb_value_state flag);
-bool pdb_set_bad_password_count(struct samu *sampass, uint16 bad_password_count, enum pdb_value_state flag);
-bool pdb_set_logon_count(struct samu *sampass, uint16 logon_count, enum pdb_value_state flag);
-bool pdb_set_unknown_6(struct samu *sampass, uint32 unkn, enum pdb_value_state flag);
-bool pdb_set_hours(struct samu *sampass, const uint8 *hours, enum pdb_value_state flag);
+bool pdb_set_bad_password_count(struct samu *sampass, uint16_t bad_password_count, enum pdb_value_state flag);
+bool pdb_set_logon_count(struct samu *sampass, uint16_t logon_count, enum pdb_value_state flag);
+bool pdb_set_unknown_6(struct samu *sampass, uint32_t unkn, enum pdb_value_state flag);
+bool pdb_set_hours(struct samu *sampass, const uint8_t *hours, enum pdb_value_state flag);
bool pdb_set_backend_private_data(struct samu *sampass, void *private_data,
void (*free_fn)(void **),
const struct pdb_methods *my_methods,
enum pdb_value_state flag);
bool pdb_set_pass_can_change(struct samu *sampass, bool canchange);
bool pdb_set_plaintext_passwd(struct samu *sampass, const char *plaintext);
-uint32 pdb_build_fields_present(struct samu *sampass);
+uint32_t pdb_build_fields_present(struct samu *sampass);
/* The following definitions come from passdb/pdb_interface.c */
struct pdb_domain_info *pdb_get_domain_info(TALLOC_CTX *mem_ctx);
bool pdb_getsampwnam(struct samu *sam_acct, const char *username) ;
bool pdb_getsampwsid(struct samu *sam_acct, const DOM_SID *sid) ;
-NTSTATUS pdb_create_user(TALLOC_CTX *mem_ctx, const char *name, uint32 flags,
- uint32 *rid);
+NTSTATUS pdb_create_user(TALLOC_CTX *mem_ctx, const char *name, uint32_t flags,
+ uint32_t *rid);
NTSTATUS pdb_delete_user(TALLOC_CTX *mem_ctx, struct samu *sam_acct);
NTSTATUS pdb_add_sam_account(struct samu *sam_acct) ;
NTSTATUS pdb_update_sam_account(struct samu *sam_acct) ;
bool pdb_getgrgid(GROUP_MAP *map, gid_t gid);
bool pdb_getgrnam(GROUP_MAP *map, const char *name);
NTSTATUS pdb_create_dom_group(TALLOC_CTX *mem_ctx, const char *name,
- uint32 *rid);
-NTSTATUS pdb_delete_dom_group(TALLOC_CTX *mem_ctx, uint32 rid);
+ uint32_t *rid);
+NTSTATUS pdb_delete_dom_group(TALLOC_CTX *mem_ctx, uint32_t rid);
NTSTATUS pdb_add_group_mapping_entry(GROUP_MAP *map);
NTSTATUS pdb_update_group_mapping_entry(GROUP_MAP *map);
NTSTATUS pdb_delete_group_mapping_entry(DOM_SID sid);
size_t *p_num_entries, bool unix_only);
NTSTATUS pdb_enum_group_members(TALLOC_CTX *mem_ctx,
const DOM_SID *sid,
- uint32 **pp_member_rids,
+ uint32_t **pp_member_rids,
size_t *p_num_members);
NTSTATUS pdb_enum_group_memberships(TALLOC_CTX *mem_ctx, struct samu *user,
DOM_SID **pp_sids, gid_t **pp_gids,
size_t *p_num_groups);
NTSTATUS pdb_set_unix_primary_group(TALLOC_CTX *mem_ctx, struct samu *user);
-NTSTATUS pdb_add_groupmem(TALLOC_CTX *mem_ctx, uint32 group_rid,
- uint32 member_rid);
-NTSTATUS pdb_del_groupmem(TALLOC_CTX *mem_ctx, uint32 group_rid,
- uint32 member_rid);
-NTSTATUS pdb_create_alias(const char *name, uint32 *rid);
+NTSTATUS pdb_add_groupmem(TALLOC_CTX *mem_ctx, uint32_t group_rid,
+ uint32_t member_rid);
+NTSTATUS pdb_del_groupmem(TALLOC_CTX *mem_ctx, uint32_t group_rid,
+ uint32_t member_rid);
+NTSTATUS pdb_create_alias(const char *name, uint32_t *rid);
NTSTATUS pdb_delete_alias(const DOM_SID *sid);
NTSTATUS pdb_get_aliasinfo(const DOM_SID *sid, struct acct_info *info);
NTSTATUS pdb_set_aliasinfo(const DOM_SID *sid, struct acct_info *info);
NTSTATUS pdb_enum_alias_memberships(TALLOC_CTX *mem_ctx,
const DOM_SID *domain_sid,
const DOM_SID *members, size_t num_members,
- uint32 **pp_alias_rids,
+ uint32_t **pp_alias_rids,
size_t *p_num_alias_rids);
NTSTATUS pdb_lookup_rids(const DOM_SID *domain_sid,
int num_rids,
- uint32 *rids,
+ uint32_t *rids,
const char **names,
enum lsa_SidType *attrs);
NTSTATUS pdb_lookup_names(const DOM_SID *domain_sid,
int num_names,
const char **names,
- uint32 *rids,
+ uint32_t *rids,
enum lsa_SidType *attrs);
bool pdb_get_account_policy(enum pdb_policy_type type, uint32_t *value);
bool pdb_set_account_policy(enum pdb_policy_type type, uint32_t value);
bool pdb_sid_to_id(const DOM_SID *sid, union unid_t *id,
enum lsa_SidType *type);
uint32_t pdb_capabilities(void);
-bool pdb_new_rid(uint32 *rid);
+bool pdb_new_rid(uint32_t *rid);
bool initialize_password_db(bool reload, struct event_context *event_ctx);
struct pdb_search *pdb_search_init(TALLOC_CTX *mem_ctx,
enum pdb_search_type type);
-struct pdb_search *pdb_search_users(TALLOC_CTX *mem_ctx, uint32 acct_flags);
+struct pdb_search *pdb_search_users(TALLOC_CTX *mem_ctx, uint32_t acct_flags);
struct pdb_search *pdb_search_groups(TALLOC_CTX *mem_ctx);
struct pdb_search *pdb_search_aliases(TALLOC_CTX *mem_ctx, const DOM_SID *sid);
-uint32 pdb_search_entries(struct pdb_search *search,
- uint32 start_idx, uint32 max_entries,
+uint32_t pdb_search_entries(struct pdb_search *search,
+ uint32_t start_idx, uint32_t max_entries,
struct samr_displayentry **result);
bool pdb_get_trusteddom_pw(const char *domain, char** pwd, DOM_SID *sid,
time_t *pass_last_set_time);
bool pdb_set_trusteddom_pw(const char* domain, const char* pwd,
const DOM_SID *sid);
bool pdb_del_trusteddom_pw(const char *domain);
-NTSTATUS pdb_enum_trusteddoms(TALLOC_CTX *mem_ctx, uint32 *num_domains,
+NTSTATUS pdb_enum_trusteddoms(TALLOC_CTX *mem_ctx, uint32_t *num_domains,
struct trustdom_info ***domains);
NTSTATUS make_pdb_method( struct pdb_methods **methods ) ;
/* The following definitions come from passdb/pdb_tdb.c */
-bool init_sam_from_buffer_v2(struct samu *sampass, uint8 *buf, uint32 buflen);
+bool init_sam_from_buffer_v2(struct samu *sampass, uint8_t *buf, uint32_t buflen);
NTSTATUS pdb_tdbsam_init(void);
/* The following definitions come from passdb/secrets.c */
preserve the "special" values.
**************************************************************/
-uint32_t convert_time_t_to_uint32(time_t t)
+uint32_t convert_time_t_to_uint32_t(time_t t)
{
#if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
/* time_t is 64-bit. */
return (uint32_t)t;
}
-time_t convert_uint32_to_time_t(uint32_t u)
+time_t convert_uint32_t_to_time_t(uint32_t u)
{
#if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
/* time_t is 64-bit. */
const char *guest_account = lp_guestaccount();
const char *domain = global_myname();
char *fullname;
- uint32 urid;
+ uint32_t urid;
if ( !pwd ) {
return NT_STATUS_NO_SUCH_USER;
netr_SamInfo3 structure) */
if ( create && (pdb_capabilities() & PDB_CAP_STORE_RIDS)) {
- uint32 user_rid;
+ uint32_t user_rid;
DOM_SID user_sid;
if ( !pdb_new_rid( &user_rid ) ) {
Routine to set 32 hex password characters from a 16 byte array.
**************************************************************/
-void pdb_sethexpwd(char p[33], const unsigned char *pwd, uint32 acct_ctrl)
+void pdb_sethexpwd(char p[33], const unsigned char *pwd, uint32_t acct_ctrl)
{
if (pwd != NULL) {
int i;
Converts NT user RID to a UNIX uid.
********************************************************************/
-uid_t algorithmic_pdb_user_rid_to_uid(uint32 user_rid)
+uid_t algorithmic_pdb_user_rid_to_uid(uint32_t user_rid)
{
int rid_offset = algorithmic_rid_base();
return (uid_t)(((user_rid & (~USER_RID_TYPE)) - rid_offset)/RID_MULTIPLIER);
converts UNIX uid to an NT User RID.
********************************************************************/
-uint32 algorithmic_pdb_uid_to_user_rid(uid_t uid)
+uint32_t algorithmic_pdb_uid_to_user_rid(uid_t uid)
{
int rid_offset = algorithmic_rid_base();
- return (((((uint32)uid)*RID_MULTIPLIER) + rid_offset) | USER_RID_TYPE);
+ return (((((uint32_t)uid)*RID_MULTIPLIER) + rid_offset) | USER_RID_TYPE);
}
/*******************************************************************
Converts NT group RID to a UNIX gid.
********************************************************************/
-gid_t pdb_group_rid_to_gid(uint32 group_rid)
+gid_t pdb_group_rid_to_gid(uint32_t group_rid)
{
int rid_offset = algorithmic_rid_base();
return (gid_t)(((group_rid & (~GROUP_RID_TYPE))- rid_offset)/RID_MULTIPLIER);
there is not anymore a direct link between the gid and the rid.
********************************************************************/
-uint32 algorithmic_pdb_gid_to_group_rid(gid_t gid)
+uint32_t algorithmic_pdb_gid_to_group_rid(gid_t gid)
{
int rid_offset = algorithmic_rid_base();
- return (((((uint32)gid)*RID_MULTIPLIER) + rid_offset) | GROUP_RID_TYPE);
+ return (((((uint32_t)gid)*RID_MULTIPLIER) + rid_offset) | GROUP_RID_TYPE);
}
/*******************************************************************
Decides if a RID is a well known RID.
********************************************************************/
-static bool rid_is_well_known(uint32 rid)
+static bool rid_is_well_known(uint32_t rid)
{
/* Not using rid_offset here, because this is the actual
NT fixed value (1000) */
Decides if a RID is a user or group RID.
********************************************************************/
-bool algorithmic_pdb_rid_is_user(uint32 rid)
+bool algorithmic_pdb_rid_is_user(uint32_t rid)
{
if ( rid_is_well_known(rid) ) {
/*
/*********************************************************************
*********************************************************************/
-static bool init_samu_from_buffer_v0(struct samu *sampass, uint8 *buf, uint32 buflen)
+static bool init_samu_from_buffer_v0(struct samu *sampass, uint8_t *buf, uint32_t buflen)
{
/* times are stored as 32bit integer
take care on system with 64bit wide time_t
--SSS */
- uint32 logon_time,
+ uint32_t logon_time,
logoff_time,
kickoff_time,
pass_last_set_time,
char *profile_path = NULL;
char *acct_desc = NULL;
char *workstations = NULL;
- uint32 username_len, domain_len, nt_username_len,
+ uint32_t username_len, domain_len, nt_username_len,
dir_drive_len, unknown_str_len, munged_dial_len,
fullname_len, homedir_len, logon_script_len,
profile_path_len, acct_desc_len, workstations_len;
- uint32 user_rid, group_rid, remove_me, hours_len, unknown_6;
- uint16 acct_ctrl, logon_divs;
- uint16 bad_password_count, logon_count;
- uint8 *hours = NULL;
- uint8 *lm_pw_ptr = NULL, *nt_pw_ptr = NULL;
- uint32 len = 0;
- uint32 lm_pw_len, nt_pw_len, hourslen;
+ uint32_t user_rid, group_rid, remove_me, hours_len, unknown_6;
+ uint16_t acct_ctrl, logon_divs;
+ uint16_t bad_password_count, logon_count;
+ uint8_t *hours = NULL;
+ uint8_t *lm_pw_ptr = NULL, *nt_pw_ptr = NULL;
+ uint32_t len = 0;
+ uint32_t lm_pw_len, nt_pw_len, hourslen;
bool ret = True;
if(sampass == NULL || buf == NULL) {
&logon_count, /* w */
&unknown_6); /* d */
- if (len == (uint32) -1) {
+ if (len == (uint32_t) -1) {
ret = False;
goto done;
}
/*********************************************************************
*********************************************************************/
-static bool init_samu_from_buffer_v1(struct samu *sampass, uint8 *buf, uint32 buflen)
+static bool init_samu_from_buffer_v1(struct samu *sampass, uint8_t *buf, uint32_t buflen)
{
/* times are stored as 32bit integer
take care on system with 64bit wide time_t
--SSS */
- uint32 logon_time,
+ uint32_t logon_time,
logoff_time,
kickoff_time,
bad_password_time,
char *profile_path = NULL;
char *acct_desc = NULL;
char *workstations = NULL;
- uint32 username_len, domain_len, nt_username_len,
+ uint32_t username_len, domain_len, nt_username_len,
dir_drive_len, unknown_str_len, munged_dial_len,
fullname_len, homedir_len, logon_script_len,
profile_path_len, acct_desc_len, workstations_len;
- uint32 user_rid, group_rid, remove_me, hours_len, unknown_6;
- uint16 acct_ctrl, logon_divs;
- uint16 bad_password_count, logon_count;
- uint8 *hours = NULL;
- uint8 *lm_pw_ptr = NULL, *nt_pw_ptr = NULL;
- uint32 len = 0;
- uint32 lm_pw_len, nt_pw_len, hourslen;
+ uint32_t user_rid, group_rid, remove_me, hours_len, unknown_6;
+ uint16_t acct_ctrl, logon_divs;
+ uint16_t bad_password_count, logon_count;
+ uint8_t *hours = NULL;
+ uint8_t *lm_pw_ptr = NULL, *nt_pw_ptr = NULL;
+ uint32_t len = 0;
+ uint32_t lm_pw_len, nt_pw_len, hourslen;
bool ret = True;
if(sampass == NULL || buf == NULL) {
&logon_count, /* w */
&unknown_6); /* d */
- if (len == (uint32) -1) {
+ if (len == (uint32_t) -1) {
ret = False;
goto done;
}
return ret;
}
-static bool init_samu_from_buffer_v2(struct samu *sampass, uint8 *buf, uint32 buflen)
+static bool init_samu_from_buffer_v2(struct samu *sampass, uint8_t *buf, uint32_t buflen)
{
/* times are stored as 32bit integer
take care on system with 64bit wide time_t
--SSS */
- uint32 logon_time,
+ uint32_t logon_time,
logoff_time,
kickoff_time,
bad_password_time,
char *profile_path = NULL;
char *acct_desc = NULL;
char *workstations = NULL;
- uint32 username_len, domain_len, nt_username_len,
+ uint32_t username_len, domain_len, nt_username_len,
dir_drive_len, unknown_str_len, munged_dial_len,
fullname_len, homedir_len, logon_script_len,
profile_path_len, acct_desc_len, workstations_len;
- uint32 user_rid, group_rid, hours_len, unknown_6;
- uint16 acct_ctrl, logon_divs;
- uint16 bad_password_count, logon_count;
- uint8 *hours = NULL;
- uint8 *lm_pw_ptr = NULL, *nt_pw_ptr = NULL, *nt_pw_hist_ptr = NULL;
- uint32 len = 0;
- uint32 lm_pw_len, nt_pw_len, nt_pw_hist_len, hourslen;
- uint32 pwHistLen = 0;
+ uint32_t user_rid, group_rid, hours_len, unknown_6;
+ uint16_t acct_ctrl, logon_divs;
+ uint16_t bad_password_count, logon_count;
+ uint8_t *hours = NULL;
+ uint8_t *lm_pw_ptr = NULL, *nt_pw_ptr = NULL, *nt_pw_hist_ptr = NULL;
+ uint32_t len = 0;
+ uint32_t lm_pw_len, nt_pw_len, nt_pw_hist_len, hourslen;
+ uint32_t pwHistLen = 0;
bool ret = True;
fstring tmp_string;
bool expand_explicit = lp_passdb_expand_explicit();
&logon_count, /* w */
&unknown_6); /* d */
- if (len == (uint32) -1) {
+ if (len == (uint32_t) -1) {
ret = False;
goto done;
}
/* Change from V1 is addition of password history field. */
pdb_get_account_policy(PDB_POLICY_PASSWORD_HISTORY, &pwHistLen);
if (pwHistLen) {
- uint8 *pw_hist = SMB_MALLOC_ARRAY(uint8, pwHistLen * PW_HISTORY_ENTRY_LEN);
+ uint8_t *pw_hist = SMB_MALLOC_ARRAY(uint8_t, pwHistLen * PW_HISTORY_ENTRY_LEN);
if (!pw_hist) {
ret = False;
goto done;
/*********************************************************************
*********************************************************************/
-static bool init_samu_from_buffer_v3(struct samu *sampass, uint8 *buf, uint32 buflen)
+static bool init_samu_from_buffer_v3(struct samu *sampass, uint8_t *buf, uint32_t buflen)
{
/* times are stored as 32bit integer
take care on system with 64bit wide time_t
--SSS */
- uint32 logon_time,
+ uint32_t logon_time,
logoff_time,
kickoff_time,
bad_password_time,
char *profile_path = NULL;
char *acct_desc = NULL;
char *workstations = NULL;
- uint32 username_len, domain_len, nt_username_len,
+ uint32_t username_len, domain_len, nt_username_len,
dir_drive_len, comment_len, munged_dial_len,
fullname_len, homedir_len, logon_script_len,
profile_path_len, acct_desc_len, workstations_len;
- uint32 user_rid, group_rid, hours_len, unknown_6, acct_ctrl;
- uint16 logon_divs;
- uint16 bad_password_count, logon_count;
- uint8 *hours = NULL;
- uint8 *lm_pw_ptr = NULL, *nt_pw_ptr = NULL, *nt_pw_hist_ptr = NULL;
- uint32 len = 0;
- uint32 lm_pw_len, nt_pw_len, nt_pw_hist_len, hourslen;
- uint32 pwHistLen = 0;
+ uint32_t user_rid, group_rid, hours_len, unknown_6, acct_ctrl;
+ uint16_t logon_divs;
+ uint16_t bad_password_count, logon_count;
+ uint8_t *hours = NULL;
+ uint8_t *lm_pw_ptr = NULL, *nt_pw_ptr = NULL, *nt_pw_hist_ptr = NULL;
+ uint32_t len = 0;
+ uint32_t lm_pw_len, nt_pw_len, nt_pw_hist_len, hourslen;
+ uint32_t pwHistLen = 0;
bool ret = True;
fstring tmp_string;
bool expand_explicit = lp_passdb_expand_explicit();
&nt_pw_len, &nt_pw_ptr, /* B */
/* Change from V1 is addition of password history field. */
&nt_pw_hist_len, &nt_pw_hist_ptr, /* B */
- /* Change from V2 is the uint32 acb_mask */
+ /* Change from V2 is the uint32_t acb_mask */
&acct_ctrl, /* d */
/* Also "remove_me" field was removed. */
&logon_divs, /* w */
&logon_count, /* w */
&unknown_6); /* d */
- if (len == (uint32) -1) {
+ if (len == (uint32_t) -1) {
ret = False;
goto done;
}
- pdb_set_logon_time(sampass, convert_uint32_to_time_t(logon_time), PDB_SET);
- pdb_set_logoff_time(sampass, convert_uint32_to_time_t(logoff_time), PDB_SET);
- pdb_set_kickoff_time(sampass, convert_uint32_to_time_t(kickoff_time), PDB_SET);
- pdb_set_bad_password_time(sampass, convert_uint32_to_time_t(bad_password_time), PDB_SET);
- pdb_set_pass_can_change_time(sampass, convert_uint32_to_time_t(pass_can_change_time), PDB_SET);
- pdb_set_pass_must_change_time(sampass, convert_uint32_to_time_t(pass_must_change_time), PDB_SET);
- pdb_set_pass_last_set_time(sampass, convert_uint32_to_time_t(pass_last_set_time), PDB_SET);
+ pdb_set_logon_time(sampass, convert_uint32_t_to_time_t(logon_time), PDB_SET);
+ pdb_set_logoff_time(sampass, convert_uint32_t_to_time_t(logoff_time), PDB_SET);
+ pdb_set_kickoff_time(sampass, convert_uint32_t_to_time_t(kickoff_time), PDB_SET);
+ pdb_set_bad_password_time(sampass, convert_uint32_t_to_time_t(bad_password_time), PDB_SET);
+ pdb_set_pass_can_change_time(sampass, convert_uint32_t_to_time_t(pass_can_change_time), PDB_SET);
+ pdb_set_pass_must_change_time(sampass, convert_uint32_t_to_time_t(pass_must_change_time), PDB_SET);
+ pdb_set_pass_last_set_time(sampass, convert_uint32_t_to_time_t(pass_last_set_time), PDB_SET);
pdb_set_username(sampass, username, PDB_SET);
pdb_set_domain(sampass, domain, PDB_SET);
pdb_get_account_policy(PDB_POLICY_PASSWORD_HISTORY, &pwHistLen);
if (pwHistLen) {
- uint8 *pw_hist = (uint8 *)SMB_MALLOC(pwHistLen * PW_HISTORY_ENTRY_LEN);
+ uint8_t *pw_hist = (uint8_t *)SMB_MALLOC(pwHistLen * PW_HISTORY_ENTRY_LEN);
if (!pw_hist) {
ret = False;
goto done;
pdb_set_bad_password_count(sampass, bad_password_count, PDB_SET);
pdb_set_logon_count(sampass, logon_count, PDB_SET);
pdb_set_unknown_6(sampass, unknown_6, PDB_SET);
- /* Change from V2 is the uint32 acct_ctrl */
+ /* Change from V2 is the uint32_t acct_ctrl */
pdb_set_acct_ctrl(sampass, acct_ctrl, PDB_SET);
pdb_set_logon_divs(sampass, logon_divs, PDB_SET);
pdb_set_hours(sampass, hours, PDB_SET);
/*********************************************************************
*********************************************************************/
-static uint32 init_buffer_from_samu_v3 (uint8 **buf, struct samu *sampass, bool size_only)
+static uint32_t init_buffer_from_samu_v3 (uint8_t **buf, struct samu *sampass, bool size_only)
{
size_t len, buflen;
/* times are stored as 32bit integer
take care on system with 64bit wide time_t
--SSS */
- uint32 logon_time,
+ uint32_t logon_time,
logoff_time,
kickoff_time,
bad_password_time,
pass_can_change_time,
pass_must_change_time;
- uint32 user_rid, group_rid;
+ uint32_t user_rid, group_rid;
const char *username;
const char *domain;
const char *profile_path;
const char *acct_desc;
const char *workstations;
- uint32 username_len, domain_len, nt_username_len,
+ uint32_t username_len, domain_len, nt_username_len,
dir_drive_len, comment_len, munged_dial_len,
fullname_len, homedir_len, logon_script_len,
profile_path_len, acct_desc_len, workstations_len;
- const uint8 *lm_pw;
- const uint8 *nt_pw;
- const uint8 *nt_pw_hist;
- uint32 lm_pw_len = 16;
- uint32 nt_pw_len = 16;
- uint32 nt_pw_hist_len;
- uint32 pwHistLen = 0;
+ const uint8_t *lm_pw;
+ const uint8_t *nt_pw;
+ const uint8_t *nt_pw_hist;
+ uint32_t lm_pw_len = 16;
+ uint32_t nt_pw_len = 16;
+ uint32_t nt_pw_hist_len;
+ uint32_t pwHistLen = 0;
*buf = NULL;
buflen = 0;
- logon_time = convert_time_t_to_uint32(pdb_get_logon_time(sampass));
- logoff_time = convert_time_t_to_uint32(pdb_get_logoff_time(sampass));
- kickoff_time = convert_time_t_to_uint32(pdb_get_kickoff_time(sampass));
- bad_password_time = convert_time_t_to_uint32(pdb_get_bad_password_time(sampass));
- pass_can_change_time = convert_time_t_to_uint32(pdb_get_pass_can_change_time_noncalc(sampass));
- pass_must_change_time = convert_time_t_to_uint32(pdb_get_pass_must_change_time(sampass));
- pass_last_set_time = convert_time_t_to_uint32(pdb_get_pass_last_set_time(sampass));
+ logon_time = convert_time_t_to_uint32_t(pdb_get_logon_time(sampass));
+ logoff_time = convert_time_t_to_uint32_t(pdb_get_logoff_time(sampass));
+ kickoff_time = convert_time_t_to_uint32_t(pdb_get_kickoff_time(sampass));
+ bad_password_time = convert_time_t_to_uint32_t(pdb_get_bad_password_time(sampass));
+ pass_can_change_time = convert_time_t_to_uint32_t(pdb_get_pass_can_change_time_noncalc(sampass));
+ pass_must_change_time = convert_time_t_to_uint32_t(pdb_get_pass_must_change_time(sampass));
+ pass_last_set_time = convert_time_t_to_uint32_t(pdb_get_pass_last_set_time(sampass));
user_rid = pdb_get_user_rid(sampass);
group_rid = pdb_get_group_rid(sampass);
}
/* malloc the space needed */
- if ( (*buf=(uint8*)SMB_MALLOC(len)) == NULL) {
+ if ( (*buf=(uint8_t*)SMB_MALLOC(len)) == NULL) {
DEBUG(0,("init_buffer_from_samu_v3: Unable to malloc() memory for buffer!\n"));
return (-1);
}
return (buflen);
}
-static bool init_samu_from_buffer_v4(struct samu *sampass, uint8 *buf, uint32 buflen)
+static bool init_samu_from_buffer_v4(struct samu *sampass, uint8_t *buf, uint32_t buflen)
{
/* nothing changed between V3 and V4 */
return init_samu_from_buffer_v3(sampass, buf, buflen);
}
-static uint32 init_buffer_from_samu_v4(uint8 **buf, struct samu *sampass, bool size_only)
+static uint32_t init_buffer_from_samu_v4(uint8_t **buf, struct samu *sampass, bool size_only)
{
/* nothing changed between V3 and V4 */
return init_buffer_from_samu_v3(buf, sampass, size_only);
*********************************************************************/
bool init_samu_from_buffer(struct samu *sampass, uint32_t level,
- uint8 *buf, uint32 buflen)
+ uint8_t *buf, uint32_t buflen)
{
switch (level) {
case SAMU_BUFFER_V0:
Intialize a BYTE buffer from a struct samu struct
*********************************************************************/
-uint32 init_buffer_from_samu (uint8 **buf, struct samu *sampass, bool size_only)
+uint32_t init_buffer_from_samu (uint8_t **buf, struct samu *sampass, bool size_only)
{
return init_buffer_from_samu_v4(buf, sampass, size_only);
}
bool pdb_copy_sam_account(struct samu *dst, struct samu *src )
{
- uint8 *buf = NULL;
+ uint8_t *buf = NULL;
int len;
len = init_buffer_from_samu(&buf, src, False);
bool pdb_update_bad_password_count(struct samu *sampass, bool *updated)
{
time_t LastBadPassword;
- uint16 BadPasswordCount;
- uint32 resettime;
+ uint16_t BadPasswordCount;
+ uint32_t resettime;
bool res;
BadPasswordCount = pdb_get_bad_password_count(sampass);
}
/* First, check if there is a reset time to compare */
- if ((resettime == (uint32) -1) || (resettime == 0)) {
+ if ((resettime == (uint32_t) -1) || (resettime == 0)) {
DEBUG(9, ("No reset time, can't reset bad pw count\n"));
return True;
}
LastBadPassword = pdb_get_bad_password_time(sampass);
DEBUG(7, ("LastBadPassword=%d, resettime=%d, current time=%d.\n",
- (uint32) LastBadPassword, resettime, (uint32)time(NULL)));
- if (time(NULL) > (LastBadPassword + convert_uint32_to_time_t(resettime)*60)){
+ (uint32_t) LastBadPassword, resettime, (uint32_t)time(NULL)));
+ if (time(NULL) > (LastBadPassword + convert_uint32_t_to_time_t(resettime)*60)){
pdb_set_bad_password_count(sampass, 0, PDB_CHANGED);
pdb_set_bad_password_time(sampass, 0, PDB_CHANGED);
if (updated) {
bool pdb_update_autolock_flag(struct samu *sampass, bool *updated)
{
- uint32 duration;
+ uint32_t duration;
time_t LastBadPassword;
bool res;
}
/* First, check if there is a duration to compare */
- if ((duration == (uint32) -1) || (duration == 0)) {
+ if ((duration == (uint32_t) -1) || (duration == 0)) {
DEBUG(9, ("pdb_update_autolock_flag: No reset duration, can't reset autolock\n"));
return True;
}
LastBadPassword = pdb_get_bad_password_time(sampass);
DEBUG(7, ("pdb_update_autolock_flag: Account %s, LastBadPassword=%d, duration=%d, current time =%d.\n",
- pdb_get_username(sampass), (uint32)LastBadPassword, duration*60, (uint32)time(NULL)));
+ pdb_get_username(sampass), (uint32_t)LastBadPassword, duration*60, (uint32_t)time(NULL)));
if (LastBadPassword == (time_t)0) {
DEBUG(1,("pdb_update_autolock_flag: Account %s "
return True;
}
- if ((time(NULL) > (LastBadPassword + convert_uint32_to_time_t(duration) * 60))) {
+ if ((time(NULL) > (LastBadPassword + convert_uint32_t_to_time_t(duration) * 60))) {
pdb_set_acct_ctrl(sampass,
pdb_get_acct_ctrl(sampass) & ~ACB_AUTOLOCK,
PDB_CHANGED);
bool pdb_increment_bad_password_count(struct samu *sampass)
{
- uint32 account_policy_lockout;
+ uint32_t account_policy_lockout;
bool autolock_updated = False, badpw_updated = False;
bool ret;
appropriate account name is stored in account_name.
*******************************************************************/
-bool get_trust_pw_hash(const char *domain, uint8 ret_pwd[16],
+bool get_trust_pw_hash(const char *domain, uint8_t ret_pwd[16],
const char **account_name,
enum netr_SchannelType *channel)
{
Collection of get...() functions for struct samu.
********************************************************************/
-uint32 pdb_get_acct_ctrl(const struct samu *sampass)
+uint32_t pdb_get_acct_ctrl(const struct samu *sampass)
{
return sampass->acct_ctrl;
}
time_t pdb_get_pass_can_change_time(const struct samu *sampass)
{
- uint32 allow;
+ uint32_t allow;
/* if the last set time is zero, it means the user cannot
change their password, and this time must be zero. jmcd
time_t pdb_get_pass_must_change_time(const struct samu *sampass)
{
- uint32 expire;
+ uint32_t expire;
if (sampass->pass_last_set_time == 0)
return (time_t) 0;
return get_time_t_max();
if (!pdb_get_account_policy(PDB_POLICY_MAX_PASSWORD_AGE, &expire)
- || expire == (uint32)-1 || expire == 0)
+ || expire == (uint32_t)-1 || expire == 0)
return get_time_t_max();
return sampass->pass_last_set_time + expire;
return True;
}
-uint16 pdb_get_logon_divs(const struct samu *sampass)
+uint16_t pdb_get_logon_divs(const struct samu *sampass)
{
return sampass->logon_divs;
}
-uint32 pdb_get_hours_len(const struct samu *sampass)
+uint32_t pdb_get_hours_len(const struct samu *sampass)
{
return sampass->hours_len;
}
return (uint8 *)sampass->lm_pw.data;
}
-const uint8 *pdb_get_pw_history(const struct samu *sampass, uint32 *current_hist_len)
+const uint8 *pdb_get_pw_history(const struct samu *sampass, uint32_t *current_hist_len)
{
SMB_ASSERT((!sampass->nt_pw_his.data)
|| ((sampass->nt_pw_his.length % PW_HISTORY_ENTRY_LEN) == 0));
return sampass->munged_dial;
}
-uint16 pdb_get_bad_password_count(const struct samu *sampass)
+uint16_t pdb_get_bad_password_count(const struct samu *sampass)
{
return sampass->bad_password_count;
}
-uint16 pdb_get_logon_count(const struct samu *sampass)
+uint16_t pdb_get_logon_count(const struct samu *sampass)
{
return sampass->logon_count;
}
-uint32 pdb_get_unknown_6(const struct samu *sampass)
+uint32_t pdb_get_unknown_6(const struct samu *sampass)
{
return sampass->unknown_6;
}
Collection of set...() functions for struct samu.
********************************************************************/
-bool pdb_set_acct_ctrl(struct samu *sampass, uint32 acct_ctrl, enum pdb_value_state flag)
+bool pdb_set_acct_ctrl(struct samu *sampass, uint32_t acct_ctrl, enum pdb_value_state flag)
{
sampass->acct_ctrl = acct_ctrl;
return pdb_set_init_flags(sampass, PDB_ACCTCTRL, flag);
return pdb_set_init_flags(sampass, PDB_PASSLASTSET, flag);
}
-bool pdb_set_hours_len(struct samu *sampass, uint32 len, enum pdb_value_state flag)
+bool pdb_set_hours_len(struct samu *sampass, uint32_t len, enum pdb_value_state flag)
{
sampass->hours_len = len;
return pdb_set_init_flags(sampass, PDB_HOURSLEN, flag);
}
-bool pdb_set_logon_divs(struct samu *sampass, uint16 hours, enum pdb_value_state flag)
+bool pdb_set_logon_divs(struct samu *sampass, uint16_t hours, enum pdb_value_state flag)
{
sampass->logon_divs = hours;
return pdb_set_init_flags(sampass, PDB_LOGONDIVS, flag);
in pwd.
********************************************************************/
-bool pdb_set_pw_history(struct samu *sampass, const uint8 *pwd, uint32 historyLen, enum pdb_value_state flag)
+bool pdb_set_pw_history(struct samu *sampass, const uint8 *pwd, uint32_t historyLen, enum pdb_value_state flag)
{
if (historyLen && pwd){
data_blob_free(&(sampass->nt_pw_his));
return pdb_set_init_flags(sampass, PDB_PLAINTEXT_PW, flag);
}
-bool pdb_set_bad_password_count(struct samu *sampass, uint16 bad_password_count, enum pdb_value_state flag)
+bool pdb_set_bad_password_count(struct samu *sampass, uint16_t bad_password_count, enum pdb_value_state flag)
{
sampass->bad_password_count = bad_password_count;
return pdb_set_init_flags(sampass, PDB_BAD_PASSWORD_COUNT, flag);
}
-bool pdb_set_logon_count(struct samu *sampass, uint16 logon_count, enum pdb_value_state flag)
+bool pdb_set_logon_count(struct samu *sampass, uint16_t logon_count, enum pdb_value_state flag)
{
sampass->logon_count = logon_count;
return pdb_set_init_flags(sampass, PDB_LOGON_COUNT, flag);
}
-bool pdb_set_unknown_6(struct samu *sampass, uint32 unkn, enum pdb_value_state flag)
+bool pdb_set_unknown_6(struct samu *sampass, uint32_t unkn, enum pdb_value_state flag)
{
sampass->unknown_6 = unkn;
return pdb_set_init_flags(sampass, PDB_UNKNOWN6, flag);
uchar new_lanman_p16[LM_HASH_LEN];
uchar new_nt_p16[NT_HASH_LEN];
uchar *pwhistory;
- uint32 pwHistLen;
- uint32 current_history_len;
+ uint32_t pwHistLen;
+ uint32_t current_history_len;
if (!plaintext)
return False;
}
/* check for any PDB_SET/CHANGED field and fill the appropriate mask bit */
-uint32 pdb_build_fields_present(struct samu *sampass)
+uint32_t pdb_build_fields_present(struct samu *sampass)
{
/* value set to all for testing */
return 0x00ffffff;
bool pdb_getsampwsid(struct samu *sam_acct, const DOM_SID *sid)
{
struct pdb_methods *pdb = pdb_get_methods();
- uint32 rid;
+ uint32_t rid;
void *cache_data;
/* hard code the Guest RID of 501 */
static NTSTATUS pdb_default_create_user(struct pdb_methods *methods,
TALLOC_CTX *tmp_ctx, const char *name,
- uint32 acb_info, uint32 *rid)
+ uint32_t acb_info, uint32_t *rid)
{
struct samu *sam_pass;
NTSTATUS status;
return status;
}
-NTSTATUS pdb_create_user(TALLOC_CTX *mem_ctx, const char *name, uint32 flags,
- uint32 *rid)
+NTSTATUS pdb_create_user(TALLOC_CTX *mem_ctx, const char *name, uint32_t flags,
+ uint32_t *rid)
{
struct pdb_methods *pdb = pdb_get_methods();
return pdb->create_user(pdb, mem_ctx, name, flags, rid);
static NTSTATUS pdb_default_create_dom_group(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
const char *name,
- uint32 *rid)
+ uint32_t *rid)
{
DOM_SID group_sid;
struct group *grp;
}
NTSTATUS pdb_create_dom_group(TALLOC_CTX *mem_ctx, const char *name,
- uint32 *rid)
+ uint32_t *rid)
{
struct pdb_methods *pdb = pdb_get_methods();
return pdb->create_dom_group(pdb, mem_ctx, name, rid);
static NTSTATUS pdb_default_delete_dom_group(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
- uint32 rid)
+ uint32_t rid)
{
DOM_SID group_sid;
GROUP_MAP map;
return NT_STATUS_OK;
}
-NTSTATUS pdb_delete_dom_group(TALLOC_CTX *mem_ctx, uint32 rid)
+NTSTATUS pdb_delete_dom_group(TALLOC_CTX *mem_ctx, uint32_t rid)
{
struct pdb_methods *pdb = pdb_get_methods();
return pdb->delete_dom_group(pdb, mem_ctx, rid);
NTSTATUS pdb_enum_group_members(TALLOC_CTX *mem_ctx,
const DOM_SID *sid,
- uint32 **pp_member_rids,
+ uint32_t **pp_member_rids,
size_t *p_num_members)
{
struct pdb_methods *pdb = pdb_get_methods();
/* special check for rid 513 */
if ( !NT_STATUS_IS_OK( result ) ) {
- uint32 rid;
+ uint32_t rid;
sid_peek_rid( sid, &rid );
static NTSTATUS pdb_default_add_groupmem(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
- uint32 group_rid,
- uint32 member_rid)
+ uint32_t group_rid,
+ uint32_t member_rid)
{
DOM_SID group_sid, member_sid;
struct samu *account = NULL;
return NT_STATUS_OK;
}
-NTSTATUS pdb_add_groupmem(TALLOC_CTX *mem_ctx, uint32 group_rid,
- uint32 member_rid)
+NTSTATUS pdb_add_groupmem(TALLOC_CTX *mem_ctx, uint32_t group_rid,
+ uint32_t member_rid)
{
struct pdb_methods *pdb = pdb_get_methods();
return pdb->add_groupmem(pdb, mem_ctx, group_rid, member_rid);
static NTSTATUS pdb_default_del_groupmem(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
- uint32 group_rid,
- uint32 member_rid)
+ uint32_t group_rid,
+ uint32_t member_rid)
{
DOM_SID group_sid, member_sid;
struct samu *account = NULL;
return NT_STATUS_OK;
}
-NTSTATUS pdb_del_groupmem(TALLOC_CTX *mem_ctx, uint32 group_rid,
- uint32 member_rid)
+NTSTATUS pdb_del_groupmem(TALLOC_CTX *mem_ctx, uint32_t group_rid,
+ uint32_t member_rid)
{
struct pdb_methods *pdb = pdb_get_methods();
return pdb->del_groupmem(pdb, mem_ctx, group_rid, member_rid);
}
-NTSTATUS pdb_create_alias(const char *name, uint32 *rid)
+NTSTATUS pdb_create_alias(const char *name, uint32_t *rid)
{
struct pdb_methods *pdb = pdb_get_methods();
return pdb->create_alias(pdb, name, rid);
NTSTATUS pdb_enum_alias_memberships(TALLOC_CTX *mem_ctx,
const DOM_SID *domain_sid,
const DOM_SID *members, size_t num_members,
- uint32 **pp_alias_rids,
+ uint32_t **pp_alias_rids,
size_t *p_num_alias_rids)
{
struct pdb_methods *pdb = pdb_get_methods();
NTSTATUS pdb_lookup_rids(const DOM_SID *domain_sid,
int num_rids,
- uint32 *rids,
+ uint32_t *rids,
const char **names,
enum lsa_SidType *attrs)
{
NTSTATUS pdb_lookup_names(const DOM_SID *domain_sid,
int num_names,
const char **names,
- uint32 *rids,
+ uint32_t *rids,
enum lsa_SidType *attrs)
{
struct pdb_methods *pdb = pdb_get_methods();
with add RIDs (assigned from previous algorithmic mappings)
********************************************************************/
-bool pdb_new_rid(uint32 *rid)
+bool pdb_new_rid(uint32_t *rid)
{
struct pdb_methods *pdb = pdb_get_methods();
const char *name = NULL;
enum lsa_SidType type;
- uint32 allocated_rid = 0;
+ uint32_t allocated_rid = 0;
int i;
TALLOC_CTX *ctx;
TALLOC_CTX *mem_ctx;
bool ret = False;
const char *name;
- uint32 rid;
+ uint32_t rid;
mem_ctx = talloc_new(NULL);
static NTSTATUS pdb_default_enum_group_members(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
const DOM_SID *group,
- uint32 **pp_member_rids,
+ uint32_t **pp_member_rids,
size_t *p_num_members)
{
gid_t gid;
if (num_uids == 0)
return NT_STATUS_OK;
- *pp_member_rids = TALLOC_ZERO_ARRAY(mem_ctx, uint32, num_uids);
+ *pp_member_rids = TALLOC_ZERO_ARRAY(mem_ctx, uint32_t, num_uids);
for (i=0; i<num_uids; i++) {
DOM_SID sid;
Look up a rid in the SAM we're responsible for (i.e. passdb)
********************************************************************/
-static bool lookup_global_sam_rid(TALLOC_CTX *mem_ctx, uint32 rid,
+static bool lookup_global_sam_rid(TALLOC_CTX *mem_ctx, uint32_t rid,
const char **name,
enum lsa_SidType *psid_name_use,
union unid_t *unix_id)
static NTSTATUS pdb_default_lookup_rids(struct pdb_methods *methods,
const DOM_SID *domain_sid,
int num_rids,
- uint32 *rids,
+ uint32_t *rids,
const char **names,
enum lsa_SidType *attrs)
{
const DOM_SID *domain_sid,
int num_names,
const char **names,
- uint32 *rids,
+ uint32_t *rids,
enum lsa_SidType *attrs)
{
int i;
if (sid_check_is_builtin(domain_sid)) {
for (i=0; i<num_names; i++) {
- uint32 rid;
+ uint32_t rid;
if (lookup_builtin_name(names[i], &rid)) {
attrs[i] = SID_NAME_ALIAS;
return result;
}
-static void fill_displayentry(TALLOC_CTX *mem_ctx, uint32 rid,
- uint16 acct_flags,
+static void fill_displayentry(TALLOC_CTX *mem_ctx, uint32_t rid,
+ uint16_t acct_flags,
const char *account_name,
const char *fullname,
const char *description,
struct samr_displayentry *entry)
{
struct group_search *state = (struct group_search *)s->private_data;
- uint32 rid;
+ uint32_t rid;
GROUP_MAP *map = &state->groups[state->current_group];
if (state->current_group == state->num_groups)
}
static struct samr_displayentry *pdb_search_getentry(struct pdb_search *search,
- uint32 idx)
+ uint32_t idx)
{
if (idx < search->num_entries)
return &search->cache[idx];
return (search->num_entries > idx) ? &search->cache[idx] : NULL;
}
-struct pdb_search *pdb_search_users(TALLOC_CTX *mem_ctx, uint32 acct_flags)
+struct pdb_search *pdb_search_users(TALLOC_CTX *mem_ctx, uint32_t acct_flags)
{
struct pdb_methods *pdb = pdb_get_methods();
struct pdb_search *result;
return result;
}
-uint32 pdb_search_entries(struct pdb_search *search,
- uint32 start_idx, uint32 max_entries,
+uint32_t pdb_search_entries(struct pdb_search *search,
+ uint32_t start_idx, uint32_t max_entries,
struct samr_displayentry **result)
{
struct samr_displayentry *end_entry;
- uint32 end_idx = start_idx+max_entries-1;
+ uint32_t end_idx = start_idx+max_entries-1;
/* The first entry needs to be searched after the last. Otherwise the
* first entry might have moved due to a realloc during the search for
return pdb->del_trusteddom_pw(pdb, domain);
}
-NTSTATUS pdb_enum_trusteddoms(TALLOC_CTX *mem_ctx, uint32 *num_domains,
+NTSTATUS pdb_enum_trusteddoms(TALLOC_CTX *mem_ctx, uint32_t *num_domains,
struct trustdom_info ***domains)
{
struct pdb_methods *pdb = pdb_get_methods();
static NTSTATUS pdb_default_enum_trusteddoms(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
- uint32 *num_domains,
+ uint32_t *num_domains,
struct trustdom_info ***domains)
{
return secrets_trusted_domains(mem_ctx, num_domains, domains);
******************************************************************/
static int ldapsam_search_suffix_by_rid (struct ldapsam_privates *ldap_state,
- uint32 rid, LDAPMessage ** result,
+ uint32_t rid, LDAPMessage ** result,
const char **attr)
{
char *filter = NULL;
*acct_desc = NULL,
*workstations = NULL,
*munged_dial = NULL;
- uint32 user_rid;
+ uint32_t user_rid;
uint8 smblmpwd[LM_HASH_LEN],
smbntpwd[NT_HASH_LEN];
bool use_samba_attrs = True;
- uint32 acct_ctrl = 0;
- uint16 logon_divs;
- uint16 bad_password_count = 0,
+ uint32_t acct_ctrl = 0;
+ uint16_t logon_divs;
+ uint16_t bad_password_count = 0,
logon_count = 0;
- uint32 hours_len;
+ uint32_t hours_len;
uint8 hours[MAX_HOURS_LEN];
char *temp = NULL;
struct login_cache cache_entry;
- uint32 pwHistLen;
+ uint32_t pwHistLen;
bool expand_explicit = lp_passdb_expand_explicit();
bool ret = false;
TALLOC_CTX *ctx = talloc_init("init_sam_from_ldap");
get_userattr_key2string(ldap_state->schema_ver,
LDAP_ATTR_USER_RID),
ctx))!=NULL) {
- user_rid = (uint32)atol(temp);
+ user_rid = (uint32_t)atol(temp);
pdb_set_user_sid_from_rid(sampass, user_rid, PDB_SET);
}
}
LDAP_ATTR_BAD_PASSWORD_COUNT),
ctx);
if (temp) {
- bad_password_count = (uint32) atol(temp);
+ bad_password_count = (uint32_t) atol(temp);
pdb_set_bad_password_count(sampass,
bad_password_count, PDB_SET);
}
LDAP_ATTR_LOGON_COUNT),
ctx);
if (temp) {
- logon_count = (uint32) atol(temp);
+ logon_count = (uint32_t) atol(temp);
pdb_set_logon_count(sampass, logon_count, PDB_SET);
}
enum pdb_elements))
{
char *temp = NULL;
- uint32 rid;
+ uint32_t rid;
if (mods == NULL || sampass == NULL) {
DEBUG(0, ("init_ldap_from_sam: NULL parameters found!\n"));
if (need_update(sampass, PDB_PWHISTORY)) {
char *pwstr = NULL;
- uint32 pwHistLen = 0;
+ uint32_t pwHistLen = 0;
pdb_get_account_policy(PDB_POLICY_PASSWORD_HISTORY, &pwHistLen);
pwstr = SMB_MALLOC_ARRAY(char, 1024);
pwstr[64] = '\0';
} else {
int i;
- uint32 currHistLen = 0;
+ uint32_t currHistLen = 0;
const uint8 *pwhist = pdb_get_pw_history(sampass, &currHistLen);
if (pwhist != NULL) {
/* We can only store (1024-1/64 password history entries. */
if (need_update(sampass, PDB_BAD_PASSWORD_COUNT)) /* &&
need_update(sampass, PDB_BAD_PASSWORD_TIME)) */ {
- uint16 badcount = pdb_get_bad_password_count(sampass);
+ uint16_t badcount = pdb_get_bad_password_count(sampass);
time_t badtime = pdb_get_bad_password_time(sampass);
- uint32 pol;
+ uint32_t pol;
pdb_get_account_policy(PDB_POLICY_BAD_ATTEMPT_LOCKOUT, &pol);
DEBUG(3, ("updating bad password fields, policy=%u, count=%u, time=%u\n",
{
int rc = -1;
const char ** attr_list;
- uint32 rid;
+ uint32_t rid;
switch ( ldap_state->schema_ver ) {
case SCHEMAVER_SAMBASAMACCOUNT: {
static NTSTATUS ldapsam_del_groupmem(struct pdb_methods *my_methods,
TALLOC_CTX *tmp_ctx,
- uint32 group_rid,
- uint32 member_rid);
+ uint32_t group_rid,
+ uint32_t member_rid);
static NTSTATUS ldapsam_enum_group_memberships(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
LDAPMessage *entry = NULL;
LDAPMod **mods = NULL;
int ldap_op = LDAP_MOD_REPLACE;
- uint32 num_result;
+ uint32_t num_result;
const char **attr_list;
char *escape_user = NULL;
const char *username = pdb_get_username(newpwd);
static bool ldapsam_extract_rid_from_entry(LDAP *ldap_struct,
LDAPMessage *entry,
const DOM_SID *domain_sid,
- uint32 *rid)
+ uint32_t *rid)
{
fstring str;
DOM_SID sid;
static NTSTATUS ldapsam_enum_group_members(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
const DOM_SID *group,
- uint32 **pp_member_rids,
+ uint32_t **pp_member_rids,
size_t *p_num_members)
{
struct ldapsam_privates *ldap_state =
{
char *sidstr;
DOM_SID sid;
- uint32 rid;
+ uint32_t rid;
sidstr = smbldap_talloc_single_attribute(conn->ldap_struct,
entry, "sambaSID",
entry != NULL;
entry = ldap_next_entry(conn->ldap_struct, entry))
{
- uint32 rid;
+ uint32_t rid;
if (!ldapsam_extract_rid_from_entry(conn->ldap_struct,
entry,
const DOM_SID *domain_sid,
const DOM_SID *members,
size_t num_members,
- uint32 **pp_alias_rids,
+ uint32_t **pp_alias_rids,
size_t *p_num_alias_rids)
{
struct ldapsam_privates *ldap_state =
{
fstring sid_str;
DOM_SID sid;
- uint32 rid;
+ uint32_t rid;
if (!smbldap_get_single_attribute(ldap_struct, entry,
LDAP_ATTRIBUTE_SID,
static NTSTATUS ldapsam_set_account_policy_in_ldap(struct pdb_methods *methods,
enum pdb_policy_type type,
- uint32 value)
+ uint32_t value)
{
NTSTATUS ntstatus = NT_STATUS_UNSUCCESSFUL;
int rc;
static NTSTATUS ldapsam_get_account_policy_from_ldap(struct pdb_methods *methods,
enum pdb_policy_type type,
- uint32 *value)
+ uint32_t *value)
{
NTSTATUS ntstatus = NT_STATUS_UNSUCCESSFUL;
LDAPMessage *result = NULL;
goto out;
}
- *value = (uint32)atol(vals[0]);
+ *value = (uint32_t)atol(vals[0]);
ntstatus = NT_STATUS_OK;
static NTSTATUS ldapsam_lookup_rids(struct pdb_methods *methods,
const DOM_SID *domain_sid,
int num_rids,
- uint32 *rids,
+ uint32_t *rids,
const char **names,
enum lsa_SidType *attrs)
{
for (entry = ldap_first_entry(ld, msg);
entry != NULL;
entry = ldap_next_entry(ld, entry)) {
- uint32 rid;
+ uint32_t rid;
int rid_index;
const char *name;
entry != NULL;
entry = ldap_next_entry(ld, entry))
{
- uint32 rid;
+ uint32_t rid;
int rid_index;
const char *attr;
enum lsa_SidType type;
struct ldap_search_state {
struct smbldap_state *connection;
- uint32 acct_flags;
- uint16 group_type;
+ uint32_t acct_flags;
+ uint16_t group_type;
const char *base;
int scope;
char **vals;
size_t converted_size;
DOM_SID sid;
- uint32 acct_flags;
+ uint32_t acct_flags;
vals = ldap_get_values(ld, entry, "sambaAcctFlags");
if ((vals == NULL) || (vals[0] == NULL)) {
static bool ldapsam_search_users(struct pdb_methods *methods,
struct pdb_search *search,
- uint32 acct_flags)
+ uint32_t acct_flags)
{
struct ldapsam_privates *ldap_state =
(struct ldapsam_privates *)methods->private_data;
char **vals;
size_t converted_size;
DOM_SID sid;
- uint16 group_type;
+ uint16_t group_type;
result->account_name = "";
result->fullname = "";
}
static NTSTATUS ldapsam_get_new_rid(struct ldapsam_privates *priv,
- uint32 *rid)
+ uint32_t *rid)
{
struct smbldap_state *smbldap_state = priv->smbldap_state;
NTSTATUS status;
char *value;
int rc;
- uint32 nextRid = 0;
+ uint32_t nextRid = 0;
const char *dn;
TALLOC_CTX *mem_ctx;
value = smbldap_talloc_single_attribute(priv2ld(priv), entry,
"sambaNextRid", mem_ctx);
if (value != NULL) {
- uint32 tmp = (uint32)strtoul(value, NULL, 10);
+ uint32_t tmp = (uint32_t)strtoul(value, NULL, 10);
nextRid = MAX(nextRid, tmp);
}
value = smbldap_talloc_single_attribute(priv2ld(priv), entry,
"sambaNextUserRid", mem_ctx);
if (value != NULL) {
- uint32 tmp = (uint32)strtoul(value, NULL, 10);
+ uint32_t tmp = (uint32_t)strtoul(value, NULL, 10);
nextRid = MAX(nextRid, tmp);
}
value = smbldap_talloc_single_attribute(priv2ld(priv), entry,
"sambaNextGroupRid", mem_ctx);
if (value != NULL) {
- uint32 tmp = (uint32)strtoul(value, NULL, 10);
+ uint32_t tmp = (uint32_t)strtoul(value, NULL, 10);
nextRid = MAX(nextRid, tmp);
}
return status;
}
-static NTSTATUS ldapsam_new_rid_internal(struct pdb_methods *methods, uint32 *rid)
+static NTSTATUS ldapsam_new_rid_internal(struct pdb_methods *methods, uint32_t *rid)
{
int i;
return NT_STATUS_ACCESS_DENIED;
}
-static bool ldapsam_new_rid(struct pdb_methods *methods, uint32 *rid)
+static bool ldapsam_new_rid(struct pdb_methods *methods, uint32_t *rid)
{
NTSTATUS result = ldapsam_new_rid_internal(methods, rid);
return NT_STATUS_IS_OK(result) ? True : False;
static NTSTATUS ldapsam_create_user(struct pdb_methods *my_methods,
TALLOC_CTX *tmp_ctx, const char *name,
- uint32 acb_info, uint32 *rid)
+ uint32_t acb_info, uint32_t *rid)
{
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
LDAPMessage *entry = NULL;
LDAPMessage *result = NULL;
- uint32 num_result;
+ uint32_t num_result;
bool is_machine = False;
bool add_posix = False;
LDAPMod **mods = NULL;
static NTSTATUS ldapsam_create_dom_group(struct pdb_methods *my_methods,
TALLOC_CTX *tmp_ctx,
const char *name,
- uint32 *rid)
+ uint32_t *rid)
{
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
NTSTATUS ret;
LDAPMessage *entry = NULL;
LDAPMessage *result = NULL;
- uint32 num_result;
+ uint32_t num_result;
bool is_new_entry = False;
LDAPMod **mods = NULL;
char *filter;
return NT_STATUS_OK;
}
-static NTSTATUS ldapsam_delete_dom_group(struct pdb_methods *my_methods, TALLOC_CTX *tmp_ctx, uint32 rid)
+static NTSTATUS ldapsam_delete_dom_group(struct pdb_methods *my_methods, TALLOC_CTX *tmp_ctx, uint32_t rid)
{
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
LDAPMessage *result = NULL;
static NTSTATUS ldapsam_change_groupmem(struct pdb_methods *my_methods,
TALLOC_CTX *tmp_ctx,
- uint32 group_rid,
- uint32 member_rid,
+ uint32_t group_rid,
+ uint32_t member_rid,
int modop)
{
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
LDAPMessage *entry = NULL;
LDAPMessage *result = NULL;
- uint32 num_result;
+ uint32_t num_result;
LDAPMod **mods = NULL;
char *filter;
char *uidstr;
static NTSTATUS ldapsam_add_groupmem(struct pdb_methods *my_methods,
TALLOC_CTX *tmp_ctx,
- uint32 group_rid,
- uint32 member_rid)
+ uint32_t group_rid,
+ uint32_t member_rid)
{
return ldapsam_change_groupmem(my_methods, tmp_ctx, group_rid, member_rid, LDAP_MOD_ADD);
}
static NTSTATUS ldapsam_del_groupmem(struct pdb_methods *my_methods,
TALLOC_CTX *tmp_ctx,
- uint32 group_rid,
- uint32 member_rid)
+ uint32_t group_rid,
+ uint32_t member_rid)
{
return ldapsam_change_groupmem(my_methods, tmp_ctx, group_rid, member_rid, LDAP_MOD_DELETE);
}
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
LDAPMessage *entry = NULL;
LDAPMessage *result = NULL;
- uint32 num_result;
+ uint32_t num_result;
LDAPMod **mods = NULL;
char *filter;
char *escape_username;
int attrsonly = 0; /* 0: return values too */
LDAPMessage *result = NULL;
char *trusted_dn;
- uint32 num_result;
+ uint32_t num_result;
filter = talloc_asprintf(talloc_tos(),
"(&(objectClass=%s)(sambaDomainName=%s))",
static NTSTATUS ldapsam_enum_trusteddoms(struct pdb_methods *methods,
TALLOC_CTX *mem_ctx,
- uint32 *num_domains,
+ uint32_t *num_domains,
struct trustdom_info ***domains)
{
int rc;
{
NTSTATUS nt_status;
struct ldapsam_privates *ldap_state = NULL;
- uint32 alg_rid_base;
+ uint32_t alg_rid_base;
char *alg_rid_base_string = NULL;
LDAPMessage *result = NULL;
LDAPMessage *entry = NULL;
LDAP_ATTR_ALGORITHMIC_RID_BASE ),
talloc_tos());
if (alg_rid_base_string) {
- alg_rid_base = (uint32)atol(alg_rid_base_string);
+ alg_rid_base = (uint32_t)atol(alg_rid_base_string);
if (alg_rid_base != algorithmic_rid_base()) {
DEBUG(0, ("The value of 'algorithmic RID base' has "
"changed since the LDAP\n"
const unsigned char *smb_passwd; /* Null if no password */
const unsigned char *smb_nt_passwd; /* Null if no password */
- uint16 acct_ctrl; /* account info (ACB_xxxx bit-mask) */
+ uint16_t acct_ctrl; /* account info (ACB_xxxx bit-mask) */
time_t pass_last_set_time; /* password last set time */
};
/* Add the account encoding and the last change time. */
slprintf((char *)p, new_entry_length - 1 - (p - new_entry), "%s:LCT-%08X:\n",
pdb_encode_acct_ctrl(newpwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN),
- (uint32)newpwd->pass_last_set_time);
+ (uint32_t)newpwd->pass_last_set_time);
return new_entry;
}
slprintf(&ascii_p16[strlen(ascii_p16)],
sizeof(ascii_p16)-(strlen(ascii_p16)+1),
"%s:LCT-%08X:",
- encode_bits, (uint32)pwd->pass_last_set_time );
+ encode_bits, (uint32_t)pwd->pass_last_set_time );
wr_len = strlen(ascii_p16);
}
static bool build_smb_pass (struct smb_passwd *smb_pw, const struct samu *sampass)
{
- uint32 rid;
+ uint32_t rid;
if (sampass == NULL)
return False;
struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
struct smb_passwd *smb_pw;
FILE *fp = NULL;
- uint32 rid;
+ uint32_t rid;
DEBUG(10, ("smbpasswd_getsampwrid: search by sid: %s\n",
sid_string_dbg(sid)));
int i;
for (i=1; decode_account_policy_name(i) != NULL; i++) {
- uint32 policy_value;
+ uint32_t policy_value;
if (!account_policy_get_default(i, &policy_value)) {
fprintf(stderr, "Can't get default account policy\n");
return -1;
int i;
for ( i=1; decode_account_policy_name(i) != NULL; i++ ) {
- uint32 policy_value;
+ uint32_t policy_value;
NTSTATUS status;
status = in->get_account_policy(in, i, &policy_value);
if (verbosity) {
char temp[44];
- const uint8 *hours;
+ const uint8_t *hours;
printf ("Unix username: %s\n", pdb_get_username(sam_pwent));
printf ("NT username: %s\n", pdb_get_nt_username(sam_pwent));
lm_passwd,
nt_passwd,
pdb_encode_acct_ctrl(pdb_get_acct_ctrl(sam_pwent),NEW_PW_FORMAT_SPACE_PADDED_LEN),
- (uint32)convert_time_t_to_uint32(pdb_get_pass_last_set_time(sam_pwent)));
+ (uint32)convert_time_t_to_uint32_t(pdb_get_pass_last_set_time(sam_pwent)));
} else {
uid = nametouid(pdb_get_username(sam_pwent));
printf ("%s:%lu:%s\n", pdb_get_username(sam_pwent), (unsigned long)uid,
return -1;
}
- value = convert_uint32_to_time_t(num);
+ value = convert_uint32_t_to_time_t(num);
}
pdb_set_kickoff_time(sam_pwent, value, PDB_CHANGED);
/* account policy operations */
if ((checkparms & BIT_ACCPOLICY) && !(checkparms & ~(BIT_ACCPOLICY + BIT_ACCPOLVAL))) {
- uint32 value;
+ uint32_t value;
enum pdb_policy_type field = account_policy_name_to_typenum(account_policy);
if (field == 0) {
const char **names;
git.samba.org / idra / samba.git / commitdiff