converted the passdb smbpasswd implementation to using talloc

for memory allocation.  This fixes a long standing seg fault
(i knew i would get around to it one day :) )

Tested with NT4 and Win2k.  Needs a little more testing with the
"create the machine account on the fly" code for NT4.

Simo, this is probably going to break the tdb passdb code.
Can you look at that when you get a chance and see what you think?
(This used to be commit 1c13110873e456748dc09fd51749f664643fe888)

1 files changed, 294 insertions, 257 deletions

diff --git a/source3/passdb/passdb.c b/source3/passdb/passdb.c
index a0b9726a63..6636285b6f 100644
--- a/source3/passdb/passdb.c
+++ b/source3/passdb/passdb.c
@@ -4,7 +4,7 @@
    Password and authentication handling
    Copyright (C) Jeremy Allison 		1996-1998
    Copyright (C) Luke Kenneth Casson Leighton 	1996-1998
-   Copyright (C) Gerald (Jerry) Carter		2000
+   Copyright (C) Gerald (Jerry) Carter		2000-2001
       
    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
@@ -21,7 +21,6 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-#include <dlfcn.h>
 #include "includes.h"
 
 extern int DEBUGLEVEL;
@@ -46,6 +45,9 @@ BOOL initialize_password_db(BOOL reload)
 
 	char*	modulename = lp_passdb_module_path();
 	
+	/* This function is unfinished right now, so just 
+	   ignore the details and always return True.  It is here 
+	   only as a placeholder --jerry */
 	return True;
 	
 	/* load another module? */
@@ -104,7 +106,10 @@ void pdb_init_sam(SAM_ACCOUNT *user)
 		return;
 	
 	ZERO_STRUCTP(user);
-	
+
+	user->mem_ctx = talloc_init();
+	DEBUG(10, ("pdb_init_sam: obtained a talloc context of 0x%x\n", user->mem_ctx));
+
 	user->logon_time            = (time_t)0;
 	user->logoff_time           = (time_t)-1;
 	user->kickoff_time          = (time_t)-1;
