int main(int argc, char **argv) {
if (argc != 2) {
fprintf(stderr, "Usage: ./parhist <filename>\n");
exit(1);
}
const char *filename = argv[1];
// create a memory-mapped view of the file
size_t file_size = get_file_size(filename);
struct mmap_region region;
map_file_region(filename, file_size, ®ion);
// This is the array of values and the number of elements
uint16_t *arr = region.addr;
size_t num_elements = file_size/sizeof(uint16_t);
// This is the histogram: each element counts the number
// of data values that fell into a particular 4000-wide range:
// Histogram element 0 counts number of values from 1..4000
// Histogram element 1 counts number of values from 4001..8000
// etc.
int histogram[NUM_BUCKETS] = { 0 };
// Sequential computation
for (size_t i = 0; i < num_elements; i++) {
uint16_t val = arr[i];
int bucket = (val-1)/BUCKET_SIZE;
if (bucket < 0) {
bucket = 0;
} else if (bucket >= NUM_BUCKETS) {
bucket = NUM_BUCKETS-1;
}
histogram[bucket]++;
}
// Print histogram
for (int i = 0; i < NUM_BUCKETS; i++) {
printf("%5i..%5i: %i\n", i*BUCKET_SIZE+1, (i+1)*BUCKET_SIZE, histogram[i]);
}
return 0;
}
void print_working_dir(pDataStruct workingData){
pNode temp = workingData->workingDir->directoryHeadNode;
printf("Type Size Date Name Perms\n_______________________________________\n");//40_
while ( temp != NULL ){
if(temp->type == FILE){
printf("FILE @d @x @s ",get_file_size(temp->file), temp->date, temp->name);
print_perms(temp,workingData);
printf("\n");
}
if(temp->type == DIRECTORY){
printf("DIR @d @x @s ",sizeof(sNode), temp->date, temp->name);
print_perms(temp,workingData);
printf("\n");
}
temp = temp->next;
}
}
CXSourceRange get_range_whole_file() const
{
size_t const file_size = get_file_size(file_name.c_str());
CXFile const file = clang_getFile(translation_unit, file_name.c_str());
auto const file_begin = clang_getLocationForOffset(translation_unit, file, 0);
auto const file_end = clang_getLocationForOffset(translation_unit, file, file_size);
if(is_null_location(file_begin) || is_null_location(file_end)) {
return clang_getNullRange();
}
auto const file_range = clang_getRange(file_begin, file_end);
if(clang_Range_isNull(file_range)) {
return clang_getNullRange();
}
return file_range;
}
static ssize_t _log_write(struct iovec *vec, int n)
{
unsigned long long tmp_size = get_file_size(_log_name);
if (UNLIKELY(tmp_size > _log_file_size)) {
fprintf(stderr, "%s size= %llu reach max %llu, splited\n",
_log_name, tmp_size, _log_file_size);
if (-1 == _log_close()) {
fprintf(stderr, "_log_close errno:%d", errno);
}
log_get_time(_log_name_time, sizeof(_log_name_time), 1);
snprintf(_log_name, sizeof(_log_name), "%s%s_%s",
_log_path, _log_name_prefix, _log_name_time);
_log_open(_log_name);
fprintf(stderr, "splited file %s\n", _log_name);
}
return writev(_log_fd, vec, n);
}
// 添加识别关键词语，开发者可以学习"语音识别芯片LD3320高阶秘籍.pdf"中关于垃圾词语吸收错误的用法
uint8 LD_AsrAddFixed(char cmd) //添加关键词语到LD3320芯片中
{
//先检查传入的文件名是否符合规范
char i;
for(i=0;i<=LD_struct_index;i++)
{
rt_kprintf("添加用户码:%d 指令: %s 播放音乐:%s 配置文件:%s 执行动作:%s \r\n",ld_struct[i].pCode,ld_struct[i].sRecog,ld_struct[i].mp3_name,ld_struct[i].next_ini,ld_struct[i].action);
LD_AsrAddFixed_ByString(ld_struct[i].sRecog,ld_struct[i].pCode);
}
wu_fd = open(Name_ini,0,0);
i = get_file_size(wu_fd);
read(wu_fd, line_data, sizeof(line_data));
line_data[i]='\0';
close(wu_fd);
rt_kprintf("添加用户码: 49 用户名: %s \r\n",line_data);
LD_AsrAddFixed_ByString(line_data,49); //添加用户名
return 1;
}
void fetch_fd_file(pid_t pid, int flags, int fd, int inode, char *fd_path,
struct cp_file *file)
{
int bufsz = 512;
int retsz;
char *buf = NULL;
file->filename = NULL;
file->deleted = 0;
file->size = get_file_size(pid, fd);
file->contents = NULL;
do {
buf = xmalloc(bufsz);
retsz = readlink(fd_path, buf, bufsz);
if (retsz <= 0) {
fprintf(stderr, "Error reading FD %d: %s\n", fd, strerror(errno));
goto out;
} else if (retsz < bufsz) {
/* Read was successful */
buf[retsz] = '\0';
file->filename = strdup(buf);
break;
}
/* Otherwise, double the buffer size and try again */
free(buf);
bufsz <<= 1;
} while (bufsz <= 8192); /* Keep it sane */
bufsz = strlen(file->filename);
if (bufsz > 10 && strcmp(" (deleted)", file->filename+bufsz-10) == 0) {
file->deleted = 1;
*(file->filename+bufsz-10) = '\0';
file->contents = xmalloc(file->size);
if (!scrape_contents(pid, fd, file->size, file->contents)) {
xfree(file->contents);
file->contents = NULL;
}
}
out:
free(buf);
}
int decode(std::string file_path, std::string &decode_content)
{
BYTE init_array[16] = {0};
FILE *data_file = fopen(file_path.c_str(), "rb");
if (data_file == NULL)
{
return -1;
}
size_t file_size = get_file_size(data_file);
BYTE *file_buffer = new BYTE[file_size];
fread(file_buffer, 1, file_size, data_file);
fclose(data_file);
//_maxthon3_default_storage_
//Maxthon3_MxCmpUrl_Mood
//Maxthon__WebSIteBooster
//guestmaxthon3_favdb_txmood
//guestmaxthon3_config_txmood
//username+maxthon3_favdb_txmood
HCRYPTKEY hCryptKey = CreateKey((BYTE *)"guestmaxthon3_favdb_txmood", 0x1a);
for (int page_index = 0; page_index < file_size / PAGE_SIZE; page_index++)
{
DWORD dwPageSize = PAGE_SIZE;
BYTE *page_content = &file_buffer[page_index * PAGE_SIZE];
CryptDecrypt(hCryptKey, 0, 1, 0, page_content, &dwPageSize);
}
FILE *fOut = fopen("maxthon_a.db", "wb");
fwrite(file_buffer, 1, file_size, fOut);
decode_content.assign((char *)file_buffer, file_size);
fclose(fOut);
return 0;
}
static void write_syslog(char *fmt,...)
{
va_list argptr;
//int cnt = 0;
char buffer[1024] = {0};
FILE *fp = NULL;
time_t t = time(NULL);
struct tm timet;
if (get_file_size(GMI_LOG_FILE) < GMI_LOG_MAX_SIZE)
{
//append log to the end of file
fp = fopen(GMI_LOG_FILE, "a+" );
}
else
{
//create a new file to write log
fp = fopen(GMI_LOG_FILE, "wb" );
}
if(fp == NULL )
{
printf("fopen error\n");
return ;
}
//write time info
memset(buffer, 0, sizeof(buffer));
localtime_r(&t, &timet);
snprintf(buffer, sizeof(buffer) - 1, "%04d-%02d-%02d %02d:%02d:%02d\n", timet.tm_year + 1900, timet.tm_mon + 1, timet.tm_mday, timet.tm_hour, timet.tm_min, timet.tm_sec);
fwrite(buffer, strlen(buffer), 1, fp);
//write log msg
memset(buffer, 0, sizeof(buffer));
va_start(argptr, fmt);
vsnprintf(buffer, sizeof(buffer) - 1, fmt, argptr);
va_end(argptr);
fwrite(buffer, strlen(buffer), 1, fp);
fflush(fp);
fclose(fp);
fp = NULL;
}
/* Steem Engine cartridge image */
static int cmd_stc(FILE* infile, const char* infilename,
FILE* outfile, const char* outfilename)
{
size_t source_size;
size_t target_size = 128 * 1024;
size_t free_size;
int ret; /* boolean return value: 0 == error, 1 == OK */
printf("# Padding %s to %ld kB Steem Engine cartridge image into %s\n", infilename, ((long)target_size) / 1024, outfilename);
/* Get the input file size */
source_size = get_file_size(infile, infilename);
if (source_size == SIZE_ERROR)
return 0;
/* Check if the input file size is not too big */
if (source_size > target_size)
{
fprintf(stderr, "%s: %s is too big: %lu extra bytes\n", g_argv0, infilename, (unsigned long)(source_size - target_size));
return 0;
}
/* Insert a long zero at the beginning */
ret = write_byte_block(outfile, outfilename, 0, 4);
if (!ret)
return ret;
/* Copy the input file */
ret = copy_stream(infile, infilename, outfile, outfilename, source_size);
if (!ret)
return ret;
/* Pad with zeroes */
free_size = target_size - source_size;
ret = write_byte_block(outfile, outfilename, 0, free_size);
if (!ret)
return ret;
printf("# %s done (%lu bytes free)\n", outfilename, (unsigned long)free_size);
return 1;
}
/**
* @brief Read a file into memory and returns a pointer to it
* @param char * filename
* @return char * ptr
*/
char * readFile(char * filename)
{
int file, length;
char * ptr; /* Contents of json file */
if((file = open(filename, O_RDONLY, 0)) == -1){
return NULL;
}
length = get_file_size(file);
if((ptr = malloc(length * sizeof(char) )) == NULL){
return NULL;
}
//TODO: Make sure everything is read?
if(read(file, ptr, length) == -1){
return NULL;
}
close(file);
return ptr;
}
// write the master hash table
void write_master_hash_table(FILE *f)
{
unsigned int i = 1;
unsigned int off, blockoff;
unsigned int filesize = get_file_size(f);
off = SECOND_HASH_START;
blockoff = BLOCK_HASH_START;
write_hash(f, off, blockoff, BLOCK_SIZE, 1);
while(1)
{
off = SECOND_HASH_START + i * 24;
blockoff = FILE_START_OFFSET + (0xAA * BLOCK_SIZE * i) + (BLOCK_SIZE * (i-1));
if (blockoff > (filesize-1)) break;
write_hash(f, off, blockoff, BLOCK_SIZE, 0);
i++;
}
}
/**
* Loads snt offsets from the given binary file.
*/
vector_int* load_snt_offsets(const char* name) {
U_FILE* f=u_fopen(BINARY,name,U_READ);
if (f==NULL) return NULL;
long size=get_file_size(f);
if (size%(3*sizeof(int))!=0) {
u_fclose(f);
return NULL;
}
vector_int* v=new_vector_int((int)(size/sizeof(int)));
if (size!=0) {
int n=(int)fread(v->tab,sizeof(int),size/sizeof(int),f);
u_fclose(f);
if (n!=(int)(size/sizeof(int))) {
free_vector_int(v);
return NULL;
}
v->nbelems=v->size;
}
return v;
}
static rc_t vdb_info_1( VSchema * schema, dump_format_t format, const VDBManager *mgr,
const char * acc_or_path, const char * table_name )
{
rc_t rc = 0;
vdb_info_data data;
memset( &data, 0, sizeof data );
data.s_platform = PT_NONE;
data.acc = acc_or_path;
/* #1 get path-type */
data.s_path_type = get_path_type( mgr, acc_or_path );
if ( data.s_path_type[ 0 ] == 'D' || data.s_path_type[ 0 ] == 'T' )
{
rc_t rc1;
/* #2 fork by table or database */
switch ( data.s_path_type[ 0 ] )
{
case 'D' : vdb_info_db( &data, schema, mgr ); break;
case 'T' : vdb_info_tab( &data, schema, mgr ); break;
}
rc1 = resolve_accession( acc_or_path, data.path, sizeof data.path, false );
if ( rc1 == 0 )
data.file_size = get_file_size( data.path );
switch ( format )
{
case df_xml : rc = vdb_info_print_xml( &data ); break;
case df_json : rc = vdb_info_print_json( &data ); break;
case df_csv : rc = vdb_info_print_sep( &data, ',' ); break;
case df_tab : rc = vdb_info_print_sep( &data, '\t' ); break;
case df_sql : rc = vdb_info_print_sql( table_name, &data ); break;
default : rc = vdb_info_print_dflt( &data ); break;
}
}
return rc;
}
static void
hexify_file (char *filename, char *target)
{
bfd *abfd;
char *dot;
char *hex_file;
if (get_file_size (filename) < 1)
return;
abfd = bfd_openr (filename, target);
if (abfd == NULL)
{
nonfatal (filename);
return;
}
if (bfd_check_format (abfd, bfd_object))
{
if (verbose)
printf ("\n");
/* strip extension from filename if present */
dot = strrchr (filename, '.');
if (dot)
dot[0] = '\0';
/* create a new name with .hex extension */
hex_file = malloc (strlen (filename) + strlen (".hex") + 1);
sprintf (hex_file, "%s%s", filename, ".hex");
exit_status = write_hex_file (hex_file, abfd);
if (verbose)
printf ("\n");
free (hex_file);
}
bfd_close (abfd);
}
/*--------------------------------------------------------------------------------*/
Data *read_gbt(const char *fname)
{
Data *dat=(Data *)malloc(sizeof(Data));
memset(dat,0,sizeof(Data));
int nchan=4096;
int npol=4;
long ndat=get_file_size(fname);
if (ndat<=0) {
printf("FILE %s unavailable for reading.\n",fname);
return NULL;
}
int nsamp=ndat/npol/nchan;
printf("have %d samples.\n",nsamp);
char **mat=cmatrix(nsamp,nchan);
char *tmp=(char *)malloc(sizeof(char)*nchan*npol);
FILE *infile=fopen(fname,"r");
for (int i=0;i<nsamp;i++) {
size_t nread=fread(tmp,sizeof(char),nchan*npol,infile);
memcpy(mat[i],tmp,sizeof(char)*nchan);
}
fclose(infile);
free(tmp);
dat->raw_nchan=nchan;
dat->ndata=nsamp;
//dat->raw_data=mat;
dat->raw_data=matrix(nchan,nsamp);
for (int i=0;i<nchan;i++)
for (int j=0;j<nsamp;j++)
dat->raw_data[i][j]=mat[j][i];
dat->raw_chans=(float *)malloc(sizeof(float)*dat->raw_nchan);
dat->dt=1e-3;
float dnu=(900-700.0)/dat->raw_nchan;
for (int i=0;i<dat->raw_nchan;i++) {
dat->raw_chans[i]=900-(0.5+i)*dnu;
}
free(mat[0]);
free(mat);
return dat;
}
/* Main function prints file size of self in bytes or argv[1] if supplied.
Works only for regular files.
*/
int main( int argc, char *argv[] ) {
long file_size = 0L;
char *file_path;
if ( argc == 2 ) {
file_path = argv[1];
}
else {
file_path = argv[0];
}
file_size = get_file_size( file_path );
if ( file_size < 0 ) {
local_perror();
return 0;
}
printf("File size of file %s is %ld bytes\n", file_path, file_size);
return 0;
}
int erase_usercalibration_partition() {
Volume *v = volume_for_path(USERCALIB_PATH);
if (v == NULL) {
// most devices won't have /mnt/usercalib, so this is not an error.
return 0;
}
int fd = open(v->blk_device, O_RDWR);
uint64_t size = get_file_size(fd);
if (size != 0) {
if (wipe_block_device(fd, size)) {
LOGE("error wiping /mnt/usercalib: %s\n", strerror(errno));
close(fd);
return -1;
}
}
close(fd);
return 0;
}
int main()
{
int a;
long size;
FILE *pFile;
pFile = fopen("text.txt", "r");
if (pFile == NULL)
{
printf("Error while opening file\n");
system("PAUSE");
return 1;
}
size = get_file_size(pFile);
printf("File size = %d\n", size);
fclose(pFile);
a = get_file_lines_count("Text.txt");
printf("Lines count = %d\n", a);
printf("s=%d\n", summAn(0, 3, 2));
system("PAUSE");
return 0;
}
int read_input_file() {
int directory_id = 0;
int entry_id = 0;
int cluster_id = 0;
int file_size = 0;
if (resolve_argument_path(argument[ARGUMENT_HEAP_SIZE-1], argument, resolve_result) == -1) {
return -1;
}
directory_id = resolve_result[0];
entry_id = resolve_result[1];
cluster_id = resolve_result[2];
file_size = get_file_size(directory_id, entry_id);
if (file_size >= 1024) {
error(TOO_MANY_INPUT);
}
read_file(cluster_id, file_size, input);
return 0;
}
/*
* Add a file to the archive in RAM
*
* path: path to the file to be added
* entry: pointer to struct dentry where file header is created
* offset: offset of the file contents from the archive header
*
* return: 0 on success or -1 on error
*/
static int add_file(const char *path, struct dentry *entry, uint32_t offset)
{
FILE *fp;
int size;
if (!path || !*path || !entry) {
fprintf(stderr, "Error: invalid path or entry\n");
return -1;
}
size = get_file_size(path);
if (size < 0)
return -1;
if (offset + size > archive->size) {
fprintf(stderr, "Error: invalid offset or size\n");
return -1;
}
fp = fopen(path, "rb");
if (!fp) {
fprintf(stderr, "Error: failed to open %s (%d: %s)\n",
path, errno, strerror(errno));
return -1;
}
if (fread((char *)archive + offset, sizeof(char), size, fp) != size) {
fprintf(stderr, "Error: failed to read %s\n", path);
fclose(fp);
return -1;
}
fclose(fp);
/* set file name*/
if (set_file_name(path, entry))
return -1;
entry->offset = offset;
entry->size = size;
return 0;
}
static void
list__process_line (char *line,
gpointer data)
{
FrCommand *comm = FR_COMMAND (data);
FileData *fdata;
char **fields;
char *filename;
fdata = file_data_new ();
fields = split_line (line, 2);
if (strcmp (fields[1], "-1") != 0)
fdata->size = g_ascii_strtoull (fields[1], NULL, 10);
g_strfreev (fields);
if (fdata->size == 0)
fdata->size = get_file_size (comm->filename);
filename = get_uncompressed_name_from_archive (comm, comm->filename);
if (filename == NULL)
filename = remove_extension_from_path (comm->filename);
fdata->full_path = g_strconcat ("/",
file_name_from_path (filename),
NULL);
g_free (filename);
fdata->original_path = fdata->full_path + 1;
fdata->link = NULL;
fdata->modified = get_file_mtime_for_path (comm->filename);
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
if (*fdata->name == 0)
file_data_free (fdata);
else
fr_command_add_file (comm, fdata);
}
struct command *next_cmd()
{
struct command *cmd;
struct xmlNode *tmp;
char *ptr = NULL;
for(; cmd_list; cmd_list = cmd_list->next)
{
if (cmd_list->type != XML_ELEMENT_NODE)
continue;
if (strcasecmp(cmd_list->name, "cmd") != 0)
continue;
cmd = malloc(sizeof(struct command));
memset(cmd, 0, sizeof(struct command));
if (strcasecmp(xmlGetProp(cmd_list, "state"), "bootstrap") == 0)
cmd->state = NULL; //need to take care of this
else
cmd->state = NULL;//crazy!!
cmd->type = get_cmd_type(xmlGetProp(cmd_list, "type"));
if ((ptr = xmlGetProp(cmd_list, "file")) != 0)
strcpy(cmd->file, ptr);
if ((ptr = xmlGetProp(cmd_list, "address")) != 0)
strcpy(cmd->address, ptr);
cmd->perform = get_cmd_handler(cmd->type);
cmd->file_size = get_file_size(cmd->file);
strcpy(cmd->message, xmlNodeGetContent(cmd_list));
cmd_list = cmd_list->next;
return cmd;
}
return cmd;
}
/* Takes a um executable file, loads the program and runs each instuction
* in segment 0 until a halt is reached.
*/
void UM_run(T um, const char *input)
{
WORD_SIZE curr_inst;
int size = get_file_size(input);
assert(Segment_map(um->memory, size) == 0);
load_file(um, size, input);
while (true) {
curr_inst = *prog_copy;
route_instruct(um, curr_inst);
prog_copy += 1;
curr_inst = *prog_copy;
route_instruct(um, curr_inst);
prog_copy += 1;
curr_inst = *prog_copy;
route_instruct(um, curr_inst);
prog_copy += 1;
}
return;
}
void Verifier::recv_file(const char *file_name) {
int size = 0;
double time = 0;
#ifdef INTERFACE_MPI
snprintf(full_file_name, BUFLEN - 1, "%s/%s", FOLDER_STATE, file_name);
if (!FOLDER_STATE_SHARED) {
Measurement get_time;
MPI_Send(const_cast<char *>(file_name), strlen(file_name)+1, MPI_CHAR, 1,
MPI_FILE_RECV, MPI_COMM_WORLD);
MPI_Status stat;
MPI_Probe(MPI_COORD_RANK, MPI_FILE_RECV, MPI_COMM_WORLD, &stat);
MPI_Get_count(&stat, MPI_BYTE, &size);
char *buf = new char[size];
get_time.begin_with_init();
MPI_Recv(buf, size, MPI_BYTE, MPI_COORD_RANK, MPI_FILE_RECV,
MPI_COMM_WORLD, MPI_STATUS_IGNORE);
get_time.end();
FILE *fp = fopen(full_file_name, "w");
fwrite(buf, size, 1, fp);
fclose(fp);
time = get_time.get_papi_elapsed_time();
delete[] buf;
}
#else
snprintf(full_file_name, BUFLEN - 1, "%s/%s", FOLDER_STATE, file_name);
snprintf(download_url, BUFLEN - 1, "%s?file=%s", prover_download_url,
file_name);
curl->recv_file(full_file_name, download_url, &size, &time);
#endif
size = get_file_size(full_file_name);
network_bytes_rcvd += size;
network_rcv_time_elapsed += time;
if (strstr(file_name, OUTPUT_FILE_NAME_SUBSTR) != NULL)
network_bytes_output_rcvd += size;
}
T* SequenceReader<T>::read(int& size) {
size = get_file_size();
if((size) <= 0) {
fprintf(stderr, "Erro de leitura sequence_size <= 0\n");
return NULL;
}
T* result = NULL;
try {
result = new T[size + 1];
} catch(std::exception& e) {
fprintf(stderr, "Erro ao alocar memoria para a sequencia %s\n", e.what());
return NULL;
}
fread(result, sizeof(T), size, f);
result[size] = 0;
return result;
}
/**
* Allocate memory and load a file there
* @param filename the file which should be loaded
* @param fsize pointer on the size of file which will be loaded
* @return file data buffer pointer
*/
char *
load_absolute_file (const char *const filename, Uint32 * const filesize)
{
size_t fsize;
FILE *fstream;
char *buffer;
fstream = fopen (filename, "r");
if (fstream == NULL)
{
LOG_ERR ("can't open file %s (%s)", filename, strerror (errno));
return NULL;
}
fsize = get_file_size (fstream);
(*filesize) = fsize;
if (fsize == 0)
{
fclose (fstream);
LOG_ERR ("file %s is empty!", filename);
return NULL;
}
buffer = memory_allocation (fsize);
if (buffer == NULL)
{
LOG_ERR ("not enough memory to allocate %i bytes!",
filename, (Sint32) fsize);
fclose (fstream);
return NULL;
}
if (fread (buffer, sizeof (char), fsize, fstream) != fsize)
{
free_memory (buffer);
LOG_ERR ("can't read file \"%s\" (%s)", filename, strerror (errno));
fclose (fstream);
return NULL;
}
fclose (fstream);
LOG_DBG ("file \"%s\" was loaded in memory", filename);
return buffer;
}
void set(uint64_t id, TValue value) {
if (id >= m_size) {
uint64_t new_size = id + size_increment;
// if the file backing this mmap is smaller than needed, increase its size
if (get_file_size() < sizeof(TValue) * new_size) {
if (ftruncate(m_fd, sizeof(TValue) * new_size) < 0) {
throw std::bad_alloc();
}
}
if (munmap(m_items, sizeof(TValue) * m_size) < 0) {
throw std::bad_alloc();
}
m_items = static_cast<TValue*>(mmap(NULL, sizeof(TValue) * new_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0));
if (m_items == MAP_FAILED) {
throw std::bad_alloc();
}
m_size = new_size;
}
m_items[id] = value;
}
int32_t map_file_in(int32_t fd, char **buf, uint64_t *size, int32_t perm)
{
int32_t rtrn = 0;
/* Get the file's size. */
rtrn = get_file_size(fd, size);
if(rtrn < 0)
{
output->write(ERROR, "Can't get file size\n");
return (-1);
}
/* Use MAP_SHARED otherwise the file won't change when we write it to disk. */
(*buf) = mmap(0, (unsigned long)(*size), perm, MAP_SHARED, fd, 0);
if((*buf) == MAP_FAILED)
{
output->write(ERROR, "mmap: %s\n", strerror(errno));
return (-1);
}
return (0);
}
int send_file(int work_sockfd, int sockfd, char* fileName) {
char buffer[8192];
FILE *fp;
int len;
bzero(buffer, 8192);
if ((fp = fopen(fileName, "rb")) == NULL) {
printf("fopen() error!\n");
close(sockfd);
return 1;
}
char *tmp_str = waiting_for(work_sockfd, "");
char num[16];
strcpy(num, split(tmp_str, " ", 2)[0]);
if (strcmp(num, "150") != 0) {
fclose(fp);
close(sockfd);
return 1;
}
sprintf(tmp_str, "(%d bytes).\r\n", get_file_size(fileName));
printf("%s", tmp_str);
len = 0;
while((len = fread(buffer, 1, 8192, fp)) > 0) {
int send_len;
if ((send_len = send(sockfd, buffer, len, 0)) < 0) {
printf("Error send(): %s(%d)\n", strerror(errno), errno);
}
bzero(buffer, 8192);
}
fclose(fp);
close(sockfd);
waiting_for(work_sockfd, "");
return STATUS_OK;
}
void *
ia_acc_open_firmware(const char *fw_path, unsigned *size)
{
FILE *file;
unsigned len;
void *fw;
if (!fw_path)
return NULL;
file = fopen(fw_path, "rb");
if (!file)
return NULL;
len = get_file_size(file);
if (!len) {
fclose(file);
return NULL;
}
fw = malloc(len);
if (!fw) {
fclose(file);
return NULL;
}
if (fread(fw, 1, len, file) != len) {
fclose(file);
free(fw);
return NULL;
}
*size = len;
fclose(file);
return fw;
}
