Riferimenti per il file open_fat.h

Creazione di un file. Continua...

#include "fat.h"

Vai al codice sorgente di questo file.

Funzioni

int fat_open (FILE *fs, struct fat_ctrl *f_ctrl, char *path)

Descrizione dettagliata

Creazione di un file.

Autore:
lcs07

Definizione nel file open_fat.h.


Documentazione delle funzioni

int fat_open ( FILE *  fs,
struct fat_ctrl f_ctrl,
char *  path 
)

Questa funzione ha il compito di creare un nuovo file all'interno del filesystem SFAT. Il nome del file F viene espresso tramite un pathname assoluto come ad esempio /dir/name/fileName in cui il nome del file F e' specificato dall'ultimo elemento del pathname (fileNmae) e la directrory D in cui deve essere creato il file e' specificata dalla prima parte del pathname (/dir/name ). In particolare questa funzione deve:

  • Separare il nome del file dal path che specifica la directory D dove il file deve essere generato.
  • Controllare che la directory D esista, ossia che il pathname sia corretto.
  • Controllare che il file F non sia gia' esistente.
  • Determinare la directory table di D.
  • Determinare in D una entry libera in cui inserire le informazioni relative al file F che deve essere generato. Puo' risultare necessario aggiungere un nuovo blocco alla directory table D.
  • Selezionare un blocco libero B che conterra' il primo byte del file F.
  • Preparare i dati da inserire nella entry che includono:
    • used valorizzata a DIR_ENTRY_BUSY.
    • name valorizzato al nome del file F.
    • attr valorizzato a FILE_ENTRY.
    • index valorizzato all'indice del blocco B che contiene il primo byte del file.
    • len valorizzato a 0 (alla creazione il file e' vuoto).
Parametri:
fs il FILE pointer che consente di acceddre al file dove il filesystem e' memorizzato.
f_ctrl puntatore alla struttura che mantiene tutte le informazioni di controllo del filesystem.
path la stringa che contiene il path assoluto del file che deve essere creato.
Restituisce:
  • EBDP (Error Bad Directory Path) se il path specificato non e' assoluto, ossia non inizia con il carattere '/'
  • ENTL (Error Name Too Long) uno degli elementi del pathname supera la lunghezza consentita (MAX_LEN_NAME).
  • ENSFD (Error Not Such File or Directory) se un elemento del pah non siste o non e' una directory.
  • ENMSD (Error No More Space on Device) se non ci sono piu' blocchi disponibili e quindi ci troviamo in una condizione di Filesystem Full.
  • ERFCD (Error Reading Fat Control Data) se si verifica un errore leggendo le strutture di controllo del filesystem Fat.
  • EWFCD (Error Writing Fat Control Data) se si verifica un errore durante la scrittura delle strutture di controllo del filesystem Fat.
  • 0 (zero) in caso di successo

Definizione alla linea 21 del file open_fat.c.

00021                                                            {
00022         struct dir_entry cart_p, file_new;
00023         char *basec, *bname;
00024         int ret_val=0;
00025         long fs_radice;
00026                 
00027         if (!(fs) || !(f_ctrl) || !(path)) return EBDP;
00028         if (!strcmp("/", path)) return EDAEX;
00029         /* a) Posizionamento nel filesystem, controllo del percoso ecc. */
00030         if ((ret_val = parsing(fs, f_ctrl, path, MKFILE))!=0) return ret_val;
00031 
00032         /* Reperisco il nome del file da creare */
00033         if (!(basec = strdup(path))) return STDLIBERR;
00034         bname = basename(basec);
00035         if (!strcmp(".", bname) || !strcmp("..", bname)){free(basec); return EDAEX;}
00036         
00037         fs_radice = ftell(fs);
00038         /* Leggo l'entry iniziale '.' della cartella corrente */
00039         if (!(fread(&cart_p, sizeof(struct dir_entry), 1, fs))){free(basec); return ERBD;}
00040 
00041         /* Queste due righe sottostanti vanno sempre insieme!! */
00042         fseek(fs, fs_radice, SEEK_SET);
00043         /* Controllo che il file non esista gia' */
00044         if ((ret_val = find(fs, f_ctrl, bname, MKFILE))!=0){free(basec); return ret_val;}
00045 
00046         file_new.attr = FILE_ENTRY;
00047         file_new.index= BLOCK_FREE;     /* Indice del blocco del nuovo file ?? */
00048         file_new.len = 0;
00049         memset(file_new.name, 0x0, MAX_LEN_NAME+1);
00050         strncpy(file_new.name,bname,MAX_LEN_NAME);
00051         file_new.used = DIR_ENTRY_BUSY;
00052         
00053         /* Scrivo l'entry del file che sto creando, nella sua cartella radice */
00054         if (!(fwrite(&file_new, sizeof(struct dir_entry), 1, fs))){free(basec); return EWFCD;}
00055         
00056         /* Devo incrementare il conteggio delle entry nella cartella che contiene
00057         il nuovo file che sto creando e scrivero' questo nuovo dato nel filesystem */
00058         fseek(fs, fs_radice, SEEK_SET);
00059         cart_p.len += sizeof(struct dir_entry);
00060         if (!(fwrite(&cart_p, sizeof(struct dir_entry), 1, fs))){free(basec); return ERBD;}
00061 
00062         /* Metto il puntatore fs all'inizio della FAT */
00063         fseek(fs, sizeof(struct boot_sector), SEEK_SET);        
00064         /* Scrittura dei nuovi dati della FAT nel file */
00065         if (!(fwrite(f_ctrl->fat_ptr, (f_ctrl->b_sector.num_block * sizeof(unsigned int)), 1, fs)))
00066                 ret_val = EWFCD;
00067         
00068         free(basec);            
00069         return ret_val;
00070 }

Generato il Fri Jan 28 22:16:31 2011 per SFAT: Simplified File Allocation Table Project da  doxygen 1.6.3