@@ -125,31 +130,13 @@ void pdb_init_sam(SAM_ACCOUNT *user)
  ***********************************************************/
 void pdb_clear_sam(SAM_ACCOUNT *user)
 {
-	/* do we have a SAM_CCOUTN struct to work with? */
 	if (user == NULL)
 		return;
+
+	/* free upany memory used */
+	DEBUG(10, ("pdb_clear_sam: releasing memory.  talloc context is 0x%x\n",user->mem_ctx));
+	talloc_destroy (user->mem_ctx);
 		
-	/* do we own the memory? */
-	if  (user->own_memory) 
-	{
-		/* clear all pointer members */
-		if (user->username) 	free(user->username);
-		if (user->full_name) 	free(user->full_name);
-		if (user->domain) 	free(user->domain);
-		if (user->nt_username)	free(user->nt_username);
-		if (user->home_dir)	free(user->home_dir);
-		if (user->dir_drive)	free(user->dir_drive);
-		if (user->logon_script)	free(user->logon_script);
-		if (user->profile_path)	free(user->profile_path);
-		if (user->acct_desc)	free(user->acct_desc);
-		if (user->workstations)	free(user->workstations);
-		if (user->unknown_str)	free(user->unknown_str);
-		if (user->munged_dial)	free(user->munged_dial);
-			
-		if (user->lm_pw)	free(user->lm_pw);
-		if (user->nt_pw)	free(user->nt_pw);
-	}
-	
 	/* now initialize */
 	pdb_init_sam(user);
 	
@@ -541,7 +528,7 @@ BOOL local_lookup_name(const char *c_domain, const char *c_user, DOM_SID *psid,
 
 	(void)map_username(user);
 
-	if(!(pass = sys_getpwnam(user))) {
+	if(!(pass = Get_Pwnam(user, True))) {
 		/*
 		 * Maybe it was a group ?
 		 */
@@ -793,97 +780,90 @@ void copy_id21_to_sam_passwd(SAM_ACCOUNT *to, SAM_USER_INFO_21 *from)
  **************************************************************/
 void copy_sam_passwd(SAM_ACCOUNT *to, const SAM_ACCOUNT *from)
 {
-	static fstring smb_name="";
-	static fstring full_name="";
-	static fstring home_dir="";
-	static fstring dir_drive="";
-	static fstring logon_script="";
-	static fstring profile_path="";
-	static fstring acct_desc="";
-	static fstring workstations="";
-	static fstring unknown_str="";
-	static fstring munged_dial="";
-	static uint8 lm_pw[16], nt_pw[16];
+	int len;
+	
+	if (!from || !to) return;
 
-	if (from == NULL || to == NULL) 
-		return;
+	pdb_clear_sam (to);
 
-	/* we won't own this memory so set the flag.
-	   This will also clear the strings from 'to' */
-	pdb_set_mem_ownership (to, False);
-	
+	/* copy all non-pointers */
 	memcpy(to, from, sizeof(*from));
 
-	if (from->username != NULL) 
-	{
-		fstrcpy(smb_name , from->username);
-		to->username = smb_name;
-	}
-	
-	if (from->full_name != NULL) 
-	{
-		fstrcpy(full_name, from->full_name);
-		to->full_name = full_name;
+	if (from->username) {
+		len=strlen(from->username)+1;
+		to->username = talloc(to->mem_ctx, len);
+		StrnCpy (to->username, from->username, len-1);
 	}
 
-	if (from->home_dir != NULL) 
-	{
-		fstrcpy(home_dir, from->home_dir);
-		to->home_dir = home_dir;
+	if (from->full_name) {
+		len=strlen(from->full_name)+1;
+		to->full_name = talloc(to->mem_ctx, len);
+		StrnCpy (to->full_name, from->full_name, len-1);
 	}
 
-	if (from->dir_drive != NULL) 
-	{
-		fstrcpy(dir_drive  , from->dir_drive);
-		to->dir_drive = dir_drive;
+	if (from->nt_username) {
+		len=strlen(from->nt_username)+1;
+		to->nt_username = talloc(to->mem_ctx, len);
+		StrnCpy (to->nt_username, from->nt_username, len-1);
 	}
 
-	if (from->logon_script != NULL) 
-	{
-		fstrcpy(logon_script  , from->logon_script);
-		to->logon_script = logon_script;
+	if (from->profile_path) {
+		len=strlen(from->profile_path)+1;
+		to->profile_path = talloc(to->mem_ctx, len);
+		StrnCpy (to->profile_path, from->profile_path, len-1);
 	}
 
-	if (from->profile_path != NULL) 
-	{
-		fstrcpy(profile_path  , from->profile_path);
-		to->profile_path = profile_path;
+	if (from->logon_script) {
+		len=strlen(from->logon_script)+1;
+		to->logon_script = talloc(to->mem_ctx, len);
+		StrnCpy (to->logon_script, from->logon_script, len-1);
 	}
 
-	if (from->acct_desc != NULL) 
-	{
-		fstrcpy(acct_desc  , from->acct_desc);
-		to->acct_desc = acct_desc;
+	if (from->home_dir) {
+		len=strlen(from->home_dir)+1;
+ 		to->home_dir = talloc(to->mem_ctx, len);
+		StrnCpy (to->home_dir, from->home_dir, len-1);
 	}
-
-	if (from->workstations != NULL) 
-	{
-		fstrcpy(workstations  , from->workstations);
-		to->workstations = workstations;
+	
+	if (from->dir_drive) {
+		len=strlen(from->dir_drive)+1;
+		to->dir_drive = talloc(to->mem_ctx, len);
+		StrnCpy (to->dir_drive, from->dir_drive, len-1);
 	}
-
-	if (from->unknown_str != NULL) 
-	{
-		fstrcpy(unknown_str  , from->unknown_str);
-		to->unknown_str = unknown_str;
+	
+	if (from->workstations) {
+		len=strlen(from->workstations)+1;
+		to->workstations = talloc(to->mem_ctx, len);
+		StrnCpy (to->workstations, from->workstations, len-1);
 	}
-
-	if (from->munged_dial != NULL) 
-	{
-		fstrcpy(munged_dial  , from->munged_dial);
-		to->munged_dial = munged_dial;
+	
+	if (from->acct_desc) {
+		len=strlen(from->acct_desc)+1;
+		to->acct_desc = talloc(to->mem_ctx, len);
+		StrnCpy (to->acct_desc, from->acct_desc, len-1);
 	}
 	
-	if (from->nt_pw != NULL)
-	{
-		memcpy (nt_pw, from->nt_pw, 16);
-		to->nt_pw = nt_pw;
+	if (from->munged_dial) {
+		len=strlen(from->munged_dial)+1;
+		to->munged_dial = talloc(to->mem_ctx, len);
+		StrnCpy (to->munged_dial, from->munged_dial, len);
+	}
+	
+	if (from->unknown_str) {
+		len=strlen(from->unknown_str)+1;
+		to->unknown_str = talloc(to->mem_ctx, len);
+		StrnCpy (to->unknown_str, from->unknown_str, len-1);
 	}
 
-	if (from->lm_pw != NULL)
-	{
-		memcpy (lm_pw, from->lm_pw, 16);
-		to->lm_pw = lm_pw;
+
+	if (from->nt_pw) {
+		to->nt_pw = talloc(to->mem_ctx, 16);
+		memcpy (to->nt_pw, from->nt_pw, 16);
+	}
+	
+	if (from->lm_pw) {
+		to->lm_pw = talloc(to->mem_ctx, 16);
+		memcpy (to->lm_pw, from->lm_pw, 16);
 	}
 
 	return;
@@ -944,7 +924,6 @@ account without a valid local system user.\n", user_name);
 		   Because the new_sam_pwd only exists in the scope of this function
 		   we will not allocate memory for members */
 		pdb_init_sam 	      (&new_sam_acct);
-		pdb_set_mem_ownership (&new_sam_acct, False);
 		pdb_set_username      (&new_sam_acct, user_name);
 		pdb_set_fullname      (&new_sam_acct, pwd->pw_gecos);
 		pdb_set_uid	      (&new_sam_acct, pwd->pw_uid);
@@ -1310,30 +1289,6 @@ uint32 pdb_get_unknown6 (SAM_ACCOUNT *sampass)
 /*********************************************************************
  collection of set...() functions for SAM_ACCOUNT_INFO
  ********************************************************************/
-
-/********************************************************************
- The purpose of this flag is to determine whether or not we 
- should free the memory when we are done.  This allows us to
- use local static variables for string (reduce the number of
- malloc() calls) while still allowing for flexibility of 
- dynamic objects.
- 
- We always clear the structure even if setting the flag to the
- same value.
- *******************************************************************/
-void pdb_set_mem_ownership (SAM_ACCOUNT *sampass, BOOL flag)
-{
-	/* if we have no SAM_ACCOUNT struct or no change, then done */
-	if (sampass == NULL)
-		return;
-
-	/* clear the struct and set the ownership flag */
-	pdb_clear_sam (sampass);
-	sampass->own_memory = flag;
-
-	return;
-}
-
 BOOL pdb_set_acct_ctrl (SAM_ACCOUNT *sampass, uint16 flags)
 {
 	if (!sampass)
@@ -1458,250 +1413,332 @@ BOOL pdb_set_group_rid (SAM_ACCOUNT *sampass, uint32 grid)
 
 BOOL pdb_set_username (SAM_ACCOUNT *sampass, char *username)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->username = username;
-	else
+	if (!username) 
 	{
-		if ( (sampass->username=strdup(username)) == NULL )
-		{
-			DEBUG (0,("pdb_set_username: ERROR - Unable to malloc memory for [%s]\n", username));
-			return False;
-		}
+		sampass->username = NULL;
+		return True;
+	}
+
+	len = strlen(username)+1;
+	sampass->username = (char*)talloc(sampass->mem_ctx, len);
+
+	if (sampass->username == NULL )
+	{
+		DEBUG (0,("pdb_set_username: ERROR - Unable to talloc memory for [%s]\n", username));
+		return False;
 	}
+	
+	StrnCpy (sampass->username, username, len-1);
 
 	return True;
 }
 
 BOOL pdb_set_domain (SAM_ACCOUNT *sampass, char *domain)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->domain = domain;
-	else
+	if (!domain) 
 	{
-		if ( (sampass->domain=strdup(domain)) == NULL )
-		{
-			DEBUG (0,("pdb_set_domain: ERROR - Unable to malloc memory for [%s]\n", domain));
-			return False;
-		}
+		sampass->domain = NULL;
+		return True;
 	}
 
+	len = strlen(domain)+1;
+	sampass->domain = talloc (sampass->mem_ctx, len);
+
+	if (sampass->domain == NULL )
+	{
+		DEBUG (0,("pdb_set_domain: ERROR - Unable to talloc memory for [%s]\n", domain));
+		return False;
+	}
+	
+	StrnCpy (sampass->domain, domain, len-1);
+
 	return True;
 }
 
 BOOL pdb_set_nt_username (SAM_ACCOUNT *sampass, char *nt_username)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->nt_username = nt_username;
-	else
+	if (!nt_username) 
 	{
-		if ( (sampass->nt_username=strdup(nt_username)) == NULL )
-		{
-			DEBUG (0,("pdb_set_nt_username: ERROR - Unable to malloc memory for [%s]\n", nt_username));
-			return False;
-		}
+		sampass->nt_username = NULL;
+		return True;
+	}
+
+	len = strlen(nt_username)+1;
+	sampass->nt_username = talloc (sampass->mem_ctx, len);
+
+	if (sampass->nt_username == NULL )
+	{
+		DEBUG (0,("pdb_set_nt_username: ERROR - Unable to talloc memory for [%s]\n", nt_username));
+		return False;
 	}
+	
+	StrnCpy (sampass->nt_username, nt_username, len-1);
 
 	return True;
 }
 
 BOOL pdb_set_fullname (SAM_ACCOUNT *sampass, char *fullname)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->full_name = fullname;
-	else
+	if (!fullname) 
 	{
-		if ( (sampass->full_name=strdup(fullname)) == NULL )
-		{
-			DEBUG (0,("pdb_set_fullname: ERROR - Unable to malloc memory for [%s]\n", fullname));
-			return False;
-		}
+		sampass->full_name = NULL;
+		return True;
 	}
 
+	len = strlen(fullname)+1;
+	sampass->full_name = talloc (sampass->mem_ctx, len);
+
+	if (sampass->full_name == NULL )
+	{
+		DEBUG (0,("pdb_set_fullname: ERROR - Unable to talloc memory for [%s]\n", fullname));
+		return False;
+	}
+	
+	StrnCpy (sampass->full_name, fullname, len-1);
+
 	return True;
 }
 
 BOOL pdb_set_logon_script (SAM_ACCOUNT *sampass, char *logon_script)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->logon_script = logon_script;
-	else
+	if (!logon_script) 
 	{
-		if ( (sampass->logon_script=strdup(logon_script)) == NULL )
-		{
-			DEBUG (0,("pdb_set_logon_script: ERROR - Unable to malloc memory for [%s]\n", logon_script));
-			return False;
-		}
+		sampass->logon_script = NULL;
+		return True;
 	}
 
+	len = strlen(logon_script)+1;
+	sampass->logon_script = talloc (sampass->mem_ctx, len);
+
+	if (sampass->logon_script == NULL )
+	{
+		DEBUG (0,("pdb_set_logon_script: ERROR - Unable to talloc memory for [%s]\n", logon_script));
+		return False;
+	}
+	
+	StrnCpy (sampass->logon_script, logon_script, len-1);
+
 	return True;
 }
 
 BOOL pdb_set_profile_path (SAM_ACCOUNT *sampass, char *profile_path)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->profile_path = profile_path;
-	else
+	if (!profile_path) 
 	{
-		if ( (sampass->profile_path=strdup(profile_path)) == NULL )
-		{
-			DEBUG (0,("pdb_set_profile_path: ERROR - Unable to malloc memory for [%s]\n", profile_path));
-			return False;
-		}
+		sampass->profile_path = NULL;
+		return True;
 	}
 
+	len = strlen(profile_path)+1;
+	sampass->profile_path = talloc (sampass->mem_ctx, len);
+
+	if (!sampass->profile_path)
+	{
+		DEBUG (0,("pdb_set_profile_path: ERROR - Unable to talloc memory for [%s]\n", profile_path));
+		return False;
+	}
+	
+	StrnCpy (sampass->profile_path, profile_path, len-1);
+	
 	return True;
 }
 
 BOOL pdb_set_dir_drive (SAM_ACCOUNT *sampass, char *dir_drive)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->dir_drive = dir_drive;
-	else
+	if (!dir_drive) 
 	{
-		if ( (sampass->dir_drive=strdup(dir_drive)) == NULL )
-		{
-			DEBUG (0,("pdb_set_dir_drive: ERROR - Unable to malloc memory for [%s]\n", dir_drive));
-			return False;
-		}
+		sampass->dir_drive = NULL;
+		return True;
 	}
 
+	len = strlen(dir_drive)+1;
+	sampass->dir_drive = talloc (sampass->mem_ctx, len);
+
+	if (sampass->dir_drive == NULL )
+	{
+		DEBUG (0,("pdb_set_dir_drive: ERROR - Unable to talloc memory for [%s]\n", dir_drive));
+		return False;
+	}
+	
+	StrnCpy (sampass->dir_drive, dir_drive, len-1);
+
 	return True;
 }
 
 BOOL pdb_set_homedir (SAM_ACCOUNT *sampass, char *homedir)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->home_dir = homedir;
-	else
+	if (!homedir) 
 	{
-		if ( (sampass->home_dir=strdup(homedir)) == NULL )
-		{
-			DEBUG (0,("pdb_set_home_dir: ERROR - Unable to malloc memory for [%s]\n", homedir));
-			return False;
-		}
+		sampass->home_dir = NULL;
+		return True;
 	}
 
+	len = strlen(homedir)+1;
+	sampass->home_dir = talloc (sampass->mem_ctx, len);
+
+	if (sampass->home_dir == NULL )
+	{
+		DEBUG (0,("pdb_set_homedir: ERROR - Unable to talloc memory for [%s]\n", homedir));
+		return False;
+	}
+	
+	StrnCpy (sampass->home_dir, homedir, len-1);
+
 	return True;
 }
 
 BOOL pdb_set_acct_desc (SAM_ACCOUNT *sampass, char *acct_desc)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->acct_desc = acct_desc;
-	else
+	if (!acct_desc) 
 	{
-		if ( (sampass->acct_desc=strdup(acct_desc)) == NULL )
-		{
-			DEBUG (0,("pdb_set_acct_desc: ERROR - Unable to malloc memory for [%s]\n", acct_desc));
-			return False;
-		}
+		sampass->acct_desc = NULL;
+		return True;
+	}
+
+	len = strlen(acct_desc)+1;
+	sampass->acct_desc = talloc (sampass->mem_ctx, len);
+
+	if (sampass->acct_desc == NULL )
+	{
+		DEBUG (0,("pdb_set_acct_desc: ERROR - Unable to talloc memory for [%s]\n", acct_desc));
+		return False;
 	}
+	
+	StrnCpy (sampass->acct_desc, acct_desc, len-1);
 
 	return True;
 }
+
 BOOL pdb_set_workstations (SAM_ACCOUNT *sampass, char *workstations)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->workstations = workstations;
-	else
+	if (!workstations) 
 	{
-		if ( (sampass->workstations=strdup(workstations)) == NULL )
-		{
-			DEBUG (0,("pdb_set_workstations: ERROR - Unable to malloc memory for [%s]\n", workstations));
-			return False;
-		}
+		sampass->workstations = NULL;
+		return True;
 	}
 
+	len = strlen(workstations)+1;
+	sampass->workstations = talloc (sampass->mem_ctx, len);
+
+	if (sampass->workstations == NULL )
+	{
+		DEBUG (0,("pdb_set_workstations: ERROR - Unable to talloc memory for [%s]\n", workstations));
+		return False;
+	}
+	
+	StrnCpy (sampass->workstations, workstations, len-1);
+
 	return True;
 }
 
 BOOL pdb_set_munged_dial (SAM_ACCOUNT *sampass, char *munged_dial)
 {
-	if (!sampass)
-		return False;
+	int len;
+	
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->munged_dial = munged_dial;
-	else
+	if (!munged_dial) 
 	{
-		if ( (sampass->munged_dial=strdup(munged_dial)) == NULL )
-		{
-			DEBUG (0,("pdb_set_munged_dial: ERROR - Unable to malloc memory for [%s]\n", munged_dial));
-			return False;
-		}
+		sampass->munged_dial = NULL;
+		return True;
+	}
+
+	len = strlen(munged_dial)+1;
+	sampass->munged_dial = talloc (sampass->mem_ctx, len);
+
+	if (sampass->munged_dial == NULL )
+	{
+		DEBUG (0,("pdb_set_munged_dial: ERROR - Unable to talloc memory for [%s]\n", munged_dial));
+		return False;
 	}
+	
+	StrnCpy (sampass->munged_dial, munged_dial, len-1);
 
 	return True;
 }
 
 BOOL pdb_set_nt_passwd (SAM_ACCOUNT *sampass, uint8 *pwd)
 {
-	if ( (!sampass) ||(pwd == NULL) )
-		return False;
+	if (!sampass || !sampass->mem_ctx) return False;
 
-	if (!sampass->own_memory)
-		sampass->nt_pw = pwd;
-	else
+	if (!pwd) 
 	{
-		if ((sampass->nt_pw=(uint8*)malloc(sizeof(uint8)*16)) == NULL)
-		{
-			DEBUG(0,("pdb_set_nt_passwd: ERROR - out of memory for nt_pw!\n"));
-			return False;
-		}
-		if (!memcpy(sampass->nt_pw, pwd, 16))
-			return False;
-	}	
+		sampass->nt_pw = NULL;
+		return True;
+	}
+	
+	sampass->nt_pw = talloc (sampass->mem_ctx, 16);
+
+	if (sampass->nt_pw == NULL )
+	{
+		DEBUG (0,("pdb_set_nt_passwd: ERROR - Unable to talloc memory for [%s]\n", pwd));
+		return False;
+	}
+	
+	memcpy (sampass->nt_pw, pwd, 16);
 
 	return True;
 }
 
 BOOL pdb_set_lanman_passwd (SAM_ACCOUNT *sampass, uint8 *pwd)
 {
-	if ( (!sampass) ||(pwd == NULL) )
-		return False;
+	if (!sampass || !sampass->mem_ctx) return False;
+	
+	if (!pwd)
+	{
+		sampass->lm_pw = NULL;
+		return True;
+	}
 
-	if (!sampass->own_memory)
-		sampass->lm_pw = pwd;
-	else
+	sampass->lm_pw = talloc (sampass->mem_ctx, 16);
+
+	if (sampass->lm_pw == NULL )
 	{
-		if ((sampass->lm_pw=(uint8*)malloc(sizeof(uint8)*16)) == NULL)
-		{
-			DEBUG(0,("pdb_set_lanman_passwd: ERROR - out of memory for lm_pw!\n"));
-			return False;
-		}
-		if (!memcpy(sampass->lm_pw, pwd, 16))
-			return False;
-	}	
+		DEBUG (0,("pdb_set_lanman_passwd: ERROR - Unable to talloc memory for [%s]\n", pwd));
+		return False;
+	}
+	
+	memcpy (sampass->lm_pw, pwd, 16);
 
 	return True;
 }