opengnsys
/
ntfs-3g
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change callers of malloc() to ntfs_malloc() (Szaka). Fix compilition (Yuval).

edge.strict_endians
uvman 2006-11-01 13:30:40 +00:00
parent 483522ec1f
commit 7d585a0327
17 changed files with 98 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ChangeLog
View File

@ -61,6 +61,7 @@ xx/xx/2006 - x.xx.x - .
and rewrite it to be clearer. (Yuval)
- Move ntfs_index_entry_mark_dirty() to index.c. (Szaka)
- Introduce misc.c. Move ntfs_[mc]alloc there. (Szaka)
- Change malloc() calls to ntfs_malloc(). (Szaka)
21/06/2006 - 1.13.1 - Various fixes.

4
include/ntfs/support.h
View File

@ -96,4 +96,8 @@
old_state; \
})
/* Memory allocation with logging. */
extern void *ntfs_calloc(size_t size);
extern void *ntfs_malloc(size_t size);
#endif /* defined _NTFS_SUPPORT_H */

33
libntfs/attrib.c
View File

@ -56,6 +56,7 @@
#include "compress.h"
#include "bitmap.h"
#include "logging.h"
#include "support.h"
ntfschar AT_UNNAMED[] = { const_cpu_to_le16('\0') };
@ -175,11 +176,10 @@ s64 ntfs_get_attribute_value(const ntfs_volume *vol,
* going to overflow in the same fashion.
* Temporary fix: same as above.
*/
intbuf = malloc(rl[i].length << vol->cluster_size_bits);
intbuf = ntfs_malloc(rl[i].length <<
vol->cluster_size_bits);
if (!intbuf) {
int eo = errno;
ntfs_log_perror("Couldn't allocate memory for "
"internal buffer.");
free(rl);
errno = eo;
return 0;
@ -1043,13 +1043,11 @@ s64 ntfs_attr_pwrite(ntfs_attr *na, const s64 pos, s64 count, const void *b)
/* If write starts beyond initialized_size, zero the gap. */
if (pos > na->initialized_size) {
char *buf;
int err;
buf = malloc(NTFS_BUF_SIZE);
if (!buf) {
ntfs_log_trace("Not enough memory.\n");
buf = ntfs_malloc(NTFS_BUF_SIZE);
if (!buf)
goto err_out;
}
memset(buf, 0, NTFS_BUF_SIZE);
ofs = na->initialized_size;
while (ofs < pos) {
@ -1057,7 +1055,7 @@ s64 ntfs_attr_pwrite(ntfs_attr *na, const s64 pos, s64 count, const void *b)
written = ntfs_rl_pwrite(vol, na->rl, ofs,
to_write, buf);
if (written <= 0) {
err = errno;
int err = errno;
ntfs_log_trace("Failed to zero space "
"between initialized "
"size and @pos.\n");
@ -2294,7 +2292,7 @@ ntfs_attr_search_ctx *ntfs_attr_get_search_ctx(ntfs_inode *ni, MFT_RECORD *mrec)
errno = EINVAL;
return NULL;
}
ctx = malloc(sizeof(ntfs_attr_search_ctx));
ctx = ntfs_malloc(sizeof(ntfs_attr_search_ctx));
if (ctx)
ntfs_attr_init_search_ctx(ctx, ni, mrec);
return ctx;
@ -4738,12 +4736,10 @@ static int ntfs_non_resident_attr_expand(ntfs_attr *na, const s64 newsize)
* sparse runs instead of real allocation of clusters.
*/
if (na->type == AT_DATA && vol->major_ver >= 3) {
rl = malloc(0x1000);
if (!rl) {
ntfs_log_trace("Not enough memory.\n");
err = ENOMEM;
rl = ntfs_malloc(0x1000);
if (!rl)
return -1;
}
rl[0].vcn = (na->allocated_size >>
vol->cluster_size_bits);
rl[0].lcn = LCN_HOLE;
@ -4983,11 +4979,10 @@ void *ntfs_attr_readall(ntfs_inode *ni, const ATTR_TYPES type,
ntfs_log_perror("ntfs_attr_open failed");
return NULL;
}
data = malloc(na->data_size);
if (!data) {
ntfs_log_perror("malloc failed");
data = ntfs_malloc(na->data_size);
if (!data)
goto out;
}
size = ntfs_attr_pread(na, 0, na->data_size, data);
if (size != na->data_size) {
ntfs_log_perror("ntfs_attr_pread failed");

4
libntfs/bitmap.c
View File

@ -78,10 +78,10 @@ static int ntfs_bitmap_set_bits_in_run(ntfs_attr *na, s64 start_bit,
if (bufsize > 8192)
bufsize = 8192;
/* Allocate memory. */
buf = (u8*)malloc(bufsize);
buf = (u8*)ntfs_malloc(bufsize);
if (!buf)
return -1;
/* Depending on @value, zero or set all bits in the allocated buffer. */
memset(buf, value ? 0xff : 0, bufsize);

6
libntfs/compress.c
View File

@ -375,12 +375,14 @@ s64 ntfs_compressed_attr_pread(ntfs_attr *na, s64 pos, s64 count, void *b)
cb_size = na->compression_block_size;
cb_size_mask = cb_size - 1UL;
cb_clusters = na->compression_block_clusters;
/* Need a temporary buffer for each loaded compression block. */
cb = malloc(cb_size);
cb = ntfs_malloc(cb_size);
if (!cb)
return -1;
/* Need a temporary buffer for each uncompressed block. */
dest = malloc(cb_size);
dest = ntfs_malloc(cb_size);
if (!dest) {
err = errno;
free(cb);

2
libntfs/device.c
View File

@ -111,7 +111,7 @@ struct ntfs_device *ntfs_device_alloc(const char *name, const long state,
return NULL;
}
dev = (struct ntfs_device *)malloc(sizeof(struct ntfs_device));
dev = (struct ntfs_device *)ntfs_malloc(sizeof(struct ntfs_device));
if (dev) {
if (!(dev->d_name = strdup(name))) {
int eo = errno;

20
libntfs/dir.c
View File

@ -1270,12 +1270,9 @@ static ntfs_inode *__ntfs_create(ntfs_inode *dir_ni,
case S_IFBLK:
case S_IFCHR:
data_len = offsetof(INTX_FILE, device_end);
data = malloc(data_len);
data = ntfs_malloc(data_len);
if (!data) {
err = errno;
ntfs_log_error("Not enough memory for "
"content of DATA "
"attribute.\n");
goto err_out;
}
data->major = cpu_to_le64(major(dev));
@ -1288,12 +1285,9 @@ static ntfs_inode *__ntfs_create(ntfs_inode *dir_ni,
case S_IFLNK:
data_len = sizeof(INTX_FILE_TYPES) +
target_len * sizeof(ntfschar);
data = malloc(data_len);
data = ntfs_malloc(data_len);
if (!data) {
err = errno;
ntfs_log_error("Not enough memory for "
"content of DATA "
"attribute.\n");
goto err_out;
}
data->magic = INTX_SYMBOLIC_LINK;
@ -1322,10 +1316,9 @@ static ntfs_inode *__ntfs_create(ntfs_inode *dir_ni,
}
/* Create FILE_NAME attribute. */
fn_len = sizeof(FILE_NAME_ATTR) + name_len * sizeof(ntfschar);
fn = calloc(1, fn_len);
fn = ntfs_calloc(fn_len);
if (!fn) {
err = errno;
ntfs_log_error("Not enough memory.\n");
goto err_out;
}
fn->parent_directory = MK_LE_MREF(dir_ni->mft_no,
@ -1711,16 +1704,15 @@ int ntfs_link(ntfs_inode *ni, ntfs_inode *dir_ni, ntfschar *name, u8 name_len)
if (!ni || !dir_ni || !name || !name_len ||
ni->mft_no == dir_ni->mft_no) {
err = errno;
ntfs_log_error("Invalid arguments.\n");
err = EINVAL;
ntfs_log_perror("ntfs_link wrong arguments");
goto err_out;
}
/* Create FILE_NAME attribute. */
fn_len = sizeof(FILE_NAME_ATTR) + name_len * sizeof(ntfschar);
fn = calloc(1, fn_len);
fn = ntfs_calloc(fn_len);
if (!fn) {
err = errno;
ntfs_log_error("Not enough memory.\n");
goto err_out;
}
fn->parent_directory = MK_LE_MREF(dir_ni->mft_no,

4
libntfs/inode.c
View File

@ -180,7 +180,7 @@ ntfs_inode *ntfs_inode_open(ntfs_volume *vol, const MFT_REF mref)
goto put_err_out;
}
ni->attr_list_size = l;
ni->attr_list = malloc(ni->attr_list_size);
ni->attr_list = ntfs_malloc(ni->attr_list_size);
if (!ni->attr_list)
goto put_err_out;
l = ntfs_get_attribute_value(vol, ctx->attr, ni->attr_list);
@ -393,7 +393,7 @@ ntfs_inode *ntfs_extent_inode_open(ntfs_inode *base_ni, const MFT_REF mref)
if (!(base_ni->nr_extents & 3)) {
i = (base_ni->nr_extents + 4) * sizeof(ntfs_inode *);
extent_nis = (ntfs_inode**)malloc(i);
extent_nis = (ntfs_inode**)ntfs_malloc(i);
if (!extent_nis)
goto err_out;
if (base_ni->nr_extents) {

4
libntfs/lcnalloc.c
View File

@ -122,7 +122,7 @@ runlist *ntfs_cluster_alloc(ntfs_volume *vol, VCN start_vcn, s64 count,
/* Return empty runlist if @count == 0 */
if (!count) {
rl = malloc(0x1000);
rl = ntfs_malloc(0x1000);
if (!rl)
return NULL;
rl[0].vcn = start_vcn;
@ -132,7 +132,7 @@ runlist *ntfs_cluster_alloc(ntfs_volume *vol, VCN start_vcn, s64 count,
}
/* Allocate memory. */
buf = (u8*)malloc(8192);
buf = (u8*)ntfs_malloc(8192);
if (!buf)
return NULL;
/*

13
libntfs/logfile.c
View File

@ -371,12 +371,9 @@ static int ntfs_check_and_load_restart_page(ntfs_attr *log_na,
* Allocate a buffer to store the whole restart page so we can multi
* sector transfer deprotect it.
*/
trp = malloc(le32_to_cpu(rp->system_page_size));
if (!trp) {
ntfs_log_error("Failed to allocate memory for $LogFile "
"restart page buffer.\n");
trp = ntfs_malloc(le32_to_cpu(rp->system_page_size));
if (!trp)
return ENOMEM;
}
/*
* Read the whole of the restart page into the buffer. If it fits
* completely inside @rp, just copy it from there. Otherwise read it
@ -500,11 +497,9 @@ BOOL ntfs_check_logfile(ntfs_attr *log_na, RESTART_PAGE_HEADER **rp)
return FALSE;
}
/* Allocate memory for restart page. */
kaddr = malloc(NTFS_BLOCK_SIZE);
if (!kaddr) {
ntfs_log_error("Not enough memory.\n");
kaddr = ntfs_malloc(NTFS_BLOCK_SIZE);
if (!kaddr)
return FALSE;
}
/*
* Read through the file looking for a restart page. Since the restart
* page header is at the beginning of a page we only need to search at

22
libntfs/mft.c
View File

@ -158,7 +158,7 @@ int ntfs_mft_records_write(const ntfs_volume *vol, const MFT_REF mref,
cnt = vol->mftmirr_size - m;
if (cnt > count)
cnt = count;
bmirr = malloc(cnt * vol->mft_record_size);
bmirr = ntfs_malloc(cnt * vol->mft_record_size);
if (!bmirr)
return -1;
memcpy(bmirr, b, cnt * vol->mft_record_size);
@ -240,7 +240,7 @@ int ntfs_file_record_read(const ntfs_volume *vol, const MFT_REF mref,
}
m = *mrec;
if (!m) {
m = (MFT_RECORD*)malloc(vol->mft_record_size);
m = (MFT_RECORD*)ntfs_malloc(vol->mft_record_size);
if (!m)
return -1;
}
@ -367,7 +367,7 @@ int ntfs_mft_record_format(const ntfs_volume *vol, const MFT_REF mref)
errno = EINVAL;
return -1;
}
m = malloc(vol->mft_record_size);
m = ntfs_calloc(vol->mft_record_size);
if (!m)
return -1;
if (ntfs_mft_record_layout(vol, mref, m)) {
@ -459,9 +459,10 @@ static int ntfs_mft_bitmap_find_free_rec(ntfs_volume *vol, ntfs_inode *base_ni)
}
}
pass_start = data_pos;
buf = (u8*)malloc(PAGE_SIZE);
buf = (u8*)ntfs_malloc(PAGE_SIZE);
if (!buf)
return -1;
ntfs_log_debug("Starting bitmap search: pass %u, pass_start 0x%llx, "
"pass_end 0x%llx, data_pos 0x%llx.\n", pass,
(long long)pass_start, (long long)pass_end,
@ -1368,12 +1369,10 @@ mft_rec_already_initialized:
* is not zero as well as the update sequence number if it is not zero
* or -1 (0xffff).
*/
m = (MFT_RECORD*)malloc(vol->mft_record_size);
if (!m) {
ntfs_log_error("Failed to allocate buffer for mft "
"record.\n");
m = (MFT_RECORD*)ntfs_malloc(vol->mft_record_size);
if (!m)
goto undo_mftbmp_alloc;
}
if (ntfs_mft_record_read(vol, bit, m)) {
err = errno;
ntfs_log_error("Failed to read mft record.\n");
@ -1437,12 +1436,9 @@ mft_rec_already_initialized:
int i;
i = (base_ni->nr_extents + 4) * sizeof(ntfs_inode *);
extent_nis = (ntfs_inode**)malloc(i);
extent_nis = (ntfs_inode**)ntfs_malloc(i);
if (!extent_nis) {
err = errno;
ntfs_log_error("Failed to allocate "
"buffer for extent inodes "
"array.\n");
free(m);
free(ni);
errno = err;

14
libntfs/runlist.c
View File

@ -766,7 +766,8 @@ runlist_element *ntfs_mapping_pairs_decompress(const ntfs_volume *vol,
/* Current position in runlist array. */
rlpos = 0;
/* Allocate first 4kiB block and set current runlist size to 4kiB. */
rl = malloc(rlsize = 0x1000);
rlsize = 0x1000;
rl = ntfs_malloc(rlsize);
if (!rl)
return NULL;
/* Insert unmapped starting element if necessary. */
@ -1824,7 +1825,10 @@ static runlist_element * test_rl_pure_src(BOOL contig, BOOL multi, int vcn, int
else
fudge = 999;
result = malloc(4096);
result = ntfs_malloc(4096);
if (!result)
return NULL;
if (multi) {
MKRL(result+0, vcn + (0*len/4), fudge + vcn + 1000 + (0*len/4), len / 4)
MKRL(result+1, vcn + (1*len/4), fudge + vcn + 1000 + (1*len/4), len / 4)
@ -2042,9 +2046,9 @@ static void test_rl_frag_combine(ntfs_volume *vol, ATTR_RECORD *attr1, ATTR_RECO
static void test_rl_frag(char *test)
{
ntfs_volume vol;
ATTR_RECORD *attr1 = malloc(1024);
ATTR_RECORD *attr2 = malloc(1024);
ATTR_RECORD *attr3 = malloc(1024);
ATTR_RECORD *attr1 = ntfs_malloc(1024);
ATTR_RECORD *attr2 = ntfs_malloc(1024);
ATTR_RECORD *attr3 = ntfs_malloc(1024);
if (!attr1 || !attr2 || !attr3)
goto out;

4
libntfs/security.c
View File

@ -85,7 +85,7 @@ char *ntfs_guid_to_mbs(const GUID *guid, char *guid_str)
}
_guid_str = guid_str;
if (!_guid_str) {
_guid_str = malloc(37);
_guid_str = ntfs_malloc(37);
if (!_guid_str)
return _guid_str;
}
@ -201,7 +201,7 @@ char *ntfs_sid_to_mbs(const SID *sid, char *sid_str, size_t sid_str_size)
cnt = ntfs_sid_to_mbs_size(sid);
if (cnt < 0)
return NULL;
s = malloc(cnt);
s = ntfs_malloc(cnt);
if (!s)
return s;
sid_str = s;

8
libntfs/unistr.c
View File

@ -299,7 +299,7 @@ ntfschar *ntfs_ucsndup(const ntfschar *s, u32 maxlen)
u32 len;
len = ntfs_ucsnlen(s, maxlen);
dst = malloc((len + 1) * sizeof(ntfschar));
dst = ntfs_malloc((len + 1) * sizeof(ntfschar));
if (dst) {
memcpy(dst, s, len * sizeof(ntfschar));
dst[len] = cpu_to_le16(L'\0');
@ -419,7 +419,7 @@ int ntfs_ucstombs(const ntfschar *ins, const int ins_len, char **outs,
}
if (!mbs) {
mbs_len = (ins_len + 1) * MB_CUR_MAX;
mbs = (char*)malloc(mbs_len);
mbs = (char*)ntfs_malloc(mbs_len);
if (!mbs)
return -1;
}
@ -436,7 +436,7 @@ int ntfs_ucstombs(const ntfschar *ins, const int ins_len, char **outs,
errno = ENAMETOOLONG;
return -1;
}
tc = (char*)malloc((mbs_len + 64) & ~63);
tc = (char*)ntfs_malloc((mbs_len + 64) & ~63);
if (!tc)
goto err_out;
memcpy(tc, mbs, mbs_len);
@ -562,7 +562,7 @@ int ntfs_mbstoucs(const char *ins, ntfschar **outs, int outs_len)
ins_len++;
if (!ucs) {
ucs_len = ins_len;
ucs = (ntfschar*)malloc(ucs_len * sizeof(ntfschar));
ucs = (ntfschar*)ntfs_malloc(ucs_len * sizeof(ntfschar));
if (!ucs)
return -1;
}

2
libntfs/unix_io.c
View File

@ -86,7 +86,7 @@ static int ntfs_device_unix_io_open(struct ntfs_device *dev, int flags)
errno = EBUSY;
return -1;
}
if (!(dev->d_private = malloc(sizeof(int))))
if (!(dev->d_private = ntfs_malloc(sizeof(int))))
return -1;
/*
* Open the device/file obtaining the file descriptor for exclusive

54
libntfs/volume.c
View File

@ -147,7 +147,7 @@ static int ntfs_mft_load(ntfs_volume *vol)
/* Manually setup an ntfs_inode. */
vol->mft_ni = ntfs_inode_allocate(vol);
mb = (MFT_RECORD*)malloc(vol->mft_record_size);
mb = (MFT_RECORD*)ntfs_malloc(vol->mft_record_size);
if (!vol->mft_ni || !mb) {
ntfs_log_perror("Error allocating memory for $MFT");
goto error_exit;
@ -198,12 +198,10 @@ static int ntfs_mft_load(ntfs_volume *vol)
goto io_error_exit;
}
vol->mft_ni->attr_list_size = l;
vol->mft_ni->attr_list = malloc(l);
if (!vol->mft_ni->attr_list) {
ntfs_log_debug("Error: failed to allocate buffer for attribute "
"list.\n");
vol->mft_ni->attr_list = ntfs_malloc(l);
if (!vol->mft_ni->attr_list)
goto error_exit;
}
l = ntfs_get_attribute_value(vol, ctx->attr, vol->mft_ni->attr_list);
if (!l) {
ntfs_log_debug("Error: failed to get value of "
@ -421,20 +419,20 @@ ntfs_volume *ntfs_volume_startup(struct ntfs_device *dev, unsigned long flags)
return NULL;
}
/* Allocate the boot sector structure. */
if (!(bs = (NTFS_BOOT_SECTOR *)malloc(sizeof(NTFS_BOOT_SECTOR))))
if (!(bs = (NTFS_BOOT_SECTOR *)ntfs_malloc(sizeof(NTFS_BOOT_SECTOR))))
return NULL;
/* Allocate the volume structure. */
vol = ntfs_volume_alloc();
if (!vol)
goto error_exit;
/* Create the default upcase table. */
vol->upcase_len = 65536;
vol->upcase = (ntfschar*)malloc(vol->upcase_len * sizeof(ntfschar));
if (!vol->upcase) {
ntfs_log_perror("Error allocating memory for upcase table.");
vol->upcase = (ntfschar*)ntfs_malloc(vol->upcase_len *
sizeof(ntfschar));
if (!vol->upcase)
goto error_exit;
}
ntfs_upcase_table_build(vol->upcase,
vol->upcase_len * sizeof(ntfschar));
if (flags & MS_RDONLY)
@ -697,11 +695,9 @@ static int ntfs_volume_check_hiberfile(ntfs_volume *vol)
return -1;
}
buf = malloc(NTFS_HIBERFILE_HEADER_SIZE);
if (!buf) {
ntfs_log_perror("Error allocating memory for hiberfile.sys header");
buf = ntfs_malloc(NTFS_HIBERFILE_HEADER_SIZE);
if (!buf)
goto out;
}
na = ntfs_attr_open(ni, AT_DATA, AT_UNNAMED, 0);
if (!na) {
@ -790,12 +786,10 @@ ntfs_volume *ntfs_device_mount(struct ntfs_device *dev, unsigned long flags)
}
/* Load data from $MFT and $MFTMirr and compare the contents. */
m = (u8*)malloc(vol->mftmirr_size << vol->mft_record_size_bits);
m2 = (u8*)malloc(vol->mftmirr_size << vol->mft_record_size_bits);
if (!m || !m2) {
ntfs_log_perror("Failed to allocate memory");
m = (u8*)ntfs_malloc(vol->mftmirr_size << vol->mft_record_size_bits);
m2 = (u8*)ntfs_malloc(vol->mftmirr_size << vol->mft_record_size_bits);
if (!m || !m2)
goto error_exit;
}
l = ntfs_attr_mst_pread(vol->mft_na, 0, vol->mftmirr_size,
vol->mft_record_size, m);
@ -932,10 +926,9 @@ ntfs_volume *ntfs_device_mount(struct ntfs_device *dev, unsigned long flags)
vol->upcase_len = na->data_size >> 1;
/* Throw away default table. */
free(vol->upcase);
vol->upcase = (ntfschar*)malloc(na->data_size);
vol->upcase = (ntfschar*)ntfs_malloc(na->data_size);
if (!vol->upcase) {
ntfs_log_debug(FAILED);
ntfs_log_debug("Not enough memory to load $UpCase.\n");
goto error_exit;
}
}
@ -1026,11 +1019,9 @@ ntfs_volume *ntfs_device_mount(struct ntfs_device *dev, unsigned long flags)
* Treat this the same way as if the attribute was present but
* had zero length.
*/
vol->vol_name = malloc(1);
vol->vol_name = ntfs_malloc(1);
if (!vol->vol_name) {
ntfs_log_debug(FAILED);
ntfs_log_debug("Error: Unable to allocate memory for volume "
"name!\n");
goto error_exit;
}
vol->vol_name[0] = '\0';
@ -1057,11 +1048,9 @@ ntfs_volume *ntfs_device_mount(struct ntfs_device *dev, unsigned long flags)
"to current locale");
ntfs_log_debug("Forcing name into ASCII by replacing "
"non-ASCII characters with underscores.\n");
vol->vol_name = malloc(u + 1);
vol->vol_name = ntfs_malloc(u + 1);
if (!vol->vol_name) {
ntfs_log_debug(FAILED);
ntfs_log_debug("Error: Unable to allocate memory for "
"volume name!\n");
goto error_exit;
}
for (j = 0; j < (s32)u; j++) {
@ -1100,10 +1089,9 @@ ntfs_volume *ntfs_device_mount(struct ntfs_device *dev, unsigned long flags)
goto error_exit;
}
vol->attrdef_len = na->data_size;
vol->attrdef = (ATTR_DEF*)malloc(na->data_size);
vol->attrdef = (ATTR_DEF*)ntfs_malloc(na->data_size);
if (!vol->attrdef) {
ntfs_log_debug(FAILED);
ntfs_log_debug("Not enough memory to load $AttrDef.\n");
goto error_exit;
}
/* Read in the $DATA attribute value into the buffer. */
@ -1303,10 +1291,10 @@ static int ntfs_mntent_check(const char *file, unsigned long *mnt_flags)
FILE *f;
int err = 0;
real_file = malloc(PATH_MAX + 1);
real_file = ntfs_malloc(PATH_MAX + 1);
if (!real_file)
return -1;
real_fsname = malloc(PATH_MAX + 1);
real_fsname = ntfs_malloc(PATH_MAX + 1);
if (!real_fsname) {
err = errno;
goto exit;

24
ntfsprogs/ntfsmount.c
View File

@ -67,6 +67,7 @@
#include "utils.h"
#include "version.h"
#include "ntfstime.h"
#include "misc.h"
#ifndef PATH_MAX
#define PATH_MAX 4096
@ -148,7 +149,7 @@ static long ntfs_fuse_get_nr_free_mft_records(ntfs_volume *vol)
if (!(ctx->state & NF_FreeMFTOutdate))
return ctx->free_mft;
buf = malloc(vol->cluster_size);
buf = ntfs_malloc(vol->cluster_size);
if (!buf)
return -ENOMEM;
while (1) {
@ -180,7 +181,7 @@ static long ntfs_fuse_get_nr_free_clusters(ntfs_volume *vol)
if (!(ctx->state & NF_FreeClustersOutdate))
return ctx->free_clusters;
buf = malloc(vol->cluster_size);
buf = ntfs_malloc(vol->cluster_size);
if (!buf)
return -ENOMEM;
while (1) {
@ -378,7 +379,7 @@ static int ntfs_fuse_getattr(const char *org_path, struct stat *stbuf)
!stream_name_len) {
INTX_FILE *intx_file;
intx_file = malloc(na->data_size);
intx_file = ntfs_malloc(na->data_size);
if (!intx_file) {
res = -errno;
ntfs_attr_close(na);
@ -474,7 +475,7 @@ static int ntfs_fuse_readlink(const char *org_path, char *buf, size_t buf_size)
goto exit;
}
/* Receive file content. */
intx_file = malloc(na->data_size);
intx_file = ntfs_malloc(na->data_size);
if (!intx_file) {
res = -errno;
goto exit;
@ -1400,11 +1401,10 @@ static struct fuse_operations ntfs_fuse_oper = {
static int ntfs_fuse_init(void)
{
ctx = malloc(sizeof(ntfs_fuse_context_t));
if (!ctx) {
ntfs_log_perror("malloc failed");
ctx = ntfs_malloc(sizeof(ntfs_fuse_context_t));
if (!ctx)
return -1;
}
*ctx = (ntfs_fuse_context_t) {
.state = NF_FreeClustersOutdate | NF_FreeMFTOutdate,
.uid = geteuid(),
@ -1458,11 +1458,11 @@ static char *parse_mount_options(const char *org_options)
* +1 for null-terminator.
* +PATH_MAX for resolved by realpath() device name.
*/
ret = malloc(strlen(def_opts) + strlen(org_options) + 9 + PATH_MAX);
if (!ret) {
ntfs_log_perror("malloc failed");
ret = ntfs_malloc(strlen(def_opts) + strlen(org_options) + PATH_MAX +
9);
if (!ret)
return NULL;
}
*ret = 0;
options = strdup(org_options);
if (!options) {