int cache_read_test(void)
{
int a,b,c;
int i;
int sizeOfFiles = 500000;
char buffer[100];
yaffs_StartUp();
yaffs_mount("/boot");
make_a_file("/boot/a",'a',sizeOfFiles);
make_a_file("/boot/b",'b',sizeOfFiles);
a = yaffs_open("/boot/a",O_RDONLY,0);
b = yaffs_open("/boot/b",O_RDONLY,0);
c = yaffs_open("/boot/c", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
do{
i = sizeOfFiles;
if (i > 100) i = 100;
sizeOfFiles -= i;
yaffs_read(a,buffer,i);
yaffs_read(b,buffer,i);
yaffs_write(c,buffer,i);
} while(sizeOfFiles > 0);
return 1;
}
/*==============================================================================
* - 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;
}
void File_Get_Config_Accumulate(int* f, Accumulate_Config* accumulate_conf)
{
int n;
char buf[BUFFERSIZE];
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
sscanf( buf, "%d %d %d %d", &accumulate_conf->testpointNo, &accumulate_conf->sensorName, &accumulate_conf->portType, &n ); //测点编号，传感器类型，端口类型，端口地址
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
strcpy( accumulate_conf->location, buf ); //安装地点
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
sscanf( buf, "%d", &accumulate_conf->measureMaxVal );
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
sscanf( buf, "%f", &accumulate_conf->coefficient );
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
sscanf( buf, "%d", &accumulate_conf->shift );
return;
}
int cache_bypass_bug_test(void)
{
// This test reporoduces a bug whereby YAFFS caching *was* buypassed
// resulting in erroneous reads after writes.
// This bug has been fixed.
int a;
int i;
char buffer1[1000];
char buffer2[1000];
memset(buffer1,0,sizeof(buffer1));
memset(buffer2,0,sizeof(buffer2));
yaffs_StartUp();
yaffs_mount("/boot");
// Create a file of 2000 bytes.
make_a_file("/boot/a",'X',2000);
a = yaffs_open("/boot/a",O_RDWR, S_IREAD | S_IWRITE);
// Write a short sequence to the file.
// This will go into the cache.
yaffs_lseek(a,0,SEEK_SET);
yaffs_write(a,"abcdefghijklmnopqrstuvwxyz",20);
// Read a short sequence from the file.
// This will come from the cache.
yaffs_lseek(a,0,SEEK_SET);
yaffs_read(a,buffer1,30);
// Read a page size sequence from the file.
yaffs_lseek(a,0,SEEK_SET);
yaffs_read(a,buffer2,512);
printf("buffer 1 %s\n",buffer1);
printf("buffer 2 %s\n",buffer2);
if(strncmp(buffer1,buffer2,20))
{
printf("Cache bypass bug detected!!!!!\n");
}
return 1;
}
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 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 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;
}
/*
* Play DSP from WAV file:
*/
int PlayDSP(DSPFILE *dfile, WAVFILE *wfile)
{
UInt32 byte_count = (UInt32) wfile->wavinfo.Samples;
int bytes;
int n;
int byte_modulo;
int total_bytes;
//First determine how many bytes are required for each channel's sample:
switch ( wfile->wavinfo.DataBits )
{
case 8 :
byte_count = 1;
break;
case 16 :
byte_count = 2;
break;
default :
printf("Cannot process %u bit samples\n", (unsigned)wfile->wavinfo.DataBits);
return -1;
}
byte_modulo = byte_count; /* This many bytes per sample */
byte_count = wfile->wavinfo.Samples * byte_modulo; /* Total bytes to process */
total_bytes = byte_count;
/* Seek to requested start sample */
yaffs_lseek(wfile->fd,wfile->StartSample*byte_modulo,SEEK_CUR);
for (; byte_count > 0 && wfile->wavinfo.DataBytes > 0; byte_count -= (UInt32) n )
{
bytes = (int) ( byte_count > dfile->dspblksiz ? dfile->dspblksiz : byte_count );
if ( bytes > wfile->wavinfo.DataBytes ) /* Size bigger than data chunk? */
bytes = wfile->wavinfo.DataBytes; /* Data chunk only has this much left */
// printf("play databytes:%d bytes:%d n:%d\n",wfile->wavinfo.DataBytes,bytes,n);
if ( (n = yaffs_read(wfile->fd,dfile->dspbuf,bytes)) != bytes )
{
if ( n >= 0 )
printf("Unexpected EOF reading samples from WAV file\n");
else
printf("Reading samples from WAV file\n");
goto errxit;
}
// printf("pcm writeing data\n");//treckle
if (pcm_write(dfile->dspbuf,n) <= 0)
{
printf("Writing samples data failed\n");
goto errxit;
}
// printf("end pcm writeing data\n");//treckle
wfile->wavinfo.DataBytes -= (UInt32) bytes; /* We have fewer bytes left to read */
//printf("dspblksize=%d bytes=%d DataBytes=%d\n", dfile->dspblksiz, bytes, wfile->wavinfo.DataBytes);
}
return 0; /* All samples played successfully */
errxit: return -1; /* Indicate error return */
}
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);
}
/*==============================================================================
* - 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;
}
}
void File_Get_Config_Analogue(int* f, Analogue_Config* analogue_conf)
{
int n;
char buf[BUFFERSIZE];
printf("In Analogue Config Function:\n");
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
printf( "buf=[%s]\n", buf );
sscanf( buf, "%d %d %d %d", &analogue_conf->testpointNo, &analogue_conf->sensorName, &analogue_conf->portType, &n ); //测点编号，传感器类型，端口类型，端口地址
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
printf( "buf=[%s]\n", buf );
strcpy( analogue_conf->location, buf ); //安装地点
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
printf( "buf=[%s]\n", buf );
sscanf( buf, "%d %d", &analogue_conf->alarm.minval, &analogue_conf->alarm.maxval );
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
printf( "buf=[%s]\n", buf );
sscanf( buf, "%d %d", &analogue_conf->liftAlarm.minval, &analogue_conf->liftAlarm.maxval );
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
printf( "buf=[%s]\n", buf );
sscanf( buf, "%d %d", &analogue_conf->measureRange.minval, &analogue_conf->measureRange.maxval );
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
printf( "buf=[%s]\n", buf );
sscanf( buf, "%d %d", &analogue_conf->outage.minval, &analogue_conf->outage.maxval );
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
printf( "buf=[%s]\n", buf );
sscanf( buf, "%d %d", &analogue_conf->recover.minval, &analogue_conf->recover.maxval );
memset(buf, '\0', sizeof(buf));
n = yaffs_read((*f), buf, BUFFERSIZE );
printf( "buf=[%s]\n", buf );
sscanf( buf, "%d %f", &analogue_conf->outputControl, &analogue_conf->coefficient );
printf("Quit Analogue Config Function\n");
return;
}
void File_Get_Config_Switch(int* f, Switch_Config* switch_conf)
{
int n;
char buf[BUFFERSIZE];
printf("In Switch Config Function:\n");
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
sscanf( buf, "%d %d %d %d", &switch_conf->testpointNo, &switch_conf->sensorName, &switch_conf->portType, &n ); //测点编号，传感器类型，端口类型，端口地址
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
strcpy( switch_conf->location, buf ); //安装地点
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
sscanf( buf, "%d", &switch_conf->outputControl );
printf("Quit Switch Config Function\n");
return;
}
void File_Get_Config_Tristate(int* f, Tristate_Config* tristate_conf)
{
int n;
char buf[BUFFERSIZE];
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
sscanf( buf, "%d %d %d %d", &tristate_conf->testpointNo, &tristate_conf->sensorName, &tristate_conf->portType, &n ); //测点编号，传感器类型，端口类型，端口地址
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
strcpy( tristate_conf->location, buf ); //安装地点
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
sscanf( buf, "%d %d %d", &tristate_conf->current[0], &tristate_conf->current[1], &tristate_conf->current[2] );
memset(buf, '\0', sizeof(buf));
n = yaffs_read( (*f), buf, BUFFERSIZE );
sscanf( buf, "%d", &tristate_conf->outputControl );
return;
}
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 simple_rw_test(const char *mountpt)
{
int i;
int h;
char a[100];
int x;
int result;
sprintf(a,"%s/aaa",mountpt);
yaffs_StartUp();
yaffs_mount(mountpt);
yaffs_unlink(a);
h = yaffs_open(a,O_CREAT| O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
for(i = 100000;i < 200000; i++){
result = yaffs_write(h,&i,sizeof(i));
if(result != 4)
{
printf("write error\n");
exit(1);
}
}
//yaffs_close(h);
// h = yaffs_open(a,O_RDWR, S_IREAD | S_IWRITE);
yaffs_lseek(h,0,SEEK_SET);
for(i = 100000; i < 200000; i++){
result = yaffs_read(h,&x,sizeof(x));
if(result != 4 || x != i){
printf("read error %d %x %x\n",i,result,x);
}
}
printf("Simple rw test passed\n");
}
int LoadImageFile(char *str, char *buf, int size)
{
int h;
int len;
h = yaffs_open(str, O_RDONLY, S_IREAD | S_IWRITE);
if(h == -1)
return 0;
len = (int)yaffs_lseek(h, 0, SEEK_END);
if(len > size)
len = size;
yaffs_lseek(h, 0, SEEK_SET);
yaffs_read(h, buf, len);
yaffs_close(h);
return len;
}
void cmd_yaffs_mread_file(char *fn, char *addr)
{
int h;
struct yaffs_stat s;
yaffs_stat(fn, &s);
printf("Copy %s to 0x%p... ", fn, addr);
h = yaffs_open(fn, O_RDWR, 0);
if (h < 0) {
printf("File not found\n");
return;
}
yaffs_read(h, addr, (int)s.st_size);
printf("\t[DONE]\n");
yaffs_close(h);
}
/*==============================================================================
* - _open_file()
*
* - open a text file, and read it's all context to memory
*/
static OS_STATUS _open_file (const char *file_name)
{
struct yaffs_stat statFile;
int fd;
int read_cnt;
/* alloc memory to store file text */
if (yaffs_stat (file_name, &statFile) < 0) { /* not exist */
return OS_STATUS_ERROR;
}
_G_text = calloc (1, statFile.st_size + 1);
/* open file */
fd = yaffs_open (file_name, O_RDONLY, 0666);
if (fd < 0) {
free (_G_text);
return OS_STATUS_ERROR;
}
/* read text */
read_cnt = yaffs_read (fd, _G_text, statFile.st_size);
if (read_cnt < 0) {
free (_G_text);
yaffs_close (fd);
return OS_STATUS_ERROR;
}
/* close file */
yaffs_close (fd);
/* make book name */
{
char *ext = NULL;
strcpy (_G_book_name, strrchr (file_name, '/') + 1);
if ((ext = strrchr (_G_book_name, '.')) != NULL) {
*ext = '\0';
}
}
return OS_STATUS_OK;
}
char *V5M_LoadImageFile(char *str, UINT32 *size)
{
int h;
char *buf = NULL;
h = yaffs_open(str, O_RDONLY, S_IREAD | S_IWRITE);
if(h == -1)
return NULL;
*size = (int)yaffs_lseek(h, 0, SEEK_END);
yaffs_lseek(h, 0, SEEK_SET);
if (*size == 0)
return NULL;
buf = (char *) gHapiContext.pmalloc(*size);
yaffs_read(h, buf, (unsigned int)(*size));
yaffs_close(h);
return buf;
}
int truncate_test(void)
{
int a;
int r;
int i;
int l;
char y[10];
yaffs_StartUp();
yaffs_mount("/boot");
yaffs_unlink("/boot/trunctest");
a = yaffs_open("/boot/trunctest", O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
yaffs_write(a,"abcdefghijklmnopqrstuvwzyz",26);
yaffs_ftruncate(a,3);
l= yaffs_lseek(a,0,SEEK_END);
printf("truncated length is %d\n",l);
yaffs_lseek(a,5,SEEK_SET);
yaffs_write(a,"1",1);
yaffs_lseek(a,0,SEEK_SET);
r = yaffs_read(a,y,10);
printf("read %d bytes:",r);
for(i = 0; i < r; i++) printf("[%02X]",y[i]);
printf("\n");
return 0;
}
int test_yaffs_read_EINVAL(void)
{
int error_code = 0;
handle=yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE);
char text[2000000];
int output=0;
if (handle<0){
print_message("could not open file\n",2);
return -1;
}
/*there needs a large amout of test in the file in order to trigger EINVAL */
output=test_yaffs_read_EINVAL_init();
if (output<0){
print_message("could not write text to the file\n",2);
return -1;
}
if (handle>=0){
output=yaffs_read(handle, text, -1);
if (output<0){
error_code=yaffs_get_error();
if (abs(error_code)== EINVAL){
return 1;
} else {
print_message("different error than expected\n",2);
return -1;
}
} else{
print_message("read a negative number of bytes (which is a bad thing)\n",2);
return -1;
}
} else {
print_message("error opening file\n",2);
return -1;
}
}
/*==============================================================================
* - T_web_server_start()
*
* - http server task
*/
void T_web_server_start ()
{
int sockfd; // Socket file descriptor
int nsockfd; // New Socket file descriptor
int num;
socklen_t sin_size; // to store struct size
char revbuf[LENGTH];
struct sockaddr_in addr_local;
struct sockaddr_in addr_remote;
/* Get the Socket file descriptor */
if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ) {
serial_printf ("ERROR: Cannot obtain Socket Despcritor.\n");
return ;
} else {
WEB_LOG ("OK: Obtain Socket Despcritor sucessfully.\n");
}
/* Fill the local socket address struct */
addr_local.sin_family = AF_INET; // Protocol Family
addr_local.sin_port = htons(PORT); // Port number
addr_local.sin_addr.s_addr = INADDR_ANY; // AutoFill local address
memset(&(addr_local.sin_zero), 0, 8); // Flush the rest of struct
/* Blind a special Port */
if( bind(sockfd, (struct sockaddr*)&addr_local, sizeof(struct sockaddr)) == -1 ) {
serial_printf ("ERROR: Cannot bind Port %d\n.",PORT);
return ;
} else {
WEB_LOG ("OK: Bind the Port %d sucessfully.\n",PORT);
}
/* Listen remote connect/calling */
if(listen(sockfd,BACKLOG) == -1) {
serial_printf ("ERROR: Cannot listen Port %d\n.", PORT);
return ;
} else {
WEB_LOG ("OK: Listening the Port %d sucessfully.\n", PORT);
}
while(1) {
sin_size = sizeof(struct sockaddr_in);
/* Wait a connection, and obtain a new socket file despriptor for single connection */
if ((nsockfd = accept(sockfd, (struct sockaddr *)&addr_remote, &sin_size)) == -1) {
serial_printf ("ERROR: Obtain new Socket Despcritor error\n");
continue;
} else {
WEB_LOG ("OK: Server has got connect from %s\n", inet_ntoa(addr_remote.sin_addr));
}
num = recv(nsockfd, revbuf, LENGTH, 0);
revbuf[num] = '\0';
WEB_LOG (revbuf);
/* Child process */
// if(!fork())
{
WEB_LOG ("OK: Http web is servering.\n");
if(revbuf[5]==' ') {
send(nsockfd, reply, sizeof(reply), 0);
send(nsockfd, html, sizeof(html), 0);
} else if(revbuf[5]=='1') {
send(nsockfd, httpgif, sizeof(httpgif), 0);
send(nsockfd, bmp, sizeof(bmp), 0);
} else {
char file_name[PATH_LEN_MAX] = {WEB_PATH};
char file_context[1024];
char send_context[2048];
int i = 5;
int fd;
int read_byte;
int send_byte;
#if 0
int f_len, h_len = strlen(HOME_HTML);
#endif
while (!isspace(revbuf[i++]))
;
revbuf[--i] = '\0';
strncat (file_name, revbuf + 5, PATH_LEN_MAX - strlen(file_name) - 1);
file_name[PATH_LEN_MAX - 1] = '\0';
#if 0
f_len = strlen (file_name);
if ((f_len > h_len) &&
(strcmp (file_name + f_len - h_len, HOME_HTML) == 0)) {
strcpy (file_name, WEB_PATH HOME_HTML);
}
#endif
fd = yaffs_open(file_name, O_RDONLY, 0);
if ( fd == -1) {
serial_printf("ERROR: Cannot open file %s", file_name);
}
if ( (strcmp (strchr (file_name, '.'), ".html") == 0) || /* *.html */
(strcmp (strchr (file_name, '.'), ".jpg") == 0)) { /* *.jpg */
read_byte = yaffs_read(fd, file_context, 1024);
while (read_byte > 0) {
send(nsockfd, file_context, read_byte, 0);
read_byte = yaffs_read(fd, file_context, 1024);
}
} else { /* !.html */
send(nsockfd, html_start, sizeof(html_start), 0);
read_byte = yaffs_read(fd, file_context+1, 1023);
file_context[0] = '|';
read_byte++;
while (read_byte > 1) {
send_byte = 0;
for (i = 0; i < read_byte; i++) {
if (file_context[i] == '\n') {
send_context[send_byte++] = '<';
send_context[send_byte++] = 'B';
send_context[send_byte++] = 'R';
send_context[send_byte++] = '>';
send_context[send_byte++] = '|';
} else if (file_context[i] == '<'){
send_context[send_byte++] = '&';
send_context[send_byte++] = 'l';
send_context[send_byte++] = 't';
} else if (file_context[i] == '&'){
send_context[send_byte++] = '&';
send_context[send_byte++] = 'a';
send_context[send_byte++] = 'm';
send_context[send_byte++] = 'p';
} else if (file_context[i] == '"'){
send_context[send_byte++] = '&';
send_context[send_byte++] = 'q';
send_context[send_byte++] = 'u';
send_context[send_byte++] = 'o';
send_context[send_byte++] = 't';
}else {
send_context[send_byte++] = file_context[i];
}
}
send(nsockfd, send_context, send_byte, 0);
read_byte = yaffs_read(fd, file_context, 1024);
}
send(nsockfd, html_end, sizeof(html_end), 0);
} /* !*.html */
yaffs_close(fd);
}
}
close(nsockfd);
// while(waitpid(-1, NULL, WNOHANG) > 0);
}
}
int long_test(int argc, char *argv[])
{
int f;
int r;
char buffer[20];
char str[100];
int h;
mode_t temp_mode;
struct yaffs_stat ystat;
yaffs_StartUp();
yaffs_mount("/boot");
yaffs_mount("/data");
yaffs_mount("/flash");
yaffs_mount("/ram");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /data\n");
dumpDir("/data");
printf("\nDirectory look-up of /flash\n");
dumpDir("/flash");
//leave_unlinked_file("/flash",20000,0);
//leave_unlinked_file("/data",20000,0);
leave_unlinked_file("/ram",20,0);
f = yaffs_open("/boot/b1", O_RDONLY,0);
printf("open /boot/b1 readonly, f=%d\n",f);
f = yaffs_open("/boot/b1", O_CREAT,S_IREAD | S_IWRITE);
printf("open /boot/b1 O_CREAT, f=%d\n",f);
r = yaffs_write(f,"hello",1);
printf("write %d attempted to write to a read-only file\n",r);
r = yaffs_close(f);
printf("close %d\n",r);
f = yaffs_open("/boot/b1", O_RDWR,0);
printf("open /boot/b1 O_RDWR,f=%d\n",f);
r = yaffs_write(f,"hello",2);
printf("write %d attempted to write to a writeable file\n",r);
r = yaffs_write(f,"world",3);
printf("write %d attempted to write to a writeable file\n",r);
r= yaffs_lseek(f,0,SEEK_END);
printf("seek end %d\n",r);
memset(buffer,0,20);
r = yaffs_read(f,buffer,10);
printf("read %d \"%s\"\n",r,buffer);
r= yaffs_lseek(f,0,SEEK_SET);
printf("seek set %d\n",r);
memset(buffer,0,20);
r = yaffs_read(f,buffer,10);
printf("read %d \"%s\"\n",r,buffer);
memset(buffer,0,20);
r = yaffs_read(f,buffer,10);
printf("read %d \"%s\"\n",r,buffer);
// Check values reading at end.
// A read past end of file should return 0 for 0 bytes read.
r= yaffs_lseek(f,0,SEEK_END);
r = yaffs_read(f,buffer,10);
printf("read at end returned %d\n",r);
r= yaffs_lseek(f,500,SEEK_END);
r = yaffs_read(f,buffer,10);
printf("read past end returned %d\n",r);
r = yaffs_close(f);
printf("close %d\n",r);
copy_in_a_file("/boot/yyfile","xxx");
// Create a file with a long name
copy_in_a_file("/boot/file with a long name","xxx");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Check stat
r = yaffs_stat("/boot/file with a long name",&ystat);
// Check rename
r = yaffs_rename("/boot/file with a long name","/boot/r1");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Check unlink
r = yaffs_unlink("/boot/r1");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Check mkdir
r = yaffs_mkdir("/boot/directory1",0);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
// add a file to the directory
copy_in_a_file("/boot/directory1/file with a long name","xxx");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
// Attempt to delete directory (should fail)
r = yaffs_rmdir("/boot/directory1");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
// Delete file first, then rmdir should work
r = yaffs_unlink("/boot/directory1/file with a long name");
r = yaffs_rmdir("/boot/directory1");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
#if 0
fill_disk_and_delete("/boot",20,20);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
#endif
yaffs_symlink("yyfile","/boot/slink");
yaffs_readlink("/boot/slink",str,100);
printf("symlink alias is %s\n",str);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
printf("\nDirectory look-up of /boot (using stat instead of lstat)\n");
dumpDirFollow("/boot");
printf("\nDirectory look-up of /boot/directory1\n");
dumpDir("/boot/directory1");
h = yaffs_open("/boot/slink",O_RDWR,0);
printf("file length is %d\n",(int)yaffs_lseek(h,0,SEEK_END));
yaffs_close(h);
yaffs_unlink("/boot/slink");
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Check chmod
yaffs_stat("/boot/yyfile",&ystat);
temp_mode = ystat.st_mode;
yaffs_chmod("/boot/yyfile",0x55555);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
yaffs_chmod("/boot/yyfile",temp_mode);
printf("\nDirectory look-up of /boot\n");
dumpDir("/boot");
// Permission checks...
PermissionsCheck("/boot/yyfile",0, O_WRONLY,0);
PermissionsCheck("/boot/yyfile",0, O_RDONLY,0);
PermissionsCheck("/boot/yyfile",0, O_RDWR,0);
PermissionsCheck("/boot/yyfile",S_IREAD, O_WRONLY,0);
PermissionsCheck("/boot/yyfile",S_IREAD, O_RDONLY,1);
PermissionsCheck("/boot/yyfile",S_IREAD, O_RDWR,0);
PermissionsCheck("/boot/yyfile",S_IWRITE, O_WRONLY,1);
PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDONLY,0);
PermissionsCheck("/boot/yyfile",S_IWRITE, O_RDWR,0);
PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_WRONLY,1);
PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDONLY,1);
PermissionsCheck("/boot/yyfile",S_IREAD | S_IWRITE, O_RDWR,1);
yaffs_chmod("/boot/yyfile",temp_mode);
//create a zero-length file and unlink it (test for scan bug)
h = yaffs_open("/boot/zlf",O_CREAT | O_TRUNC | O_RDWR,0);
yaffs_close(h);
yaffs_unlink("/boot/zlf");
yaffs_DumpDevStruct("/boot");
fill_disk_and_delete("/boot",20,20);
yaffs_DumpDevStruct("/boot");
fill_files("/boot",1,10000,0);
fill_files("/boot",1,10000,5000);
fill_files("/boot",2,10000,0);
fill_files("/boot",2,10000,5000);
leave_unlinked_file("/data",20000,0);
leave_unlinked_file("/data",20000,5000);
leave_unlinked_file("/data",20000,5000);
leave_unlinked_file("/data",20000,5000);
leave_unlinked_file("/data",20000,5000);
leave_unlinked_file("/data",20000,5000);
yaffs_DumpDevStruct("/boot");
yaffs_DumpDevStruct("/data");
return 0;
}
void small_mount_test(const char *mountpt,int nmounts)
{
char a[30];
int i;
int j;
int h0;
int h1;
int len0;
int len1;
int nread;
sprintf(a,"%s/a",mountpt);
yaffs_StartUp();
for(i = 0; i < nmounts; i++){
static char xx[1000];
printf("############### Iteration %d Start\n",i);
if(1 || i == 0 || i == 5)
yaffs_mount(mountpt);
dump_directory_tree(mountpt);
yaffs_mkdir(a,0);
sprintf(xx,"%s/0",a);
if(i ==0){
h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
for(j = 0; j < 130; j++)
yaffs_write(h0,xx,1000);
yaffs_close(h0);
}
h0 = yaffs_open(xx,O_RDONLY,0);
sprintf(xx,"%s/1",a);
h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
while((nread = yaffs_read(h0,xx,1000)) > 0)
yaffs_write(h1,xx,nread);
len0 = yaffs_lseek(h0,0,SEEK_END);
len1 = yaffs_lseek(h1,0,SEEK_END);
yaffs_lseek(h0,0,SEEK_SET);
yaffs_lseek(h1,0,SEEK_SET);
for(j = 0; j < 200; j++){
yaffs_read(h0,xx,1000);
yaffs_read(h1,xx,1000);
}
yaffs_close(h0);
yaffs_close(h1);
printf("########### %d\n",i);
dump_directory_tree(mountpt);
if(1 || i == 4 || i == nmounts -1)
yaffs_unmount(mountpt);
}
}
static int yVerifyFile(const char *fName)
{
unsigned checksum = 0;
unsigned totalSize;
unsigned sz32;
unsigned recordedSize = 0;
int r;
int h;
int i;
int retval = 0;
printf("Verifying file %s\n",fName);
h = yaffs_open(fName, O_RDONLY,S_IREAD | S_IWRITE);
if(h < 0){
printf("could not open file %s\n",fName);
return -1;
}
totalSize = yaffs_lseek(h,0,SEEK_END);
yaffs_lseek(h,0,SEEK_SET);
r = yaffs_read(h,&sz32,sizeof(sz32));
if(r != sizeof(sz32)){
printf("reading size failed ... returned %d\n",r);
yaffs_close(h);
return -1;
}
recordedSize = sz32 * sizeof(xx) + 8;
printf("verify %s: file size is %d, recorded size is %d\n", fName, totalSize, recordedSize);
if(totalSize != recordedSize){
printf("!!!!!!!!!!!!!!!!!!!!!!!!file size is wrong, should be %d, is %d\n", recordedSize,totalSize);
yaffs_close(h);
return -1;
}
checksum ^= sz32;
while(sz32 > 0){
r = yaffs_read(h,xx,sizeof(xx));
if(r != sizeof(xx)){
printf("!!!!!!!!!!!!!!!!!!!!!!!!!!reading data failed ... returned %d\n",r);
yaffs_close(h);
return -1;
}
for(i = 0; i < XX_SIZE; i++)
checksum ^= xx[i];
sz32--;
}
r = yaffs_read(h,xx,sizeof(xx[0]));
if(r != sizeof(xx[0])){
printf("!!!!!!!!!!!!!!!!!!!!!!!!!!reading data failed ... returned %d\n",r);
yaffs_close(h);
return -1;
}
checksum ^= xx[0];
if(checksum != 0){
printf("!!!!!!!!!!!!!!!!!!!!! checksum failed\n");
retval = -1;
} else
printf("verified ok\n");
yaffs_close(h);
return retval;
}
/*
* Open a WAV file for reading: returns (WAVFILE *)
*
* The opened file is positioned at the first byte of WAV file data, or
* NULL is returned if the open is unsuccessful.
*/
WAVFILE *WavOpenForRead(const char *Pathname)
{
WAVFILE *wfile;
UInt32 offset; /* File offset */
Byte ubuf[4]; /* 4 byte buffer */
UInt32 dbytes; /* Data byte count */
/* wavfile.c values : */
int channels; /* Channels recorded in this wav file */
u_long samplerate; /* Sampling rate */
int sample_bits; /* data bit size (8/12/16) */
u_long samples; /* The number of samples in this file */
u_long datastart; /* The offset to the wav data */
if(g_wfile) WavClose(g_wfile);
wfile = wavfile_alloc(Pathname);
if ( wfile == NULL )
return NULL; /* Insufficient memory (class B msg) */
/*
* Open the file for reading:
*/
printf("Opening WAV file %s\n", wfile->Pathname);
if ( (wfile->fd = yaffs_open(wfile->Pathname,O_RDONLY)) < 0 )
{
printf("Opening WAV file %s failed\n", wfile->Pathname);
goto errxit;
}
if ( yaffs_lseek(wfile->fd,0,SEEK_SET) != 0 )
{
printf("Rewinding WAV file %s\n",wfile->Pathname);
goto errxit; /* Wav file must be seekable device */
}
if ( WaveReadHeader(wfile->fd,&channels,&samplerate,&sample_bits,&samples,&datastart) != 0 )
{
printf("Reading WAV header from %s", wfile->Pathname);
goto errxit;
}
/*
* Copy WAV data over to WAVFILE struct:
*/
if ( channels == 2 )
wfile->wavinfo.Channels = Stereo;
else wfile->wavinfo.Channels = Mono;
wfile->wavinfo.SamplingRate = (UInt32) samplerate;
wfile->wavinfo.Samples = (UInt32) samples;
wfile->wavinfo.DataBits = (UInt16) sample_bits;
wfile->wavinfo.DataStart = (UInt32) datastart;
wfile->num_samples = wfile->wavinfo.Samples;
offset = wfile->wavinfo.DataStart - 4;
/*
* Seek to byte count and read dbytes:
*/
if ( yaffs_lseek(wfile->fd,offset,SEEK_SET) != offset )
{
printf("Seeking to WAV data in %s",wfile->Pathname);
goto errxit; /* Seek failure */
}
if ( yaffs_read(wfile->fd,ubuf,4) != 4 )
{
printf("Reading dbytes from %s",wfile->Pathname);
goto errxit;
}
/*
* Put little endian value into 32 bit value:
*/
dbytes = ubuf[3];
dbytes = (dbytes << 8) | ubuf[2];
dbytes = (dbytes << 8) | ubuf[1];
dbytes = (dbytes << 8) | ubuf[0];
wfile->wavinfo.DataBytes = dbytes;
/*
* Open succeeded:
*/
return wfile; /* Return open descriptor */
/*
* Return error after failed open:
WavClose*/
errxit:
mem_free(wfile); /* Dispose of WAVFILE struct */
return NULL; /* Return error indication */
}
UINT32 V5M_fread(UINT8 *buf, UINT32 length, V5MF_HANDLE file)
{
return (UINT32) yaffs_read(file, (void *)buf, (unsigned int) length );
}
static ssize_t __yaffs_read(mount_point_t *point, file_t *file, void *buf, size_t len)
{
return yaffs_read((int)file->ctx, buf, len);
}
//void main(void)
void yaffstest(void)
{
int i = 0,j;
int f = -1,f1=-1;
int fd[Nfile];
#if 1
char file[20];
char buf[2048];
char buffer[2048];
#endif
struct yaffs_stat s;
int ret;
unsigned int block;
unsigned int page;
int size;
#if 0
unsigned char buffer0[16];
unsigned char buffer1[2048];
unsigned char buffer2[64];
unsigned char buffer3[2048];
jz_nand_init ();
#if mkyaffs
/* we want to write the oob to spare here */
memset(buffer1,0xff,2048);
memset(buffer0,0xff,16);
#else
memset(buffer0,0x2,16);
buffer0[0]=0xff;
memset(buffer1,0xb,2048);
#endif
for(i=16;i<80;i++)
nand_flash_erase_block(i);
for(i=16;i<80;i++)
{
block=i;
printf("block=%d ok\n",block);
for(j=0;j<128;j++){
memset(buffer2,0,16);
memset(buffer3,0,2048);
page=block*128+j;
nand_flash_program_buf(page, buffer1,buffer0);//writeing data
// nand_flash_program_buf(page, NULL, buffer0);//writeing spare
if(nand_flash_read_buf(page, buffer3,buffer2)!=0)
printf("*********read nand failed\n");
if(nand_flash_read_buf(page, NULL,buffer2)!=0)
printf("*********read nand oob failed\n");
// ret=memcmp(buffer1+512+256+128,buffer3+512+256+128,64);
ret=memcmp(buffer1,buffer3,512);
if(ret!=0)
printf("ret=%d\n",ret);
ret=memcmp(buffer2,buffer0,16);
if(ret!=0)
printf("ret=%d\n \r\n",ret);
}
}
/*
for(i=0;i<16;i++)
printf("***data[%d]=%x,spare[%d]=%x\n",i,buffer3[i],i,buffer2[i]);
for(i=896+64;i>896;i--)
printf("*** buffer3[%d]=%x,buffer1[%d]=%x\n",i,buffer3[i],i,buffer1[i]);
*/
#else
#if 1
yaffs_StartUp();
yaffs_mount("/mnt");
// yaffs_mount("/d");
// return;
// ListDir("/mnt");
yaffs_mkdir("/mnt/mtdblock", 0);
yaffs_mkdir("/mnt/mtdblock/font", 0);
// yaffs_mkdir("/c/data1", 0);
// ListDir("/mnt/mtdblock");
// ListDir("/mnt/mtdblock/font");
#endif
#if 0
printf("testing serial\n\n");
Updatefile();
ReadOptions("/mnt/mtdblock/test1");
ReadOptions("/mnt/mtdblock/options.cfg");
// ReadOptions("/mnt/mtdblock/font/LANGUAGE.E");
ListDir("/mnt/mtdblock");
ListDir("/mnt/mtdblock/font");
return;
#else
/* testing memory */
return;
#endif
#if 1
// f = yaffs_open("/mnt/mtdblock/bigfile", O_CREAT | O_RDWR , S_IREAD | S_IWRITE);
f = yaffs_open("/mnt/mtdblock/options.cfg", O_CREAT | O_RDWR , S_IREAD | S_IWRITE);
if(f<0)
printf("Yaffs Open File Failed\n");
#if 1
// for(i=0;i<12000;i++)
for(i=0;i<1200;i++)
{
yaffs_lseek(f,0,SEEK_SET);
yaffs_read(f,buffer,50);
memset(buffer,i%255,2048);
size=yaffs_lseek(f,0,SEEK_END);
// ret=yaffs_write(f,buffer,2048);
ret=yaffs_write(f,buffer,100);
// printf("the result write = %d,No.%d\n",ret,i);
yaffs_lseek(f,0,SEEK_SET);
yaffs_read(f,buffer,50);
}
#endif
yaffs_lseek(f,0,SEEK_SET);
size=yaffs_lseek(f,0,SEEK_END);
yaffs_close(f);
printf("the length of file =%d,it should be %d\n",size,i*2048);
ListDir("/mnt/mtdblock");
// yaffs_unlink("/c/data1/bigfile");
// ListDir("/c/data1");
#else
for(i=0;i<Nfile;i++)
{
sprintf(file,"/c/data0/file%d",i);
printf("will open file %s\n",file);
// fd[i] = yaffs_open(file, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
fd[i] = yaffs_open(file, O_CREAT | O_RDWR , S_IREAD | S_IWRITE);
// printf("**************fd[%d]=%d\n",i,fd[i]);
memset(buffer,0x5b+i,2048);
#if 1
size=yaffs_lseek(fd[i],0,SEEK_END);
ret=yaffs_write(fd[i],buffer,2048);
printf("the result of yaffs write file %s = %d\n",file,ret);
/* for(j=0;j<2;j++)
{
printf("buffer[%i]=%x\n",j,buffer[j]);
}*/
yaffs_lseek(fd[i],0,SEEK_SET);
#endif
size=yaffs_lseek(fd[i],0,SEEK_END);
printf("the length of file %s=%d\n",file,size);
yaffs_lseek(fd[i],-2048,SEEK_END);
#if 1
memset(buf,0,2048);
ret=yaffs_read(fd[i],buf,2048);
printf("the result of yaffs read file %s ==%d\n",file,ret);
/*
for(j=0;j<2;j++)
{
printf("buf[%i]=%x\n",j,buf[j]);
} */
ret=memcmp(buffer,buf,2048);
printf("the result of compare read*write file %s = %d\n",file,ret);
#endif
// yaffs_close(fd[i]);
}
#endif
#endif
#if 0
yaffs_mkdir("/c/mydoc", 0);
yaffs_mkdir("/d/data0", 0);
yaffs_mkdir("/d/data1", 0);
f = yaffs_open("/d/data0/file1.gsk", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
yaffs_close(f);
f = yaffs_open("/d/data0/file2.gsk", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);
yaffs_close(f);
#endif
// yaffs_unlink("/d/data0/file1");
// ListDir("/d/data0");
}
