sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-08-04 08:22:08 +03:00
Code Activity

sync with HEAD

Browse Source
This commit is contained in:
Gerald Carter
-
parent 9d9f7bbf87
commit ee9cbf5807
8 changed files with 253 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
source/lib/time.c
View File

@ -1,8 +1,8 @@
/*
Unix SMB/CIFS implementation.
time handling functions
Copyright (C) Andrew Tridgell 1992-1998
Copyright (C) Andrew Tridgell 1992-1998
Copyright (C) Stefan (metze) Metzmacher 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
@ -748,3 +748,13 @@ void init_nt_time(NTTIME *nt)
nt->high = 0x7FFFFFFF;
nt->low = 0xFFFFFFFF;
}
/****************************************************************************
check if NTTIME is 0
****************************************************************************/
BOOL nt_time_is_zero(NTTIME *nt)
{
if(nt->high==0)
return True;
return False;
}

2
source/passdb/passdb.c
View File

@ -978,7 +978,7 @@ const char *pdb_unistr2_convert(const UNISTR2 *from)
static pstring convert_buffer;
*convert_buffer = 0;
if (!from) {
return convert_buffer;
return NULL;
}
unistr2_to_ascii(convert_buffer, from, sizeof(pstring));

1
source/passdb/pdb_get_set.c
View File

@ -964,6 +964,7 @@ BOOL pdb_set_plaintext_pw_only (SAM_ACCOUNT *sampass, const char *password)
if (password) {
if (sampass->private.plaintext_pw!=NULL)
memset(sampass->private.plaintext_pw,'\0',strlen(sampass->private.plaintext_pw)+1);
sampass->private.plaintext_pw = talloc_strdup(sampass->mem_ctx, password);
if (!sampass->private.plaintext_pw) {

116
source/passdb/pdb_interface.c
View File

@ -39,26 +39,28 @@ const struct pdb_init_function_entry builtin_pdb_init_functions[] = {
{ NULL, NULL}
};
static BOOL context_setsampwent(struct pdb_context *context, BOOL update)
static NTSTATUS context_setsampwent(struct pdb_context *context, BOOL update)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
if (!context) {
DEBUG(0, ("invalid pdb_context specified!\n"));
return False;
return ret;
}
context->pwent_methods = context->pdb_methods;
if (!context->pwent_methods) {
/* No passdbs at all */
return True;
return ret;
}
while (!(context->pwent_methods->setsampwent) || !(context->pwent_methods->setsampwent(context->pwent_methods, update))) {
while (NT_STATUS_IS_ERR(ret = context->pwent_methods->setsampwent(context->pwent_methods, update))) {
context->pwent_methods = context->pwent_methods->next;
if (context->pwent_methods == NULL)
return False;
return NT_STATUS_UNSUCCESSFUL;
}
return True;
return ret;
}
static void context_endsampwent(struct pdb_context *context)
@ -75,81 +77,82 @@ static void context_endsampwent(struct pdb_context *context)
context->pwent_methods = NULL;
}
static BOOL context_getsampwent(struct pdb_context *context, SAM_ACCOUNT *user)
static NTSTATUS context_getsampwent(struct pdb_context *context, SAM_ACCOUNT *user)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
if ((!context) || (!context->pwent_methods)) {
DEBUG(0, ("invalid pdb_context specified!\n"));
return False;
return ret;
}
/* Loop until we find something useful */
while ((!context->pwent_methods->getsampwent) ||
context->pwent_methods->getsampwent(context->pwent_methods, user) == False){
while (NT_STATUS_IS_ERR(ret = context->pwent_methods->getsampwent(context->pwent_methods, user))) {
if (context->pwent_methods->endsampwent)
context->pwent_methods->endsampwent(context->pwent_methods);
context->pwent_methods->endsampwent(context->pwent_methods);
context->pwent_methods = context->pwent_methods->next;
/* All methods are checked now. There are no more entries */
if (context->pwent_methods == NULL)
return False;
return ret;
if (!context->pwent_methods->setsampwent){
DEBUG(5, ("next backend does not implment setsampwent\n"));
return False;
}
context->pwent_methods->setsampwent(context->pwent_methods, False);
}
user->methods = context->pwent_methods;
return True;
return ret;
}
static BOOL context_getsampwnam(struct pdb_context *context, SAM_ACCOUNT *sam_acct, const char *username)
static NTSTATUS context_getsampwnam(struct pdb_context *context, SAM_ACCOUNT *sam_acct, const char *username)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct pdb_methods *curmethods;
if ((!context)) {
DEBUG(0, ("invalid pdb_context specified!\n"));
return False;
return ret;
}
curmethods = context->pdb_methods;
while (curmethods){
if (curmethods->getsampwnam && curmethods->getsampwnam(curmethods, sam_acct, username) == True){
if (NT_STATUS_IS_OK(ret = curmethods->getsampwnam(curmethods, sam_acct, username))) {
sam_acct->methods = curmethods;
return True;
return ret;
}
curmethods = curmethods->next;
}
return False;
return ret;
}
static BOOL context_getsampwsid(struct pdb_context *context, SAM_ACCOUNT *sam_acct, const DOM_SID *sid)
static NTSTATUS context_getsampwsid(struct pdb_context *context, SAM_ACCOUNT *sam_acct, const DOM_SID *sid)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct pdb_methods *curmethods;
if ((!context)) {
DEBUG(0, ("invalid pdb_context specified!\n"));
return False;
return ret;
}
curmethods = context->pdb_methods;
while (curmethods){
if (curmethods->getsampwsid && curmethods->getsampwsid(curmethods, sam_acct, sid) == True){
if (NT_STATUS_IS_OK(ret = curmethods->getsampwsid(curmethods, sam_acct, sid))) {
sam_acct->methods = curmethods;
return True;
return ret;
}
curmethods = curmethods->next;
}
return False;
return ret;
}
static BOOL context_add_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
static NTSTATUS context_add_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
{
if ((!context) || (!context->pdb_methods) || (!context->pdb_methods->add_sam_account)) {
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
if ((!context) || (!context->pdb_methods)) {
DEBUG(0, ("invalid pdb_context specified!\n"));
return False;
return ret;
}
/** @todo This is where a 're-read on add' should be done */
@ -159,21 +162,18 @@ static BOOL context_add_sam_account(struct pdb_context *context, SAM_ACCOUNT *sa
return context->pdb_methods->add_sam_account(context->pdb_methods, sam_acct);
}
static BOOL context_update_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
static NTSTATUS context_update_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
if (!context) {
DEBUG(0, ("invalid pdb_context specified!\n"));
return False;
return ret;
}
if (!sam_acct || !sam_acct->methods){
DEBUG(0, ("invalid sam_acct specified\n"));
return False;
}
if (!sam_acct->methods->update_sam_account){
DEBUG(0, ("invalid sam_acct->methods\n"));
return False;
return ret;
}
/** @todo This is where a 're-read on update' should be done */
@ -181,12 +181,14 @@ static BOOL context_update_sam_account(struct pdb_context *context, SAM_ACCOUNT
return sam_acct->methods->update_sam_account(sam_acct->methods, sam_acct);
}
static BOOL context_delete_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
static NTSTATUS context_delete_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct pdb_methods *pdb_selected;
if (!context) {
DEBUG(0, ("invalid pdb_context specified!\n"));
return False;
return ret;
}
if (!sam_acct->methods){
@ -197,17 +199,17 @@ static BOOL context_delete_sam_account(struct pdb_context *context, SAM_ACCOUNT
* in /etc/passwd.
*/
while (pdb_selected){
if (pdb_selected->delete_sam_account && pdb_selected->delete_sam_account(pdb_selected, sam_acct)){
return True;
if (NT_STATUS_IS_OK(ret = pdb_selected->delete_sam_account(pdb_selected, sam_acct))) {
return ret;
}
pdb_selected = pdb_selected->next;
}
return False;
return ret;
}
if (!sam_acct->methods->delete_sam_account){
DEBUG(0,("invalid sam_acct->methods->delete_sam_account\n"));
return False;
return ret;
}
return sam_acct->methods->delete_sam_account(sam_acct->methods, sam_acct);
@ -223,9 +225,7 @@ static void free_pdb_context(struct pdb_context **context)
struct pdb_methods *pdb_selected = (*context)->pdb_methods;
while (pdb_selected){
if (pdb_selected->free_private_data) {
pdb_selected->free_private_data(&(pdb_selected->private_data));
}
pdb_selected->free_private_data(&(pdb_selected->private_data));
pdb_selected = pdb_selected->next;
}
@ -371,13 +371,13 @@ static struct pdb_context *pdb_get_static_context(BOOL reload)
if ((pdb_context) && (reload)) {
pdb_context->free_fn(&pdb_context);
if (!NT_STATUS_IS_OK(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
if (NT_STATUS_IS_ERR(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
return NULL;
}
}
if (!pdb_context) {
if (!NT_STATUS_IS_OK(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
if (NT_STATUS_IS_ERR(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
return NULL;
}
}
@ -399,7 +399,7 @@ BOOL pdb_setsampwent(BOOL update)
return False;
}
return pdb_context->pdb_setsampwent(pdb_context, update);
return NT_STATUS_IS_OK(pdb_context->pdb_setsampwent(pdb_context, update));
}
void pdb_endsampwent(void)
@ -421,7 +421,7 @@ BOOL pdb_getsampwent(SAM_ACCOUNT *user)
return False;
}
return pdb_context->pdb_getsampwent(pdb_context, user);
return NT_STATUS_IS_OK(pdb_context->pdb_getsampwent(pdb_context, user));
}
BOOL pdb_getsampwnam(SAM_ACCOUNT *sam_acct, const char *username)
@ -432,7 +432,7 @@ BOOL pdb_getsampwnam(SAM_ACCOUNT *sam_acct, const char *username)
return False;
}
return pdb_context->pdb_getsampwnam(pdb_context, sam_acct, username);
return NT_STATUS_IS_OK(pdb_context->pdb_getsampwnam(pdb_context, sam_acct, username));
}
BOOL pdb_getsampwsid(SAM_ACCOUNT *sam_acct, const DOM_SID *sid)
@ -443,7 +443,7 @@ BOOL pdb_getsampwsid(SAM_ACCOUNT *sam_acct, const DOM_SID *sid)
return False;
}
return pdb_context->pdb_getsampwsid(pdb_context, sam_acct, sid);
return NT_STATUS_IS_OK(pdb_context->pdb_getsampwsid(pdb_context, sam_acct, sid));
}
BOOL pdb_add_sam_account(SAM_ACCOUNT *sam_acct)
@ -454,7 +454,7 @@ BOOL pdb_add_sam_account(SAM_ACCOUNT *sam_acct)
return False;
}
return pdb_context->pdb_add_sam_account(pdb_context, sam_acct);
return NT_STATUS_IS_OK(pdb_context->pdb_add_sam_account(pdb_context, sam_acct));
}
BOOL pdb_update_sam_account(SAM_ACCOUNT *sam_acct)
@ -465,7 +465,7 @@ BOOL pdb_update_sam_account(SAM_ACCOUNT *sam_acct)
return False;
}
return pdb_context->pdb_update_sam_account(pdb_context, sam_acct);
return NT_STATUS_IS_OK(pdb_context->pdb_update_sam_account(pdb_context, sam_acct));
}
BOOL pdb_delete_sam_account(SAM_ACCOUNT *sam_acct)
@ -476,7 +476,7 @@ BOOL pdb_delete_sam_account(SAM_ACCOUNT *sam_acct)
return False;
}
return pdb_context->pdb_delete_sam_account(pdb_context, sam_acct);
return NT_STATUS_IS_OK(pdb_context->pdb_delete_sam_account(pdb_context, sam_acct));
}
#endif /* !defined(WITH_NISPLUS_SAM) */

