void *malloc(size_t size)
{
void *ptr;
size = 0 ? 1 : size;
if (!g_map.tiny && !g_map.small && !g_map.large)
init_glob();
if (size + sizeof(t_header) > g_map.max_size || size > g_map.max_size)
return (NULL);
size += sizeof(t_block);
if (size - sizeof(t_block) <= g_map.size_tiny)
{
if (!g_map.tiny && new_map(g_map.size_tiny, &g_map.tiny, NULL) < 0)
return (NULL);
ptr = find_free_space(g_map.size_tiny, size, &g_map.tiny);
}
else if (size - sizeof(t_block) <= g_map.size_small)
{
if (!g_map.small && new_map(g_map.size_small, &g_map.small, NULL) < 0)
return (NULL);
ptr = find_free_space(g_map.size_small, size, &g_map.small);
}
else
ptr = large_alloc(size, &g_map.large);
if (ptr)
ptr = (void *)ptr + sizeof(t_block);
return (ptr);
}
int move_file(struct flist * file, off_t wsize)
{
char *from, *to, *buf;
off_t size;
FILE *input, *output;
int ret, dir_id;
struct utimbuf ftime = {0};
struct statvfs svf;
fsblkcnt_t space;
struct stat st;
mhdd_debug(MHDD_MSG, "move_file: %s\n", file->real_name);
/* TODO: it would be nice to contrive something alter */
flist_wrlock_locked();
from=file->real_name;
/* We need to check if already moved */
if (statvfs(from, &svf) != 0)
return -errno;
space = svf.f_bsize;
space *= svf.f_bavail;
/* get file size */
if (fstat(file->fh, &st) != 0) {
mhdd_debug(MHDD_MSG, "move_file: error stat %s: %s\n",
from, strerror(errno));
return -errno;
}
/* Hard link support is limited to a single device, and files with
>1 hardlinks cannot be moved between devices since this would
(a) result in partial files on the source device (b) not free
the space from the source device during unlink. */
if (st.st_nlink > 1) {
mhdd_debug(MHDD_MSG, "move_file: cannot move "
"files with >1 hardlinks\n");
return -ENOTSUP;
}
size = st.st_size;
if (size < wsize) size=wsize;
if (space > size) {
mhdd_debug(MHDD_MSG, "move_file: we have enough space\n");
return 0;
}
if ((dir_id=find_free_space(size)) == -1) {
mhdd_debug(MHDD_MSG, "move_file: can not find space\n");
return -1;
}
if (!(input = fopen(from, "r")))
return -errno;
create_parent_dirs(dir_id, file->name);
to = create_path(mhdd.dirs[dir_id], file->name);
if (!(output = fopen(to, "w+"))) {
ret = -errno;
mhdd_debug(MHDD_MSG, "move_file: error create %s: %s\n",
to, strerror(errno));
free(to);
fclose(input);
return(ret);
}
mhdd_debug(MHDD_MSG, "move_file: move %s to %s\n", from, to);
// move data
buf=(char *)calloc(sizeof(char), MOVE_BLOCK_SIZE);
while((size = fread(buf, sizeof(char), MOVE_BLOCK_SIZE, input))) {
if (size != fwrite(buf, sizeof(char), size, output)) {
mhdd_debug(MHDD_MSG,
"move_file: error move data to %s: %s\n",
to, strerror(errno));
fclose(output);
fclose(input);
free(buf);
unlink(to);
free(to);
return -1;
}
}
free(buf);
mhdd_debug(MHDD_MSG, "move_file: done move data\n");
fclose(input);
// owner/group/permissions
fchmod(fileno(output), st.st_mode);
fchown(fileno(output), st.st_uid, st.st_gid);
fclose(output);
// time
ftime.actime = st.st_atime;
ftime.modtime = st.st_mtime;
utime(to, &ftime);
#ifndef WITHOUT_XATTR
// extended attributes
if (copy_xattrs(from, to) == -1)
mhdd_debug(MHDD_MSG,
"copy_xattrs: error copying xattrs from %s to %s\n",
from, to);
#endif
from = strdup(from);
if ((ret = reopen_files(file, to)) == 0)
unlink(from);
else
unlink(to);
mhdd_debug(MHDD_MSG, "move_file: %s -> %s: done, code=%d\n",
from, to, ret);
free(to);
free(from);
return ret;
}
int main(int argc, char* argv[])
{
FILE* file; /* file pointer to work with input and output file */
char* inputfile; /* path to input file*/
char* outputfile; /* path to output file */
unsigned char* buffer; /* buffer to read input file into */
size_t filesize; /* size of opened file */
size_t read; /* read bytes counter */
size_t rest; /* rest of filesize to search in */
unsigned char* asusbkp; /* ASUSBKP header */
unsigned char* module; /* FD44 module header */
unsigned char* me; /* ME firmware header */
unsigned char* gbe; /* GbE firmware header */
unsigned char* s2lp; /* */
unsigned char* keys; /* */
unsigned char* freespace; /* */
unsigned char* msoa; /* */
ptrdiff_t asusbkp_start_address = -1; /* */
ptrdiff_t asusbkp_s2lp_address = -1; /* */
ptrdiff_t asusbkp_keys_address = -1; /* */
ptrdiff_t asusbkp_freespace_address = -1; /* ASUSBKP free space address*/
ptrdiff_t slic_s2lp_address = -1; /* */
ptrdiff_t slic_keys_address = -1; /* */
ptrdiff_t slic_freespace_address = -1; /* */
ptrdiff_t me_start_address = -1; /* ME start address */
ptrdiff_t gbe_start_address = -1; /* GbE start address */
ptrdiff_t bsa_adresses[MAX_FD44_MODULES]; /* BSA modules addresses*/
size_t bsa_count = 0; /* BSA modules count*/
if(argc < 3)
{
printf("AddrInfo v0.2.1\nThis program finds addresses of different BIOS structures of ASUS BIOS files and stores them to INI-formated file\n\n"
"Usage: AddrInfo BIOSFILE INIFILE\n\n");
return ERR_ARGS;
}
inputfile = argv[1];
outputfile = argv[2];
/* Opening input file */
file = fopen(inputfile, "rb");
if (!file)
{
fprintf(stderr, "Can't open input file\n");
return ERR_INPUT_FILE;
}
/* Determining file size */
fseek(file, 0, SEEK_END);
filesize = ftell(file);
fseek(file, 0, SEEK_SET);
/* Allocating memory for buffer */
buffer = (unsigned char*)malloc(filesize);
if (!buffer)
{
fprintf(stderr, "Can't allocate memory for input buffer\n");
return ERR_MEMORY;
}
/* Reading whole file to buffer */
read = fread((void*)buffer, sizeof(char), filesize, file);
if (read != filesize)
{
fprintf(stderr, "Can't read input file\n");
return ERR_INPUT_FILE;
}
/* Searching for ASUSBKP */
asusbkp = memmem(buffer, filesize, ASUSBKP_HEADER, sizeof(ASUSBKP_HEADER));
if(!asusbkp)
{
fprintf(stderr, "ASUSBKP signature not found in BIOS file. Nothing to do\n");
return ERR_NO_ASUSBKP;
}
/* Storing ASUSBKP address */
asusbkp_start_address = asusbkp - buffer;
/* Finding free space in ASUSBKP, alligned to 4 */
freespace = find_free_space(asusbkp, buffer + filesize - 1, ASUSBKP_FREE_SPACE_LENGTH, 4);
if(!freespace)
{
fprintf(stderr, "No space left in ASUSBKP to insert data\n");
return ERR_NO_ASUSBKP;
}
/* Storing free space address */
asusbkp_freespace_address = freespace - buffer;
/* Searching for S2LP in ASUSBKP */
rest = freespace - asusbkp;
s2lp = memmem(asusbkp, rest, ASUSBKP_S2LP_HEADER, sizeof(ASUSBKP_S2LP_HEADER));
if(s2lp)
asusbkp_s2lp_address = s2lp - buffer;
/* Searching for KEYS in ASUSBKP */
keys = memmem(asusbkp, rest, ASUSBKP_KEYS_HEADER, sizeof(ASUSBKP_KEYS_HEADER));
if(keys)
asusbkp_keys_address = keys - buffer;
/* Searching for ME firmware address*/
me = memmem(buffer, filesize, ME_HEADER, sizeof(ME_HEADER));
if(me)
me_start_address = me - buffer;
/* Searching for GbE firmware address*/
gbe = memmem(buffer, filesize, GBE_HEADER, sizeof(GBE_HEADER));
if(gbe)
gbe_start_address = gbe + GBE_MAC_OFFSET - buffer;
/* Searching for MSOA module*/
msoa = memmem(buffer, filesize, MSOA_MODULE_HEADER, sizeof(MSOA_MODULE_HEADER));
if(msoa)
{
rest = filesize - (msoa - buffer);
/* Searching for S2LP module*/
s2lp = memmem(msoa, rest, SLIC_S2LP_HEADER, sizeof(SLIC_S2LP_HEADER));
if(s2lp)
slic_s2lp_address = s2lp - buffer;
/* Searching for KEYS module*/
keys = memmem(msoa, rest, SLIC_KEYS_HEADER, sizeof(SLIC_KEYS_HEADER));
if(keys)
slic_keys_address = keys - buffer;
/* Finding free space and alligning it to 8*/
freespace = find_free_space(msoa, buffer + filesize - 1, SLIC_FREE_SPACE_LENGTH, 8);
if (freespace)
slic_freespace_address = freespace - buffer;
}
/* Searching for module header */
module = memmem(buffer, filesize, FD44_MODULE_HEADER, sizeof(FD44_MODULE_HEADER));
if(module)
{
/* Looking for BSA_ module */
rest = filesize - (module - buffer);
while(module)
{
/* If one found, storing the address of it */
if (!memcmp(module + FD44_MODULE_HEADER_BSA_OFFSET, FD44_MODULE_HEADER_BSA, sizeof(FD44_MODULE_HEADER_BSA)))
{
module = module + FD44_MODULE_HEADER_LENGTH;
bsa_adresses[bsa_count++] = module - buffer;
}
module = memmem(module + FD44_MODULE_HEADER_LENGTH, rest, FD44_MODULE_HEADER, sizeof(FD44_MODULE_HEADER));
rest = filesize - (module - buffer);
}
}
/* Closing input file */
fclose(file);
/* Creating output file*/
file = fopen(outputfile, "w");
/* Writing data to output file */
fprintf(file, "[ASUSBKP]\n");
asusbkp_start_address > 0 ? fprintf(file,"START=0x%08X\n", asusbkp_start_address) : fprintf(file,"START=NOT_FOUND\n");
asusbkp_keys_address > 0 ? fprintf(file,"KEYS=0x%08X\n", asusbkp_keys_address) : fprintf(file,"KEYS=NOT_FOUND\n");
asusbkp_s2lp_address > 0 ? fprintf(file,"S2LP=0x%08X\n", asusbkp_s2lp_address) : fprintf(file,"S2LP=NOT_FOUND\n");
asusbkp_freespace_address > 0 ? fprintf(file,"FREESPACE=0x%08X\n", asusbkp_freespace_address) : fprintf(file,"FREESPACE=NOT_FOUND\n");
fprintf(file, "\n[SLIC]\n");
slic_keys_address > 0 ? fprintf(file,"KEYS=0x%08X\n", slic_keys_address) : fprintf(file,"KEYS=NOT_FOUND\n");
slic_s2lp_address > 0 ? fprintf(file,"S2LP=0x%08X\n", slic_s2lp_address) : fprintf(file,"S2LP=NOT_FOUND\n");
slic_freespace_address > 0 ? fprintf(file,"FREESPACE=0x%08X\n", slic_freespace_address) : fprintf(file,"FREESPACE=NOT_FOUND\n");
fprintf(file, "\n[ME]\n");
me_start_address > 0 ? fprintf(file, "START=0x%08X\n", me_start_address) : fprintf(file,"START=NOT_FOUND\n");
fprintf(file, "\n[GBE]\n");
gbe_start_address > 0 ? fprintf(file, "START=0x%08X\n", gbe_start_address) : fprintf(file,"START=NOT_FOUND\n");
if(bsa_count)
{
int i;
fprintf(file, "\n[BSA]\n");
for(i = 0; i < bsa_count; i++)
{
fprintf(file, "START%i=0x%08X\n", i, bsa_adresses[i] - FD44_MODULE_HEADER_LENGTH);
fprintf(file, "DATA%i=0x%08X\n", i, bsa_adresses[i]);
}
}
/* Closing output file */
fclose(file);
/* Freeing buffer */
free(buffer);
return ERR_OK;
}
