int EDirectory::FmChDir(const char *Name) {
char Dir[256];
char CName[256] = "";
if (strcmp(Name, SSLASH) == 0) {
JustRoot(Path, Dir, sizeof(Dir));
} else if (strcmp(Name, SDOT SDOT) == 0) {
Slash(Path, 0);
JustFileName(Path, CName, sizeof(CName));
JustDirectory(Path, Dir, sizeof(Dir));
} else {
JustDirectory(Path, Dir, sizeof(Dir));
Slash(Dir, 1);
strlcat(Dir, Name, sizeof(Dir));
}
Slash(Dir, 1);
free(Path);
Path = strdup(Dir);
Row = 0;
RescanList();
if (CName[0] != 0) {
for (int i = 0; i < FCount; i++) {
if (filecmp(Files[i]->Name(), CName) == 0)
{
Row = i;
break;
}
}
}
UpdateTitle();
return 1;
}
int EView::OpenDir(char *Path) {
char XPath[MAXPATH];
EDirectory *dir = 0;
if (ExpandPath(Path, XPath, sizeof(XPath)) == -1)
return 0;
{
EModel *x = Model;
while (x) {
if (x->GetContext() == CONTEXT_DIRECTORY) {
if (filecmp(((EDirectory *)x)->Path, XPath) == 0) {
dir = (EDirectory *)x;
break;
}
}
x = x->Next;
if (x == Model)
break;
}
}
if (dir == 0)
dir = new EDirectory(0, &ActiveModel, XPath);
SelectModel(dir);
return 1;
}
int main(int argc, char *argv[]) {
FILE *fp1, *fp2;
void filecmp(FILE *, FILE *);
if (argc == 1)
{
/* no args; copy standard input */
printf("Please provide two files");
return 1;
}
else
while (--argc > 0) {
if ((fp1 = fopen(argv[1], "r")) == NULL) {
printf("cat: can't open %s\n", *argv);
return 1;
}
if ((fp2 = fopen(argv[2], "r")) == NULL) {
printf("cat: can't open %s\n", *argv);
return 1;
}
filecmp(fp1, fp2);
fclose(fp1);
fclose(fp2);
}
return 0;
}
int EMarkIndex::retrieveForBuffer(EBuffer *aBuffer) {
for (int n = 0; n < markCount; n++)
if (marks[n]->getBuffer() == 0 &&
filecmp(aBuffer->FileName, marks[n]->getFileName()) == 0) {
if (marks[n]->setBuffer(aBuffer) == 0)
return 0;
}
return 1;
}
void ESvnBase::FindFileLines (EBuffer *B) {
char path[MAXPATH];
char *pos;
strcpy (path,Directory);Slash (path,1);pos=path+strlen (path);
for (int i=0;i<LineCount;i++)
if (Lines[i]->Buf==0&&Lines[i]->File!=0) {
strcpy (pos,Lines[i]->File);
if (filecmp (B->FileName,path)==0) {
AssignBuffer (B,i);
}
}
}
int _LNK_CONV FileNameCmp(const void *a, const void *b) {
const FileInfo *A = *(const FileInfo **)a;
const FileInfo *B = *(const FileInfo **)b;
if (!(A->Type() == fiDIRECTORY) && (B->Type() == fiDIRECTORY))
return 1;
if ((A->Type() == fiDIRECTORY) && !(B->Type() == fiDIRECTORY))
return -1;
return filecmp(A->Name(), B->Name());
}
int EMark::removeBuffer(EBuffer *aBuffer) {
assert(aBuffer != 0);
if (Buffer == 0 || Buffer != aBuffer)
return 0;
assert(filecmp(aBuffer->FileName, FileName) == 0);
if (Buffer->GetBookmark(Name, Point) == 0)
return 0;
if (Buffer->RemoveBookmark(Name) == 0)
return 0;
Buffer = 0;
return 1;
}
int EMark::setBuffer(EBuffer *aBuffer) {
assert(aBuffer != 0);
assert(filecmp(aBuffer->FileName, FileName) == 0);
if (Point.Row >= aBuffer->RCount)
Point.Row = aBuffer->RCount - 1;
if (Point.Row < 0)
Point.Row = 0;
if (aBuffer->PlaceBookmark(Name, Point) == 1) {
Buffer = aBuffer;
return 1;
}
return 0;
}
EBuffer *FindFile(char *FileName) {
EModel *M;
EBuffer *B;
M = ActiveModel;
while (M) {
if (M->GetContext() == CONTEXT_FILE) {
B = (EBuffer *)M;
if (filecmp(B->FileName, FileName) == 0) { return B; }
}
M = M->Next;
if (M == ActiveModel) break;
}
return 0;
}
int EDirectory::RescanDir() {
char CName[256] = "";
if (Row >= 0 && Row < FCount)
strcpy(CName, Files[Row]->Name());
Row = 0;
RescanList();
if (CName[0] != 0) {
for (int i = 0; i < FCount; i++) {
if (filecmp(Files[i]->Name(), CName) == 0) {
Row = i;
break;
}
}
}
return 1;
}
/* writer_write:
*/
void writer_write ( Writer *writer )
{
gchar *tmpname;
FILE *f;
/* CL_DEBUG("WRITE: '%s'", writer->fname); */
tmpname = g_strdup_printf("%s.tmp", writer->fname);
if (!(f = fopen(tmpname, "w")))
CL_ERROR("could not open '%s' : %s", tmpname, strerror(errno));
wnode_dump(writer->root, f);
fclose(f);
if (!g_file_test(writer->fname, G_FILE_TEST_EXISTS)) {
CL_DEBUG(" C %s", writer->fname);
rename(tmpname, writer->fname);
} else if (filecmp(tmpname, writer->fname)) {
CL_DEBUG(" U %s", writer->fname);
rename(tmpname, writer->fname);
} else {
/* CL_DEBUG(" - %s", writer->fname); */
unlink(tmpname);
}
}
/* check if a file is in the array of known files.
* if no, store the file at the array's end.
* returns array index.
* used for the main source and all INCLUDEd files.
* the array is stored in the standard C heap!
* the filenames are stored in the "local" heap.
*/
static unsigned AddFile( char const *fname )
/******************************************/
{
unsigned index;
DebugMsg1(("AddFile(%s) enter, curr index=%u\n", fname, ModuleInfo.g.cnt_fnames ));
for( index = 0; index < ModuleInfo.g.cnt_fnames; index++ ) {
if( filecmp( fname, ModuleInfo.g.FNames[index].fname ) == 0 ) {
#ifdef DEBUG_OUT
if ( Parse_Pass == PASS_1 )
ModuleInfo.g.FNames[index].included++;
#endif
return( index );
}
}
if ( ( index % 64 ) == 0 ) {
struct fname_item *newfn;
newfn = (struct fname_item *)MemAlloc( ( index + 64 ) * sizeof( struct fname_item ) );
if ( ModuleInfo.g.FNames ) {
memcpy( newfn, ModuleInfo.g.FNames, index * sizeof( struct fname_item ) );
MemFree( ModuleInfo.g.FNames );
}
ModuleInfo.g.FNames = newfn;
}
ModuleInfo.g.cnt_fnames++;
/* v2.11: use name directly - allows COFF .file entries with relative paths */
//_splitpath( fname, NULL, NULL, name, ext );
ModuleInfo.g.FNames[index].fname = (char *)LclAlloc( strlen( fname ) + 1 );
strcpy( ModuleInfo.g.FNames[index].fname, fname );
/* v2.11: field fullname removed */
//ModuleInfo.g.FNames[index].fullname = (char *)LclAlloc( strlen( fullname ) + 1 );
//strcpy( ModuleInfo.g.FNames[index].fullname, fullname );
DebugCmd( ModuleInfo.g.FNames[index].included = 1 );
return( index );
}
char ESvn::GetFileStatus(char *file) {
// Search backward, file can be present several times (old messages)
for (int i = LineCount - 1;i >= 0;i--)
if (Lines[i]->File && filecmp(Lines[i]->File, file) == 0) return Lines[i]->Msg[0];
return 0;
}
void
cs_restore(
boolean strip_slashes, /* should leading slash be stripped? */
int fcount, /* number of filename patterns in flist */
char **flist) /* filename patterns to select for restore */
{
int file_data = 0;
int file_data_read;
csd_fhdr_t file_hdr;
char name[MAXPATHLEN + 1];
/* name to compare for selective rstr */
char *name_compare = &name[0];
char slink[MAXPATHLEN + 1];
char *save_path = (char *)NULL; /* Prev path opened for SAM_fd */
char *last_path = NULL; /* Last compared path */
char *slash_loc; /* Last loc of a '/' in filename */
char unused; /* A safe value for slash_loc */
int namelen;
int skipping;
struct sam_perm_inode perm_inode;
struct sam_stat sb;
struct sam_vsn_section *vsnp;
void *data;
int n_acls;
aclent_t *aclp;
/*
* Read the dump file
*/
while (csd_read_header(&file_hdr) > 0) {
namelen = file_hdr.namelen;
csd_read(name, namelen, &perm_inode);
data = NULL;
vsnp = NULL;
aclp = NULL;
n_acls = 0;
if (file_hdr.flags & CSD_FH_DATA) {
BUMP_STAT(data_files);
file_data_read = 0;
file_data++;
} else {
file_data_read = file_data = 0;
}
if (S_ISREQ(perm_inode.di.mode)) {
SamMalloc(data, perm_inode.di.psize.rmfile);
}
csd_read_next(&perm_inode, &vsnp, slink, data, &n_acls, &aclp);
if (dont_process_this_entry) { /* if problem reading inode */
BUMP_STAT(errors);
goto skip_file;
}
/* Skip privileged files except root */
if (SAM_PRIVILEGE_INO(perm_inode.di.version,
perm_inode.di.id.ino)) {
if (perm_inode.di.id.ino != SAM_ROOT_INO) {
goto skip_file;
}
}
/* select subset of file names to restore. */
name_compare = &name[0];
if (fcount != 0) { /* Search the file name list */
int i;
for (i = 0; i < fcount; i++) {
/*
* If stripping first slash to make relative
* path and dump file name begins with '/' and
* select file name does not being with '/',
* then move name compare ahead past first '/'
*/
if (strip_slashes && ('/' == *name) &&
('/' != *flist[i])) {
name_compare = &name[1];
}
/*
* filecmp returns:
* 0 for no match
* 1 exact match,
* 2 name prefix of flist[i],
* 3 flist[i] prefix of name.
*/
if (filecmp(name_compare, flist[i]) != 0) {
break;
}
}
if (i >= fcount) {
if (S_ISSEGI(&perm_inode.di)) {
skipping = 1;
goto skip_seg_file;
}
goto skip_file;
}
}
/*
* If stripping first slash to make relative path and
* dump file name begins with '/'
* then move location ahead past first '/'
*/
if (strip_slashes && ('/' == *name)) {
name_compare = &name[1];
}
/*
* Make sure that we don't restore into a non-SAM-FS
* filesystem.
* If relative path to be restored, check current directory for
* being in a SAM-FS filesystem. If absolute path to be
* restored, search backwards through path for a viable
* SAM-FS path by calling sam_stat() and checking the
* directory attributes.
*/
if ((strip_slashes && ('/' == *name)) || ('/' != *name)) {
char *check_name = ".";
char *next_name;
if ((save_path != (char *)NULL) &&
(strcmp(check_name, save_path) != 0)) {
check_samfs_fs();
free(save_path);
(void) close(SAM_fd);
save_path = strdup(check_name);
SAM_fd = open_samfs(save_path);
} else if (save_path == (char *)NULL) {
check_samfs_fs();
save_path = strdup(check_name);
SAM_fd = open_samfs(save_path);
}
/*
* Check if last path matches this path. Otherwise,
* If subpath does not yet exist, make directories
* as needed.
*/
if (last_path != NULL) {
char *name_cmp;
int path_len;
path_len = strlen(last_path);
/* Copy filename */
name_cmp = strdup(name_compare);
if ((slash_loc = strrchr(name_cmp, '/')) !=
NULL) {
*slash_loc = '\0';
if ((path_len == strlen(name_cmp)) &&
(last_path[path_len-1] ==
name_cmp[path_len-1]) &&
(bcmp(last_path, name_cmp,
path_len) == 0)) {
free(name_cmp);
goto restore_file;
}
}
free(name_cmp);
}
if (last_path != NULL) {
free(last_path);
last_path = NULL;
}
/* Save path for check above */
last_path = strdup(name_compare);
if ((slash_loc = strrchr(last_path, '/')) != NULL) {
*slash_loc = '\0';
} else {
free(last_path);
last_path = NULL;
}
/* Copy filename */
next_name = check_name = strdup(name_compare);
while ((slash_loc = strchr(next_name, '/')) !=
(char *)NULL) {
*slash_loc = '\0';
if (mkdir(check_name,
S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (EEXIST == errno) {
*slash_loc = '/';
next_name = slash_loc + 1;
continue;
}
BUMP_STAT(errors);
error(1, errno,
catgets(catfd, SET, 222,
"%s: Cannot mkdir()"),
check_name);
break;
}
*slash_loc = '/';
next_name = slash_loc + 1;
}
free(check_name);
} else {
/*
* Search through absolute path from end for
* SAM-FS file system
*/
/* Copy filename */
char *check_name = strdup(name_compare);
slash_loc = &unused;
do {
*slash_loc = '\0';
/*
* Make sure we don't restore into a
* non-SAM-FS filesystem
* by calling sam_stat() and checking the
* directory attributes.
*/
if (sam_stat(check_name, &sb,
sizeof (sb)) == 0 &&
SS_ISSAMFS(sb.attr)) {
if ((save_path != (char *)NULL) &&
(strcmp(check_name,
save_path) != 0)) {
free(save_path);
(void) close(SAM_fd);
save_path = strdup(check_name);
SAM_fd = open_samfs(save_path);
} else if (save_path == (char *)NULL) {
save_path = strdup(check_name);
SAM_fd = open_samfs(save_path);
}
break;
}
slash_loc = strrchr(check_name, '/');
} while (slash_loc != (char *)NULL);
/*
* If no SAM-FS file system found in path, issue error
*/
if ((char *)NULL == slash_loc) {
BUMP_STAT(errors);
BUMP_STAT(errors_dir);
error(1, 0,
catgets(catfd, SET, 259,
"%s: Not a SAM-FS file."),
name_compare);
}
free(check_name);
}
restore_file:
if (verbose) {
sam_ls(name_compare, &perm_inode, NULL);
}
/* If not already offline */
if (!perm_inode.di.status.b.offline) {
/* If archived */
if (perm_inode.di.arch_status) {
print_reslog(log_st, name_compare,
&perm_inode, "online");
}
} else if (perm_inode.di.status.b.pextents) {
print_reslog(log_st, name_compare, &perm_inode,
"partial");
}
/*
* if segment index, we have to skip the data segment inodes
* before we can get to the dumped data.
*/
if (!(S_ISSEGI(&perm_inode.di) && file_data)) {
sam_restore_a_file(name_compare, &perm_inode,
vsnp, slink, data,
n_acls, aclp, file_data, &file_data_read);
}
skipping = 0;
skip_seg_file:
if (S_ISSEGI(&perm_inode.di)) {
struct sam_perm_inode seg_inode;
int i;
offset_t seg_size;
int no_seg;
sam_id_t seg_parent_id = perm_inode.di.id;
/*
* If we are restoring the data, don't restore the
* data segment inodes. This means we will lose the
* archive copies, if any.
*/
if (file_data) skipping++;
/*
* Read each segment inode. If archive copies
* overflowed,
* read vsn sections directly after each segment inode.
*/
seg_size =
(offset_t)perm_inode.di.rm.info.dk.seg_size *
SAM_MIN_SEGMENT_SIZE;
no_seg = (perm_inode.di.rm.size + seg_size - 1) /
seg_size;
for (i = 0; i < no_seg; i++) {
struct sam_vsn_section *seg_vsnp;
readcheck(&seg_inode, sizeof (seg_inode),
5002);
if (swapped) {
if (sam_byte_swap(
sam_perm_inode_swap_descriptor,
&seg_inode, sizeof (seg_inode))) {
error(0, 0,
catgets(catfd, SET, 13531,
"%s: segment inode byte "
"swap error - skipping."),
name);
dont_process_this_entry = 1;
}
}
if (!(SAM_CHECK_INODE_VERSION(
seg_inode.di.version))) {
if (debugging) {
fprintf(stderr,
"cs_restore: seg %d "
"inode version %d\n",
i, seg_inode.di.version);
}
error(0, 0, catgets(catfd, SET, 739,
"%s: inode version incorrect - "
"skipping"),
name);
dont_process_this_entry = 1;
}
if (skipping || dont_process_this_entry) {
continue;
}
seg_inode.di.parent_id = seg_parent_id;
seg_vsnp = NULL;
csd_read_mve(&seg_inode, &seg_vsnp);
if (verbose) {
sam_ls(name_compare, &seg_inode, NULL);
}
sam_restore_a_file(name_compare, &seg_inode,
seg_vsnp,
NULL, NULL, 0, NULL, file_data, NULL);
if (seg_vsnp) {
SamFree(seg_vsnp);
}
}
/*
* Now that we have skipped the data segment inodes
* we can restore the dumped data if any.
*/
if (file_data) {
sam_restore_a_file(name_compare, &perm_inode,
vsnp, slink, data,
n_acls, aclp, file_data, &file_data_read);
}
}
skip_file:
if (data) {
SamFree(data);
data = NULL;
}
if (vsnp) {
SamFree(vsnp);
vsnp = NULL;
}
if (aclp) {
SamFree(aclp);
aclp = NULL;
}
if (file_data && file_data_read == 0) {
skip_embedded_file_data();
}
}
if (last_path != NULL) {
free(last_path);
}
if (save_path != (char *)NULL) {
free(save_path);
}
if (open_dir_fd > 0) {
(void) close(open_dir_fd);
}
pop_permissions_stack();
pop_times_stack();
}
END_TEST
START_TEST(test_dn_write_file)
{
const char *tf = "/HADOOFUS_TEST_WRITE_FILE",
*client = "HADOOFUS_CLIENT", *err;
bool s;
struct hdfs_datanode *dn;
struct hdfs_object *e = NULL, *bl, *fs, *bls;
uint64_t begin, end;
s = hdfs_delete(h, tf, false/*recurse*/, &e);
if (e)
fail("exception: %s", hdfs_exception_get_message(e));
hdfs_create(h, tf, 0644, client, true/*overwrite*/,
false/*createparent*/, 1/*replication*/, blocksz, &e);
if (e)
fail("exception: %s", hdfs_exception_get_message(e));
begin = _now();
// write first block (full)
bl = hdfs_addBlock(h, tf, client, NULL, &e);
if (e)
fail("exception: %s", hdfs_exception_get_message(e));
dn = hdfs_datanode_new(bl, client, HDFS_DATANODE_AP_1_0, &err);
ck_assert_msg((intptr_t)dn, "error connecting to datanode: %s", err);
hdfs_object_free(bl);
err = hdfs_datanode_write_file(dn, fd, blocksz, 0, _i/*crcs*/);
fail_if(err, "error writing block: %s", err);
hdfs_datanode_delete(dn);
// write second block (partial)
bl = hdfs_addBlock(h, tf, client, NULL, &e);
if (e)
fail("exception: %s", hdfs_exception_get_message(e));
dn = hdfs_datanode_new(bl, client, HDFS_DATANODE_AP_1_0, &err);
ck_assert_msg((intptr_t)dn, "error connecting to datanode: %s", err);
hdfs_object_free(bl);
err = hdfs_datanode_write_file(dn, fd, towrite-blocksz, blocksz, _i/*crcs*/);
fail_if(err, "error writing block: %s", err);
hdfs_datanode_delete(dn);
end = _now();
fprintf(stderr, "Wrote %d MB from file in %ld ms%s, %02g MB/s\n",
towrite/1024/1024, end - begin, _i? " (with crcs)":"",
(double)towrite/(end-begin)/1024*1000/1024);
fs = hdfs_getFileInfo(h, tf, &e);
if (e)
fail("exception: %s", hdfs_exception_get_message(e));
ck_assert(fs->ob_val._file_status._size == towrite);
hdfs_object_free(fs);
s = hdfs_complete(h, tf, client, &e);
if (e)
fail("exception: %s", hdfs_exception_get_message(e));
ck_assert_msg(s, "did not complete");
bls = hdfs_getBlockLocations(h, tf, 0, towrite, &e);
if (e)
fail("exception: %s", hdfs_exception_get_message(e));
begin = _now();
for (int i = 0; i < bls->ob_val._located_blocks._num_blocks; i++) {
struct hdfs_object *bl =
bls->ob_val._located_blocks._blocks[i];
dn = hdfs_datanode_new(bl, client, HDFS_DATANODE_AP_1_0, &err);
ck_assert_msg((intptr_t)dn, "error connecting to datanode: %s", err);
err = hdfs_datanode_read_file(dn, 0/*offset-in-block*/,
bl->ob_val._located_block._len,
ofd,
i*blocksz/*fd offset*/,
_i/*crcs*/);
hdfs_datanode_delete(dn);
if (err == HDFS_DATANODE_ERR_NO_CRCS) {
fprintf(stderr, "Warning: test server doesn't support "
"CRCs, skipping validation.\n");
_i = 0;
// reconnect, try again without validating CRCs (for
// isi_hdfs_d)
dn = hdfs_datanode_new(bl, client, HDFS_DATANODE_AP_1_0, &err);
ck_assert_msg((intptr_t)dn, "error connecting to datanode: %s", err);
err = hdfs_datanode_read_file(dn, 0/*offset-in-block*/,
bl->ob_val._located_block._len,
ofd,
i*blocksz,
false/*crcs*/);
hdfs_datanode_delete(dn);
}
fail_if(err, "error reading block: %s", err);
}
end = _now();
fprintf(stderr, "Read %d MB to file in %ld ms%s, %02g MB/s\n",
towrite/1024/1024, end - begin, _i? " (with crcs)":"",
(double)towrite/(end-begin)/1024*1000/1024);
hdfs_object_free(bls);
fail_if(filecmp(fd, ofd, towrite), "read differed from write");
s = hdfs_delete(h, tf, false/*recurse*/, &e);
if (e)
fail("exception: %s", hdfs_exception_get_message(e));
ck_assert_msg(s, "delete returned false");
}
/* 校验读出的与写入的是否致 */
int main(int argc, char *argv[])
{
int bufsize = BUFSIZE; /* Buffer size. Default 8k */
int numblks = NBLKS; /* Number of blocks. Default 20 */
char infile[LEN]; /* Input file. Default "infile" */
char outfile[LEN]; /* Output file. Default "outfile" */
int fd, fd1, fd2;
int i, n, offset;
char *buf;
/* Options */
strcpy(infile, "infile"); /* Default input file */
strcpy(outfile, "outfile"); /* Default outfile file */
while ((i = getopt(argc, argv, "b:n:i:o:")) != -1) {
switch (i) {
case 'b':
if ((bufsize = atoi(optarg)) <= 0) {
fprintf(stderr, "bufsize must be > 0\n");
prg_usage();
}
if (bufsize % 4096 != 0) {
fprintf(stderr,
"bufsize must be multiple of 4k\n");
prg_usage();
}
break;
case 'n':
if ((numblks = atoi(optarg)) <= 0) {
fprintf(stderr, "numblks must be > 0\n");
prg_usage();
}
break;
case 'i':
strcpy(infile, optarg);
break;
case 'o':
strcpy(outfile, optarg);
break;
default:
prg_usage();
}
}
/* 检测系统是否支持O_DIRECT标志 */
/* Test for filesystem support of O_DIRECT */
if ((fd = open(infile, O_DIRECT | O_RDWR | O_CREAT, 0666)) < 0) {
tst_brkm(TCONF,
NULL,
"O_DIRECT is not supported by this filesystem.");
} else {
close(fd);
}
/* 创建文件1 */
/* Open files */
if ((fd1 = open(infile, O_DIRECT | O_RDWR | O_CREAT, 0666)) < 0) {
tst_brkm(TFAIL, NULL, "open infile failed: %s",
strerror(errno));
}
/* 创建文件2 */
if ((fd2 = open(outfile, O_DIRECT | O_RDWR | O_CREAT, 0666)) < 0) {
close(fd1);
unlink(infile);
tst_brkm(TFAIL, NULL, "open outfile failed: %s",
strerror(errno));
}
/* Allocate for buf, Create input file */
if ((buf = valloc(bufsize)) == 0) {
tst_resm(TFAIL, "valloc() failed: %s", strerror(errno));
fail_clean(fd1, fd2, infile, outfile);
}
/* 将数据写入到文件1 */
for (i = 0; i < numblks; i++) {
fillbuf(buf, bufsize, (char)(i % 256));
if (write(fd1, buf, bufsize) < 0) {
tst_resm(TFAIL, "write infile failed: %s",
strerror(errno));
fail_clean(fd1, fd2, infile, outfile);
}
}
/* Copy infile to outfile using direct read and direct write */
offset = 0;
if (lseek(fd1, offset, SEEK_SET) < 0) {
tst_resm(TFAIL, "lseek(infd) failed: %s", strerror(errno));
fail_clean(fd1, fd2, infile, outfile);
}
/* 从文件1读取数据，并写入文件2 */
while ((n = read(fd1, buf, bufsize)) > 0) {
if (lseek(fd2, offset, SEEK_SET) < 0) {
tst_resm(TFAIL, "lseek(outfd) failed: %s",
strerror(errno));
fail_clean(fd1, fd2, infile, outfile);
}
if (write(fd2, buf, n) < n) {
tst_resm(TFAIL, "write(outfd) failed: %s",
strerror(errno));
fail_clean(fd1, fd2, infile, outfile);
}
offset += n;
if (lseek(fd1, offset, SEEK_SET) < 0) {
tst_resm(TFAIL, "lseek(infd) failed: %s",
strerror(errno));
fail_clean(fd1, fd2, infile, outfile);
}
}
/* 检测两文件的内容是否一致 */
/* Verify */
if (filecmp(infile, outfile) != 0) {
tst_resm(TFAIL, "file compare failed for %s and %s",
infile, outfile);
fail_clean(fd1, fd2, infile, outfile);
}
/* Cleanup */
close(fd1);
close(fd2);
unlink(infile);
unlink(outfile);
tst_resm(TPASS, "Test passed");
tst_exit();
}
void test_filecmp()
{
char * f1 = "/home/liheyuan/.xsession-errors";
char * f2 = "/tmp/.xsession-errors";
printf("filecmp():%d\n", filecmp(f1, f2));
}
