fs/fdos/subdir.c - uboot/mindspeed - Git at Google

 /*
  * (C) Copyright 2002
  * Stäubli Faverges - <www.staubli.com>
  * Pierre AUBERT  p.aubert@staubli.com
  *
  * See file CREDITS for list of people who contributed to this
  * project.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  */

 #include <common.h>
 #include <config.h>
 #include <malloc.h>

 #if (CONFIG_COMMANDS & CFG_CMD_FDOS)

 #include "dos.h"
 #include "fdos.h"

 static int cache_sect;
 static unsigned char cache [SZ_STD_SECTOR];


 #define min(x,y) ((x)<(y)?(x):(y))

 static int descend (Slot_t *parent,
 	     Fs_t *fs,
 		    char *path);

 /*-----------------------------------------------------------------------------
  * init_subdir --
  *-----------------------------------------------------------------------------
  */
 void init_subdir (void)
 {
     cache_sect = -1;
 }
 /*-----------------------------------------------------------------------------
  * basename --
  *-----------------------------------------------------------------------------
  */
 char *basename (char *name)
 {
     register char *cptr;

     if (!name || !*name) {
 	return ("");
     }

     for (cptr= name; *cptr++; );
     while (--cptr >= name) {
 	if (*cptr == '/')    {
 	    return (cptr + 1);
 	}
     }
     return(name);
 }
 /*-----------------------------------------------------------------------------
  * root_map --
  *-----------------------------------------------------------------------------
  */
 static int root_map (Fs_t *fs, Slot_t *file, int where, int *len)
 {
     *len = min (*len, fs -> dir_len * SZ_STD_SECTOR - where);
     if (*len < 0 ) {
 	*len = 0;
 	return (-1);
     }
     return fs -> dir_start * SZ_STD_SECTOR + where;
 }
 /*-----------------------------------------------------------------------------
  * normal_map --
  *-----------------------------------------------------------------------------
  */
 static int normal_map (Fs_t *fs, Slot_t *file, int where, int *len)
 {
     int offset;
     int NrClu;
     unsigned short RelCluNr;
     unsigned short CurCluNr;
     unsigned short NewCluNr;
     unsigned short AbsCluNr;
     int clus_size;

     clus_size = fs -> cluster_size * SZ_STD_SECTOR;
     offset = where % clus_size;

     *len = min (*len, file -> FileSize - where);

     if (*len < 0 ) {
 	*len = 0;
 	return (0);
     }

     if (file -> FirstAbsCluNr < 2){
 	*len = 0;
 	return (0);
     }

     RelCluNr = where / clus_size;

     if (RelCluNr >= file -> PreviousRelCluNr){
 	CurCluNr = file -> PreviousRelCluNr;
 	AbsCluNr = file -> PreviousAbsCluNr;
     } else {
 	CurCluNr = 0;
 	AbsCluNr = file -> FirstAbsCluNr;
     }


     NrClu = (offset + *len - 1) / clus_size;
     while (CurCluNr <= RelCluNr + NrClu) {
 	if (CurCluNr == RelCluNr){
 	    /* we have reached the beginning of our zone. Save
 	     * coordinates */
 	    file -> PreviousRelCluNr = RelCluNr;
 	    file -> PreviousAbsCluNr = AbsCluNr;
 	}
 	NewCluNr = fat_decode (fs, AbsCluNr);
 	if (NewCluNr == 1 || NewCluNr == 0) {
 	    PRINTF("Fat problem while decoding %d %x\n",
 		    AbsCluNr, NewCluNr);
 	    return (-1);
 	}
 	if (CurCluNr == RelCluNr + NrClu) {
 	    break;
 	}

 	if (CurCluNr < RelCluNr && NewCluNr == FAT12_END) {
 	    *len = 0;
 	    return 0;
 	}

 	if (CurCluNr >= RelCluNr && NewCluNr != AbsCluNr + 1)
 	    break;
 	CurCluNr++;
 	AbsCluNr = NewCluNr;
     }

     *len = min (*len, (1 + CurCluNr - RelCluNr) * clus_size - offset);

     return (((file -> PreviousAbsCluNr - 2) * fs -> cluster_size +
 	     fs -> dir_start + fs -> dir_len) *
 	    SZ_STD_SECTOR + offset);
 }
 /*-----------------------------------------------------------------------------
  * open_subdir -- open the subdir containing the file
  *-----------------------------------------------------------------------------
  */
 int open_subdir (File_t *desc)
 {
     char *pathname;
     char *tmp, *s, *path;
     char terminator;

     if ((pathname = (char *)malloc (MAX_PATH)) == NULL) {
 	return (-1);
     }

     strcpy (pathname, desc -> name);

     /* Suppress file name                                                    */
     tmp = basename (pathname);
     *tmp = '\0';

     /* root directory  init                                                  */
     desc -> subdir.FirstAbsCluNr = 0;
     desc -> subdir.FileSize = -1;
     desc -> subdir.map = root_map;
     desc -> subdir.dir.attr = ATTR_DIRECTORY;

     tmp = pathname;
     for (s = tmp; ; ++s) {
 	if (*s == '/' || *s == '\0') {
 	    path = tmp;
 	    terminator = *s;
 	    *s = '\0';
 	    if (s != tmp && strcmp (path,".")) {
 		if (descend (&desc -> subdir, desc -> fs, path) < 0) {
 		    free (pathname);
 		    return (-1);
 		}
 	    }
 	    if (terminator == 0) {
 		break;
 	    }
 	    tmp = s + 1;
 	}
     }
     free (pathname);
     return (0);
 }
 /*-----------------------------------------------------------------------------
  * descend --
  *-----------------------------------------------------------------------------
  */
 static int descend (Slot_t *parent,
 	     Fs_t *fs,
 	     char *path)
 {
     int entry;
     Slot_t SubDir;

     if(path[0] == '\0' || strcmp (path, ".") == 0) {
 	return (0);
     }


     entry = 0;
     if (vfat_lookup (parent,
 		     fs,
 		     &(SubDir.dir),
 		     &entry,
 		     0,
 		     path,
 		     ACCEPT_DIR | SINGLE | DO_OPEN,
 		     0,
 		     &SubDir) == 0) {
 	*parent = SubDir;
 	return (0);
     }

     if (strcmp(path, "..") == 0) {
 	parent -> FileSize = -1;
 	parent -> FirstAbsCluNr = 0;
 	parent -> map = root_map;
 	return (0);
     }
     return (-1);
 }
 /*-----------------------------------------------------------------------------
  * open_file --
  *-----------------------------------------------------------------------------
  */
 int open_file (Slot_t *file, Directory_t *dir)
 {
     int first;
     unsigned long size;

     first = __le16_to_cpu (dir -> start);

     if(first == 0 &&
        (dir -> attr & ATTR_DIRECTORY) != 0) {
 	file -> FirstAbsCluNr = 0;
 	file -> FileSize = -1;
 	file -> map = root_map;
 	return (0);
     }

     if ((dir -> attr & ATTR_DIRECTORY) != 0) {
 	size = (1UL << 31) - 1;
     }
     else {
 	size = __le32_to_cpu (dir -> size);
     }

     file -> map = normal_map;
     file -> FirstAbsCluNr = first;
     file -> PreviousRelCluNr = 0xffff;
     file -> FileSize = size;
     return (0);
 }
 /*-----------------------------------------------------------------------------
  * read_file --
  *-----------------------------------------------------------------------------
  */
 int read_file (Fs_t *fs,
 	       Slot_t *file,
 	       char *buf,
 	       int where,
 	       int len)
 {
     int pos;
     int read, nb, sect, offset;

     pos = file -> map (fs, file, where, &len);
     if  (pos < 0) {
 	return -1;
     }
     if (len == 0) {
 	return (0);
     }

     /* Compute sector number                                                 */
     sect = pos / SZ_STD_SECTOR;
     offset = pos % SZ_STD_SECTOR;
     read = 0;

     if (offset) {
 	/* Read doesn't start at the sector beginning. We need to use our    */
 	/* cache                                                             */
 	if (sect != cache_sect) {
 	    if (dev_read (cache, sect, 1) < 0) {
 		return (-1);
 	    }
 	    cache_sect = sect;
 	}
 	nb = min (len, SZ_STD_SECTOR - offset);

 	memcpy (buf, cache + offset, nb);
 	read += nb;
 	len -= nb;
 	sect += 1;
     }

     if (len > SZ_STD_SECTOR) {
 	nb = (len - 1) / SZ_STD_SECTOR;
 	if (dev_read (buf + read, sect, nb) < 0) {
 	    return ((read) ? read : -1);
 	}
 	/* update sector position                                            */
 	sect += nb;

 	/* Update byte position                                              */
 	nb *= SZ_STD_SECTOR;
 	read += nb;
 	len -= nb;
     }

     if (len) {
 	if (sect != cache_sect) {
 	    if (dev_read (cache, sect, 1) < 0) {
 		return ((read) ? read : -1);
 		cache_sect = -1;
 	    }
 	    cache_sect = sect;
 	}

 	memcpy (buf + read, cache, len);
 	read += len;
     }
     return (read);
 }
 #endif
	/*
	* (C) Copyright 2002
	* Stäubli Faverges - <www.staubli.com>
	* Pierre AUBERT p.aubert@staubli.com
	*
	* See file CREDITS for list of people who contributed to this
	* project.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License as
	* published by the Free Software Foundation; either version 2 of
	* the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	* MA 02111-1307 USA
	*/

	#include <common.h>
	#include <config.h>
	#include <malloc.h>

	#if (CONFIG_COMMANDS & CFG_CMD_FDOS)

	#include "dos.h"
	#include "fdos.h"

	static int cache_sect;
	static unsigned char cache [SZ_STD_SECTOR];


	#define min(x,y) ((x)<(y)?(x):(y))

	static int descend (Slot_t *parent,
	Fs_t *fs,
	char *path);

	/*-----------------------------------------------------------------------------
	* init_subdir --
	*-----------------------------------------------------------------------------
	*/
	void init_subdir (void)
	{
	cache_sect = -1;
	}
	/*-----------------------------------------------------------------------------
	* basename --
	*-----------------------------------------------------------------------------
	*/
	char basename (char name)
	{
	register char *cptr;

	if (!name \|\| !*name) {
	return ("");
	}

	for (cptr= name; *cptr++; );
	while (--cptr >= name) {
	if (*cptr == '/') {
	return (cptr + 1);
	}
	}
	return(name);
	}
	/*-----------------------------------------------------------------------------
	* root_map --
	*-----------------------------------------------------------------------------
	*/
	static int root_map (Fs_t fs, Slot_t file, int where, int *len)
	{
	len = min (len, fs -> dir_len * SZ_STD_SECTOR - where);
	if (*len < 0 ) {
	*len = 0;
	return (-1);
	}
	return fs -> dir_start * SZ_STD_SECTOR + where;
	}
	/*-----------------------------------------------------------------------------
	* normal_map --
	*-----------------------------------------------------------------------------
	*/
	static int normal_map (Fs_t fs, Slot_t file, int where, int *len)
	{
	int offset;
	int NrClu;
	unsigned short RelCluNr;
	unsigned short CurCluNr;
	unsigned short NewCluNr;
	unsigned short AbsCluNr;
	int clus_size;

	clus_size = fs -> cluster_size * SZ_STD_SECTOR;
	offset = where % clus_size;

	len = min (len, file -> FileSize - where);

	if (*len < 0 ) {
	*len = 0;
	return (0);
	}

	if (file -> FirstAbsCluNr < 2){
	*len = 0;
	return (0);
	}

	RelCluNr = where / clus_size;

	if (RelCluNr >= file -> PreviousRelCluNr){
	CurCluNr = file -> PreviousRelCluNr;
	AbsCluNr = file -> PreviousAbsCluNr;
	} else {
	CurCluNr = 0;
	AbsCluNr = file -> FirstAbsCluNr;
	}


	NrClu = (offset + *len - 1) / clus_size;
	while (CurCluNr <= RelCluNr + NrClu) {
	if (CurCluNr == RelCluNr){
	/* we have reached the beginning of our zone. Save
	* coordinates */
	file -> PreviousRelCluNr = RelCluNr;
	file -> PreviousAbsCluNr = AbsCluNr;
	}
	NewCluNr = fat_decode (fs, AbsCluNr);
	if (NewCluNr == 1 \|\| NewCluNr == 0) {
	PRINTF("Fat problem while decoding %d %x\n",
	AbsCluNr, NewCluNr);
	return (-1);
	}
	if (CurCluNr == RelCluNr + NrClu) {
	break;
	}

	if (CurCluNr < RelCluNr && NewCluNr == FAT12_END) {
	*len = 0;
	return 0;
	}

	if (CurCluNr >= RelCluNr && NewCluNr != AbsCluNr + 1)
	break;
	CurCluNr++;
	AbsCluNr = NewCluNr;
	}

	len = min (len, (1 + CurCluNr - RelCluNr) * clus_size - offset);

	return (((file -> PreviousAbsCluNr - 2) * fs -> cluster_size +
	fs -> dir_start + fs -> dir_len) *
	SZ_STD_SECTOR + offset);
	}
	/*-----------------------------------------------------------------------------
	* open_subdir -- open the subdir containing the file
	*-----------------------------------------------------------------------------
	*/
	int open_subdir (File_t *desc)
	{
	char *pathname;
	char tmp, s, *path;
	char terminator;

	if ((pathname = (char *)malloc (MAX_PATH)) == NULL) {
	return (-1);
	}

	strcpy (pathname, desc -> name);

	/* Suppress file name */
	tmp = basename (pathname);
	*tmp = '\0';

	/* root directory init */
	desc -> subdir.FirstAbsCluNr = 0;
	desc -> subdir.FileSize = -1;
	desc -> subdir.map = root_map;
	desc -> subdir.dir.attr = ATTR_DIRECTORY;

	tmp = pathname;
	for (s = tmp; ; ++s) {
	if (s == '/' \|\| s == '\0') {
	path = tmp;
	terminator = *s;
	*s = '\0';
	if (s != tmp && strcmp (path,".")) {
	if (descend (&desc -> subdir, desc -> fs, path) < 0) {
	free (pathname);
	return (-1);
	}
	}
	if (terminator == 0) {
	break;
	}
	tmp = s + 1;
	}
	}
	free (pathname);
	return (0);
	}
	/*-----------------------------------------------------------------------------
	* descend --
	*-----------------------------------------------------------------------------
	*/
	static int descend (Slot_t *parent,
	Fs_t *fs,
	char *path)
	{
	int entry;
	Slot_t SubDir;

	if(path[0] == '\0' \|\| strcmp (path, ".") == 0) {
	return (0);
	}


	entry = 0;
	if (vfat_lookup (parent,
	fs,
	&(SubDir.dir),
	&entry,
	0,
	path,
	ACCEPT_DIR \| SINGLE \| DO_OPEN,
	0,
	&SubDir) == 0) {
	*parent = SubDir;
	return (0);
	}

	if (strcmp(path, "..") == 0) {
	parent -> FileSize = -1;
	parent -> FirstAbsCluNr = 0;
	parent -> map = root_map;
	return (0);
	}
	return (-1);
	}
	/*-----------------------------------------------------------------------------
	* open_file --
	*-----------------------------------------------------------------------------
	*/
	int open_file (Slot_t file, Directory_t dir)
	{
	int first;
	unsigned long size;

	first = __le16_to_cpu (dir -> start);

	if(first == 0 &&
	(dir -> attr & ATTR_DIRECTORY) != 0) {
	file -> FirstAbsCluNr = 0;
	file -> FileSize = -1;
	file -> map = root_map;
	return (0);
	}

	if ((dir -> attr & ATTR_DIRECTORY) != 0) {
	size = (1UL << 31) - 1;
	}
	else {
	size = __le32_to_cpu (dir -> size);
	}

	file -> map = normal_map;
	file -> FirstAbsCluNr = first;
	file -> PreviousRelCluNr = 0xffff;
	file -> FileSize = size;
	return (0);
	}
	/*-----------------------------------------------------------------------------
	* read_file --
	*-----------------------------------------------------------------------------
	*/
	int read_file (Fs_t *fs,
	Slot_t *file,
	char *buf,
	int where,
	int len)
	{
	int pos;
	int read, nb, sect, offset;

	pos = file -> map (fs, file, where, &len);
	if (pos < 0) {
	return -1;
	}
	if (len == 0) {
	return (0);
	}

	/* Compute sector number */
	sect = pos / SZ_STD_SECTOR;
	offset = pos % SZ_STD_SECTOR;
	read = 0;

	if (offset) {
	/* Read doesn't start at the sector beginning. We need to use our */
	/* cache */
	if (sect != cache_sect) {
	if (dev_read (cache, sect, 1) < 0) {
	return (-1);
	}
	cache_sect = sect;
	}
	nb = min (len, SZ_STD_SECTOR - offset);

	memcpy (buf, cache + offset, nb);
	read += nb;
	len -= nb;
	sect += 1;
	}

	if (len > SZ_STD_SECTOR) {
	nb = (len - 1) / SZ_STD_SECTOR;
	if (dev_read (buf + read, sect, nb) < 0) {
	return ((read) ? read : -1);
	}
	/* update sector position */
	sect += nb;

	/* Update byte position */
	nb *= SZ_STD_SECTOR;
	read += nb;
	len -= nb;
	}

	if (len) {
	if (sect != cache_sect) {
	if (dev_read (cache, sect, 1) < 0) {
	return ((read) ? read : -1);
	cache_sect = -1;
	}
	cache_sect = sect;
	}

	memcpy (buf + read, cache, len);
	read += len;
	}
	return (read);
	}
	#endif