133
source/passdb/pdb_ldap.c
View File

@ -1183,18 +1183,19 @@ static uint32 ldapsam_get_next_available_nua_rid(struct ldapsam_privates *ldap_s
/**********************************************************************
Connect to LDAP server for password enumeration
*********************************************************************/
static BOOL ldapsam_setsampwent(struct pdb_methods *my_methods, BOOL update)
static NTSTATUS ldapsam_setsampwent(struct pdb_methods *my_methods, BOOL update)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
int rc;
pstring filter;
if (!ldapsam_open_connection(ldap_state, &ldap_state->ldap_struct)) {
return False;
return ret;
}
if (!ldapsam_connect_system(ldap_state, ldap_state->ldap_struct)) {
ldap_unbind(ldap_state->ldap_struct);
return False;
return ret;
}
pstrcpy(filter, lp_ldap_filter());
@ -1211,7 +1212,7 @@ static BOOL ldapsam_setsampwent(struct pdb_methods *my_methods, BOOL update)
ldap_unbind(ldap_state->ldap_struct);
ldap_state->ldap_struct = NULL;
ldap_state->result = NULL;
return False;
return ret;
}
DEBUG(2, ("ldapsam_setsampwent: %d entries in the base!\n",
@ -1222,7 +1223,7 @@ static BOOL ldapsam_setsampwent(struct pdb_methods *my_methods, BOOL update)
ldap_state->result);
ldap_state->index = 0;
return True;
return NT_STATUS_OK;
}
/**********************************************************************
@ -1242,56 +1243,58 @@ static void ldapsam_endsampwent(struct pdb_methods *my_methods)
/**********************************************************************
Get the next entry in the LDAP password database
*********************************************************************/
static BOOL ldapsam_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *user)
static NTSTATUS ldapsam_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *user)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
BOOL ret = False;
BOOL bret = False;
/* The rebind proc needs this *HACK*. We are not multithreaded, so
this will work, but it's not nice. */
static_ldap_state = ldap_state;
while (!ret) {
while (!bret) {
if (!ldap_state->entry)
return False;
return ret;
ldap_state->index++;
ret = init_sam_from_ldap(ldap_state, user, ldap_state->ldap_struct,
bret = init_sam_from_ldap(ldap_state, user, ldap_state->ldap_struct,
ldap_state->entry);
ldap_state->entry = ldap_next_entry(ldap_state->ldap_struct,
ldap_state->entry);
}
return True;
return NT_STATUS_OK;
}
/**********************************************************************
Get SAM_ACCOUNT entry from LDAP by username
*********************************************************************/
static BOOL ldapsam_getsampwnam(struct pdb_methods *my_methods, SAM_ACCOUNT *user, const char *sname)
static NTSTATUS ldapsam_getsampwnam(struct pdb_methods *my_methods, SAM_ACCOUNT *user, const char *sname)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
LDAP *ldap_struct;
LDAPMessage *result;
LDAPMessage *entry;
if (!ldapsam_open_connection(ldap_state, &ldap_struct))
return False;
return ret;
if (!ldapsam_connect_system(ldap_state, ldap_struct)) {
ldap_unbind(ldap_struct);
return False;
return ret;
}
if (ldapsam_search_one_user_by_name(ldap_state, ldap_struct, sname, &result) != LDAP_SUCCESS) {
ldap_unbind(ldap_struct);
return False;
return ret;
}
if (ldap_count_entries(ldap_struct, result) < 1) {
DEBUG(4,
("We don't find this user [%s] count=%d\n", sname,
ldap_count_entries(ldap_struct, result)));
ldap_unbind(ldap_struct);
return False;
return ret;
}
entry = ldap_first_entry(ldap_struct, result);
if (entry) {
@ -1299,39 +1302,39 @@ static BOOL ldapsam_getsampwnam(struct pdb_methods *my_methods, SAM_ACCOUNT *use
DEBUG(1,("ldapsam_getsampwnam: init_sam_from_ldap failed for user '%s'!\n", sname));
ldap_msgfree(result);
ldap_unbind(ldap_struct);
return False;
return ret;
}
ldap_msgfree(result);
ldap_unbind(ldap_struct);
return True;
ret = NT_STATUS_OK;
} else {
ldap_msgfree(result);
ldap_unbind(ldap_struct);
return False;
}
return ret;
}
/**********************************************************************
Get SAM_ACCOUNT entry from LDAP by rid
*********************************************************************/
static BOOL ldapsam_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *user, uint32 rid)
static NTSTATUS ldapsam_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *user, uint32 rid)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
LDAP *ldap_struct;
LDAPMessage *result;
LDAPMessage *entry;
if (!ldapsam_open_connection(ldap_state, &ldap_struct))
return False;
return ret;
if (!ldapsam_connect_system(ldap_state, ldap_struct)) {
ldap_unbind(ldap_struct);
return False;
return ret;
}
if (ldapsam_search_one_user_by_rid(ldap_state, ldap_struct, rid, &result) !=
LDAP_SUCCESS) {
if (ldapsam_search_one_user_by_rid(ldap_state, ldap_struct, rid, &result) != LDAP_SUCCESS) {
ldap_unbind(ldap_struct);
return False;
return ret;
}
if (ldap_count_entries(ldap_struct, result) < 1) {
@ -1339,7 +1342,7 @@ static BOOL ldapsam_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *use
("We don't find this rid [%i] count=%d\n", rid,
ldap_count_entries(ldap_struct, result)));
ldap_unbind(ldap_struct);
return False;
return ret;
}
entry = ldap_first_entry(ldap_struct, result);
@ -1348,28 +1351,29 @@ static BOOL ldapsam_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *use
DEBUG(1,("ldapsam_getsampwrid: init_sam_from_ldap failed!\n"));
ldap_msgfree(result);
ldap_unbind(ldap_struct);
return False;
return ret;
}
ldap_msgfree(result);
ldap_unbind(ldap_struct);
return True;
ret = NT_STATUS_OK;
} else {
ldap_msgfree(result);
ldap_unbind(ldap_struct);
return False;
}
return ret;
}
static BOOL ldapsam_getsampwsid(struct pdb_methods *my_methods, SAM_ACCOUNT * user, const DOM_SID *sid)
static NTSTATUS ldapsam_getsampwsid(struct pdb_methods *my_methods, SAM_ACCOUNT * user, const DOM_SID *sid)
{
uint32 rid;
if (!sid_peek_check_rid(get_global_sam_sid(), sid, &rid))
return False;
return NT_STATUS_UNSUCCESSFUL;
return ldapsam_getsampwrid(my_methods, user, rid);
}
static BOOL ldapsam_modify_entry(LDAP *ldap_struct,SAM_ACCOUNT *newpwd,char *dn,LDAPMod **mods,int ldap_op)
static NTSTATUS ldapsam_modify_entry(LDAP *ldap_struct,SAM_ACCOUNT *newpwd,char *dn,LDAPMod **mods,int ldap_op)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
int version;
int rc;
@ -1386,7 +1390,7 @@ static BOOL ldapsam_modify_entry(LDAP *ldap_struct,SAM_ACCOUNT *newpwd,char *dn,
pdb_get_username(newpwd), ldap_err2string(rc),
ld_error));
free(ld_error);
return False;
return ret;
}
break;
case LDAP_MOD_REPLACE:
@ -1399,12 +1403,12 @@ static BOOL ldapsam_modify_entry(LDAP *ldap_struct,SAM_ACCOUNT *newpwd,char *dn,
pdb_get_username(newpwd), ldap_err2string(rc),
ld_error));
free(ld_error);
return False;
return ret;
}
break;
default:
DEBUG(0,("Wrong LDAP operation type: %d!\n",ldap_op));
return False;
return ret;
}
#ifdef LDAP_EXOP_X_MODIFY_PASSWD
@ -1425,7 +1429,7 @@ static BOOL ldapsam_modify_entry(LDAP *ldap_struct,SAM_ACCOUNT *newpwd,char *dn,
if ((ber = ber_alloc_t(LBER_USE_DER))==NULL) {
DEBUG(0,("ber_alloc_t returns NULL\n"));
return False;
return ret;
}
ber_printf (ber, "{");
ber_printf (ber, "ts", LDAP_TAG_EXOP_X_MODIFY_PASSWD_ID,dn);
@ -1434,7 +1438,7 @@ static BOOL ldapsam_modify_entry(LDAP *ldap_struct,SAM_ACCOUNT *newpwd,char *dn,
if ((rc = ber_flatten (ber, &bv))<0) {
DEBUG(0,("ber_flatten returns a value <0\n"));
return False;
return ret;
}
ber_free(ber,1);
@ -1454,14 +1458,15 @@ static BOOL ldapsam_modify_entry(LDAP *ldap_struct,SAM_ACCOUNT *newpwd,char *dn,
#else
DEBUG(10,("LDAP PASSWORD SYNC is not supported!\n"));
#endif /* LDAP_EXOP_X_MODIFY_PASSWD */
return True;
return NT_STATUS_OK;
}
/**********************************************************************
Delete entry from LDAP for username
*********************************************************************/
static BOOL ldapsam_delete_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT * sam_acct)
static NTSTATUS ldapsam_delete_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT * sam_acct)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
const char *sname;
int rc;
@ -1472,20 +1477,20 @@ static BOOL ldapsam_delete_sam_account(struct pdb_methods *my_methods, SAM_ACCOU
if (!sam_acct) {
DEBUG(0, ("sam_acct was NULL!\n"));
return False;
return ret;
}
sname = pdb_get_username(sam_acct);
if (!ldapsam_open_connection(ldap_state, &ldap_struct))
return False;
return ret;
DEBUG (3, ("Deleting user %s from LDAP.\n", sname));
if (!ldapsam_connect_system(ldap_state, ldap_struct)) {
ldap_unbind (ldap_struct);
DEBUG(0, ("Failed to delete user %s from LDAP.\n", sname));
return False;
return ret;
}
rc = ldapsam_search_one_user_by_name(ldap_state, ldap_struct, sname, &result);
@ -1493,7 +1498,7 @@ static BOOL ldapsam_delete_sam_account(struct pdb_methods *my_methods, SAM_ACCOU
DEBUG (0, ("User doesn't exit!\n"));
ldap_msgfree (result);
ldap_unbind (ldap_struct);
return False;
return ret;
}
entry = ldap_first_entry (ldap_struct, result);
@ -1510,19 +1515,20 @@ static BOOL ldapsam_delete_sam_account(struct pdb_methods *my_methods, SAM_ACCOU
sname, ldap_err2string (rc), ld_error));
free (ld_error);
ldap_unbind (ldap_struct);
return False;
return ret;
}
DEBUG (2,("successfully deleted uid = %s from the LDAP database\n", sname));
ldap_unbind (ldap_struct);
return True;
return NT_STATUS_OK;
}
/**********************************************************************
Update SAM_ACCOUNT
*********************************************************************/
static BOOL ldapsam_update_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT * newpwd)
static NTSTATUS ldapsam_update_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT * newpwd)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
int rc;
char *dn;
@ -1532,11 +1538,11 @@ static BOOL ldapsam_update_sam_account(struct pdb_methods *my_methods, SAM_ACCOU
LDAPMod **mods;
if (!ldapsam_open_connection(ldap_state, &ldap_struct)) /* open a connection to the server */
return False;
return ret;
if (!ldapsam_connect_system(ldap_state, ldap_struct)) { /* connect as system account */
ldap_unbind(ldap_struct);
return False;
return ret;
}
rc = ldapsam_search_one_user_by_name(ldap_state, ldap_struct,
@ -1546,26 +1552,26 @@ static BOOL ldapsam_update_sam_account(struct pdb_methods *my_methods, SAM_ACCOU
DEBUG(0, ("No user to modify!\n"));
ldap_msgfree(result);
ldap_unbind(ldap_struct);
return False;
return ret;
}
if (!init_ldap_from_sam(ldap_state, &mods, LDAP_MOD_REPLACE, newpwd)) {
DEBUG(0, ("ldapsam_update_sam_account: init_ldap_from_sam failed!\n"));
ldap_msgfree(result);
ldap_unbind(ldap_struct);
return False;
return ret;
}
entry = ldap_first_entry(ldap_struct, result);
dn = ldap_get_dn(ldap_struct, entry);
ldap_msgfree(result);
if (!ldapsam_modify_entry(ldap_struct,newpwd,dn,mods,LDAP_MOD_REPLACE)) {
if (NT_STATUS_IS_ERR(ldapsam_modify_entry(ldap_struct,newpwd,dn,mods,LDAP_MOD_REPLACE))) {
DEBUG(0,("failed to modify user with uid = %s\n",
pdb_get_username(newpwd)));
ldap_mods_free(mods,1);
ldap_unbind(ldap_struct);
return False;
return ret;
}
@ -1574,14 +1580,15 @@ static BOOL ldapsam_update_sam_account(struct pdb_methods *my_methods, SAM_ACCOU
pdb_get_username(newpwd)));
ldap_mods_free(mods, 1);
ldap_unbind(ldap_struct);
return True;
return NT_STATUS_OK;
}
/**********************************************************************
Add SAM_ACCOUNT to LDAP
*********************************************************************/
static BOOL ldapsam_add_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT * newpwd)
static NTSTATUS ldapsam_add_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT * newpwd)
{
NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
struct ldapsam_privates *ldap_state = (struct ldapsam_privates *)my_methods->private_data;
int rc;
pstring filter;
@ -1595,15 +1602,15 @@ static BOOL ldapsam_add_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT
const char *username = pdb_get_username(newpwd);
if (!username || !*username) {
DEBUG(0, ("Cannot add user without a username!\n"));
return False;
return ret;
}
if (!ldapsam_open_connection(ldap_state, &ldap_struct)) /* open a connection to the server */
return False;
return ret;
if (!ldapsam_connect_system(ldap_state, ldap_struct)) { /* connect as system account */
ldap_unbind(ldap_struct);
return False;
return ret;
}
rc = ldapsam_search_one_user_by_name (ldap_state, ldap_struct, username, &result);
@ -1612,7 +1619,7 @@ static BOOL ldapsam_add_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT
DEBUG(0,("User already in the base, with samba properties\n"));
ldap_msgfree(result);
ldap_unbind(ldap_struct);
return False;
return ret;
}
ldap_msgfree(result);
@ -1623,7 +1630,7 @@ static BOOL ldapsam_add_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT
if (num_result > 1) {
DEBUG (0, ("More than one user with that uid exists: bailing out!\n"));
ldap_msgfree(result);
return False;
return ret;
}
/* Check if we need to update an existing entry */
@ -1654,22 +1661,22 @@ static BOOL ldapsam_add_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT
DEBUG(0, ("ldapsam_add_sam_account: init_ldap_from_sam failed!\n"));
ldap_mods_free(mods, 1);
ldap_unbind(ldap_struct);
return False;
return ret;
}
make_a_mod(&mods, LDAP_MOD_ADD, "objectclass", "sambaAccount");
if (!ldapsam_modify_entry(ldap_struct,newpwd,dn,mods,ldap_op)) {
if (NT_STATUS_IS_ERR(ldapsam_modify_entry(ldap_struct,newpwd,dn,mods,ldap_op))) {
DEBUG(0,("failed to modify/add user with uid = %s (dn = %s)\n",
pdb_get_username(newpwd),dn));
ldap_mods_free(mods,1);
ldap_unbind(ldap_struct);
return False;
return ret;
}
DEBUG(2,("added: uid = %s in the LDAP database\n", pdb_get_username(newpwd)));
ldap_mods_free(mods, 1);
ldap_unbind(ldap_struct);
return True;
return NT_STATUS_OK;
}
static void free_private_data(void **vp)

