}
}
- free(workstation_list);
+ SAFE_FREE(workstation_list);
if (invalid_ws)
return NT_STATUS_INVALID_WORKSTATION;
} else {
- free(workstation_list);
+ SAFE_FREE(workstation_list);
}
} else {
return NT_STATUS_NO_MEMORY;
}
}
- free(pserver);
+ SAFE_FREE(pserver);
if (!connected_ok) {
DEBUG(0,("password server not available\n"));
}
}
- free(pserver);
+ SAFE_FREE(pserver);
if (!connected_ok) {
DEBUG(0,("password server not available\n"));
}
}
- free(workstation_list);
+ SAFE_FREE(workstation_list);
if (invalid_ws)
return NT_STATUS_INVALID_WORKSTATION;
} else {
- free(workstation_list);
+ SAFE_FREE(workstation_list);
}
} else {
return NT_STATUS_NO_MEMORY;
static void free_blocking_lock_record(blocking_lock_record *blr)
{
- free(blr->inbuf);
- free((char *)blr);
+ SAFE_FREE(blr->inbuf);
+ SAFE_FREE(blr);
}
/****************************************************************************
if((blr->inbuf = (char *)malloc(length)) == NULL) {
DEBUG(0,("push_blocking_lock_request: Malloc fail (2)!\n" ));
- free((char *)blr);
+ SAFE_FREE(blr);
return False;
}
GET_DELETE_ON_CLOSE_FLAG(share_entry->share_mode) )
delete_on_close = True;
- safe_free(share_entry);
+ SAFE_FREE(share_entry);
/*
* NT can set delete_on_close of the last open
DLIST_REMOVE(Connections, conn);
if (conn->ngroups && conn->groups) {
- free(conn->groups);
- conn->groups = NULL;
+ SAFE_FREE(conn->groups);
conn->ngroups = 0;
}
num_open--;
ZERO_STRUCTP(conn);
- free(conn);
+ SAFE_FREE(conn);
}
}
/* Lanman 2 specific code */
- if (dptr->wcard)
- free(dptr->wcard);
+ SAFE_FREE(dptr->wcard);
string_set(&dptr->path,"");
- free((char *)dptr);
+ SAFE_FREE(dptr);
}
/****************************************************************************
if(dptr->dnum == -1 || dptr->dnum > 254) {
DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
- free((char *)dptr);
+ SAFE_FREE(dptr);
return -1;
}
}
if(dptr->dnum == -1 || dptr->dnum < 255) {
DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
- free((char *)dptr);
+ SAFE_FREE(dptr);
return -1;
}
}
if (asprintf(&entry, "%s/%s/%s", conn->origpath, name, n) > 0) {
ret = user_can_read_file(conn, entry);
- free(entry);
+ SAFE_FREE(entry);
}
if (!ret) continue;
}
void CloseDir(void *p)
{
- Dir *dirp = (Dir *)p;
- if (!dirp) return;
- if (dirp->data) free(dirp->data);
- free(dirp);
+ if (!p) return;
+ SAFE_FREE(((Dir *)p)->data);
+ SAFE_FREE(p);
}
/*******************************************************************
/* Free excess cache entries. */
while( DIRCACHESIZE < dir_cache->count )
- free( ubi_dlRemTail( dir_cache ) );
+ safe_free( ubi_dlRemTail( dir_cache ) );
}
NULL != entry; ) {
next = ubi_dlNext( entry );
if( entry->snum == snum )
- free( ubi_dlRemThis( dir_cache, entry ) );
+ safe_free( ubi_dlRemThis( dir_cache, entry ) );
entry = (dir_cache_entry *)next;
}
}
SMB_ASSERT(wcp->data_size == 0);
- free(wcp->data);
- free(wcp);
-
- fsp->wcp = NULL;
+ SAFE_FREE(wcp->data);
+ SAFE_FREE(fsp->wcp);
DEBUG(10,("delete_write_cache: File %s deleted write cache\n", fsp->fsp_name ));
if((wcp->data = malloc(wcp->alloc_size)) == NULL) {
DEBUG(0,("setup_write_cache: malloc fail for buffer size %u.\n",
(unsigned int)wcp->alloc_size ));
- free(wcp);
+ SAFE_FREE(wcp);
return False;
}
if (fsp == chain_fsp) chain_fsp = NULL;
- free(fsp);
+ SAFE_FREE(fsp);
}
groupname_map_entry *gmep;
while((gmep = (groupname_map_entry *)ubi_slRemHead( &groupname_map_list )) != NULL) {
- if(gmep->windows_name)
- free(gmep->windows_name);
- if(gmep->unix_name)
- free(gmep->unix_name);
- free((char *)gmep);
+ SAFE_FREE(gmep->windows_name);
+ SAFE_FREE(gmep->unix_name);
+ SAFE_FREE(gmep);
}
}
if(new_ep->windows_name == NULL || new_ep->unix_name == NULL) {
DEBUG(0,("load_groupname_map: malloc fail for names in groupname_map_entry.\n"));
fclose(fp);
- if(new_ep->windows_name != NULL)
- free(new_ep->windows_name);
- if(new_ep->unix_name != NULL)
- free(new_ep->unix_name);
- free((char *)new_ep);
+ SAFE_FREE(new_ep->windows_name);
+ SAFE_FREE(new_ep->unix_name);
+ SAFE_FREE(new_ep);
file_lines_free(lines);
return;
}
}
if((data_len = read_from_pipe( p, rdata, p->max_trans_reply)) < 0) {
- free(rdata);
+ SAFE_FREE(rdata);
return False;
}
send_trans_reply(outbuf, NULL, 0, rdata, data_len, p->out_data.current_pdu_len > data_len);
- free(rdata);
+ SAFE_FREE(rdata);
return True;
}
DEBUG(0,("reply_trans: %s in getting secondary trans response.\n",
(smb_read_error == READ_ERROR) ? "error" : "timeout" ));
}
- if (params)
- free(params);
- if (data)
- free(data);
- if (setup)
- free(setup);
+ SAFE_FREE(params);
+ SAFE_FREE(data);
+ SAFE_FREE(setup);
END_PROFILE(SMBtrans);
return(ERROR_DOS(ERRSRV,ERRerror));
}
}
- if (data)
- free(data);
- if (params)
- free(params);
- if (setup)
- free(setup);
+ SAFE_FREE(data);
+ SAFE_FREE(params);
+ SAFE_FREE(setup);
if (close_on_completion)
close_cnum(conn,vuid);
DEBUG(4,("printqgetinfo: errorcode %d\n",desc.errcode));
- if (queue)
- free(queue);
- if (tmpdata)
- free (tmpdata);
+ SAFE_FREE(queue);
+ SAFE_FREE(tmpdata);
return(True);
}
}
}
- if (subcntarr) free(subcntarr);
+ SAFE_FREE(subcntarr);
*rdata_len = desc.usedlen;
*rparam_len = 8;
SSVAL(*rparam,6,queuecnt);
for (i = 0; i < queuecnt; i++) {
- if (queue && queue[i]) free(queue[i]);
+ if (queue) SAFE_FREE(queue[i]);
}
- if (queue) free(queue);
- if (status) free(status);
+ SAFE_FREE(queue);
+ SAFE_FREE(status);
return True;
}
SSVAL(*rparam,4,counted);
SSVAL(*rparam,6,counted+missed);
- if (servers) free(servers);
+ SAFE_FREE(servers);
DEBUG(3,("NetServerEnum domain = %s uLevel=%d counted=%d total=%d\n",
domain,uLevel,counted,counted+missed));
pstrcpy(comment,servers[i].comment);
}
}
- if (servers) free(servers);
+ SAFE_FREE(servers);
SCVAL(p,0,lp_major_announce_version());
SCVAL(p,1,lp_minor_announce_version());
SSVAL(*rparam,2,0);
SSVAL(*rparam,4,desc.neededlen);
- if (queue) free(queue);
- if (tmpdata) free(tmpdata);
+ SAFE_FREE(queue);
+ SAFE_FREE(tmpdata);
DEBUG(4,("WPrintJobGetInfo: errorcode %d\n",desc.errcode));
return(True);
SSVAL(*rparam,4,succnt);
SSVAL(*rparam,6,count);
- if (queue) free(queue);
+ SAFE_FREE(queue);
DEBUG(4,("WPrintJobEnumerate: errorcode %d\n",desc.errcode));
return(True);
SSVAL(*rparam,4,desc.neededlen);
DEBUG(4,("WPrintDestGetInfo: errorcode %d\n",desc.errcode));
- if (tmpdata) free (tmpdata);
+ SAFE_FREE(tmpdata);
return(True);
}
send_trans_reply(outbuf, rparam, rparam_len, rdata, rdata_len, False);
- if (rdata )
- free(rdata);
- if (rparam)
- free(rparam);
+ SAFE_FREE(rdata);
+ SAFE_FREE(rparam);
return -1;
}
static void cache_free_entry( ubi_trNodePtr WarrenZevon )
{
ZERO_STRUCTP(WarrenZevon);
- free( WarrenZevon );
+ SAFE_FREE( WarrenZevon );
} /* cache_free_entry */
/* ************************************************************************** **
{
/* Replace the saved_ext as it was truncated. */
(void)pstrcat( s, saved_ext );
- free(saved_ext);
+ SAFE_FREE(saved_ext);
}
return( False );
}
{
/* Replace the saved_ext as it was truncated. */
(void)pstrcat( s, saved_ext );
- free(saved_ext);
+ SAFE_FREE(saved_ext);
}
DEBUG( 3, ("as %s\n", s) );
if(tmp != NULL) {
cache_mangled_name(OutName, tmp);
- free(tmp);
+ SAFE_FREE(tmp);
}
}
cnotify->remove_notify(cnbp->change_data);
DLIST_REMOVE(change_notify_list, cnbp);
ZERO_STRUCTP(cnbp);
- free(cnbp);
+ SAFE_FREE(cnbp);
}
cnbp->change_data = cnotify->register_notify(conn, fsp->fsp_name, flags);
if (!cnbp->change_data) {
- free(cnbp);
+ SAFE_FREE(cnbp);
return False;
}
*****************************************************************************/
static void hash_remove_notify(void *datap)
{
- free(datap);
+ SAFE_FREE(datap);
}
}
close(fd);
}
- free(data);
+ SAFE_FREE(data);
DEBUG(3,("removed kernel change notify fd=%d\n", fd));
}
if ((total_parameter_count && !params) || (total_data_count && !data) ||
(setup_count && !setup)) {
- safe_free(setup);
- safe_free(params);
- safe_free(data);
+ SAFE_FREE(setup);
+ SAFE_FREE(params);
+ SAFE_FREE(data);
DEBUG(0,("reply_nttrans : Out of memory\n"));
END_PROFILE(SMBnttrans);
return ERROR_DOS(ERRDOS,ERRnomem);
DEBUG(0,("reply_nttrans: %s in getting secondary nttrans response.\n",
(smb_read_error == READ_ERROR) ? "error" : "timeout" ));
}
- if(params)
- free(params);
- if(data)
- free(data);
- if(setup)
- free(setup);
+ SAFE_FREE(params);
+ SAFE_FREE(data);
+ SAFE_FREE(setup);
END_PROFILE(SMBnttrans);
return ERROR_DOS(ERRSRV,ERRerror);
}
default:
/* Error in request */
DEBUG(0,("reply_nttrans: Unknown request %d in nttrans call\n", function_code));
- if(setup)
- free(setup);
- if(params)
- free(params);
- if(data)
- free(data);
+ SAFE_FREE(setup);
+ SAFE_FREE(params);
+ SAFE_FREE(data);
END_PROFILE(SMBnttrans);
return ERROR_DOS(ERRSRV,ERRerror);
}
an error packet.
*/
- if(setup)
- free(setup);
- if(params)
- free(params);
- if(data)
- free(data);
+ SAFE_FREE(setup);
+ SAFE_FREE(params);
+ SAFE_FREE(data);
END_PROFILE(SMBnttrans);
return outsize; /* If a correct response was needed the call_nt_transact_xxxx
calls have already sent it. If outsize != -1 then it is
if(opb_ret == False) {
DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
- free((char *)old_shares);
+ SAFE_FREE(old_shares);
errno = EACCES;
unix_ERR_class = ERRDOS;
unix_ERR_code = ERRbadshare;
if we can too */
if(check_share_mode(share_entry, share_mode, fname, fcbopen, p_flags) == False) {
- free((char *)old_shares);
+ SAFE_FREE(old_shares);
errno = EACCES;
return -1;
}
} /* end for */
if(broke_oplock) {
- free((char *)old_shares);
+ SAFE_FREE(old_shares);
num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
oplock_contention_count++;
* other process's entry.
*/
- free((char *)old_shares);
+ SAFE_FREE(old_shares);
num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
break;
}
} while(broke_oplock);
if(old_shares != 0)
- free((char *)old_shares);
+ SAFE_FREE(old_shares);
/*
* Refuse to grant an oplock in case the contention limit is
DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
- free((char *)old_shares);
+ SAFE_FREE(old_shares);
return False;
}
lock_share_entry(conn, dev, inode);
if(broke_oplock)
{
- free((char *)old_shares);
+ SAFE_FREE(old_shares);
num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
}
} while(broke_oplock);
free_and_exit:
unlock_share_entry(conn, dev, inode);
- if(old_shares != NULL)
- free((char *)old_shares);
+ SAFE_FREE(old_shares);
return(ret);
}
if((outbuf = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL)
{
DEBUG(0,("oplock_break: malloc fail for output buffer.\n"));
- free(inbuf);
- inbuf = NULL;
+ SAFE_FREE(inbuf);
return False;
}
file_chain_restore();
/* Free the buffers we've been using to recurse. */
- free(inbuf);
- free(outbuf);
+ SAFE_FREE(inbuf);
+ SAFE_FREE(outbuf);
/* We need this in case a readraw crossed on the wire. */
if(global_oplock_break)
}
}
- if (share_list)
- free((char *)share_list);
+ SAFE_FREE(share_list);
unlock_share_entry_fsp(fsp);
/* Paranoia check... */
DLIST_REMOVE(validated_users, vuser);
- safe_free(vuser->groups);
+ SAFE_FREE(vuser->groups);
delete_nt_token(&vuser->nt_user_token);
- safe_free(vuser);
+ SAFE_FREE(vuser);
num_validated_vuids--;
}
num_sids = 5 + ngroups;
if ((token->user_sids = (DOM_SID *)malloc( num_sids*sizeof(DOM_SID))) == NULL) {
- free(token);
+ SAFE_FREE(token);
return NULL;
}
}
}
- free(user_list);
+ SAFE_FREE(user_list);
}
/* check for a previously validated username/password pair */
while (list_head) {
canon_ace *old_head = list_head;
DLIST_REMOVE(list_head, list_head);
- free(old_head);
+ SAFE_FREE(old_head);
}
}
curr_ace_outer->perms |= curr_ace->perms;
DLIST_REMOVE(list_head, curr_ace);
- free(curr_ace);
+ SAFE_FREE(curr_ace);
curr_ace_outer_next = curr_ace_outer->next; /* We may have deleted the link. */
}
}
*/
DLIST_REMOVE(list_head, curr_ace);
- free(curr_ace);
+ SAFE_FREE(curr_ace);
curr_ace_outer_next = curr_ace_outer->next; /* We may have deleted the link. */
} else {
*/
DLIST_REMOVE(list_head, curr_ace_outer);
- free(curr_ace_outer);
+ SAFE_FREE(curr_ace_outer);
}
}
free_canon_ace_list(file_ace);
free_canon_ace_list(dir_ace);
- free(current_ace);
+ SAFE_FREE(current_ace);
DEBUG(0,("create_canon_ace_lists: unable to map SID %s to uid or gid.\n",
sid_to_string(str, ¤t_ace->sid) ));
return False;
Deny entry after Allow entry. Failing to set on file %s.\n", fsp->fsp_name ));
free_canon_ace_list(file_ace);
free_canon_ace_list(dir_ace);
- free(current_ace);
+ SAFE_FREE(current_ace);
return False;
}
Deny entry after Allow entry. Failing to set on file %s.\n", fsp->fsp_name ));
free_canon_ace_list(file_ace);
free_canon_ace_list(dir_ace);
- free(current_ace);
+ SAFE_FREE(current_ace);
return False;
}
* Free if ACE was not added.
*/
- if (current_ace)
- free(current_ace);
+ SAFE_FREE(current_ace);
}
if (fsp->is_directory && all_aces_are_inherit_only) {
sys_acl_free_acl(dir_acl);
free_canon_ace_list(file_ace);
free_canon_ace_list(dir_ace);
- if (nt_ace_list)
- free(nt_ace_list);
+ SAFE_FREE(nt_ace_list);
return sd_size;
}
if(msg->msg_buf == NULL)
{
DEBUG(0,("push_message: malloc fail (2)\n"));
- free((char *)msg);
+ SAFE_FREE(msg);
return False;
}
memcpy(buffer, msg->msg_buf, MIN(buffer_len, msg->msg_len));
/* Free the message we just copied. */
- free((char *)msg->msg_buf);
- free((char *)msg);
+ SAFE_FREE(msg->msg_buf);
+ SAFE_FREE(msg);
DEBUG(5,("receive_message_or_smb: returning queued smb message.\n"));
return True;
DEBUG(5,("nfs_quotas: For path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)*bsize,(double)*dfree,(double)*dsize));
- safe_free(cutstr);
+ SAFE_FREE(cutstr);
DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
return ret;
}
SSVAL(smb_buf(outbuf),1,28*count);
}
- if (queue) free(queue);
+ SAFE_FREE(queue);
DEBUG(3,("%d entries returned in queue\n",count));
}
}
if ((ngroups = sys_getgroups(ngroups,groups)) == -1) {
- safe_free(groups);
+ SAFE_FREE(groups);
return -1;
}
{
if (*pptoken) {
NT_USER_TOKEN *ptoken = *pptoken;
- safe_free( ptoken->user_sids );
+ SAFE_FREE( ptoken->user_sids );
ZERO_STRUCTP(ptoken);
}
- safe_free(*pptoken);
- *pptoken = NULL;
+ SAFE_FREE(*pptoken);
}
/****************************************************************************
ZERO_STRUCTP(token);
if ((token->user_sids = (DOM_SID *)memdup( ptoken->user_sids, sizeof(DOM_SID) * ptoken->num_sids )) == NULL) {
- free(token);
+ SAFE_FREE(token);
return NULL;
}
prev_ctx_p = &sec_ctx_stack[sec_ctx_stack_ndx - 1];
- safe_free(prev_ctx_p->groups);
- prev_ctx_p->groups = NULL;
+ SAFE_FREE(prev_ctx_p->groups);
prev_ctx_p->ngroups = 0;
get_current_groups(&prev_ctx_p->ngroups, &prev_ctx_p->groups);
ctx_p->ngroups = ngroups;
- safe_free(ctx_p->groups);
+ SAFE_FREE(ctx_p->groups);
if (token && (token == ctx_p->token))
smb_panic("DUPLICATE_TOKEN");
ctx_p->uid = (uid_t)-1;
ctx_p->gid = (gid_t)-1;
- safe_free(ctx_p->groups);
+ SAFE_FREE(ctx_p->groups);
ctx_p->ngroups = 0;
delete_nt_token(&ctx_p->token);
memcpy(&sessionid, dbuf.dptr, sizeof(sessionid));
- safe_free(dbuf.dptr);
- dbuf.dptr = NULL;
+ SAFE_FREE(dbuf.dptr);
#if WITH_UTMP
if (lp_utmp()) {
if ((total_params && !params) || (total_data && !data)) {
DEBUG(2,("Out of memory in reply_trans2\n"));
- if(params)
- free(params);
- if(data)
- free(data);
+ SAFE_FREE(params);
+ SAFE_FREE(data);
END_PROFILE(SMBtrans2);
return ERROR_DOS(ERRDOS,ERRnomem);
}
else
DEBUG(0,("reply_trans2: %s in getting secondary trans2 response.\n",
(smb_read_error == READ_ERROR) ? "error" : "timeout" ));
- if(params)
- free(params);
- if(data)
- free(data);
+ SAFE_FREE(params);
+ SAFE_FREE(data);
END_PROFILE(SMBtrans2);
return ERROR_DOS(ERRSRV,ERRerror);
}
default:
/* Error in request */
DEBUG(2,("Unknown request %d in trans2 call\n", tran_call));
- if(params)
- free(params);
- if(data)
- free(data);
+ SAFE_FREE(params);
+ SAFE_FREE(data);
END_PROFILE(SMBtrans2);
return ERROR_DOS(ERRSRV,ERRerror);
}
an error packet.
*/
- if(params)
- free(params);
- if(data)
- free(data);
+ SAFE_FREE(params);
+ SAFE_FREE(data);
END_PROFILE(SMBtrans2);
return outsize; /* If a correct response was needed the
call_trans2xxx calls have already sent
memcpy(p,array + element * elsize, elsize);
memmove(array + elsize,array,elsize*element);
memcpy(array,p,elsize);
- free(p);
+ SAFE_FREE(p);
}
/*******************************************************************
slprintf(server, sizeof(server), "%s#1D", name);
if (smbw_server(server, "IPC$")) {
smbw_setshared("WORKGROUP", name);
- free(ip_list);
+ SAFE_FREE(ip_list);
return name;
}
}
}
- free(ip_list);
+ SAFE_FREE(ip_list);
return p;
}
cli_shutdown(&c);
if (!srv) return NULL;
- if (srv->server_name) free(srv->server_name);
- if (srv->share_name) free(srv->share_name);
- free(srv);
+ SAFE_FREE(srv->server_name);
+ SAFE_FREE(srv->share_name);
+ SAFE_FREE(srv);
return NULL;
}
}
if (file) {
if (file->f) {
- if (file->f->fname) {
- free(file->f->fname);
- }
- free(file->f);
+ SAFE_FREE(file->f->fname);
+ SAFE_FREE(file->f);
}
- free(file);
+ SAFE_FREE(file);
}
smbw_busy--;
return -1;
file->f->ref_count--;
if (file->f->ref_count == 0) {
- free(file->f->fname);
- free(file->f);
+ SAFE_FREE(file->f->fname);
+ SAFE_FREE(file->f);
}
ZERO_STRUCTP(file);
- free(file);
+ SAFE_FREE(file);
smbw_busy--;
cli_shutdown(&srv->cli);
- free(srv->server_name);
- free(srv->share_name);
+ SAFE_FREE(srv->server_name);
+ SAFE_FREE(srv->share_name);
DLIST_REMOVE(smbw_srvs, srv);
ZERO_STRUCTP(srv);
- free(srv);
+ SAFE_FREE(srv);
smbw_busy--;
}
next = tmp->next;
- free(tmp->name);
- free(tmp->comment);
- free(tmp);
+ SAFE_FREE(tmp->name);
+ SAFE_FREE(tmp->comment);
+ SAFE_FREE(tmp);
tmp = next;
}
*******************************************************/
static void free_dir(struct smbw_dir *dir)
{
- if (dir->list) {
- free(dir->list);
- }
- if (dir->path) free(dir->path);
+ if(!dir) return;
+
+ SAFE_FREE(dir->list);
+ SAFE_FREE(dir->path);
ZERO_STRUCTP(dir);
- free(dir);
+ SAFE_FREE(dir);
}
static struct smbw_dir *cur_dir;
return dir->fd;
failed:
- if (dir) {
- free_dir(dir);
- }
-
+ free_dir(dir);
+
return -1;
}