自学教程：C++ yaffs_close函数代码示例

void rename_over_test(const char *mountpt){	int i;	char a[100];	char b[100];	char c[100];		sprintf(a,"%s/a",mountpt);	sprintf(b,"%s/b",mountpt);	sprintf(c,"%s/c",mountpt);		yaffs_StartUp();		yaffs_mount(mountpt);		printf("Existing files/n");	dumpDirFollow(mountpt);				i = yaffs_open(c,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);	printf("File c handle is %d/n",i);	yaffs_close(i);	i = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR,  S_IREAD | S_IWRITE); 	yaffs_close(i);	i = yaffs_open(b,O_CREAT | O_TRUNC | O_RDWR,  S_IREAD | S_IWRITE);	yaffs_close(i);	yaffs_rename(a,b); // rename over	yaffs_rename(b,a); // rename back again (not renaimng over)	yaffs_rename(a,b); // rename back again (not renaimng over)			yaffs_unmount(mountpt);	}

static int yWriteFile(const char *fname, unsigned sz32){	int h;	int r;	int i;	unsigned checksum = 0;		printf("Writing file %s/n",fname);	h = yaffs_open(fname,O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);	if(h < 0){		printf("could not open file %s/n",fname);		return h;	}        xx[0] = sz32;        checksum ^= xx[0];	if((r = yaffs_write(h,xx,sizeof(unsigned))) != sizeof(unsigned)){		goto WRITE_ERROR;	}			while(sz32> 0){        	for(i = 0; i < XX_SIZE; i++){        	  xx[i] = sz32 + i;        	  checksum ^= xx[i];                }		if((r = yaffs_write(h,xx,sizeof(xx))) != sizeof(xx)){			goto WRITE_ERROR;		}		sz32--;	}	xx[0] = checksum;	if((r = yaffs_write(h,xx,sizeof(unsigned))) != sizeof(unsigned)){		goto WRITE_ERROR;	}			yaffs_close(h);	return 0;WRITE_ERROR:	printf("ywrite error at position %d/n",(int)yaffs_lseek(h,0,SEEK_END));	yaffs_close(h);	return -1;	}

static void UpdateCounter(const char *name, unsigned *val,  int initialise){  int inh=-1;  int outh=-1;  unsigned x[2];  int nread = 0;  int nwritten = 0;    x[0] = x[1] = 0;    if(initialise){    x[0] = 0;     x[1] = 1;  } else {    inh = yaffs_open(name,O_RDONLY, S_IREAD | S_IWRITE);    if(inh >= 0){      nread = yaffs_read(inh,x,sizeof(x));      yaffs_close(inh);    }    if(nread != sizeof(x) ||       x[0] + 1 != x[1]){      printf("Error reading counter %s handle %d, x[0] %u x[1] %u last error %d/n",              name, inh, x[0], x[1],yaffsfs_GetLastError());      FatalError();                  }    x[0]++;    x[1]++;  }    outh = yaffs_open(fullTempCounterName, O_RDWR | O_TRUNC | O_CREAT, S_IREAD | S_IWRITE);  if(outh >= 0){    nwritten = yaffs_write(outh,x,sizeof(x));    yaffs_close(outh);    yaffs_rename(fullTempCounterName,name);  }    if(nwritten != sizeof(x)){      printf("Error writing counter %s handle %d, x[0] %u x[1] %u/n",              name, inh, x[0], x[1]);      FatalError();  }    *val = x[0];    printf("##/n"         "## Set counter %s to %u/n"         "##/n", name,x[0]);}

void fill_empty_files_test(const char *mountpt){	int i;	yaffs_StartUp();	char name[100];	int result = 0;		int d,f;	for(i = 0; i < 5; i++)	{		yaffs_mount(mountpt);		for(d = 0; result >= 0 && d < 1000; d++){			sprintf(name,"%s/%d",mountpt,d);			result= yaffs_mkdir(name,0);			printf("creating directory %s result %d/n",name,result);						for(f = 0; result >= 0 && f < 100; f++){				sprintf(name,"%s/%d/%d",mountpt,d,f);				result= yaffs_open(name,O_CREAT, 0);				yaffs_close(result);				printf("creating file %s result %d/n",name,result);			}		}		yaffs_unmount(mountpt);	}	}

int dump_file_data(char *fn){	int h;	int i = 0;	int ok = 1;	unsigned char b;		h = yaffs_open(fn, O_RDWR,0);					printf("%s/n",fn);	while(yaffs_read(h,&b,1)> 0)	{		printf("%02x",b);		i++;		if(i > 32) 		{		   printf("/n");		   i = 0;;		 }	}	printf("/n");	yaffs_close(h);	return ok;}

