static void get_log_file_tail(const char *despath, const char *srcpath,
const int lines)
{
char *start;
int start_line;
int file_lines;
struct mm_file_t *mfile;
int ret;
mfile = mmap_file(srcpath);
if (!mfile) {
LOGE("mmap (%s) failed, error (%s)\n", srcpath,
strerror(errno));
return;
}
file_lines = mm_count_lines(mfile);
if (file_lines <= 0) {
LOGW("get lines (%s, %d) failed\n", mfile->path, file_lines);
goto unmap;
}
start_line = MAX(file_lines - lines, 0) + 1;
start = mm_get_line(mfile, start_line);
ret = overwrite_file(despath, start);
if (ret < 0) {
LOGE("create file with (%s, %p) failed, error (%s)\n",
despath, start, strerror(errno));
goto unmap;
}
unmap:
unmap_file(mfile);
}
void pb_free(void)
{
if (polyhash) {
unmap_file(polyhash, mapping);
polyhash = NULL;
}
}
static void calc_checksum(char *name)
{
long64 orig_size;
if (!work) work = alloc_work(total_work);
data = map_file(name, 0, &size);
orig_size = size;
if ((size & 0x3f) == 0x10) {
size &= ~0x3fULL;
memcpy(checksum1, data + size, 16);
checksum_found = 1;
} else {
if (size & 0x3f) {
printf("Size of %s is not a multiple of 64.\n", name);
exit(1);
}
checksum_found = 0;
}
int chunks = (size + CHUNK - 1) / CHUNK;
results = (uint64 *)malloc(32 * chunks);
fill_work(total_work, chunks, 0, work);
run_threaded(checksum_worker, work, 0);
CityHashCrc128((char *)results, 32 * chunks, checksum2);
unmap_file(data, orig_size);
free(results);
if (checksum_found)
checksum_match = (checksum1[0] == checksum2[0]
&& checksum1[1] == checksum2[1]);
}
ROMappedFile &ROMappedFile::map_file(const char *filepath)
{
unmap_file();
assert(!is_mapped());
#ifndef WIN32
const int fid = open(filepath, O_RDONLY);
if (fid < 0) {
return *this;
}
struct stat fid_info;
memset(&fid_info, 0, sizeof(fid_info));
// check for 32 bit limitations - off_t will be 32 bit on a 32 bit system, so we will be limited
// to mapping 2gig there
if (fstat(fid, &fid_info) < 0 || fid_info.st_size > std::numeric_limits<off_t>::max()) {
close(fid);
return *this;
}
_mem = mmap(0, fid_info.st_size, PROT_READ, MAP_PRIVATE, fid, 0);
// mmap keeps a reference to the handle, keeping the file open effectively
close(fid);
if (_mem) {
_len = fid_info.st_size;
}
assert (is_mapped());
#endif
return *this;
}
int main(int ac, char **av)
{
int failed = 0, verbose = 0;
struct snappy_env env;
snappy_init_env(&env);
if (av[1] && !strcmp(av[1], "-v")) {
verbose++;
av++;
}
while (*++av) {
size_t size;
char *map = mapfile(*av, O_RDONLY, &size);
if (!map) {
if (size > 0) {
perror(*av);
failed = 1;
}
continue;
}
size_t outlen;
int err;
char *out = xmalloc(snappy_max_compressed_length(size));
char *buf2 = xmalloc(size);
err = snappy_compress(&env, map, size, out, &outlen);
if (err) {
failed = 1;
printf("compression of %s failed: %d\n", *av, err);
goto next;
}
err = snappy_uncompress(out, outlen, buf2);
if (err) {
failed = 1;
printf("uncompression of %s failed: %d\n", *av, err);
goto next;
}
if (memcmp(buf2, map, size)) {
int o = compare(buf2, map, size);
if (o >= 0) {
failed = 1;
printf("final comparision of %s failed at %d of %lu\n",
*av, o, (unsigned long)size);
}
} else {
if (verbose)
printf("%s OK!\n", *av);
}
next:
unmap_file(map, size);
free(out);
free(buf2);
}
return failed;
}
/*!
\brief Close down the graphics processing. This gets called only at driver
termination time.
*/
void PNG_Graph_close(void)
{
write_image();
if (png.mapped)
unmap_file();
else
G_free(png.grid);
}
int main(int ac, char **av)
{
int snappy_only = 0;
if (av[1] && !strcmp(av[1], "-s")) {
snappy_only = 1;
av++;
}
#ifdef SIMPLE_PMU
pin_cpu(NULL);
if(perfmon_available() == 0) {
printf("no perfmon support\n");
exit(1);
}
#endif
while (*++av) {
size_t size;
char *map = mapfile(*av, O_RDONLY, &size);
if (!map)
err(*av);
int i, v;
for (i = 0; i < size; i += 4096)
v = ((volatile char *)map)[i];
#ifdef COMP
test_lz4(map, size, *av);
#endif
test_snappy(map, size, *av);
if (snappy_only)
goto unmap;
#ifdef COMP
test_lzo(map, size, *av);
test_zlib(map, size, *av, 1);
test_zlib(map, size, *av, 3);
//test_zlib(map, size, *av, 5);
test_lzf(map, size, *av);
test_quicklz(map, size, *av);
test_fastlz(map, size, *av);
#endif
#ifdef SNAPREF
test_snapref(map, size, *av);
#endif
unmap:
unmap_file(map, size);
}
return 0;
}
int open_trace(mf_t *mf, char *file) {
if(mf->mem)
unmap_file(mf);
assert(!(map_file(mf, file, 0, 0)));
madvise(mf->ptr, mf->len, MADV_WILLNEED);
return 0;
}
/**
* Destroy global objects allocated by load_case_tables()
**/
void gfree_case_tables(void)
{
if ( upcase_table ) {
if ( upcase_table_use_unmap )
unmap_file(upcase_table, 0x20000);
else
SAFE_FREE(upcase_table);
}
if ( lowcase_table ) {
if ( lowcase_table_use_unmap )
unmap_file(lowcase_table, 0x20000);
else
SAFE_FREE(lowcase_table);
}
if ( valid_table ) {
if ( valid_table_use_unmap )
unmap_file(valid_table, 0x10000);
else
SAFE_FREE(valid_table);
}
}
int main(int argc, char **argv)
{
waveinfo_t *wi;
wview_t *wv = NULL;
mf_t mf;
assert(argc > 1);
assert(!(map_file(&mf, argv[1], 0, 0)));
assert((wv = wview_init(1400-30, 512)));
wi = (waveinfo_t *) mf.ptr;
assert(mf.len >= sizeof(waveinfo_t));
if (wi->magic != WVINFO_MAGIC) {
printf("loading raw file\n");
wptr = malloc(mf.len + sizeof(waveinfo_t));
wi = (waveinfo_t *) wptr;
memcpy(wptr + sizeof(waveinfo_t), mf.ptr, mf.len);
wi->magic = WVINFO_MAGIC;
wi->capture_time = 0;
wi->capture_cnt = 0;
wi->scnt = mf.len;
wi->pre = 0;
wi->ns = 1;
wi->ch_config = 1;
wi->scale[0] = wi->scale[1] = 0.0;
wv->sbuf[0].y_ofs = 256; // channel y offset
wv->sbuf[0].invert_y = 0;
wv->sbuf[0].max_val = 128;
wv->sbuf[0].min_val = -128;
wv->sbuf[0].dtype = INT8;
unmap_file(&mf);
}
else {
//load_wave(wv, mf.ptr);
wptr = mf.ptr;
}
event_loop(wv);
// wview_destroy - unmap file, free
return 0;
}
int cmd_dump(int argc, char **argv)
{
struct mapped_file map;
struct blob *blob;
argc = parse_options(dump_option_specs, argc, argv);
die_if(argc == 0, "usage: arsc dump <resource-file-or-apk>");
map_file(argv[0], &map);
blob_init(&blob, map.data, map.data_size);
dump(blob);
blob_destroy(blob);
unmap_file(&map);
return 0;
}
int main(int argc, char **argv) {
mf_t mf, mf2;
char buf[128];
int i, res, len, min_i = 0;
float min_diff = 0;
assert(argc>1);
res = map_file(&mf, argv[1], 0, 0);
assert(!res);
len = mf.len;
assert(len >= 400000);
while(fgets(buf,128,stdin)) {
int slen = strlen(buf);
buf[--slen]=0;
res = map_file(&mf2, buf, 0, 0);
assert(!res);
assert(mf2.len == len);
min_diff = -1.0;
for(i=-1000;i<=1000;i++) {
float val = lsqd(mf.ptr + 90000, mf2.ptr + 90000 + i, 1000);
if(min_diff == -1.0) {
min_diff = val;
min_i = i;
}
if(val < min_diff) {
min_diff = val;
min_i = i;
}
//printf("%d %f\n",i,val);
}
printf("%s %d %f\n",buf,min_i,min_diff);
unmap_file(&mf2);
}
return 0;
}
/**
* Includes a rule file.
*
* @1 Filename
* @2 The ruleset structure
*
* Returns: 0 if success, -1 otherwise
*/
int rules_include(const char *filename, struct rules_t **return_rules) {
struct filemap_t filemap;
struct rules_t *rules;
if (map_file(filename, &filemap)) {
ERROR("rules parse","Unable to open/mmap rules file.");
return -1;
}
rules = rules_from_config((char*)(filemap.map), *return_rules);
if (rules == NULL) {
ERROR("rules parse","Unable to parse rules file.");
return -1;
}
*return_rules = rules;
unmap_file(&filemap);
return 0;
}
XkbFile *
XkbParseFile(struct xkb_context *ctx, FILE *file,
const char *file_name, const char *map)
{
bool ok;
XkbFile *xkb_file;
const char *string;
size_t size;
ok = map_file(file, &string, &size);
if (!ok) {
log_err(ctx, "Couldn't read XKB file %s: %s\n",
file_name, strerror(errno));
return NULL;
}
xkb_file = XkbParseString(ctx, string, size, file_name, map);
unmap_file(string, size);
return xkb_file;
}
void
privload_unmap_file(privmod_t *privmod)
{
/* walk the program header to unmap files, also the tls data */
uint i;
os_privmod_data_t *opd = (os_privmod_data_t *) privmod->os_privmod_data;
/* unmap segments */
for (i = 0; i < opd->os_data.num_segments; i++) {
unmap_file(opd->os_data.segments[i].start,
opd->os_data.segments[i].end -
opd->os_data.segments[i].start);
}
/* free segments */
HEAP_ARRAY_FREE(GLOBAL_DCONTEXT, opd->os_data.segments,
module_segment_t,
opd->os_data.alloc_segments,
ACCT_OTHER, PROTECTED);
/* delete os_privmod_data */
privload_delete_os_privmod_data(privmod);
}
int main(int argc, char* argv[])
{
if (argc!=2) {
show_usage();
return 0;
}
//while(true) {
MAPPED_FILE view = {0};
if( 0 != map_file( argv[1], &view ) ) {
printf( "open file failed: %s\n", argv[2]);
return -1;
}
int pe = pe_open((const char*)view.data, view.size);
if (pe == INVALID_PE) {
printf( "file is not pe format");
return -1;
}
dump_entry(pe);
dump_version(pe);
dump_section(pe);
dump_export(pe);
dump_import(pe);
dump_overlay(pe);
dump_resource(pe);
char path[256] = {0};
strcat(getcwd(path, sizeof(path) - 1), "\\sample.ico");
dump_icon(pe, path);
pe_close(pe);
unmap_file(&view);
//}
system("pause");
return 0;
}
void llvm_gcda_end_file() {
/* Write out EOF record. */
if (output_file) {
write_bytes("\0\0\0\0\0\0\0\0", 8);
if (new_file) {
fwrite(write_buffer, cur_pos, 1, output_file);
free(write_buffer);
} else {
unmap_file();
}
fclose(output_file);
output_file = NULL;
write_buffer = NULL;
}
free(filename);
#ifdef DEBUG_GCDAPROFILING
fprintf(stderr, "llvmgcda: -----\n");
#endif
}
int main(int ac, char **av)
{
while (*++av) {
unsigned long start, end;
uint64_t h1, h2;
struct spooky_state state;
size_t size;
char *map = mapfile(*av, O_RDONLY, &size);
if (!map) {
perror(*av);
continue;
}
int i;
for (i = 0; i < size; i += 64)
use_value(((volatile char *)map)[i]);
spooky_init(&state, 0x123456789abcdef, 0xfedcba987654321);
spooky_update(&state, map, size);
spooky_final(&state, &h1, &h2);
start = __builtin_ia32_rdtsc();
for (i = 0; i < ITER; i++) {
spooky_init(&state, 0x123456789abcdef, 0xfedcba987654321);
spooky_update(&state, map, size);
spooky_final(&state, &h1, &h2);
}
end = __builtin_ia32_rdtsc();
printf("%s: %016llx%016llx [%f c/b]\n", *av,
(unsigned long long)h1,
(unsigned long long)h2,
((end - start) / ITER) / (double)size);
unmap_file(map, size);
}
return 0;
}
void print_checksum(char *name)
{
printf("%s: ", name);
data = map_file(name, 1, &size);
if ((size & 0x3f) == 0x10) {
memcpy(checksum1, data + (size & ~0x3fULL), 16);
} else {
printf("No checksum found.\n");
exit(1);
}
unmap_file(data, size);
int i;
static char nibble[16] = "0123456789abcdef";
ubyte *c = (ubyte *)checksum1;
for (i = 0; i < 16; i++) {
ubyte b = c[i];
putc(nibble[b >> 4], stdout);
putc(nibble[b & 0x0f], stdout);
}
putc('\n', stdout);
}
void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
{
int fd;
STRUCT_STAT st;
struct map_struct *buf;
struct sum_struct *s;
int statret;
struct file_struct *file = flist->files[i];
char *fnamecmp;
char fnamecmpbuf[MAXPATHLEN];
extern char *compare_dest;
extern int list_only;
if (list_only) return;
if (verbose > 2)
rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
statret = link_stat(fname,&st);
if (S_ISDIR(file->mode)) {
if (dry_run) return;
if (statret == 0 && !S_ISDIR(st.st_mode)) {
if (robust_unlink(fname) != 0) {
rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
return;
}
statret = -1;
}
if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
if (!(relative_paths && errno==ENOENT &&
create_directory_path(fname)==0 &&
do_mkdir(fname,file->mode)==0)) {
rprintf(FERROR,"mkdir %s : %s (2)\n",
fname,strerror(errno));
}
}
if (set_perms(fname,file,NULL,0) && verbose)
rprintf(FINFO,"%s/\n",fname);
return;
}
if (preserve_links && S_ISLNK(file->mode)) {
#if SUPPORT_LINKS
char lnk[MAXPATHLEN];
int l;
extern int safe_symlinks;
if (safe_symlinks && unsafe_symlink(file->link, fname)) {
if (verbose) {
rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
fname,file->link);
}
return;
}
if (statret == 0) {
l = readlink(fname,lnk,MAXPATHLEN-1);
if (l > 0) {
lnk[l] = 0;
if (strcmp(lnk,file->link) == 0) {
set_perms(fname,file,&st,1);
return;
}
}
}
delete_file(fname);
if (do_symlink(file->link,fname) != 0) {
rprintf(FERROR,"link %s -> %s : %s\n",
fname,file->link,strerror(errno));
} else {
set_perms(fname,file,NULL,0);
if (verbose) {
rprintf(FINFO,"%s -> %s\n",
fname,file->link);
}
}
#endif
return;
}
#ifdef HAVE_MKNOD
if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
if (statret != 0 ||
st.st_mode != file->mode ||
st.st_rdev != file->rdev) {
delete_file(fname);
if (verbose > 2)
rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
fname,(int)file->mode,(int)file->rdev);
if (do_mknod(fname,file->mode,file->rdev) != 0) {
rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
} else {
set_perms(fname,file,NULL,0);
if (verbose)
rprintf(FINFO,"%s\n",fname);
}
} else {
set_perms(fname,file,&st,1);
}
return;
}
#endif
if (preserve_hard_links && check_hard_link(file)) {
if (verbose > 1)
rprintf(FINFO,"%s is a hard link\n",f_name(file));
return;
}
if (!S_ISREG(file->mode)) {
rprintf(FINFO,"skipping non-regular file %s\n",fname);
return;
}
fnamecmp = fname;
if ((statret == -1) && (compare_dest != NULL)) {
/* try the file at compare_dest instead */
int saveerrno = errno;
slprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
statret = link_stat(fnamecmpbuf,&st);
if (!S_ISREG(st.st_mode))
statret = -1;
if (statret == -1)
errno = saveerrno;
else
fnamecmp = fnamecmpbuf;
}
if (statret == -1) {
if (errno == ENOENT) {
write_int(f_out,i);
if (!dry_run) send_sums(NULL,f_out);
} else {
if (verbose > 1)
rprintf(FERROR,"recv_generator failed to open %s\n",fname);
}
return;
}
if (!S_ISREG(st.st_mode)) {
if (delete_file(fname) != 0) {
return;
}
/* now pretend the file didn't exist */
write_int(f_out,i);
if (!dry_run) send_sums(NULL,f_out);
return;
}
if (update_only && st.st_mtime > file->modtime && fnamecmp == fname) {
if (verbose > 1)
rprintf(FINFO,"%s is newer\n",fname);
return;
}
if (skip_file(fname, file, &st)) {
if (fnamecmp == fname)
set_perms(fname,file,&st,1);
return;
}
if (dry_run) {
write_int(f_out,i);
return;
}
if (whole_file) {
write_int(f_out,i);
send_sums(NULL,f_out);
return;
}
/* open the file */
fd = open(fnamecmp,O_RDONLY);
if (fd == -1) {
rprintf(FERROR,"failed to open %s : %s\n",fnamecmp,strerror(errno));
rprintf(FERROR,"skipping %s\n",fname);
return;
}
if (st.st_size > 0) {
buf = map_file(fd,st.st_size);
} else {
buf = NULL;
}
if (verbose > 3)
rprintf(FINFO,"gen mapped %s of size %d\n",fnamecmp,(int)st.st_size);
s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
if (verbose > 2)
rprintf(FINFO,"sending sums for %d\n",i);
write_int(f_out,i);
send_sums(s,f_out);
close(fd);
if (buf) unmap_file(buf);
free_sums(s);
}
~file_map()
{
unmap_file( data, fd, size );
}
/**
@brief dynamic linker ops
*/
static ke_handle process_ld(struct sysreq_process_ld *req)
{
ke_handle handle;
xstring module_name;
switch (req->function_type)
{
case SYSREQ_PROCESS_OPEN_EXE:
{
struct ko_exe *image;
module_name = req->name;
if (ke_validate_user_buffer(req->context, req->context_length, true) == false)
goto ld_0_err;
if (ke_validate_user_buffer(module_name, strlen(module_name), false) == false)
goto ld_0_err;
if (ke_validate_user_buffer(&req->map_base, sizeof(req->map_base), true) == false)
goto ld_0_err;
if ((image = kp_exe_open_by_name(KP_CURRENT(), module_name, &req->map_base)) == NULL)
goto ld_0_err;
if (kp_exe_copy_private(image, req->context, req->context_length) == false)
goto ld_0_err1;
/* Create handle for this image */
handle = ke_handle_create(image);
if (handle == KE_INVALID_HANDLE)
goto ld_0_err1;
return handle;
ld_0_err1:
//TODO: close the object
ld_0_err:
return KE_INVALID_HANDLE;
}
/* Return the map base */
case SYSREQ_PROCESS_MAP_EXE_FILE:
{
struct ko_section *file_section;
module_name = req->name;
//printk("mapping exe file %s at user.\n", module_name);
if (ke_validate_user_buffer(module_name, strlen(module_name), false) == false)
goto map_0_err;
file_section = map_file(KP_CURRENT(), module_name, KM_PROT_READ, &req->context_length);
if (file_section == NULL)
goto map_0_err;
/* We are preparing to use this section for EXE file ananlyzing, so no real handle is needed */
//printk("map ok\n");
return (ke_handle)file_section->node.start;
map_0_err:
return 0;
}
/*
Unamp file or module in current process space,
req->handle is the module handle(if not by address of req->name)
req->name is map base, return bool
*/
case SYSREQ_PROCESS_UNMAP_EXE_FILE:
{
if (req->name)
return unmap_file(KP_CURRENT(), req->name);
//TODO handle
}
break;
/* Add a new exe object, return bool */
case SYSREQ_PROCESS_ENJECT_EXE:
{
void *ctx;
int ctx_size;
struct ko_section *file_section;
ctx_size = req->context_length;
ctx = req->context;
module_name = req->name;
if (ke_validate_user_buffer(ctx, ctx_size, false) == false)
goto ld_3_err;
if (ke_validate_user_buffer(module_name, strlen(module_name), false) == false)
goto ld_3_err;
if (ctx_size > kp_exe_get_context_size())
goto ld_3_err;
if ((file_section = map_file(kp_get_file_process(), module_name, KM_PROT_READ, NULL)) == NULL)
goto ld_3_err;
if (kp_exe_create_from_file(module_name, file_section, ctx, NULL) == NULL)
goto ld_3_err;
return true;
ld_3_err:
return false;
}
default:
break;
}
return 0;
}
static int receive_data(int f_in, char *fname_r, int fd_r, OFF_T size_r,
const char *fname, int fd, OFF_T total_size)
{
static char file_sum1[MAX_DIGEST_LEN];
static char file_sum2[MAX_DIGEST_LEN];
struct map_struct *mapbuf;
struct sum_struct sum;
int32 len, sum_len;
OFF_T offset = 0;
OFF_T offset2;
char *data;
int32 i;
char *map = NULL;
read_sum_head(f_in, &sum);
if (fd_r >= 0 && size_r > 0) {
int32 read_size = MAX(sum.blength * 2, 16*1024);
mapbuf = map_file(fd_r, size_r, read_size, sum.blength);
if (verbose > 2) {
rprintf(FINFO, "recv mapped %s of size %.0f\n",
fname_r, (double)size_r);
}
} else
mapbuf = NULL;
sum_init(checksum_seed);
if (append_mode > 0) {
OFF_T j;
sum.flength = (OFF_T)sum.count * sum.blength;
if (sum.remainder)
sum.flength -= sum.blength - sum.remainder;
if (append_mode == 2) {
for (j = CHUNK_SIZE; j < sum.flength; j += CHUNK_SIZE) {
if (do_progress)
show_progress(offset, total_size);
sum_update(map_ptr(mapbuf, offset, CHUNK_SIZE),
CHUNK_SIZE);
offset = j;
}
if (offset < sum.flength) {
int32 len = (int32)(sum.flength - offset);
if (do_progress)
show_progress(offset, total_size);
sum_update(map_ptr(mapbuf, offset, len), len);
}
}
offset = sum.flength;
if (fd != -1 && (j = do_lseek(fd, offset, SEEK_SET)) != offset) {
rsyserr(FERROR_XFER, errno, "lseek of %s returned %.0f, not %.0f",
full_fname(fname), (double)j, (double)offset);
exit_cleanup(RERR_FILEIO);
}
}
while ((i = recv_token(f_in, &data)) != 0) {
if (do_progress)
show_progress(offset, total_size);
if (i > 0) {
if (verbose > 3) {
rprintf(FINFO,"data recv %d at %.0f\n",
i,(double)offset);
}
stats.literal_data += i;
cleanup_got_literal = 1;
sum_update(data, i);
if (fd != -1 && write_file(fd,data,i) != i)
goto report_write_error;
offset += i;
continue;
}
i = -(i+1);
offset2 = i * (OFF_T)sum.blength;
len = sum.blength;
if (i == (int)sum.count-1 && sum.remainder != 0)
len = sum.remainder;
stats.matched_data += len;
if (verbose > 3) {
rprintf(FINFO,
"chunk[%d] of size %ld at %.0f offset=%.0f\n",
i, (long)len, (double)offset2, (double)offset);
}
if (mapbuf) {
map = map_ptr(mapbuf,offset2,len);
see_token(map, len);
sum_update(map, len);
}
if (updating_basis_or_equiv) {
if (offset == offset2 && fd != -1) {
OFF_T pos;
if (flush_write_file(fd) < 0)
goto report_write_error;
offset += len;
if ((pos = do_lseek(fd, len, SEEK_CUR)) != offset) {
rsyserr(FERROR_XFER, errno,
"lseek of %s returned %.0f, not %.0f",
full_fname(fname),
(double)pos, (double)offset);
exit_cleanup(RERR_FILEIO);
}
continue;
}
}
if (fd != -1 && map && write_file(fd, map, len) != (int)len)
goto report_write_error;
offset += len;
}
if (flush_write_file(fd) < 0)
goto report_write_error;
#ifdef HAVE_FTRUNCATE
if (inplace && fd != -1
&& ftruncate(fd, offset) < 0) {
rsyserr(FERROR_XFER, errno, "ftruncate failed on %s",
full_fname(fname));
}
#endif
if (do_progress)
end_progress(total_size);
if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
report_write_error:
rsyserr(FERROR_XFER, errno, "write failed on %s",
full_fname(fname));
exit_cleanup(RERR_FILEIO);
}
sum_len = sum_end(file_sum1);
if (mapbuf)
unmap_file(mapbuf);
read_buf(f_in, file_sum2, sum_len);
if (verbose > 2)
rprintf(FINFO,"got file_sum\n");
if (fd != -1 && memcmp(file_sum1, file_sum2, sum_len) != 0)
return 0;
return 1;
}
/* Read the system's package database and extract information about
* 'pkgname'. Return 0 in case of success, or -1 in case of error.
*
* If the package is unknown, return -1 and set errno to ENOENT
* If the package database is corrupted, return -1 and set errno to EINVAL
*/
int
get_package_info(const char* pkgName, PackageInfo *info)
{
char* buffer;
size_t buffer_len;
const char* p;
const char* buffer_end;
int result = -1;
info->uid = 0;
info->isDebuggable = 0;
info->dataDir[0] = '\0';
info->seinfo[0] = '\0';
buffer = map_file(PACKAGES_LIST_FILE, &buffer_len);
if (buffer == NULL)
return -1;
p = buffer;
buffer_end = buffer + buffer_len;
/* expect the following format on each line of the control file:
*
* <pkgName> <uid> <debugFlag> <dataDir>
*
* where:
* <pkgName> is the package's name
* <uid> is the application-specific user Id (decimal)
* <debugFlag> is 1 if the package is debuggable, or 0 otherwise
* <dataDir> is the path to the package's data directory (e.g. /data/data/com.example.foo)
* <seinfo> is the seinfo label associated with the package
*
* The file is generated in com.android.server.PackageManagerService.Settings.writeLP()
*/
while (p < buffer_end) {
/* find end of current line and start of next one */
const char* end = find_first(p, buffer_end, '\n');
const char* next = (end < buffer_end) ? end + 1 : buffer_end;
const char* q;
int uid, debugFlag;
/* first field is the package name */
p = compare_name(p, end, pkgName);
if (p == NULL)
goto NEXT_LINE;
/* skip spaces */
if (parse_spaces(&p, end) < 0)
goto BAD_FORMAT;
/* second field is the pid */
uid = parse_positive_decimal(&p, end);
if (uid < 0)
return -1;
info->uid = (uid_t) uid;
/* skip spaces */
if (parse_spaces(&p, end) < 0)
goto BAD_FORMAT;
/* third field is debug flag (0 or 1) */
debugFlag = parse_positive_decimal(&p, end);
switch (debugFlag) {
case 0:
info->isDebuggable = 0;
break;
case 1:
info->isDebuggable = 1;
break;
default:
goto BAD_FORMAT;
}
/* skip spaces */
if (parse_spaces(&p, end) < 0)
goto BAD_FORMAT;
/* fourth field is data directory path and must not contain
* spaces.
*/
q = skip_non_spaces(p, end);
if (q == p)
goto BAD_FORMAT;
p = string_copy(info->dataDir, sizeof info->dataDir, p, q - p);
/* skip spaces */
if (parse_spaces(&p, end) < 0)
goto BAD_FORMAT;
/* grab the seinfo string */
q = skip_non_spaces(p, end);
if (q == p)
goto BAD_FORMAT;
string_copy(info->seinfo, sizeof info->seinfo, p, q - p);
/* Ignore the rest */
result = 0;
goto EXIT;
NEXT_LINE:
p = next;
}
/* the package is unknown */
errno = ENOENT;
result = -1;
goto EXIT;
BAD_FORMAT:
errno = EINVAL;
result = -1;
EXIT:
unmap_file(buffer, buffer_len);
return result;
}
/**
* Acts on file number @p i from @p flist, whose name is @p fname.
*
* First fixes up permissions, then generates checksums for the file.
*
* @note This comment was added later by mbp who was trying to work it
* out. It might be wrong.
**/
int recv_generator(char *fname, struct file_list *flist, int i, int f_out)
{
int fd;
STRUCT_STAT st;
struct map_struct *buf;
struct sum_struct *s;
int statret;
struct file_struct *file = flist->files[i];
struct timeval tv_start;
char *fnamecmp;
char fnamecmpbuf[MAXPATHLEN];
extern char *compare_dest;
extern int list_only;
extern int preserve_perms;
extern int only_existing;
extern int orig_umask;
if (list_only) return 0;
if (verbose > 2)
rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
statret = link_stat(fname,&st);
if (only_existing && statret == -1 && errno == ENOENT) {
/* we only want to update existing files */
if (verbose > 1) rprintf(FINFO, "not creating new file \"%s\"\n",fname);
return 0;
}
if (statret == 0 &&
!preserve_perms &&
(S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) {
/* if the file exists already and we aren't perserving
presmissions then act as though the remote end sent
us the file permissions we already have */
file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT);
}
if (S_ISDIR(file->mode)) {
/* The file to be received is a directory, so we need
* to prepare appropriately. If there is already a
* file of that name and it is *not* a directory, then
* we need to delete it. If it doesn't exist, then
* recursively create it. */
if (dry_run) return 0; /* XXXX -- might cause inaccuracies?? -- mbp */
if (statret == 0 && !S_ISDIR(st.st_mode)) {
if (robust_unlink(fname) != 0) {
rprintf(FERROR, RSYNC_NAME
": recv_generator: unlink \"%s\" to make room for directory: %s\n",
fname,strerror(errno));
return 0;
}
statret = -1;
}
if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
if (!(relative_paths && errno==ENOENT &&
create_directory_path(fname, orig_umask)==0 &&
do_mkdir(fname,file->mode)==0)) {
rprintf(FERROR, RSYNC_NAME ": recv_generator: mkdir \"%s\": %s (2)\n",
fname,strerror(errno));
}
}
/* f_out is set to -1 when doing final directory
permission and modification time repair */
if (set_perms(fname,file,NULL,0) && verbose && (f_out != -1))
rprintf(FINFO,"%s/\n",fname);
return 0;
}
if (preserve_links && S_ISLNK(file->mode)) {
#if SUPPORT_LINKS
char lnk[MAXPATHLEN];
int l;
extern int safe_symlinks;
if (safe_symlinks && unsafe_symlink(file->link, fname)) {
if (verbose) {
rprintf(FINFO,"ignoring unsafe symlink \"%s\" -> \"%s\"\n",
fname,file->link);
}
return 0;
}
if (statret == 0) {
l = readlink(fname,lnk,MAXPATHLEN-1);
if (l > 0) {
lnk[l] = 0;
/* A link already pointing to the
* right place -- no further action
* required. */
if (strcmp(lnk,file->link) == 0) {
set_perms(fname,file,&st,1);
return 0;
}
}
/* Not a symlink, so delete whatever's
* already there and put a new symlink
* in place. */
delete_file(fname);
}
if (do_symlink(file->link,fname) != 0) {
rprintf(FERROR,RSYNC_NAME": symlink \"%s\" -> \"%s\": %s\n",
fname,file->link,strerror(errno));
} else {
set_perms(fname,file,NULL,0);
if (verbose) {
rprintf(FINFO,"%s -> %s\n", fname,file->link);
}
}
#endif
return 0;
}
#ifdef HAVE_MKNOD
if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
if (statret != 0 ||
st.st_mode != file->mode ||
st.st_rdev != file->rdev) {
delete_file(fname);
if (verbose > 2)
rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
fname,(int)file->mode,(int)file->rdev);
if (do_mknod(fname,file->mode,file->rdev) != 0) {
rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
} else {
set_perms(fname,file,NULL,0);
if (verbose)
rprintf(FINFO,"%s\n",fname);
}
} else {
set_perms(fname,file,&st,1);
}
return 0;
}
#endif
if (preserve_hard_links && check_hard_link(file)) {
if (verbose > 1)
rprintf(FINFO, "recv_generator: \"%s\" is a hard link\n",f_name(file));
return 0;
}
if (!S_ISREG(file->mode)) {
rprintf(FINFO, "skipping non-regular file \"%s\"\n",fname);
return 0;
}
fnamecmp = fname;
if ((statret == -1) && (compare_dest != NULL)) {
/* try the file at compare_dest instead */
int saveerrno = errno;
snprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname);
statret = link_stat(fnamecmpbuf,&st);
if (!S_ISREG(st.st_mode))
statret = -1;
if (statret == -1)
errno = saveerrno;
else
fnamecmp = fnamecmpbuf;
}
if (statret == -1) {
if (errno == ENOENT) {
write_int(f_out,i);
if (!dry_run) {
if(do_stats){
gettimeofday(&tv_start,0);
rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp,
tv_start.tv_sec,
tv_start.tv_usec);
}
send_sums(NULL,f_out);
return 1;
}
} else {
if (verbose > 1)
rprintf(FERROR, RSYNC_NAME
": recv_generator failed to open \"%s\": %s\n",
fname, strerror(errno));
return 0;
}
}
if (!S_ISREG(st.st_mode)) {
if (delete_file(fname) != 0) {
return 0;
}
if(do_stats){
gettimeofday(&tv_start,0);
rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp,
tv_start.tv_sec,
tv_start.tv_usec);
}
/* now pretend the file didn't exist */
write_int(f_out,i);
if (!dry_run) send_sums(NULL,f_out);
return 1;
}
if (opt_ignore_existing && fnamecmp == fname) {
if (verbose > 1)
rprintf(FINFO,"%s exists\n",fname);
return 0;
}
if (update_only && cmp_modtime(st.st_mtime,file->modtime)>0 && fnamecmp == fname) {
if (verbose > 1)
rprintf(FINFO,"%s is newer\n",fname);
return 0;
}
if (skip_file(fname, file, &st)) {
if (fnamecmp == fname)
set_perms(fname,file,&st,1);
return 0;
}
if (dry_run) {
if(do_stats){
gettimeofday(&tv_start,0);
rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp,
tv_start.tv_sec,
tv_start.tv_usec);
}
write_int(f_out,i);
return 1;
}
if (disable_deltas_p()) {
if(do_stats){
gettimeofday(&tv_start,0);
rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp,
tv_start.tv_sec,
tv_start.tv_usec);
}
write_int(f_out,i);
send_sums(NULL,f_out);
return 1;
}
if(do_stats){
gettimeofday(&tv_start,0);
rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp,
tv_start.tv_sec,
tv_start.tv_usec);
}
/* open the file */
fd = do_open(fnamecmp, O_RDONLY, 0);
if (fd == -1) {
rprintf(FERROR,RSYNC_NAME": failed to open \"%s\", continuing : %s\n",fnamecmp,strerror(errno));
/* pretend the file didn't exist */
write_int(f_out,i);
send_sums(NULL,f_out);
return 1;
}
if (st.st_size > 0) {
buf = map_file(fd,st.st_size);
} else {
buf = NULL;
}
if (verbose > 3)
rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size);
if(do_stats){
timing(TIMING_START);
}
s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
if(do_stats){
rprintf(FINFO, "Generator: %s %s\n", fnamecmp,timing(TIMING_END));
}
if (verbose > 2)
rprintf(FINFO,"sending sums for %d\n",i);
write_int(f_out,i);
if(do_stats){
timing(TIMING_START);
}
send_sums(s,f_out);
if(do_stats){
rprintf(FINFO, "Send sums: %s %s\n", fnamecmp,timing(TIMING_END));
}
close(fd);
if (buf) unmap_file(buf);
free_sums(s);
return 1;
}
/*
* Files like compose.dir have the format LEFT: RIGHT. Lookup @name in
* such a file and return its matching value, according to @direction.
* @filename is relative to the xlocaledir.
*/
static char *
resolve_name(const char *filename, enum resolve_name_direction direction,
const char *name)
{
int ret;
bool ok;
const char *xlocaledir;
char path[512];
FILE *file;
const char *string, *end;
size_t string_size;
const char *s, *left, *right;
char *match;
size_t left_len, right_len, name_len;
xlocaledir = get_xlocaledir_path();
ret = snprintf(path, sizeof(path), "%s/%s", xlocaledir, filename);
if (ret < 0 || (size_t) ret >= sizeof(path))
return false;
file = fopen(path, "r");
if (!file)
return false;
ok = map_file(file, &string, &string_size);
fclose(file);
if (!ok)
return false;
s = string;
end = string + string_size;
name_len = strlen(name);
match = NULL;
while (s < end) {
/* Skip spaces. */
while (s < end && is_space(*s))
s++;
/* Skip comments. */
if (s < end && *s == '#') {
while (s < end && *s != '\n')
s++;
continue;
}
/* Get the left value. */
left = s;
while (s < end && !is_space(*s) && *s != ':')
s++;
left_len = s - left;
/* There's an optional colon between left and right. */
if (s < end && *s == ':')
s++;
/* Skip spaces. */
while (s < end && is_space(*s))
s++;
/* Get the right value. */
right = s;
while (s < end && !is_space(*s))
s++;
right_len = s - right;
/* Discard rest of line. */
while (s < end && *s != '\n')
s++;
if (direction == LEFT_TO_RIGHT) {
if (left_len == name_len && memcmp(left, name, left_len) == 0) {
match = strndup(right, right_len);
break;
}
}
else if (direction == RIGHT_TO_LEFT) {
if (right_len == name_len && memcmp(right, name, right_len) == 0) {
match = strndup(left, left_len);
break;
}
}
}
unmap_file(string, string_size);
return match;
}
void
terminate_lexicon(MalagaState * malagaState)
/* Terminate this module. */
{
unmap_file(&(malagaState->lexicon.lexicon_data), malagaState->lexicon.lexicon_length);
}
GLuint
sgLoadProgram(const char *key,
const char *vspath,
const char *fspath,
const char *gspath)
{
assert(key != NULL);
assert(vspath != NULL);
assert(fspath != NULL);
SGshaderinfo *tmp = hashtable_lookup(shaderKeyMap, key);
if (tmp) return tmp->ident;
SGshaderinfo *si = malloc(sizeof(SGshaderinfo));
GLuint shaderProgram = glCreateProgram();
si->ident = shaderProgram;
hashtable_insert(shaderKeyMap, key, si); // Memoize if loaded again
bool didLoadVertexShader = false;
bool didLoadFragShader = false;
bool didLoadGeoShader = false;
if (vspath) {
mapped_file_t mf;
GLuint shaderId;
char pattern[strlen(vspath)+1+9];
strcpy(pattern, vspath);
strcat(pattern, "/*.vertex");
glob_t shaders = ooResGetFilePaths(pattern);
if (shaders.gl_matchc > 0) didLoadVertexShader = true;
for (int i = 0 ; i < shaders.gl_matchc ; ++ i) {
mf = map_file(shaders.gl_pathv[i]);
if (mf.fd == -1) return 0;
shaderId = glCreateShader(GL_VERTEX_SHADER);
GLint len = mf.fileLenght;
glShaderSource(shaderId, 1, (const GLchar**)&mf.data, &len);
unmap_file(&mf);
glCompileShader(shaderId);
GLint compileStatus = 0;
glGetShaderiv(shaderId, GL_COMPILE_STATUS, &compileStatus);
if (compileStatus == GL_FALSE) {
GLint logLen = 0;
GLint retrievedLen = 0;
glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &logLen);
char *tmp = malloc(logLen);
glGetShaderInfoLog(shaderId, logLen, &retrievedLen, tmp);
fputs(tmp, stderr);
free(tmp);
// No globfree as this is a fatal error
ooLogFatal("vertex shader '%s' did not compile", shaders.gl_pathv[i]);
}
glAttachShader(shaderProgram, shaderId);
ooLogTrace("loaded vertex shader '%s'", shaders.gl_pathv[i]);
}
globfree(&shaders);
}
if (fspath) {
mapped_file_t mf;
GLuint shaderId;
char pattern[strlen(vspath)+1+11];
strcpy(pattern, vspath);
strcat(pattern, "/*.fragment");
glob_t shaders = ooResGetFilePaths(pattern);
if (shaders.gl_matchc > 0) didLoadFragShader = true;
for (int i = 0 ; i < shaders.gl_matchc ; ++ i) {
mf = map_file(shaders.gl_pathv[i]);
if (mf.fd == -1) return 0;
shaderId = glCreateShader(GL_FRAGMENT_SHADER);
GLint len = mf.fileLenght;
glShaderSource(shaderId, 1, (const GLchar**)&mf.data, &len);
unmap_file(&mf);
glCompileShader(shaderId);
GLint compileStatus = 0;
glGetShaderiv(shaderId, GL_COMPILE_STATUS, &compileStatus);
if (compileStatus == GL_FALSE) {
GLint logLen = 0;
GLint retrievedLen = 0;
glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &logLen);
char *tmp = malloc(logLen);
glGetShaderInfoLog(shaderId, logLen, &retrievedLen, tmp);
fputs(tmp, stderr);
free(tmp);
// No globfree as this is a fatal error
ooLogFatal("fragment shader '%s' did not compile", shaders.gl_pathv[i]);
}
glAttachShader(shaderProgram, shaderId);
ooLogTrace("loaded fragment shader '%s'", shaders.gl_pathv[i]);
}
globfree(&shaders);
}
// Ignore geometry shaders for now...
glLinkProgram(shaderProgram);
GLint linkStatus = 0;
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &linkStatus);
if (linkStatus == GL_FALSE) {
GLint logLen = 0;
GLint retrievedLen = 0;
glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &logLen);
char *tmp = malloc(logLen);
glGetProgramInfoLog(shaderProgram, logLen, &retrievedLen, tmp);
fputs(tmp, stderr);
free(tmp);
ooLogFatal("shader linking did not succeed");
}
ooLogInfo("shader program '%s' succesfully linked", key);
if (!didLoadVertexShader && !didLoadFragShader && !didLoadGeoShader) {
ooLogInfo("no shaders found for '%s'", key);
glDeleteProgram(shaderProgram);
hashtable_remove(shaderKeyMap, key); // Memoize if loaded again
return 0;
}
return shaderProgram;
}
static int receive_data(int f_in, char *fname_r, int fd_r, OFF_T size_r,
const char *fname, int fd, OFF_T total_size,
struct sum_struct *sum, int numMatchTokens,
int nextToken, char *nextData,
char *file_sum2)
{
static char file_sum1[MAX_DIGEST_LEN];
struct map_struct *mapbuf;
int32 len, sum_len;
OFF_T offset = 0;
OFF_T offset2;
int offsetDefer;
char *data;
int32 i;
char *map = NULL;
int replayTokenCnt = 0;
if (fd_r >= 0 && size_r > 0) {
int32 read_size = MAX(sum->blength * 2, 16*1024);
mapbuf = map_file(fd_r, size_r, read_size, sum->blength);
if (verbose > 2) {
rprintf(FINFO, "recv mapped %s of size %.0f\n",
fname_r, (double)size_r);
}
} else
mapbuf = NULL;
sum_init(checksum_seed);
if (append_mode > 0) {
OFF_T j;
sum->flength = (OFF_T)sum->count * sum->blength;
if (sum->remainder)
sum->flength -= sum->blength - sum->remainder;
if (append_mode == 2) {
for (j = CHUNK_SIZE; j < sum->flength; j += CHUNK_SIZE) {
if (do_progress)
show_progress(offset, total_size);
sum_update(map_ptr(mapbuf, offset, CHUNK_SIZE),
CHUNK_SIZE);
offset = j;
}
if (offset < sum->flength) {
int32 len = (int32)(sum->flength - offset);
if (do_progress)
show_progress(offset, total_size);
sum_update(map_ptr(mapbuf, offset, len), len);
}
}
offset = sum->flength;
if (fd != -1 && (j = do_lseek(fd, offset, SEEK_SET)) != offset) {
rsyserr(FERROR_XFER, errno, "lseek of %s returned %.0f, not %.0f",
full_fname(fname), (double)j, (double)offset);
exit_cleanup(RERR_FILEIO);
}
}
offsetDefer = 0;
while ( 1 ) {
/*
* We have to replay any tokens that were potentially read-ahead
* to see if the file was identical.
* numMatchTokens < 0 means there are no replay tokens
* numMatchTokens >= 0 means there are numMatchTokens from -1
* to -numMatchTokens, followed by
* (nextToken, *nextData).
*
* If numMatchTokens >= 0 and nextToken == 0, then then file_sum
* was already ready from f_in. Otherwise, we need to read it
* here.
*/
if ( replayTokenCnt >= 0 && numMatchTokens >= 0 ) {
if ( replayTokenCnt < numMatchTokens ) {
/*
* replay -1, -2, ..., -numMatchTokens
*/
i = -replayTokenCnt - 1;
replayTokenCnt++;
} else {
/*
* replay the next token - after this we are
* up to date.
*/
i = nextToken;
data = nextData;
replayTokenCnt = -1;
}
} else {
i = recv_token(f_in, &data);
}
if ( i == 0 ) break;
if (do_progress)
show_progress(offset, total_size);
if (i > 0) {
if (verbose > 3) {
rprintf(FINFO,"data recv %d at %.0f\n",
i,(double)offset);
}
stats.literal_data += i;
cleanup_got_literal = 1;
sum_update(data, i);
if ( offsetDefer ) {
OFF_T pos;
if (flush_write_file(fd) < 0)
goto report_write_error;
if ((pos = do_lseek(fd, offset, SEEK_SET)) != offset) {
rsyserr(FERROR_XFER, errno,
"lseek of %s returned %.0f, not %.0f",
full_fname(fname),
(double)pos, (double)offset);
exit_cleanup(RERR_FILEIO);
}
offsetDefer = 0;
}
if (fd != -1 && write_file(fd,data,i) != i)
goto report_write_error;
offset += i;
continue;
}
i = -(i+1);
offset2 = i * (OFF_T)sum->blength;
len = sum->blength;
if (i == (int)sum->count-1 && sum->remainder != 0)
len = sum->remainder;
stats.matched_data += len;
if (verbose > 3) {
rprintf(FINFO,
"chunk[%d] of size %ld at %.0f offset=%.0f%s\n",
i, (long)len, (double)offset2, (double)offset,
updating_basis_or_equiv && offset == offset2 ? " (seek)" : "");
}
if (mapbuf) {
map = map_ptr(mapbuf,offset2,len);
see_token(map, len);
sum_update(map, len);
}
if (updating_basis_or_equiv) {
if (offset == offset2 && fd != -1) {
offset += len;
offsetDefer = 1;
continue;
}
}
if (fd != -1 && map) {
if ( offsetDefer ) {
OFF_T pos;
if (flush_write_file(fd) < 0)
goto report_write_error;
if ((pos = do_lseek(fd, offset, SEEK_SET)) != offset) {
rsyserr(FERROR_XFER, errno,
"lseek of %s returned %.0f, not %.0f",
full_fname(fname),
(double)pos, (double)offset);
exit_cleanup(RERR_FILEIO);
}
offsetDefer = 0;
}
if ( write_file(fd, map, len) != (int)len)
goto report_write_error;
}
offset += len;
}
if ( offsetDefer ) {
OFF_T pos;
if (flush_write_file(fd) < 0)
goto report_write_error;
if ((pos = do_lseek(fd, offset, SEEK_SET)) != offset) {
rsyserr(FERROR_XFER, errno,
"lseek of %s returned %.0f, not %.0f",
full_fname(fname),
(double)pos, (double)offset);
exit_cleanup(RERR_FILEIO);
}
offsetDefer = 0;
}
if (flush_write_file(fd) < 0)
goto report_write_error;
#ifdef HAVE_FTRUNCATE
if (fd != -1 && do_ftruncate(fd, offset) < 0) {
rsyserr(FERROR_XFER, errno, "ftruncate failed on %s",
full_fname(fname));
}
#endif
if (do_progress)
end_progress(total_size);
if (fd != -1 && offset > 0 && sparse_end(fd, offset) != 0) {
report_write_error:
rsyserr(FERROR_XFER, errno, "write failed on %s",
full_fname(fname));
exit_cleanup(RERR_FILEIO);
}
sum_len = sum_end(file_sum1);
if (mapbuf)
unmap_file(mapbuf);
if ( numMatchTokens < 0 || nextToken != 0 ) {
/*
* If numMatchTokens >= 0 and nextToken == 0, then the caller already
* read ahead to the digest. Otherwise we have to read it here.
*/
read_buf(f_in, file_sum2, sum_len);
}
if (verbose > 2)
rprintf(FINFO,"got file_sum\n");
if (fd != -1 && memcmp(file_sum1, file_sum2, sum_len) != 0)
return 0;
return 1;
}
ROMappedFile::~ROMappedFile()
{
unmap_file();
}