ffile.c

ATmega103、ATmega128做的开发板web server源码

  for (x=0;x<32;x++)                                                                       //
    EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+x, buffer[FILE_MST_DEALLOCATED_PTRS+x]); //
  
  /* Initialize FILE structs.*/
  for (x=0;x<FILE_MAX_OPEN_FILES;x++)
  { 
    file[x].file_id = 0;
    file[x].file_name[0] = '\0';
    file[x].file_ext[x] = '\0';
    file[x].count = 0;
    file[x].file_size = 0;
    file[x].status = FILE_READY;
    file[x].start_page = FILE_FNULL;
    file[x].end_page = FILE_FNULL;
  }
  
  directory.state = FILE_UNFILE_LOCKED;           //Initialize DIR struct.
  directory.fileNr = 0;
  directory.pageNr = 0;
  directory.dirEntry[0] = '\0';
  return 1;
}

/*fdelete deletes file by putting the page number of the
  file header into the deallocated_ptrs storage. The space
  is not freed before reclaim() is activated.*/
char ffdelete(char *file)
{
  unsigned int x, tmp;
  char i, buffer[42];
  char filen[12];
  char *fileext, *filename;
  
  strncpy(filen, file, 12);
  filename = strtok(filen, ".");
  fileext = strtok(NULL, " ");
  x = ffindFile(filename, fileext);                // Check if file exists.
  if (x == FILE_FNULL)
  {
    return 0;
  }
  for(i=0;i<16;i++)                               // Find a free space in deallocated_ptrs to store the page number.
  {
    tmp = EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*i);
    if (tmp == FILE_FNULL)
    {
      EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*i, (unsigned char)(x&0xff));
      EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*i+1, (unsigned char)((x>>8)&0xff));
      read_page(x, buffer, 41);
      tmp = buffer[FILE_NUM_PAGES_l] + buffer[FILE_NUM_PAGES_h]*256;
      x = EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_SPACE_l);
      x += tmp;
      EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_SPACE_l, (x&0xff));
      EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_SPACE_h, ((x>>8)&0xff));
      saveMST();
      if (i > 15)                                  // If there is 16 deallocated file, reclaim the space.
      {
        reclaim();
      }
      return (1);
    }
  }
  return(0);    
}

/*opendir opens the directory for reading*/
DIR *opendir(void)
{
  if (directory.state == FILE_UNFILE_LOCKED)
  {
    directory.state = FILE_LOCKED;
    directory.fileNr = 0;
    directory.pageNr = 0;
    return (DIR *)&directory;
  }
  return NULL;
}

/*Check if file is deleted. Returns 1 if it is deleted.*/
unsigned char deleted(unsigned int pageNr)
{
  unsigned char x;
  unsigned int page;
  
  for (x=0;x<16;x++)
  {
    page = EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*x);
    if (page == FILE_FNULL)
    {
      return 0;
    }
    else if (page == pageNr)
    {
      return 1;
    }
  }
  return 0;
}

/* readdir outputs one line of dir in reduced mode (only file name).*/
char *readdir(DIR *_dir)
{
  unsigned long fileSize;
  char buffer[30], tmp[9], tmp2[4];
  unsigned int pages, last;
  
  if ((_dir == NULL) || (_dir->state == FILE_UNFILE_LOCKED) || (_dir->pageNr == FILE_FNULL))
  {
    return NULL;
  }
  else 
  {
    last = EEgetInt(FILE_MST_BASE+FILE_MST_LAST_PAGE_l);
    
    /*do untill a file is found which is not deleted*/
    do {          
      read_page(_dir->pageNr, buffer, 30);
      pages = buffer[FILE_NUM_PAGES_l];
      pages += buffer[FILE_NUM_PAGES_h]*256;
      _dir->pageNr += pages;
    }while ( (deleted((_dir->pageNr-pages))) && (_dir->pageNr < last) && (pages != FILE_FNULL) );
    
    if ( (_dir->pageNr <= last) && (pages < FLASH_NUMBER_OF_PAGES) && !deleted(_dir->pageNr-pages)) 
    {
      fileSize = (buffer[FILE_SIZE_ll]&0xff);
      fileSize += ((buffer[FILE_SIZE_lh]<<8)&0xff00);
      fileSize += (unsigned long)((buffer[FILE_SIZE_hl])*0x10000);
      fileSize += (unsigned long)((buffer[FILE_SIZE_hh])*0x1000000);
      strncpy(tmp, &buffer[FILE_NAME], 8);
      tmp[8] = '\0';
      strncpy(tmp2, &buffer[FILE_EXT], 3);
      tmp2[3] = '\0';
      sprintf(_dir->dirEntry, "%s.%s\r\n\0", tmp, tmp2); //Output filename.
      _dir->fileNr++;
      if (_dir->pageNr >= last)
      {
        _dir->pageNr++;
      }
      return (_dir->dirEntry);
    }
    else 
    {
      _dir->pageNr = FILE_FNULL;
      return NULL;
    }
  }
}