int overwrite_test(const char *path){   char aname[100];   char bname[100];   int i;   int j;      int a;   int b;   yaffs_StartUp();      yaffs_mount(path);      sprintf(aname,"%s%s",path,"/a");   sprintf(bname,"%s%s",path,"/b");      b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);   for(j= 0; j < 500; j++){   	yaffs_write(b,bname,100);	a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);   	for(i = 0; i < rand() % 20000; i++)   		yaffs_write(a,&a,sizeof(a));	yaffs_close(a);   }      return 0;   }

void read_a_file(char *fn){	int h;	int i = 0;	unsigned char b;	h = yaffs_open(fn, O_RDWR,0);	if(h<0)	{		printf("File not found/n");		return;	}	while(yaffs_read(h,&b,1)> 0)	{		printf("%02x ",b);		i++;		if(i > 32)		{		   printf("/n");		   i = 0;;		 }	}	printf("/n");	yaffs_close(h);}

int test_yaffs_chmod_EROFS(void){	int error=0;	int output;	if (yaffs_close(yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	EROFS_setup();	output = yaffs_chmod(FILE_PATH,S_IREAD|S_IWRITE);	if (output<0){		error=yaffs_get_error();		if (abs(error)==EROFS){			return 1;		} else {			print_message("different error than expected/n",2);			return -1;		}	} else {		print_message("chmoded with EROFS setup (which is a bad thing)/n",2);		return -1;	}}

int test_yaffs_rename_file_to_dir(void){    int output=0;    if (0 !=  yaffs_access(FILE_PATH,0)) {        output = test_yaffs_open();        if (output < 0) {            print_message("failed to create file/n",2);            return -1;        } else {            output = yaffs_close(output);            if (output < 0) {                print_message("failed to close file/n",2);                return -1;            }        }    }    output = yaffs_rename( "/yaffs2/foo" , RENAME_DIR_PATH);    if (output<0) {        print_message("failed to rename a file over an empty directory/n",2);        return -1;    } else {        return 1;    }}

int  test_yaffs_rename_ENOTEMPTY(void){	int output=0;	int error_code =0;	if (yaffs_mkdir(DIR_PATH,O_CREAT | O_RDWR)==-1){		print_message("failed to create dir/n",1);		return -1;	}	if (yaffs_mkdir(DIR_PATH2,O_CREAT | O_RDWR)==-1){		print_message("failed to create dir2/n",1);		return -1;	}	if (yaffs_close(yaffs_open(DIR_PATH2_FILE,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	output = yaffs_rename( DIR_PATH,DIR_PATH2 );	if (output<0){ 		error_code=yaffs_get_error();		if (abs(error_code)==ENOTEMPTY){			return 1;		} else {			print_message("different error than expected/n",2);			return -1;		}		print_message("could not rename a directory over a nonempty directory (which is a bad thing)/n",2);		return -1;	} 			return 1;}

int  test_yaffs_rename_full_dir_over_dir(void){	int output=0;	int error_code =0;	if (yaffs_mkdir(DIR_PATH,O_CREAT | O_RDWR)==-1){		print_message("failed to create dir/n",1);		return -1;	}	if (yaffs_mkdir(DIR_PATH2,O_CREAT | O_RDWR)==-1){		print_message("failed to create dir2/n",1);		return -1;	}	if (yaffs_close(yaffs_open(DIR_PATH2_FILE,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	output = yaffs_rename( DIR_PATH2,DIR_PATH );	if (output<0){ 		print_message("could not rename a directory over a empty directory (which is a bad thing)/n",2);		return -1;	} 			return 1;}

int test_yaffs_fsync_EROFS(void){	int output = 0;	int error_code = 0;	if (yaffs_close(yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	EROFS_setup();	handle = yaffs_open(FILE_PATH,O_CREAT  ,S_IREAD  );	if (handle<0){		print_message("failed to open file/n",2);		return -1;	}	output = yaffs_fsync(handle);	if (output==-1){		error_code=yaffs_get_error();		if (abs(error_code)==EROFS){			return 1;		} else {			print_message("different error than expected/n",2);			return -1;		}	} else {		print_message("file synced with EROFS set.(which is a bad thing)/n",2);		return -1;	}}

void handle_test(const char *mountpt){	int i;	int h;	int cycle;	char a[100];	sprintf(a,"%s/aaa",mountpt);		yaffs_StartUp();		yaffs_mount(mountpt);        for(cycle = 0; cycle < 5; cycle++){        printf("Start cycle %d/n",cycle); 	i = 0;	do {        h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);	printf("%d  handle %d/n",i,h);	i++;	} while(h >= 0);		while(i >= -1) {	 yaffs_close(i);	 i--;        }        }		yaffs_unmount(mountpt);}

void write_200k_file(const char *fn, const char *fdel, const char *fdel1){   int h1;   int i;   int offs;      h1 = yaffs_open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);      for(i = 0; i < 100000; i+= 10000)   {   	write_10k(h1);   }      offs = yaffs_lseek(h1,0,SEEK_CUR);   if( offs != 100000)   {   	printf("Could not write file/n");   }      yaffs_unlink(fdel);   for(i = 0; i < 100000; i+= 10000)   {   	write_10k(h1);   }      offs = yaffs_lseek(h1,0,SEEK_CUR);   if( offs != 200000)   {   	printf("Could not write file/n");   }      yaffs_close(h1);   yaffs_unlink(fdel1);   }

int test_yaffs_rmdir_ENOTDIR(void){	int output=0;	int error_code =0;	if (yaffs_close(yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	if (0 !=  yaffs_access(DIR_PATH,0)) {		output = yaffs_mkdir(DIR_PATH,S_IWRITE | S_IREAD);		if (output < 0) {			print_message("failed to create directory/n",2);			return -1;		}	}	output = yaffs_rmdir("/yaffs2/test_dir/foo/dir/");	if (output<0){ 		error_code=yaffs_get_error();		if (abs(error_code)==ENOTDIR){			return 1;		} else {			print_message("returned error does not match the the expected error/n",2);			return -1;		}	} else{		print_message("removed /yaffs2/ directory (which is a bad thing)/n",2);		return -1;	}	}

void make_a_file(char *yaffsName, char bval, int sizeOfFile){	int outh;	int i;	unsigned char buffer[100];	outh = yaffs_open(yaffsName,				O_CREAT | O_RDWR | O_TRUNC,				S_IREAD | S_IWRITE);	if (outh < 0) {		printf("Error opening file: %d. %s/n", outh, yaffs_error_str());		return;	}	memset(buffer, bval, 100);	do {		i = sizeOfFile;		if (i > 100)			i = 100;		sizeOfFile -= i;		yaffs_write(outh, buffer, i);	} while (sizeOfFile > 0);	yaffs_close(outh);}

int test_yaffs_open_EACCES(void){	int error_code=0;	int output =-1;	if (yaffs_access(FILE_PATH,0)!=0){		output=yaffs_close(test_yaffs_open());		if (output<0){			print_message("failed to open file/n",2);			return -1;		}	}	output=yaffs_chmod(FILE_PATH,S_IREAD);	if (output<0){		print_message("failed to chmod file/n",2);		return -1;	}	handle=yaffs_open(FILE_PATH, O_TRUNC| O_RDWR,FILE_MODE );	if (handle <0){		error_code=yaffs_get_error();		if (abs(error_code)==EACCES){			return 1;		}		else {			print_message("different error than expected/n",2);			return -1;		}	}	else {		print_message("file opened with read and write permissions, chmoded to read only.(which is a bad thing)/n",2);		return -1;	}}

void fill_disk(const char *path,int nfiles){	int h;	int n;	int result;	int f;        static char xx[600];		char str[50];		for(n = 0; n < nfiles; n++)	{		sprintf(str,"%s/%d",path,n);				h = yaffs_open(str, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);				printf("writing file %s handle %d ",str, h);				while ((result = yaffs_write(h,xx,600)) == 600)		{			f = yaffs_freespace(path);		}		result = yaffs_close(h);		printf(" close %d/n",result);	}}

/*============================================================================== * - cat() * * - print a file context */int cat(int argc, char *argv[]){    int fd;    int read_byte;    char file_context[1024];    char path_name[PATH_LEN_MAX];    CHECK_ARG_NUM(2, "please type file name");    _make_abs_path(path_name, argv[1]);    /*     * open file     */    fd = yaffs_open(path_name, O_RDONLY, 0);    if ( fd ==  -1) {        serial_printf("cannot open file '%s'", path_name);        return CMD_ERROR;    }    /*     * read and print file context     */    read_byte = yaffs_read(fd, file_context, 1023);    while (read_byte > 0) {        file_context[read_byte] = '/0';        serial_printf(file_context);        read_byte = yaffs_read(fd, file_context, 1023);    }    yaffs_close(fd);    return CMD_OK;}

int check_pattern_file(char *fn){	int h;	int marker;	int i;	int size;	int ok = 1;		h = yaffs_open(fn, O_RDWR,0);	size = yaffs_lseek(h,0,SEEK_END);			for(i = 0; i < size; i+=256)	{		yaffs_lseek(h,i,SEEK_SET);		yaffs_read(h,&marker,sizeof(marker));		ok = (marker == ~i);		if(!ok)		{		   printf("pattern check failed on file %s, size %d at position %d. Got %x instead of %x/n",					fn,size,i,marker,~i);		}	}	yaffs_close(h);	return ok;}

void create_resized_file_of_size(const char *fn,int syze1,int reSyze, int syze2){	int h;		int iterations;		h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);			iterations = (syze1 + strlen(fn) -1)/ strlen(fn);	while (iterations > 0)	{		yaffs_write(h,fn,strlen(fn));		iterations--;	}		yaffs_ftruncate(h,reSyze);		yaffs_lseek(h,0,SEEK_SET);	iterations = (syze2 + strlen(fn) -1)/ strlen(fn);	while (iterations > 0)	{		yaffs_write(h,fn,strlen(fn));		iterations--;	}		yaffs_close (h);}

void verify_file_of_size(const char *fn,int syze){	int h;	int result;		char xx[200];	char yy[200];	int l;		int iterations = (syze + strlen(fn) -1)/ strlen(fn);		h = yaffs_open(fn, O_RDONLY, S_IREAD | S_IWRITE);			while (iterations > 0)	{		sprintf(xx,"%s %8d",fn,iterations);		l = strlen(xx);				result = yaffs_read(h,yy,l);		yy[l] = 0;				if(strcmp(xx,yy)){			printf("=====>>>>> verification of file %s failed near position %lld/n",fn,(long long)yaffs_lseek(h,0,SEEK_CUR));		}		iterations--;	}	yaffs_close (h);}

void verify_200k_file(const char *fn){   int h1;   int i;   char x[11];   const char *s="0123456789";   int errCount = 0;      h1 = yaffs_open(fn, O_RDONLY, 0);      for(i = 0; i < 200000 && errCount < 10; i+= 10)   {   	yaffs_read(h1,x,10);	if(strncmp(x,s,10) != 0)	{		printf("File %s verification failed at %d/n",fn,i);		errCount++;	}   }   if(errCount >= 10)   	printf("Too many errors... aborted/n");         yaffs_close(h1);	   	}

int test_yaffs_fchmod_EROFS_clean(void){	int output =-1;	if (handle >= 0) {		output= yaffs_close(handle);	}	return (EROFS_clean() && output);}

int test_yaffs_open_EEXIST_clean(void){	if (handle >=0){		return yaffs_close(handle);	} else {		return 1;	/* the file failed to open so there is no need to close it*/	}}

/*============================================================================== * - cp() * * - copy a file form here to there */int cp(int argc, char *argv[]){    int fd_in, fd_out;    int read_byte, write_byte;    char file_context[1024];    char old_path_name[PATH_LEN_MAX];    char new_path_name[PATH_LEN_MAX];    CHECK_ARG_NUM(3, "too few argument");    _make_abs_path(old_path_name, argv[1]);    fd_in = yaffs_open(old_path_name, O_RDONLY, 0);    CHECK_YAFFS_RETVAL(fd_in, "can't open file '%s'%s/n", old_path_name, "");    _make_abs_path(new_path_name, argv[2]);    fd_out = yaffs_open(new_path_name, O_CREAT|O_RDWR|O_TRUNC, S_IREAD|S_IWRITE);    if (fd_out == -1) {        yaffs_close(fd_in);        serial_printf("can't create file '%s'", new_path_name);        return CMD_ERROR;    }    /*     * read from fd_in and write to fd_out     */    read_byte = yaffs_read(fd_in, file_context, 1024);    while (read_byte > 0) {        write_byte = yaffs_write(fd_out, file_context, read_byte);        if (write_byte != read_byte) {            serial_printf("copy file failed!");            break;        }        read_byte = yaffs_read(fd_in, file_context, 1024);    }    yaffs_close(fd_in);    yaffs_close(fd_out);    if (read_byte > 0) {        return CMD_ERROR;    } else {        return CMD_OK;    }}

int test_yaffs_ftruncate_EROFS_clean(void){	int output=1;	if (handle >= 0) {		output= yaffs_close(handle);	}	return (EROFS_clean() && output);}

void V5M_SaveImageFile(char *str, char *buf, UINT32 len){	int h;	yaffs_unlink(str);	h = yaffs_open(str,  O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);	yaffs_write(h, buf, (unsigned int)len);	yaffs_close(h);}

void SaveImageFile(char *str, char *buf, int len){	int h;	yaffs_unlink(str);	h = yaffs_open(str,  O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);	yaffs_write(h, buf, len);	yaffs_close(h);}

int test_yaffs_access(void){    if (-1==yaffs_close(yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE))) {        print_message("failed to create file/n",1);        return -1;    }    return yaffs_access(FILE_PATH,0);}