/*
** ./tfs_analyze [name]
** Permet d'obtenir les informations d'un disque.
** Taille, nombre de partitions, taille de chaque partition...
*/
int main(int argc, char *argv[]) {
if(argc!=1 && argc!=2) {
fprintf(stderr, "Nombre d'arguments incorrect (%d).\n", argc);
fprintf(stderr, "./tfs_analyze [name]\n");
return 1;
}
disk_id id;
char *name;
name = ((argc==2)?argv[1]:"disk.tfs");
if(start_disk(name, &id).error_id==1) {
fprintf(stderr, "Erreur lors du démarrage du disque.\n");
return 1;
}
printf("--- Démarrage du disque. ---\n");
block b;
b.block_block = malloc(1024);
if(read_block(id, b, 0).error_id==1) {
stop_disk(id);
fprintf(stderr, "Erreur lors de la lecture du block.\n");
return 1;
}
uint32_t size = read_inblock(0,b);
uint32_t nb_part = read_inblock(1,b);
printf("Lecture des informations.\n");
printf(" > Nom du disque : %s\n", name);
printf(" > Nombre de blocks : %d\n", size);
printf(" > Nombre de Partitions : %d\n", nb_part);
if(nb_part>0) {
uint32_t i = 0;
for(i=0; i<nb_part; i++) {
printf(" > Partition %d : %d blocks\n", i, read_inblock(i+2,b));
block desc_b;
desc_b.block_block = malloc(1024);
if(read_block(id, desc_b, get_description_block(b,i+1)).error_id==1) {
stop_disk(id);
fprintf(stderr, "Erreur lors de la lecture d'un block de description.\n");
return 1;
}
if(read_inblock(0,desc_b)>0) {
printf(" > La partition est formatee.\n");
}
else {
printf(" > La partition n'est pas formatee.\n");
}
}
}
printf("Lecture terminée.\n");
if(stop_disk(id).error_id==1) {
fprintf(stderr, "Erreur lors de l'arrêt du disque.\n");
return 1;
}
else {
printf("--- Arrêt du disque. ---\n");
}
return 0;
}
int main(int argc, char **argv)
{
FILE* file;
error err;
disk_id disk;
block bk;
char* name;
if(argc < 1 || argc > 2)
{
fprintf(stderr, ERROR_TFS_ANALYSE);
fprintf(stderr, ERROR_NUMBBER_ARGUMENT);
exit(EXIT_FAILURE);
}
name = argc == 2 ? argv[1] : "disk.tfs";
while(access(name, F_OK) == -1)
{
printf("%s no exists, new disk name :\n", name);
scanf("%s", name);
}
if((err = start_disk(name, &disk)).flag == FLAG_ERROR)
{
fprintf(stderr, err.desc);
exit(EXIT_FAILURE);
}
memset(bk.desc, uint32_to_little_endian(0), TTTFS_VOLUME_BLOCK_SIZE);
if((err = read_block(disk, &bk, 0)).flag == FLAG_ERROR)
{
fprintf(stderr, err.desc);
if((err = stop_disk(disk)).flag == FLAG_ERROR)
fprintf(stderr, err.desc);
exit(EXIT_FAILURE);
}
display(disk, bk);
if((err = stop_disk(disk)).flag == FLAG_ERROR)
{
fprintf(stderr, err.desc);
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
/**
*\fn int main(int argc, char* argv[])
*\brief Command tfs_analyse Show a little description of a disk, the option -p is for a partition
*\param argc Integer represents strings number on argv
*\param argv Array of string
*\return Integer represents the result of the command
* */
int main(int argc, char* argv[]){
error e;
int i;
int used_space=0;
if(argc >= 2){
disk_id* disk = malloc(sizeof(disk_id));
e = start_disk(argv[argc-1],disk);
if(e.errnb!=-1){
switch(argc){
case 2 :
fprintf(stdout,"\n\t\t\t\t\tDisk Configuration : %s\n",argv[argc-1]);
if((*disk).nbPart>0){
fprintf(stdout,"Partition number : %d\n\n\tList of partitions : \n",(*disk).nbPart);
for(i=0; i<(*disk).nbPart;i++){
used_space += (*disk).tabPart[i].taille+1;
fprintf(stdout,"Partition %d : \t%dB\n",i,(*disk).tabPart[i].taille);
}
}
int free_space = (*disk).nbBlock - used_space;
fprintf(stdout,"\nDisk : %s\n\t\tBlocks number : %d\tUsed blocks : %d\t\tFree blocks : %d\n",argv[argc-1],(*disk).nbBlock,used_space,free_space);
break;
case 4 :
if(strcmp(argv[1],"-p")==0){
int pnum = atoi(argv[argc-2]);
if((*disk).nbPart>0 && pnum<(*disk).nbPart && pnum>-1 ){
fprintf(stdout,"\n\t\t\t\t\tPartition %d Configuration on %s : \n",pnum,argv[argc-1]);
Part p = (*disk).tabPart[pnum];
fprintf(stdout,"Size of partition : %d B\n\n",p.taille);
fprintf(stdout,"\tNumber of the description block of the partition on disk : Block N° %d\n\n",p.num_first_block);
fprintf(stdout,"\tSize of free blocks in partition : %dB\n\n",p.free_block_count);
fprintf(stdout,"\tNumber of the first free block in the partition : Block N° %d\n\n",p.first_free_block);
fprintf(stdout,"\t\tSize of the files Table in partiton : %dB\n",p.file_table_size);
fprintf(stdout,"\t\tMaximum number of file in partition : %d\n",p.max_file_count);
fprintf(stdout,"\t\tNumber of free file in partition : %d\n",p.free_file_count);
fprintf(stdout,"\t\tNumber of the first free file in partition : %d\n\n",p.first_free_file);
}
}else{
fprintf(stderr,"tfs_analyse : Wrong arguments for partition option. Do you mean -p instead of %s\n",argv[1]);
exit(-1);
}
break;
}
stop_disk(*disk);
exit(0);
}else{
exit(-1);
}
}else{
fprintf(stderr,"tfs_analyse : Wrong arguments number\n");
exit(-1);
}
}
int main(int argc, char* argv[])
{
char* nom;
int npartition = 0;
int i;
if(argc < 3)
{
fprintf(stderr, "Erreur: le nombre d'argument est invalide \n");
exit(-1);
}
for(i=1;i<argc-1;i++)
{
if(!strcmp(argv[i], "-p"))
{
if(atoi(argv[i+1]) ==0)
{
fprintf(stderr, "Erreur: L'argument -p doit être suivi par un nombre\n");
exit(-1);
}
npartition++;
}
}
int partition[npartition];
//printf("npar = %d \n", npartition);
int k=0;
for(i=1;i<argc-1;i++)
{
if(!strcmp(argv[i], "-p"))
{
if(!atoi(argv[i+1]) || atoi(argv[i+1]) < 0)
{
fprintf(stderr, "Erreur: L'argument -p doit être suivi par un nombre positif \n");
exit(-1);
}
partition[k] = atoi(argv[i+1]);
k++;
}
}
for(i = 0; i<npartition;i++)
{
if(partition[i] < 0)
{
fprintf(stderr, "Erreur: La taille des partitions ne peut pas être négative\n");
exit(-1);
}
}
if(atoi(argv[argc-1]) == 0) // Si le dernier argument n'est pas un nombre alors on a donné le nom du disque
{ // en parametre
nom = argv[argc-1];
}
else
{
nom = "disk.tfs";
}
/*
d = malloc(sizeof(disk_id_s));
b = malloc(BLOCK_SIZE);
f = malloc(BLOCK_SIZE);
printf("%d", size);
strncpy(f,toLittleEndian(size),4);
if(argc == 4)
nom = argv[3];
else
nom = "disk.tfs";
start_disk(nom, &d);
write_block(d, b, size-1);
write_block(d, f, 0);
printf("Creation du disque %s de taille %d blocs (%d octets) \n", nom, size, size*BLOCK_SIZE);*/
int offset = 4;
disk_id d;
d=malloc(sizeof(disk_id_s));
block first_block = malloc(1024);
char* n_little = toLittleEndian(npartition);
//printf("%s", nom);
start_disk(nom, &d);
read_block(d, first_block, 0);
int tmp = 0;
for(i=0;i<npartition;i++)
{
tmp+= partition[i];
}
char* sub = blocksub(first_block,0);
int taille_disk = data_to_int(sub, 4);
//printf("-> %d\n", taille_disk);
if(tmp > taille_disk-1)
{
fprintf(stderr, "Erreur: La taille totale des partitions dépasse la taille du disque \n");
exit(-1);
}
ajouter_infos(first_block,offset,n_little, sizeof(n_little));
offset += 4;
write_block(d, first_block,0);
for(i = 0; i<npartition;i++)
{
printf("Creation de la partition : %d de taille %d bloc(s)\n", i, partition[i]);
char* p = toLittleEndian(partition[i]);
ajouter_infos(first_block,offset,p, sizeof(p));
offset +=4;
}
stop_disk(d);
return 0;
}
int main(int argc, char *argv[]) {
if (argc > 2 && strcmp(argv[1], "-s") == 0) {
int size;
int valReturn = sscanf(argv[2], "%d", &size);
if (valReturn != 1 || size < 2) {
fprintf(stderr, "tfs_create -s need 1 argument :"
" the size enter : %d is not CORRECT \n", size);
return 1;
} else {
error er;
disk_id *disk = malloc(sizeof(*disk));
if(disk==NULL){
er.val=1;
er.message="ERROR MALLOC DISK in TFS_CREATE";
testerror(er);
}
char* nameFile;
if (argc > 3) { //the user give a name to the file
nameFile = argv[3];
} else {
nameFile = "disk.tfs";
}
er = createFile(nameFile);
testerror(er);
er = start_disk(nameFile, disk);
testerror(er);
int sizeInOctal = size * 1024;
/*
int i=0;
for(i; i<sizeInOctal;i++){
fputc(45,r);
}
ftruncate(fileno(r) sizeInOctal);
deplace le curseur a la position max-1
*/
fseek(disk->fichier, (sizeInOctal - 1), SEEK_CUR);
fputc(0, disk->fichier); //ecris un octet en position max
//Il faut reouvrir le fichier en mode binaire apres avoir fait un fputc
fseek(disk->fichier, 0, SEEK_CUR);
stop_disk(*disk);
er = start_disk(nameFile, disk);
testerror(er);
block *b;
b = initBlock();
free(b->valeur[0]);
b->valeur[0] = valueToNombre32bits(size);
//b->valeur[1] = valueToNombre32bits(1);// there is 1 partition at first
//b->valeur[2] = valueToNombre32bits(size-1);
er=write_block(*disk, *b, 0);
testerror(er);
/*
read_block(*disk,*b,0);
printf("dans fonction afficahge de block apres read\n");
printBlock(b);
*/
er=stop_disk(*disk);
testerror(er);
freeBlock(b);
freeDisk(disk);
return 0;
}
} else {
fprintf(stderr,
"tfs_create need at minimum 1 argument :\n -s "
"follow by the size ( a POSITIVE NUMBER)of "
"the new tfs\n [name] is optional, it is the name of the tfs\n");
return 1;
}
return 0;
}
/**
*\fn main(int argc, char *argv[]){
*\brief on initialise une partition, c'est a dire on remplie son premier block avec toutes les informations nécessaires, puis on construit le file table, avec le chainage des fichiers libres, puis on construit le dossier racine(on ajoute aussi son entrée dans la table des fichiers), et enfin on initialise le chainage des blocks libres.
**/
int main(int argc, char *argv[]){
int i; // i pour les for
if(argc==6){
if(strcmp(argv[1], "-p")==0){
if(strcmp(argv[3], "-mf")==0){
disk_id *id=malloc(sizeof(disk_id));
error err = start_disk(argv[argc-1], id);
if(err.errnb==0){
int partition =atoi(argv[2]); //la première partition à l'id 0
if(0<=partition && partition<=id->nbPart){
int file_count=atoi(argv[4]);
int taille=id->tabPart[partition].taille;
int taille_descripteur=((file_count-1)/16)+1;
if(0<file_count && taille>(1+taille_descripteur+file_count)){ //on vérifie qu'il y a bien assez de blocs dans la partition pour y mettre file_count fichiers.
//tout les tests sont faits, on commence a initialiser le premier bloc de la partition.
block b;
int l;
for(l=0;l<1024;l++){
b.buff[l]='\0';
}
fill_block(&b, MAGIC_NUMBER, 0);
fill_block(&b, SIZEBLOCK, 4);
fill_block(&b, taille, 8);
fill_block(&b,taille-2-taille_descripteur , 12);
fill_block(&b, taille_descripteur+2, 16);
fill_block(&b, file_count, 20);
fill_block(&b, file_count-1, 24);
fill_block(&b,1, 28); //Il y a un fichier 0, le dossier racine.
//trouver l'indice du premier block de la partition.
uint32_t id_first=1;
for(i=0;i<partition; i++){
id_first+=id->tabPart[i].taille;
}
write_block(*id, b,int_to_little(id_first));
//initialisation file table
block file_table;
int k;
for(k=0;k<1024;k++){
file_table.buff[k]='\0';
}
printf("1 %d \n", taille_descripteur);
printf("2 %d \n", id_first);
for(i=1; i<=taille_descripteur; i++){
if(i==1){
fill_block(&file_table, 64, 0);
fill_block(&file_table, 1, 4);
fill_block(&file_table, 0, 8);
fill_block(&file_table, taille_descripteur+1, 12);
}else{
fill_block(&file_table, 16*(i-1)+1, 60);
}
int j;
for(j=1; j<=15; j++){
if((16*(i-1)+j)<file_count){
fill_block(&file_table, (i-1)*16+j+1, j*64+60);
}else{
if(16*(i-1)+j==file_count){
fill_block(&file_table, (i-1)*16+j, j*64+60);
}
}
}
write_physical_block(*id, file_table,i+id_first);
for(k=0;k<1024;k++){
file_table.buff[k]='\0';
}
}
//initialisation du dossier racine
block racine;
for(k=0;k<1024;k++){
racine.buff[k]='\0';
}
fill_block(&racine,0,0);
racine.buff[4]='.';
racine.buff[5]='0';
fill_block(&racine,0,32);
racine.buff[36]='.';
racine.buff[37]='.';
racine.buff[38]='0';
write_block(*id, racine,int_to_little(id_first+taille_descripteur+1));
//initialisation des blocs restants (chainage)
block reste;
for(i= taille_descripteur+2; i<taille;i++){
int k;
for(k=0;k<1024;k++){
reste.buff[k]='\0';
}
if(i!=(taille-1)){
fill_block(&reste,i+1, 1020);
} else{
fill_block(&reste,i, 1020);
}
write_block(*id, reste,int_to_little(id_first+i));
fill_block(&reste,0, 1020);
}
}else{
printf("tfs format : wrong arguments, too much files : %d \n", file_count);
}
}else{
printf("tfs format : wrong arguments, no partition %d \n", partition);
}
}
stop_disk(*id);
}else{
printf("tfs format : wrong arguments, miss -mf \n");
}
}else{
printf("tfs format : wrong arguments, miss -p \n");
}
}else{
printf("tfs format : wrong arguments number %d \n", (argc-1));
}
return 0;
}