111
source/passdb/pdb_nisplus.c
View File

@ -130,7 +130,7 @@ static nis_result *nisp_get_nis_list (const char *nisname,
Start enumeration of the passwd list.
****************************************************************/
static BOOL nisplussam_setsampwent (struct pdb_methods *methods, BOOL update)
static NTSTATUS nisplussam_setsampwent (struct pdb_methods *methods, BOOL update)
{
struct nisplus_private_info *private =
(struct nisplus_private_info *) methods->private_data;
@ -148,7 +148,10 @@ static BOOL nisplussam_setsampwent (struct pdb_methods *methods, BOOL update)
pdb_endsampwent (); /* just in case */
global_nisp_ent->result = nisp_get_nis_list (pfiletmp, 0);
global_nisp_ent->enum_entry = 0;
return global_nisp_ent->result != NULL ? True : False;
if (global_nisp_ent->result != NULL)
return NT_STATUS_UNSUCCESSFUL;
else
return NT_STATUS_OK;
}
/***************************************************************
@ -169,10 +172,10 @@ static void nisplussam_endsampwent (struct pdb_methods *methods)
Get one SAM_ACCOUNT from the list (next in line)
*****************************************************************/
static BOOL nisplussam_getsampwent (struct pdb_methods *methods,
static NTSTATUS nisplussam_getsampwent (struct pdb_methods *methods,
SAM_ACCOUNT * user)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
struct nisplus_private_info *global_nisp_ent =
(struct nisplus_private_info *) methods->private_data;
int enum_entry = (int) (global_nisp_ent->enum_entry);
@ -180,33 +183,31 @@ static BOOL nisplussam_getsampwent (struct pdb_methods *methods,
if (user == NULL) {
DEBUG (0, ("SAM_ACCOUNT is NULL.\n"));
return False;
return nt_status;
}
if (result == NULL ||
enum_entry < 0 || enum_entry >= (NIS_RES_NUMOBJ (result) - 1)) {
return False;
if (result == NULL || enum_entry < 0 || enum_entry >= (NIS_RES_NUMOBJ (result) - 1)) {
return nt_status;
}
if (!make_sam_from_nisp_object
(user, &NIS_RES_OBJECT (result)[enum_entry])) {
if (!make_sam_from_nisp_object(user, &NIS_RES_OBJECT (result)[enum_entry])) {
DEBUG (0, ("Bad SAM_ACCOUNT entry returned from NIS+!\n"));
return False;
return nt_status;
}
(int) (global_nisp_ent->enum_entry)++;
return True;
DEBUG (10, ("nisplussam_getsampwent called\n"));
return False;
return nt_status;
}
/******************************************************************
Lookup a name in the SAM database
******************************************************************/
static BOOL nisplussam_getsampwnam (struct pdb_methods *methods,
static NTSTATUS nisplussam_getsampwnam (struct pdb_methods *methods,
SAM_ACCOUNT * user, const char *sname)
{
/* Static buffers we will return. */
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
nis_result *result = NULL;
pstring nisname;
BOOL ret;
@ -215,7 +216,7 @@ static BOOL nisplussam_getsampwnam (struct pdb_methods *methods,
if (!private->location || !(*private->location)) {
DEBUG (0, ("No SMB password file set\n"));
return False;
return nt_status;
}
if (strrchr (private->location, '/'))
private->location = strrchr (private->location, '/') + 1;
@ -227,25 +228,25 @@ static BOOL nisplussam_getsampwnam (struct pdb_methods *methods,
/* Search the table. */
if (!(result = nisp_get_nis_list (nisname, 0))) {
return False;
return nt_status;
}
ret = make_sam_from_nisresult (user, result);
nis_freeresult (result);
return ret;
if (ret) nt_status = NT_STATUS_OK;
DEBUG (10, ("nisplussam_getsampwnam called\n"));
return False;
return nt_status;
}
/***************************************************************************
Search by sid
**************************************************************************/
static BOOL nisplussam_getsampwrid (struct pdb_methods *methods,
static NTSTATUS nisplussam_getsampwrid (struct pdb_methods *methods,
SAM_ACCOUNT * user, uint32 rid)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
nis_result *result;
char *nisname;
BOOL ret;
@ -256,7 +257,7 @@ static BOOL nisplussam_getsampwrid (struct pdb_methods *methods,
if (!private->location || !(*private->location)) {
DEBUG (0, ("no SMB password file set\n"));
return False;
return nt_status;
}
if ((sp = strrchr (private->location, '/')))
@ -273,22 +274,24 @@ static BOOL nisplussam_getsampwrid (struct pdb_methods *methods,
/* Search the table. */
if (!(result = nisp_get_nis_list (nisname, 0))) {
return False;
return nt_status;
}
ret = make_sam_from_nisresult (user, result);
nis_freeresult (result);
return ret;
if (ret) nt_status = NT_STATUS_OK;
return nt_status;
}
static BOOL nisplussam_getsampwsid (struct pdb_methods *methods,
static NTSTATUS nisplussam_getsampwsid (struct pdb_methods *methods,
SAM_ACCOUNT * user, const DOM_SID * sid)
{
uint32 rid;
if (!sid_peek_check_rid (get_global_sam_sid (), sid, &rid))
return False;
return NT_STATUS_UNSUCCESSFUL;
return nisplussam_getsampwrid (methods, user, rid);
}
@ -298,9 +301,10 @@ static BOOL nisplussam_getsampwsid (struct pdb_methods *methods,
Delete a SAM_ACCOUNT
****************************************************************************/
static BOOL nisplussam_delete_sam_account (struct pdb_methods *methods,
SAM_ACCOUNT * user)
static NTSTATUS nisplussam_delete_sam_account (struct pdb_methods *methods,
SAM_ACCOUNT * user)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
const char *sname;
pstring nisname;
nis_result *result, *delresult;
@ -310,14 +314,14 @@ static BOOL nisplussam_delete_sam_account (struct pdb_methods *methods,
if (!user) {
DEBUG (0, ("no SAM_ACCOUNT specified!\n"));
return False;
return nt_status;
}
sname = pdb_get_username (user);
if (!private->location || !(*private->location)) {
DEBUG (0, ("no SMB password file set\n"));
return False;
return nt_status;
}
if (strrchr (private->location, '/'))
@ -332,14 +336,14 @@ static BOOL nisplussam_delete_sam_account (struct pdb_methods *methods,
MASTER_ONLY | FOLLOW_LINKS |
FOLLOW_PATH | EXPAND_NAME |
HARD_LOOKUP))) {
return False;
return nt_status;
}
if (result->status != NIS_SUCCESS || NIS_RES_NUMOBJ (result) <= 0) {
/* User not found. */
DEBUG (0, ("user not found in NIS+\n"));
nis_freeresult (result);
return False;
return nt_status;
}
obj = NIS_RES_OBJECT (result);
@ -358,21 +362,21 @@ static BOOL nisplussam_delete_sam_account (struct pdb_methods *methods,
DEBUG (0, ("NIS+ table update failed: %s %s\n",
nisname, nis_sperrno (delresult->status)));
nis_freeresult (delresult);
return False;
return nt_status;
}
nis_freeresult (delresult);
return True;
DEBUG (10, ("nisplussam_delete_sam_account called\n"));
return False;
return NT_STATUS_OK;
}
/***************************************************************************
Modifies an existing SAM_ACCOUNT
****************************************************************************/
static BOOL nisplussam_update_sam_account (struct pdb_methods *methods,
static NTSTATUS nisplussam_update_sam_account (struct pdb_methods *methods,
SAM_ACCOUNT * newpwd)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
nis_result *result, *addresult;
nis_object *obj;
nis_object new_obj;
@ -384,7 +388,7 @@ static BOOL nisplussam_update_sam_account (struct pdb_methods *methods,
if (!private->location || !(*private->location)) {
DEBUG (0, ("no SMB password file set\n"));
return False;
return nt_status;
}
if (strrchr (private->location, '/'))
private->location = strrchr (private->location, '/') + 1;
@ -401,14 +405,14 @@ static BOOL nisplussam_update_sam_account (struct pdb_methods *methods,
nisp_get_nis_list (nisname,
MASTER_ONLY | FOLLOW_LINKS | FOLLOW_PATH |
EXPAND_NAME | HARD_LOOKUP))) {
return False;
return ne_status;
}
if (result->status != NIS_SUCCESS || NIS_RES_NUMOBJ (result) <= 0) {
/* User not found. */
DEBUG (0, ("user not found in NIS+\n"));
nis_freeresult (result);
return False;
return nt_status;
}
obj = NIS_RES_OBJECT (result);
@ -425,7 +429,7 @@ static BOOL nisplussam_update_sam_account (struct pdb_methods *methods,
if (!(ecol = (entry_col *) malloc (ta_maxcol * sizeof (entry_col)))) {
DEBUG (0, ("memory allocation failure\n"));
nis_freeresult (result);
return False;
return nt_status;
}
memmove ((char *) ecol, obj->EN_data.en_cols.en_cols_val,
@ -449,7 +453,7 @@ static BOOL nisplussam_update_sam_account (struct pdb_methods *methods,
nis_freeresult (addresult);
nis_freeresult (result);
free (ecol);
return False;
return nt_status;
}
DEBUG (6, ("password changed\n"));
@ -461,16 +465,17 @@ static BOOL nisplussam_update_sam_account (struct pdb_methods *methods,
free (ecol);
nis_freeresult (result);
return True;
return NT_STATUS_OK;
}
/***************************************************************************
Adds an existing SAM_ACCOUNT
****************************************************************************/
static BOOL nisplussam_add_sam_account (struct pdb_methods *methods,
static NTSTATUS nisplussam_add_sam_account (struct pdb_methods *methods,
SAM_ACCOUNT * newpwd)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
int local_user = 0;
char *pfile;
pstring pfiletmp;
@ -518,7 +523,7 @@ static BOOL nisplussam_add_sam_account (struct pdb_methods *methods,
nisname = make_nisname_from_name (pdb_get_username (newpwd),
pfiletmp);
} else {
return False;
return nt_status;
}
if (!
@ -526,20 +531,20 @@ static BOOL nisplussam_add_sam_account (struct pdb_methods *methods,
nisp_get_nis_list (nisname,
MASTER_ONLY | FOLLOW_LINKS | FOLLOW_PATH |
EXPAND_NAME | HARD_LOOKUP))) {
return False;
return nt_status;
}
if (result->status != NIS_SUCCESS && result->status != NIS_NOTFOUND) {
DEBUG (3, ("nis_list failure: %s: %s\n",
nisname, nis_sperrno (result->status)));
nis_freeresult (result);
return False;
return nt_status;
}
if (result->status == NIS_SUCCESS && NIS_RES_NUMOBJ (result) > 0) {
DEBUG (3, ("User already exists in NIS+ password db: %s\n",
pfile));
nis_freeresult (result);
return False;
return nt_status;
}
nis_freeresult (result); /* no such user, free results */
@ -565,7 +570,7 @@ static BOOL nisplussam_add_sam_account (struct pdb_methods *methods,
if (!(passwd = getpwnam_alloc (pdb_get_username (newpwd)))) {
/* no such user in system! */
return False;
return nt_status;
}
passwd_free (&passwd);
@ -607,7 +612,7 @@ static BOOL nisplussam_add_sam_account (struct pdb_methods *methods,
nis_freeresult (tblresult);
DEBUG (3, ("nis_lookup failure: %s\n",
nis_sperrno (tblresult->status)));
return False;
return nt_status;
}
/* we need full name for nis_add_entry() */
safe_strcpy (pfiletmp, pfile, sizeof (pfiletmp) - 1);
@ -636,7 +641,7 @@ static BOOL nisplussam_add_sam_account (struct pdb_methods *methods,
if (!(ecol = (entry_col *) malloc (ta_maxcol * sizeof (entry_col)))) {
DEBUG (0, ("memory allocation failure\n"));
nis_freeresult (tblresult);
return False;
return nt_status;
}
memset ((char *) ecol, 0, ta_maxcol * sizeof (entry_col));
@ -655,13 +660,13 @@ static BOOL nisplussam_add_sam_account (struct pdb_methods *methods,
nisname, nis_sperrno (result->status)));
nis_freeresult (tblresult);
nis_freeresult (result);
return False;
return nt_status;
}
nis_freeresult (tblresult);
nis_freeresult (result);
return True;
return NT_STATUS_OK;
}
/***************************************************************

71
source/passdb/pdb_smbpasswd.c
View File

@ -1248,7 +1248,7 @@ static BOOL build_sam_account(struct smbpasswd_privates *smbpasswd_state,
/*****************************************************************
Functions to be implemented by the new passdb API
****************************************************************/
static BOOL smbpasswd_setsampwent (struct pdb_methods *my_methods, BOOL update)
static NTSTATUS smbpasswd_setsampwent (struct pdb_methods *my_methods, BOOL update)
{
struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
@ -1275,7 +1275,10 @@ static BOOL smbpasswd_setsampwent (struct pdb_methods *my_methods, BOOL update)
&(smbpasswd_state->pw_file_lock_depth));
}
return (smbpasswd_state->pw_file != NULL);
if (smbpasswd_state->pw_file != NULL)
return NT_STATUS_OK;
else
return NT_STATUS_UNSUCCESSFUL;
}
static void smbpasswd_endsampwent (struct pdb_methods *my_methods)
@ -1286,8 +1289,9 @@ static void smbpasswd_endsampwent (struct pdb_methods *my_methods)
/*****************************************************************
****************************************************************/
static BOOL smbpasswd_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *user)
static NTSTATUS smbpasswd_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *user)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
struct smb_passwd *pw_buf=NULL;
BOOL done = False;
@ -1298,7 +1302,7 @@ static BOOL smbpasswd_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *u
#if 0
smb_panic("NULL pointer passed to getsampwent (smbpasswd)\n");
#endif
return False;
return nt_status;
}
while (!done)
@ -1306,7 +1310,7 @@ static BOOL smbpasswd_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *u
/* do we have an entry? */
pw_buf = getsmbfilepwent(smbpasswd_state, smbpasswd_state->pw_file);
if (pw_buf == NULL)
return False;
return nt_status;
/* build the SAM_ACCOUNT entry from the smb_passwd struct.
We loop in case the user in the pdb does not exist in
@ -1318,7 +1322,7 @@ static BOOL smbpasswd_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *u
DEBUG(5,("getsampwent (smbpasswd): done\n"));
/* success */
return True;
return NT_STATUS_OK;
}
@ -1327,9 +1331,10 @@ static BOOL smbpasswd_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *u
call getpwnam() for unix account information until we have found
the correct entry
***************************************************************/
static BOOL smbpasswd_getsampwnam(struct pdb_methods *my_methods,
static NTSTATUS smbpasswd_getsampwnam(struct pdb_methods *my_methods,
SAM_ACCOUNT *sam_acct, const char *username)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
struct smb_passwd *smb_pw;
void *fp = NULL;
@ -1343,7 +1348,7 @@ static BOOL smbpasswd_getsampwnam(struct pdb_methods *my_methods,
if (fp == NULL) {
DEBUG(0, ("unable to open passdb database.\n"));
return False;
return nt_status;
}
while ( ((smb_pw=getsmbfilepwent(smbpasswd_state, fp)) != NULL)&& (!strequal(smb_pw->smb_name, username)) )
@ -1354,7 +1359,7 @@ static BOOL smbpasswd_getsampwnam(struct pdb_methods *my_methods,
/* did we locate the username in smbpasswd */
if (smb_pw == NULL)
return False;
return nt_status;
DEBUG(10, ("getsampwnam (smbpasswd): found by name: %s\n", smb_pw->smb_name));
@ -1363,19 +1368,20 @@ static BOOL smbpasswd_getsampwnam(struct pdb_methods *my_methods,
#if 0
smb_panic("NULL pointer passed to pdb_getsampwnam\n");
#endif
return False;
return nt_status;
}
/* now build the SAM_ACCOUNT */
if (!build_sam_account(smbpasswd_state, sam_acct, smb_pw))
return False;
return nt_status;
/* success */
return True;
return NT_STATUS_OK;
}
static BOOL smbpasswd_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *sam_acct,uint32 rid)
static NTSTATUS smbpasswd_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *sam_acct,uint32 rid)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
struct smb_passwd *smb_pw;
void *fp = NULL;
@ -1387,7 +1393,7 @@ static BOOL smbpasswd_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *s
const char *guest_account = lp_guestaccount();
if (!(guest_account && *guest_account)) {
DEBUG(1, ("Guest account not specfied!\n"));
return False;
return nt_status;
}
return smbpasswd_getsampwnam(my_methods, sam_acct, guest_account);
}
@ -1397,7 +1403,7 @@ static BOOL smbpasswd_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *s
if (fp == NULL) {
DEBUG(0, ("unable to open passdb database.\n"));
return False;
return nt_status;
}
while ( ((smb_pw=getsmbfilepwent(smbpasswd_state, fp)) != NULL) && (fallback_pdb_uid_to_user_rid(smb_pw->smb_userid) != rid) )
@ -1408,7 +1414,7 @@ static BOOL smbpasswd_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *s
/* did we locate the username in smbpasswd */
if (smb_pw == NULL)
return False;
return nt_status;
DEBUG(10, ("getsampwrid (smbpasswd): found by name: %s\n", smb_pw->smb_name));
@ -1417,44 +1423,44 @@ static BOOL smbpasswd_getsampwrid(struct pdb_methods *my_methods, SAM_ACCOUNT *s
#if 0
smb_panic("NULL pointer passed to pdb_getsampwrid\n");
#endif
return False;
return nt_status;
}
/* now build the SAM_ACCOUNT */
if (!build_sam_account (smbpasswd_state, sam_acct, smb_pw))
return False;
return nt_status;
/* success */
return True;
return NT_STATUS_OK;
}
static BOOL smbpasswd_getsampwsid(struct pdb_methods *my_methods, SAM_ACCOUNT * user, const DOM_SID *sid)
static NTSTATUS smbpasswd_getsampwsid(struct pdb_methods *my_methods, SAM_ACCOUNT * user, const DOM_SID *sid)
{
uint32 rid;
if (!sid_peek_check_rid(get_global_sam_sid(), sid, &rid))
return False;
return NT_STATUS_UNSUCCESSFUL;
return smbpasswd_getsampwrid(my_methods, user, rid);
}
static BOOL smbpasswd_add_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT *sampass)
static NTSTATUS smbpasswd_add_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT *sampass)
{
struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
struct smb_passwd smb_pw;
/* convert the SAM_ACCOUNT */
if (!build_smb_pass(&smb_pw, sampass)) {
return False;
return NT_STATUS_UNSUCCESSFUL;
}
/* add the entry */
if(!add_smbfilepwd_entry(smbpasswd_state, &smb_pw)) {
return False;
return NT_STATUS_UNSUCCESSFUL;
}
return True;
return NT_STATUS_OK;
}
static BOOL smbpasswd_update_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT *sampass)
static NTSTATUS smbpasswd_update_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT *sampass)
{
struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
struct smb_passwd smb_pw;
@ -1462,25 +1468,28 @@ static BOOL smbpasswd_update_sam_account(struct pdb_methods *my_methods, SAM_ACC
/* convert the SAM_ACCOUNT */
if (!build_smb_pass(&smb_pw, sampass)) {
DEBUG(0, ("smbpasswd_update_sam_account: build_smb_pass failed!\n"));
return False;
return NT_STATUS_UNSUCCESSFUL;
}
/* update the entry */
if(!mod_smbfilepwd_entry(smbpasswd_state, &smb_pw)) {
DEBUG(0, ("smbpasswd_update_sam_account: mod_smbfilepwd_entry failed!\n"));
return False;
return NT_STATUS_UNSUCCESSFUL;
}
return True;
return NT_STATUS_OK;
}
static BOOL smbpasswd_delete_sam_account (struct pdb_methods *my_methods, SAM_ACCOUNT *sampass)
static NTSTATUS smbpasswd_delete_sam_account (struct pdb_methods *my_methods, SAM_ACCOUNT *sampass)
{
struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
const char *username = pdb_get_username(sampass);
return del_smbfilepwd_entry(smbpasswd_state, username);
if (del_smbfilepwd_entry(smbpasswd_state, username))
return NT_STATUS_OK;
return NT_STATUS_UNSUCCESSFUL;
}
static void free_private_data(void **vp)

26
source/utils/pdbedit.c
View File

@ -62,7 +62,7 @@ extern BOOL AllowDebugChange;
static int export_database (struct pdb_context *in, struct pdb_context *out) {
SAM_ACCOUNT *user = NULL;
if (!in->pdb_setsampwent(in, 0)) {
if (NT_STATUS_IS_ERR(in->pdb_setsampwent(in, 0))) {
fprintf(stderr, "Can't sampwent!\n");
return 1;
}
@ -72,7 +72,7 @@ static int export_database (struct pdb_context *in, struct pdb_context *out) {
return 1;
}
while (in->pdb_getsampwent(in, user)) {
while (NT_STATUS_IS_OK(in->pdb_getsampwent(in, user))) {
out->pdb_add_sam_account(out, user);
if (!NT_STATUS_IS_OK(pdb_reset_sam(user))){
fprintf(stderr, "Can't reset SAM_ACCOUNT!\n");
@ -188,7 +188,7 @@ static int print_user_info (struct pdb_context *in, char *username, BOOL verbosi
return -1;
}
ret = in->pdb_getsampwnam (in, sam_pwent, username);
ret = NT_STATUS_IS_OK(in->pdb_getsampwnam (in, sam_pwent, username));
if (ret==False) {
fprintf (stderr, "Username not found!\n");
@ -210,7 +210,7 @@ static int print_users_list (struct pdb_context *in, BOOL verbosity, BOOL smbpwd
SAM_ACCOUNT *sam_pwent=NULL;
BOOL check, ret;
check = in->pdb_setsampwent(in, False);
check = NT_STATUS_IS_OK(in->pdb_setsampwent(in, False));
if (!check) {
return 1;
}
@ -218,7 +218,7 @@ static int print_users_list (struct pdb_context *in, BOOL verbosity, BOOL smbpwd
check = True;
if (!(NT_STATUS_IS_OK(pdb_init_sam(&sam_pwent)))) return 1;
while (check && (ret = in->pdb_getsampwent (in, sam_pwent))) {
while (check && (ret = NT_STATUS_IS_OK(in->pdb_getsampwent (in, sam_pwent)))) {
if (verbosity)
printf ("---------------\n");
print_sam_info (sam_pwent, verbosity, smbpwdstyle);
@ -242,7 +242,7 @@ static int set_user_info (struct pdb_context *in, char *username, char *fullname
pdb_init_sam(&sam_pwent);
ret = in->pdb_getsampwnam (in, sam_pwent, username);
ret = NT_STATUS_IS_OK(in->pdb_getsampwnam (in, sam_pwent, username));
if (ret==False) {
fprintf (stderr, "Username not found!\n");
pdb_free_sam(&sam_pwent);
@ -260,7 +260,7 @@ static int set_user_info (struct pdb_context *in, char *username, char *fullname
if (profile)
pdb_set_profile_path (sam_pwent, profile, True);
if (in->pdb_update_sam_account (in, sam_pwent))
if (NT_STATUS_IS_OK(in->pdb_update_sam_account (in, sam_pwent)))
print_user_info (in, username, True, False);
else {
fprintf (stderr, "Unable to modify entry!\n");
@ -328,7 +328,7 @@ static int new_user (struct pdb_context *in, char *username, char *fullname, cha
pdb_set_acct_ctrl (sam_pwent, ACB_NORMAL);
if (in->pdb_add_sam_account (in, sam_pwent)) {
if (NT_STATUS_IS_OK(in->pdb_add_sam_account (in, sam_pwent))) {
print_user_info (in, username, True, False);
} else {
fprintf (stderr, "Unable to add user! (does it alredy exist?)\n");
@ -370,7 +370,7 @@ static int new_machine (struct pdb_context *in, char *machinename)
pdb_set_group_sid_from_rid(sam_pwent, DOMAIN_GROUP_RID_COMPUTERS);
if (in->pdb_add_sam_account (in, sam_pwent)) {
if (NT_STATUS_IS_OK(in->pdb_add_sam_account (in, sam_pwent))) {
print_user_info (in, name, True, False);
} else {
fprintf (stderr, "Unable to add machine! (does it already exist?)\n");
@ -393,12 +393,12 @@ static int delete_user_entry (struct pdb_context *in, char *username)
return -1;
}
if (!in->pdb_getsampwnam(in, samaccount, username)) {
if (NT_STATUS_IS_ERR(in->pdb_getsampwnam(in, samaccount, username))) {
fprintf (stderr, "user %s does not exist in the passdb\n", username);
return -1;
}
return in->pdb_delete_sam_account (in, samaccount);
return NT_STATUS_IS_OK(in->pdb_delete_sam_account (in, samaccount));
}
/*********************************************************
@ -418,12 +418,12 @@ static int delete_machine_entry (struct pdb_context *in, char *machinename)
return -1;
}
if (!in->pdb_getsampwnam(in, samaccount, name)) {
if (NT_STATUS_IS_ERR(in->pdb_getsampwnam(in, samaccount, name))) {
fprintf (stderr, "machine %s does not exist in the passdb\n", name);
return -1;
}
return in->pdb_delete_sam_account (in, samaccount);
return NT_STATUS_IS_OK(in->pdb_delete_sam_account (in, samaccount));
}
/*********************************************************