/* readdir outputs one line of dir in extended mode (file name and file size).*/
char *readwdir(DIR *_dir)
{
  unsigned long fileSize;
  char buffer[30], tmp[9], tmp2[4], size[8];
  unsigned int pages, last;
  
  if ((_dir == NULL) || (_dir->state == FILE_UNFILE_LOCKED) || (_dir->pageNr == FILE_FNULL))
  {
    return NULL;
  }
  else 
  {
    last = EEgetInt(FILE_MST_BASE+FILE_MST_LAST_PAGE_l);
    do {
      read_page(_dir->pageNr, buffer, 30);
      pages = buffer[FILE_NUM_PAGES_l];
      pages += buffer[FILE_NUM_PAGES_h]*256;
      _dir->pageNr += pages;
    }while ( (deleted((_dir->pageNr-pages))) && (_dir->pageNr < last) && (pages != FILE_FNULL) );
    
    if ( (_dir->pageNr <= last) && (pages < FLASH_NUMBER_OF_PAGES) && !deleted(_dir->pageNr-pages)) 
    {
      fileSize = (buffer[FILE_SIZE_ll]&0xff);
      fileSize += ((buffer[FILE_SIZE_lh]<<8)&0xff00);
      fileSize += (unsigned long)((buffer[FILE_SIZE_hl])*0x10000);
      fileSize += (unsigned long)((buffer[FILE_SIZE_hh])*0x1000000);
      strncpy(tmp, &buffer[FILE_NAME], 8);
      tmp[8] = '\0';
      strncpy(tmp2, &buffer[FILE_EXT], 3);
      tmp2[3] = '\0';
      longToAscii(fileSize,size);      
      sprintf(_dir->dirEntry, "---------- 1 ews ews    %s  Jan  1 10:12 %s.%s \r\n\0", size, tmp, tmp2);
      _dir->fileNr++;                             //Formatting of output is tested on cuteFTP. Do not know how 
      if (_dir->pageNr >= last)                   //ftp clients parse directories.
      {
        _dir->pageNr++;
      }
      return (_dir->dirEntry);
    }
    else 
    {
      fileSize = (unsigned long)EEget(FILE_MST_BASE+FILE_MST_FREE_SPACE_l)*FLASH_PAGE_SIZE;
      fileSize += (unsigned long)EEget(FILE_MST_BASE+FILE_MST_FREE_SPACE_h)*256*FLASH_PAGE_SIZE;
      fileSize += (unsigned long)EEget(FILE_MST_BASE+FILE_MST_DEALLOCATED_SPACE_l)*FLASH_PAGE_SIZE;
      fileSize += (unsigned long)EEget(FILE_MST_BASE+FILE_MST_DEALLOCATED_SPACE_h)*256*FLASH_PAGE_SIZE;
      longToAscii(fileSize,buffer);
      sprintf(_dir->dirEntry, "Free space: %s\r\n", buffer);
      //sprintf(_dir->dirEntry, "Free space: %lu\r\n", fileSize);   //After last file is output, free space is output
      _dir->pageNr = FILE_FNULL;
      return (_dir->dirEntry);
    }
  }
}

/*rewinddir put the pointer to the first file.*/
void rewinddir(DIR *_dir)
{
  _dir->fileNr = 0;
  _dir->pageNr = 0;
}

/*closedir prepare DIR for new directory.*/
char closedir(DIR *_dir)
{
  if (_dir->state == FILE_UNFILE_LOCKED)
  {
    return (0);
  }
  else
  {
    _dir->state = FILE_UNFILE_LOCKED;
  }
  return (1);
}

/*saveMST can be removed after debug.
  It is only used to save the Media Status Table in case EEPROM is deleted.*/
void saveMST(void)
{
  char buffer[80],x;
  for (x=0;x<80;x++)
  {
    buffer[x] = EEget(FILE_MST_BASE+x);
  }
  write_page(1023, buffer);
}

/*reclaim frees deallocated files. Files after the deallocated space
  is moved so that all files are positioned after each other.*/
