static int write_file(struct Stream_t *Stream, char *buf, off_t iwhere, size_t len)
{
DeclareThis(struct File_t);
off_t pos;
struct Stream_t *Disk = This->Fs->Next;
off_t where = truncBytes32(iwhere);
const size_t requestedLen = len;
int err = This->map(This, where, &len, MT_WRITE, &pos);
if (err <= 0)
return err;
int ret = WRITES(Disk, buf, pos, len);
if(ret > (signed int) requestedLen)
ret = requestedLen;
if (ret > 0 && where + ret > (off_t) This->FileSize)
This->FileSize = where + ret;
recalcPreallocSize(This);
return ret;
}
static int write_file(Stream_t *Stream, char *buf, mt_off_t iwhere, size_t len)
{
DeclareThis(File_t);
mt_off_t pos;
int ret;
size_t requestedLen;
Stream_t *Disk = This->Fs->Next;
off_t where = truncBytes32(iwhere);
int err;
requestedLen = len;
err = This->map(This, where, &len, MT_WRITE, &pos);
if( err <= 0)
return err;
if(batchmode)
ret = force_write(Disk, buf, pos, len);
else
ret = WRITES(Disk, buf, pos, len);
if(ret > requestedLen)
ret = requestedLen;
if (ret > 0 && where + ret > This->FileSize )
This->FileSize = where + ret;
recalcPreallocSize(This);
return ret;
}
static int read_file(struct Stream_t *Stream, char *buf, off_t iwhere, size_t len)
{
DeclareThis(struct File_t);
off_t pos;
off_t where = truncBytes32(iwhere);
struct Stream_t *Disk = This->Fs->Next;
int err = This->map(This, where, &len, MT_READ, &pos);
return (err <= 0) ? err : READS(Disk, buf, pos, len);
}
static int read_file(Stream_t *Stream, char *buf, mt_off_t iwhere,
size_t len)
{
DeclareThis(File_t);
mt_off_t pos;
int err;
off_t where = truncBytes32(iwhere);
Stream_t *Disk = This->Fs->Next;
err = This->map(This, where, &len, MT_READ, &pos);
if(err <= 0)
return err;
return READS(Disk, buf, pos, len);
}
static int xdf_read(Stream_t *Stream, char *buf, mt_off_t where, size_t len)
{
off_t begin, end;
size_t len2;
DeclareThis(Xdf_t);
decompose(This, truncBytes32(where), len, &begin, &end, 0);
len2 = load_data(This, begin, end, 4);
if(len2 < 0)
return len2;
len2 -= begin;
maximize(len, len2);
memcpy(buf, This->buffer + begin, len);
return end - begin;
}
static int xdf_write(Stream_t *Stream, char *buf, mt_off_t where, size_t len)
{
off_t begin, end;
size_t len2;
DeclareThis(Xdf_t);
decompose(This, truncBytes32(where), len, &begin, &end, 0);
len2 = load_bounds(This, begin, end);
if(len2 < 0)
return len2;
maximize(end, len2);
len2 -= begin;
maximize(len, len2);
memcpy(This->buffer + begin, buf, len);
mark_dirty(This, begin, end);
return end - begin;
}
/*
* Open the named file for read, create the cluster chain, return the
* directory structure or NULL on error.
*/
static int writeit(char *dosname,
char *longname,
void *arg0,
direntry_t *entry)
{
Stream_t *Target;
time_t now;
int type, fat, ret;
time_t date;
mt_size_t filesize, newsize;
Arg_t *arg = (Arg_t *) arg0;
if (arg->mp.File->Class->get_data(arg->mp.File,
& date, &filesize, &type, 0) < 0 ){
fprintf(stderr, "Can't stat source file\n");
return -1;
}
if (type){
if (arg->verbose)
fprintf(stderr, "\"%s\" is a directory\n", longname);
return -1;
}
/*if (!arg->single || arg->recursive)*/
if(arg->verbose)
fprintf(stderr,"Copying %s\n", longname);
if(got_signal)
return -1;
/* will it fit? */
if (!getfreeMinBytes(arg->mp.targetDir, filesize))
return -1;
/* preserve mod time? */
if (arg->preserveTime)
now = date;
else
getTimeNow(&now);
mk_entry(dosname, arg->attr, 1, 0, now, &entry->dir);
Target = OpenFileByDirentry(entry);
if(!Target){
fprintf(stderr,"Could not open Target\n");
exit(1);
}
if (arg->needfilter & arg->textmode)
Target = open_filter(Target);
ret = copyfile(arg->mp.File, Target);
GET_DATA(Target, 0, &newsize, 0, &fat);
FREE(&Target);
if (arg->needfilter & arg->textmode)
newsize++; /* ugly hack: we gathered the size before the Ctrl-Z
* was written. Increment it manually */
if(ret < 0 ){
fat_free(arg->mp.targetDir, fat);
return -1;
} else {
mk_entry(dosname, arg->attr, fat, truncBytes32(newsize),
now, &entry->dir);
return 0;
}
}
