Example #1
0
int		is_correct_syntax(const char *str, t_node **list, t_type *type)
{
	char	**split;
	int		ret;

	if ((ret = is_correct_syntax2(str, type)))
		return (ret);
	split = ft_strsplit(str, ' ');
	if (tablen(split) == 3 && !ft_contain(split[0], '-') &&
			!name_exist(*list, split[0]))
	{
		add_cell(list, split, *type);
		freetab(split);
		return (NODE);
	}
	else if (tablen(split) == 1)
		ret = is_correct_syntax3(str, split, list);
	if (ret == EDGE)
		return (ret);
	else
	{
		ft_putstr_fd("Syntax error : ", 2);
		ft_putendl_fd(str, 2);
	}
	freetab(split);
	return (FALSE);
}
Example #2
0
void crear_pl(char nombre[200], char path[200], int tamano, char fit,int unit){
    printf("-------------CREANDO PARTICION-------------\n");

    struct stat st = {0};
    if(stat(path,&st)==-1){
        printf("ERROR: el archivo especificado no existe.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        return;
    }

    FILE *disco;

    disco = fopen(path,"r+b");

    if(!disco){
        printf("ERROR: el Disco no ha podido Abrirse.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        return;
    }

    MBR leido;

    if(fread(&leido,sizeof(MBR),1,disco)!=1){
        printf("ERROR:al cargar la data del disco\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    int tamano_real;

    switch(unit){
        case 1:
            tamano_real=tamano*1024*1024;
            break;
        case 2:
            tamano_real=tamano*1024;
            break;
        case 3:
            tamano_real=tamano;
            break;
    }

    printf("-------------------DATOS-------------------\n");
    printf("Nombre: %s\nPath: %s\nTamano: %i\nFit: %c\nUnit: %i\nTipo: Logica\n",nombre,path,tamano_real,fit,unit);

    int parti = extendida_exist(leido);

    if(parti==0){
        printf("ERROR: no exite una particion extendida.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    if(name_exist(disco,leido,nombre)!=0){
        printf("ERROR: El nombre ya existe como particion.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    EBR leido2;
    int tamano_particion = 0;
    int inicio = 0;

    switch(parti){
        case 1:
            fseek(disco,leido.mbr_partition_1.part_start,SEEK_SET);
            tamano_particion=leido.mbr_partition_1.part_size;
            inicio = leido.mbr_partition_1.part_start;
            break;
        case 2:
            fseek(disco,leido.mbr_partition_2.part_start,SEEK_SET);
            tamano_particion=leido.mbr_partition_2.part_size;
            inicio = leido.mbr_partition_2.part_start;
            break;
        case 3:
            fseek(disco,leido.mbr_partition_3.part_start,SEEK_SET);
            tamano_particion=leido.mbr_partition_3.part_size;
            inicio = leido.mbr_partition_2.part_start;
            break;
        case 4:
            fseek(disco,leido.mbr_partition_4.part_start,SEEK_SET);
            tamano_particion=leido.mbr_partition_4.part_size;
            inicio = leido.mbr_partition_2.part_start;
            break;
    }

    if(fread(&leido2,sizeof(EBR),1,disco)!=1){
        printf("ERROR:al cargar la data del disco\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    int bandera = 1;
    int tamano_recorrido = (int)sizeof(EBR)+leido2.part_size;

    while(1){
        if(leido2.part_status=='n' && leido2.part_next==-1){
            if(tamano_real<=(tamano_particion-sizeof(EBR)-tamano_recorrido)){
                leido2.part_fit=fit;
                strcpy(leido2.part_name,nombre);
                leido2.part_size=tamano_real;
                leido2.part_start=inicio + tamano_recorrido;
                leido2.part_status='s';
                leido2.part_next = leido2.part_start + leido2.part_size;

                fseek(disco,-sizeof(EBR),SEEK_CUR);
                fwrite(&leido2,sizeof(EBR),1,disco);

                fseek(disco,leido2.part_size,SEEK_CUR);

                EBR nuevoebr;
                nuevoebr.part_fit='n';
                strcpy(nuevoebr.part_name,"-vacio-");
                nuevoebr.part_next=-1;
                nuevoebr.part_size=0;
                nuevoebr.part_start=0;
                nuevoebr.part_status='n';

                fwrite(&nuevoebr,sizeof(EBR),1,disco);

                bandera = 0;
                break;
            }else{
                bandera =-1;
                return;
            }
        }else{
            if((leido2.part_next-(leido2.part_start+leido2.part_size))>0){
                if(tamano_real<=(leido2.part_next-(leido2.part_start+leido2.part_size+sizeof(EBR)))){

                    EBR nuevoe;
                    nuevoe.part_fit=fit;
                    strcpy(nuevoe.part_name,nombre);
                    nuevoe.part_next=leido2.part_next;
                    nuevoe.part_size=tamano_real;
                    nuevoe.part_start=leido2.part_start+leido2.part_size+sizeof(EBR);
                    nuevoe.part_status='s';

                    leido2.part_next=leido2.part_start+leido2.part_size;

                    fseek(disco,-sizeof(MBR),SEEK_CUR);
                    fwrite(&leido2,sizeof(EBR),1,disco);

                    fseek(disco,leido2.part_size,SEEK_CUR);
                    fwrite(&nuevoe,sizeof(EBR),1,disco);

                    bandera = 0;
                    break;
                }
            }
        }
        tamano_recorrido+=leido2.part_size+sizeof(EBR);
        fseek(disco,leido2.part_size,SEEK_CUR);
        fread(&leido2,sizeof(EBR),1,disco);
    }

    if(bandera==0){
        printf("-------------CREACION EXITOSA--------------\n\n");
    }else{
        printf("ERROR: no hay espacio disponible para crear la particion en la particion extendida.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
    }

    fclose(disco);

    /* prueba de datos */

/*    disco = fopen(path,"r+b");

    if(!disco){
        printf("ERROR: el Disco no ha podido Abrirse.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        return;
    }

    if(fread(&leido,sizeof(MBR),1,disco)!=1){
        printf("ERROR:al cargar la data del disco\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    switch(unit){
        case 1:
            tamano_real=tamano*1024*1024;
            break;
        case 2:
            tamano_real=tamano*1024;
            break;
        case 3:
            tamano_real=tamano;
            break;
    }

    parti = extendida_exist(leido);

    if(parti==0){
        printf("ERROR: no exite una particion extendida.\n");
        fclose(disco);
        return;
    }

    tamano_particion = 0;
    inicio = 0;

    switch(parti){
        case 1:
            if(fseek(disco,leido.mbr_partition_1.part_start,SEEK_SET)!=0){
                printf("cagada.\n");
                break;
            };
            tamano_particion=leido.mbr_partition_1.part_size;
            inicio = leido.mbr_partition_1.part_start;
            break;
        case 2:
            if(fseek(disco,leido.mbr_partition_2.part_start,SEEK_SET)!=0){
                printf("cagada.\n");
                break;
            };
            tamano_particion=leido.mbr_partition_2.part_size;
            inicio = leido.mbr_partition_2.part_start;
            break;
        case 3:
            if(fseek(disco,leido.mbr_partition_3.part_start,SEEK_SET)!=0){
                printf("cagada.\n");
                break;
            };
            tamano_particion=leido.mbr_partition_3.part_size;
            inicio = leido.mbr_partition_2.part_start;
            break;
        case 4:
            if(fseek(disco,leido.mbr_partition_4.part_start,SEEK_SET)!=0){
                printf("cagada.\n");
                break;
            };
            tamano_particion=leido.mbr_partition_4.part_size;
            inicio = leido.mbr_partition_2.part_start;
            break;
    }

    if(fread(&leido2,sizeof(EBR),1,disco)!=1){
        printf("ERROR:al cargar la data del disco\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    while(leido2.part_next!=-1){
        printf("EBR:\n\tFit: %c\n\tNombre: %s\n\tNext: %i\n\tSize: %i\n\tStart: %i\n\tStatus: %c\n",leido2.part_fit,leido2.part_name,leido2.part_next,leido2.part_size,leido2.part_start,leido2.part_status);
        if(fseek(disco,leido2.part_size,SEEK_CUR)!=0){
            printf("cagada.\n");
            break;
        };
        if(fread(&leido2,sizeof(EBR),1,disco)!=1){
            printf("cagada.\n");
            break;
        };
    }

    printf("EBR:\n\tFit: %c\n\tNombre: %s\n\tNext: %i\n\tSize: %i\n\tStart: %i\n\tStatus: %c\n",leido2.part_fit,leido2.part_name,leido2.part_next,leido2.part_size,leido2.part_start,leido2.part_status);

    fclose(disco);
*/
}
Example #3
0
void eliminar_particion(char *name,char *path,char tipo){
    printf("-------------ELIMINAR PARTICION------------\n");
    printf("Nombre: %s\nPath: %s\nTipo: %c\n",name,path,tipo);

    struct stat st = {0};
    if(stat(path,&st)==-1){
        printf("ERROR: el archivo especificado no existe.\n");
        printf("-----------ELIMINACION FALLIDA-----------\n\n");
        return;
    }

    FILE *disco;

    disco = fopen(path,"r+b");

    if(!disco){
        printf("ERROR: el Disco no ha podido Abrirse.\n");
        printf("-----------ELIMINACION FALLIDA-----------\n\n");
        return;
    }

    MBR leido;

    if(fread(&leido,sizeof(MBR),1,disco)!=1){
        printf("ERROR:al cargar la data del disco\n");
        printf("-----------ELIMINACION FALLIDA-----------\n\n");
        fclose(disco);
        return;
    }

    int extendida = 0;
    char byte = '\0';

    switch(name_exist(disco,leido,name)){
        case 0:
            printf("ERROR: No existe la particion.\n");
            printf("----------ELIMINACION FALLIDA----------\n\n");
            fclose(disco);
            return;
        case 1:
            if(tipo=='a'){
                if(leido.mbr_partition_1.part_status!='n')
                    if(strcmp(leido.mbr_partition_1.part_name,name)==0){
                        leido.mbr_partition_1.part_status='n';
                    }
                if(leido.mbr_partition_2.part_status!='n')
                    if(strcmp(leido.mbr_partition_2.part_name,name)==0){
                        leido.mbr_partition_1.part_status='n';
                    }
                if(leido.mbr_partition_3.part_status!='n')
                    if(strcmp(leido.mbr_partition_3.part_name,name)==0){
                        leido.mbr_partition_1.part_status='n';
                    }
                if(leido.mbr_partition_4.part_status!='n')
                    if(strcmp(leido.mbr_partition_4.part_name,name)==0){
                        leido.mbr_partition_1.part_status='n';
                    }
            }else if(tipo=='u'){
                if(leido.mbr_partition_1.part_status!='n')
                    if(strcmp(leido.mbr_partition_1.part_name,name)==0){
                        leido.mbr_partition_1.part_status='n';
                        fseek(disco,leido.mbr_partition_1.part_start,SEEK_SET);
                        fwrite(&byte,sizeof(char),leido.mbr_partition_1.part_size,disco);
                    }
                if(leido.mbr_partition_2.part_status!='n')
                    if(strcmp(leido.mbr_partition_2.part_name,name)==0){
                        leido.mbr_partition_2.part_status='n';
                        fseek(disco,leido.mbr_partition_2.part_start,SEEK_SET);
                        fwrite(&byte,sizeof(char),leido.mbr_partition_2.part_size,disco);
                    }
                if(leido.mbr_partition_3.part_status!='n')
                    if(strcmp(leido.mbr_partition_3.part_name,name)==0){
                        leido.mbr_partition_3.part_status='n';
                        fseek(disco,leido.mbr_partition_3.part_start,SEEK_SET);
                        fwrite(&byte,sizeof(char),leido.mbr_partition_3.part_size,disco);
                    }
                if(leido.mbr_partition_4.part_status!='n')
                    if(strcmp(leido.mbr_partition_4.part_name,name)==0){
                        leido.mbr_partition_4.part_status='n';
                        fseek(disco,leido.mbr_partition_4.part_start,SEEK_SET);
                        fwrite(&byte,sizeof(char),leido.mbr_partition_4.part_size,disco);
                    }
            }
            fseek(disco,0,SEEK_SET);
            fwrite(&leido,sizeof(MBR),1,disco);
            break;
        case 2:
                if(leido.mbr_partition_1.part_status!='n')
                    if(leido.mbr_partition_1.part_type=='e')
                        extendida = 1;

                if(leido.mbr_partition_2.part_status!='n')
                    if(leido.mbr_partition_2.part_type=='e')
                        extendida = 2;

                if(leido.mbr_partition_3.part_status!='n')
                    if(leido.mbr_partition_3.part_type=='e')
                        extendida = 3;

                if(leido.mbr_partition_4.part_status!='n')
                    if(leido.mbr_partition_4.part_type=='e')
                        extendida = 4;

                if(extendida!=0){

                    switch(extendida){
                    case 1:
                        if(fseek(disco,leido.mbr_partition_1.part_start,SEEK_SET)!=0){
                            printf("cagada.\n");
                            break;
                        };
                        break;
                    case 2:
                        if(fseek(disco,leido.mbr_partition_2.part_start,SEEK_SET)!=0){
                            printf("cagada.\n");
                            break;
                        };
                        break;
                    case 3:
                        if(fseek(disco,leido.mbr_partition_3.part_start,SEEK_SET)!=0){
                            printf("cagada.\n");
                            break;
                        };
                        break;
                    case 4:
                        if(fseek(disco,leido.mbr_partition_4.part_start,SEEK_SET)!=0){
                            printf("cagada.\n");
                        };
                        break;
                    }

                    EBR leidoe;
                    EBR anterior;

                    if(fread(&leidoe,sizeof(EBR),1,disco)!=1){
                        printf("ERROR:al cargar la data del disco\n");
                        fclose(disco);
                        return;
                    }

                    anterior = leidoe;
                    while(strcmp(leidoe.part_name,name)!=0 && leidoe.part_next!=-1){
                         if(fseek(disco,leidoe.part_size,SEEK_CUR)!=0){
                            printf("cagada.\n");
                            break;
                        };
                        anterior=leidoe;
                        if(fread(&leidoe,sizeof(EBR),1,disco)!=1){
                            printf("cagada.\n");
                            break;
                        };
                    }

                    if(strcmp(leidoe.part_name,name)==0){
                        if(tipo=='a'){
                            if(strcmp(anterior.part_name,leidoe.part_name)==0){
                                leidoe.part_size=0;
                                fseek(disco,-sizeof(EBR),SEEK_CUR);
                                fwrite(&leido,sizeof(EBR),1,disco);
                            }else{
                                anterior.part_next=leidoe.part_next;
                                fseek(disco,-2*sizeof(EBR)-anterior.part_size,SEEK_CUR);
                                fwrite(&anterior,sizeof(EBR),1,disco);
                            }
                        }else if(tipo=='u'){
                            if(strcmp(anterior.part_name,leidoe.part_name)==0){
                                leidoe.part_size=0;
                                fwrite(&byte,sizeof(char),leidoe.part_size,disco);
                                fseek(disco,-sizeof(EBR),SEEK_CUR);
                                fwrite(&leido,sizeof(EBR),1,disco);
                            }else{
                                anterior.part_next=leidoe.part_next;
                                fwrite(&byte,sizeof(char),leidoe.part_size,disco);
                                fseek(disco,-2*sizeof(EBR)-anterior.part_size,SEEK_CUR);
                                fwrite(&anterior,sizeof(EBR),1,disco);
                            }
                        }
                    }
                }
            break;
    }
    fclose(disco);
    printf("-------------ELIMINACION EXITOSA-----------\n\n");
}
Example #4
0
void crear_pe(char *nombre, char *path, int tamano, char fit,int unit){
    printf("-------------CREANDO PARTICION-------------\n");

    struct stat st = {0};
    if(stat(path,&st)==-1){
        printf("ERROR: el archivo especificado no existe.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        return;
    }

    FILE *disco;

    disco = fopen(path,"r+b");

    if(!disco){
        printf("ERROR: el Disco no ha podido Abrirse.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        return;
    }

    MBR leido;

    if(fread(&leido,sizeof(MBR),1,disco)!=1){
        printf("ERROR:al cargar la data del disco\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    int tamano_real;

    switch(unit){
        case 1:
            tamano_real=tamano*1024*1024;
            break;
        case 2:
            tamano_real=tamano*1024;
            break;
        case 3:
            tamano_real=tamano;
            break;
    }

    printf("-------------------DATOS-------------------\n");
    printf("Nombre: %s\nPath: %s\nTamano: %i\nFit: %c\nUnit: %i\nTipo: Extendida\n",nombre,path,tamano_real,fit,unit);


    int posicion = lugar(leido,tamano_real);

    if(posicion==0){
        printf("ERROR: ya no es posible crear particion devido a que ya se a sobrepadaso el numero de particiones posibles.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    if(posicion==-1){
        printf("ERROR: ya no es posible crear particion devido a que ya no espacio disponible.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    if(name_exist(disco,leido,nombre)){
        printf("ERROR: el nombre ya existen entre las particiones.\n");
        printf("-------------CREACION FALLIDA--------------\n\n");
        fclose(disco);
        return;
    }

    if(extendida_exist(leido)!=0){
        printf("ERROR: ya existe una particion Extendida en el disco.\n");
        fclose(disco);
        return;
    }

    particion partnueva;

    partnueva.part_status='s';
    partnueva.part_type='e';
    partnueva.part_fit=fit;

    switch(unit){
        case 1:
            partnueva.part_size=tamano*1024*1024;
            break;
        case 2:
            partnueva.part_size=tamano*1024;
            break;
        case 3:
            partnueva.part_size=tamano;
            break;
    }
    strcpy(partnueva.part_name,nombre);

    switch(posicion){
        case 1:
            partnueva.part_start=sizeof(MBR);
            leido.mbr_partition_1=partnueva;
            break;
        case 2:
            partnueva.part_start=leido.mbr_partition_1.part_start+leido.mbr_partition_1.part_size;
            leido.mbr_partition_2=partnueva;
            break;
        case 3:
            partnueva.part_start=leido.mbr_partition_2.part_start+leido.mbr_partition_2.part_size;
            leido.mbr_partition_3=partnueva;
            break;
        case 4:
            partnueva.part_start=leido.mbr_partition_3.part_start+leido.mbr_partition_3.part_size;
            leido.mbr_partition_4=partnueva;
            break;
    }

    fseek(disco,0,SEEK_SET);
    fwrite(&leido,sizeof(MBR),1,disco);

    EBR nuevoebr;

    nuevoebr.part_fit='n';
    strcpy(nuevoebr.part_name,"-vacio-");
    nuevoebr.part_next=-1;
    nuevoebr.part_status='n';
    nuevoebr.part_size=0;
    nuevoebr.part_start=-1;
    switch(posicion){
        case 1:
            nuevoebr.part_size=leido.mbr_partition_1.part_size-sizeof(EBR);
            fseek(disco,leido.mbr_partition_1.part_start,SEEK_SET);
            fwrite(&nuevoebr,sizeof(EBR),1,disco);
            break;
        case 2:
            nuevoebr.part_size=leido.mbr_partition_2.part_size-sizeof(EBR);
            fseek(disco,leido.mbr_partition_2.part_start,SEEK_SET);
            fwrite(&nuevoebr,sizeof(EBR),1,disco);
            break;
        case 3:
            nuevoebr.part_size=leido.mbr_partition_3.part_size-sizeof(EBR);
            fseek(disco,leido.mbr_partition_3.part_start,SEEK_SET);
            fwrite(&nuevoebr,sizeof(EBR),1,disco);
            break;
        case 4:
            nuevoebr.part_size=leido.mbr_partition_4.part_size-sizeof(EBR);
            fseek(disco,leido.mbr_partition_4.part_start,SEEK_SET);
            fwrite(&nuevoebr,sizeof(EBR),1,disco);
            break;
    }

    printf("-------------CREACION EXITOSA--------------\n");

    fclose(disco);
/*
    disco = fopen(path,"r+b");

    if(!disco){
        printf("ERROR: el Disco no ha podido Abrirse.\n");
        return;
    }

    MBR master;

    if(fread(&master,sizeof(MBR),1,disco)!=1){
        printf("ERROR:al cargar la data del disco\n");
        fclose(disco);
        return;
    }

    printf("Particion 1:\n\tNombre:%s\n\tInicio: %i\n\tTamano: %i\n",master.mbr_partition_1.part_name,master.mbr_partition_1.part_start,master.mbr_partition_1.part_size);
    printf("Particion 2:\n\tNombre:%s\n\tInicio: %i\n\tTamano: %i\n",master.mbr_partition_2.part_name,master.mbr_partition_2.part_start,master.mbr_partition_2.part_size);
    printf("Particion 3:\n\tNombre:%s\n\tInicio: %i\n\tTamano: %i\n",master.mbr_partition_3.part_name,master.mbr_partition_3.part_start,master.mbr_partition_3.part_size);
    printf("Particion 4:\n\tNombre:%s\n\tInicio: %i\n\tTamano: %i\n",master.mbr_partition_4.part_name,master.mbr_partition_4.part_start,master.mbr_partition_4.part_size);

    fclose(disco);*/
}