void reclaim(void)
{
  char x,i, buffer[80];
  unsigned int page, nextPage, list[16], offset, temp, lastPage;
  
  EEput(FILE_MST_BASE+FILE_MST_STATUS, FILE_RECLAIM);
  
  /*Sort the list of page pointers*/
  for (x=0;x<16;x++)     
  {  
    list[x] = EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*x);
  }

  for (x=0;x<4;x++)
  {
    for (i=0;i<4;i++)
    {
      if (list[2*i]>list[2*i+1])
      {
        temp = list[2*i];
        list[2*i] = list[2*i+1];
        list[2*i+1] = temp;
      }
    }
    for (i=0;i<3;i++)
    {
      if (list[2*i+1]>list[2*i+2])
      {
        temp = list[2*i+1];
        list[2*i+1] = list[2*i+2];
        list[2*i+2] = temp;
      }
    }
  }
  for (x=0;x<16;x++)
  {
    EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*x, list[x]&0xff);
    EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*x+1, (list[x]>>8)&0xff);
  }
  saveMST();                                      //Could be removed after debug.
  nextPage = 0;

  /*Here the list is sorted with the smallest page number first*/
  for (i=0;i<16;i++)
  {
    page = EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*i);
    if (page != FILE_FNULL)
    {
      read_page(page, buffer, 50);
      nextPage += (buffer[FILE_NUM_PAGES_l] + buffer[FILE_NUM_PAGES_h]*256);
      EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_PAGES+2*i, nextPage&0xff);
      EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_PAGES+2*i+1, ((nextPage>>8)&0xff));
    }
  }
  
/*Here offsets after each deleted file are computed.
  Example:   DEALLOCATED_PTRS          DEALLOCATED_PAGES
                    0                       5
                    20                      10
                    325                     40
                    355                     45
   This means: file starting at page 0 is deleted. Files after this file should be moved 5 pages forward.
               file starting at page 20 is deleted. Files after this file should be moved 10 pages forward.
               ......*/
  i=0;
  lastPage = EEgetInt(FILE_MST_BASE+FILE_MST_LAST_PAGE_l);
  if (lastWrittenPage > lastPage)
  {
    lastPage = lastWrittenPage;
  }
  page = EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*i);
  if (page != FILE_FNULL)
  {
    do 
    {
      nextPage = EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*(i+1));
      if (nextPage == FILE_FNULL)
      {
        nextPage = lastPage;
      }
      offset = (EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_PAGES+2*i));
      while( ((page+offset)<nextPage) )
      {
		copy_page(page+offset,page);
        page++;
      }
      i++;
    } while((page+offset)<lastPage);
    
  lastPage = EEgetInt(FILE_MST_BASE+FILE_MST_LAST_PAGE_l);
  EEput(FILE_MST_BASE+FILE_MST_LAST_PAGE_l, (lastPage-offset)&0xff);
  EEput(FILE_MST_BASE+FILE_MST_LAST_PAGE_h, ((lastPage-offset)>>8)&0xff);
  }
  
  /* Here all deallocated space is freed. */
  for (x=0;x<FILE_MAX_OPEN_FILES;x++)             //Must move page pointers in open files (in FILE struct).
  {  
    if (file[x].status != FILE_READY)
    {
      for (i=16;i>0;i--)
      {
        lastPage = EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+2*(i-1));
        if ( lastPage < file[x].start_page )
        {
          offset = EEgetInt(FILE_MST_BASE+FILE_MST_DEALLOCATED_PAGES+2*(i-1));
          file[x].start_page -= offset;
          file[x].end_page -= offset;
          break;
        }
      }
    }
  }
  
  /*Save new status in Media Status Table*/
  EEput(FILE_MST_BASE+FILE_MST_STATUS, FILE_OK);
  EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_SPACE_l, 0);
  EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_SPACE_h, 0);
  offset = FLASH_NUMBER_OF_PAGES-page;
  for(x=0;x<32;x++)
  {
    EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_PTRS+x, 0xff);
    EEput(FILE_MST_BASE+FILE_MST_DEALLOCATED_PAGES+x, 0xff);
  }
  EEput(FILE_MST_BASE+FILE_MST_FREE_SPACE_l, offset&0xff);
  EEput(FILE_MST_BASE+FILE_MST_FREE_SPACE_h, (offset>>8)&0xff);
  saveMST();                                      //Could be removed after debug.
}
 
/*converts a long to ASCII, the result is copied to buffer */
void longToAscii(unsigned long number,char * buffer)
{
  unsigned char i=0,temp;
  unsigned char leading0=1;
  unsigned long div;

  for (div=100000000;div>0;div=div/10)
  {
    temp = number/div;
    number -= temp*div;
    temp += 0x30;
    if (!(temp == 0x30 && leading0))
    {
      buffer[i++]=temp;
      leading0 = 0;
    }
  } 
  buffer[i]='\0';
}