API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 20th, 2019
107
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 303.82 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <dirent.h>
  4. #include <sys/stat.h>
  5. #include <string.h>
  6. #include <time.h>
  7. #include <math.h>
  8. int ContadorInstrucciones;
  9. int ContadorComandosExitosos;
  10.  
  11. int ErrorInterprete;
  12. int ErrorComando;
  13. int ErrorCrearDisco;
  14. int ErrorEliminarDisco;
  15. int ErrorCrearParticion;
  16. int ErrorEliminarParticion;
  17. int ErrorCrearParticionLogica;
  18. int ErrorEliminarLogica;
  19. int ErrorReporte1;
  20. int ErrorReporte2;
  21.  
  22.  
  23.  
  24. int comentario;
  25.  
  26. int fin=0;
  27.  
  28. char sincomillas[1000];// se usa en el Metodo quitarComillas
  29.  
  30. typedef struct
  31. {
  32. char nombre[150];
  33. }pathFile;
  34.  
  35. typedef struct
  36. {
  37.  
  38. int esnuevonodo;
  39. char nombre[100];
  40. char name2[100];
  41. int contador;
  42. char nombreparametro[100];
  43. char parametro[100];
  44. int size;
  45. char size2[100];
  46. char unit;
  47. char path[150];
  48. char dest[150];
  49. char cont[150];
  50. char ruta[100];
  51. char type;
  52. char typeFormatear[100];
  53. char delete_[100];
  54. char name[100];
  55. char Contenido[1000];
  56. char id[100];
  57. char usr[100];
  58. char pwd[100];
  59. char fileid[100];
  60. int add;
  61. pathFile fileN[10];
  62. char fit[30];
  63. char allocation[100];
  64. char idvector[6];
  65. int p;
  66. char grp[100];
  67. char fs[100];
  68. int tamano;
  69. char count[100];
  70. int count2;
  71.  
  72. }Funcion;
  73.  
  74. typedef struct
  75. {
  76. char part_status;
  77. char part_type;
  78. char part_fit[3];
  79. int part_start;
  80. int part_size;
  81. char part_name[16];
  82.  
  83. }Particion;
  84.  
  85.  
  86.  
  87. typedef struct
  88. {
  89. char parte[64];
  90.  
  91. }Parte;
  92.  
  93. typedef struct
  94. {
  95.  
  96. Parte part[64];
  97. int cantidad;
  98. }Cadena;
  99.  
  100. typedef struct
  101. {
  102. char part_status;
  103. char part_type;
  104. char part_fit[3];
  105. int part_start;
  106. int part_size;
  107. int part_next;
  108. char part_name[16];
  109.  
  110. }EBR;
  111. struct retorno
  112. {
  113. int disco;
  114. int particion;
  115. };
  116. typedef struct retorno Retorno;
  117.  
  118. struct montura
  119. {
  120. char path[250];
  121. char name[15];
  122. char nombre[15];
  123. struct montura *siguiente;
  124. };
  125. typedef struct montura Montura;
  126.  
  127. struct lista
  128. {
  129. struct montura *primero;
  130. struct montura *ultimo;
  131. };
  132. typedef struct lista Lista;
  133.  
  134. struct bloque
  135. {
  136. int inicio;
  137. int fin;
  138. int tamano;
  139. struct bloque *siguiente;
  140. struct bloque *anterior;
  141. };
  142. typedef struct bloque Bloque;
  143.  
  144. struct espacios
  145. {
  146. struct bloque *primero;
  147. struct bloque *ultimo;
  148. };
  149. typedef struct espacios Espacios;
  150.  
  151. typedef struct
  152. {
  153. int s_filesystem_type;
  154. int s_inodes_count;
  155. int s_blocks_count;
  156. int s_free_blocks_count;
  157. int s_free_inodes_count;
  158. char s_mtime[16];
  159. char s_umtime[16];
  160. int s_mnt_count;
  161. int s_magic;
  162. int s_inode_size;
  163. int s_block_size;
  164. int s_first_ino;
  165. int s_first_blo;
  166. int s_bm_inode_start;
  167. int s_bm_block_start;
  168. int s_inode_start;
  169. int s_block_start;
  170.  
  171.  
  172. }SuperBlock;
  173.  
  174. typedef struct
  175. {
  176. int i_uid;
  177. int I_gid;
  178. int i_size;
  179. char i_atime[16];
  180. char i_ctime[16];
  181. char i_mtime[16];
  182. int i_block[15];
  183. char i_type;
  184. int i_perm;
  185.  
  186. }Inodo;
  187.  
  188. typedef struct
  189. {
  190. char operacion;
  191. char tipo;
  192. char path[100];
  193. char cont[100];
  194. char fecha[16];
  195. char propietario[16];
  196. char permisos[16];
  197. int siguiente;
  198. int posicion;
  199.  
  200. }Journal;
  201.  
  202.  
  203.  
  204. typedef struct
  205. {
  206. char b_name[12];
  207. int b_inodo;
  208.  
  209. }content;
  210.  
  211. typedef struct
  212. {
  213. content b_content[4];
  214.  
  215. }BloqueCarpeta;
  216.  
  217. typedef struct
  218. {
  219. char b_content[64];
  220.  
  221. }BloqueArchivo;
  222.  
  223.  
  224. typedef struct
  225. {
  226. char b_pointers[16];
  227.  
  228. }BloqueApuntador;
  229.  
  230.  
  231. typedef struct
  232. {
  233. char cadena[800];
  234. int grupos;
  235. int usuarios;
  236.  
  237.  
  238. }Retornoo;
  239.  
  240. Lista *sistema;
  241.  
  242.  
  243. typedef struct
  244. {
  245. int mbr_tamano;
  246. char mbr_fecha_creacion[25];
  247. int mbr_disk_signature;
  248. char mbr_fit[3];
  249. Particion particiones[4];
  250. int cantParticones;
  251. int bandera;
  252.  
  253. }MbrDisco;
  254. MbrDisco mbrG;
  255. char pathG[100];
  256. char nombG[30];
  257. int actual=0;
  258. int logu=1;
  259. char NombreUsuario[100];
  260. int root=0;
  261. int cambioCortar=0;
  262. char cambioCortarNom[50];
  263. void limpiarvar(char aux[], int n) {
  264. int i;
  265. for (i = 0; i < n; i++) {
  266. aux[i] = '\0';
  267. }
  268. }
  269.  
  270. MbrDisco obtenerMBR(Funcion funcion)
  271. {
  272. MbrDisco mbr;
  273. mbr.bandera=-4;
  274. char path[250];
  275. limpiarvar(path,150);
  276. Montura *pivote=sistema->primero;
  277. while (pivote!=NULL) {
  278. if(!strcmp(funcion.id,pivote->name))
  279. {
  280.  
  281.  
  282. FILE *fp;
  283. printf("Se encontro la particion montada-> %s\n",pivote->path);
  284. strcpy(path,pivote->path);
  285. fp=fopen(path, "rb");
  286. printf("Abrio archivo\n");
  287. if(fp == NULL)
  288. {
  289. printf("\n Error::-> No se encontro el disco\n");
  290. }else {
  291. fseek(fp,0,SEEK_SET);
  292. fread(&mbr, sizeof(MbrDisco), 1, fp);
  293. printf("Guardo mbr\n");
  294. fclose(fp);
  295. limpiarvar(path,250);
  296. return mbr;
  297. }
  298. break;
  299. }
  300. pivote=pivote->siguiente;
  301. }
  302.  
  303. printf("No se encotro ninguna particion montada con ese nombre\n");
  304. limpiarvar(path,250);
  305. return mbr;
  306.  
  307. }
  308. MbrDisco obtenerMBR2()
  309. {
  310. //printf("%s\n",nombG);
  311. MbrDisco mbr;
  312. mbr.bandera=-4;
  313. char path[250];
  314. limpiarvar(path,150);
  315. Montura *pivote=sistema->primero;
  316. while (pivote!=NULL) {
  317. if(!strcmp(nombG,pivote->nombre))
  318. {
  319.  
  320.  
  321. FILE *fp;
  322. //printf("Se encontro la particion montada-> %s\n",pivote->path);
  323. strcpy(path,pivote->path);
  324. fp=fopen(path, "rb");
  325. //printf("Abrio archivo\n");
  326. if(fp == NULL)
  327. {
  328. printf("\n Error::-> No se encontro el disco\n");
  329. }else {
  330. fseek(fp,0,SEEK_SET);
  331. fread(&mbr, sizeof(MbrDisco), 1, fp);
  332. //printf("Guardo mbr\n");
  333. fclose(fp);
  334. limpiarvar(path,250);
  335. return mbr;
  336. }
  337. break;
  338. }
  339. pivote=pivote->siguiente;
  340. }
  341.  
  342. printf("No se encotro ninguna particion montada con ese nombre\n");
  343. limpiarvar(path,250);
  344. return mbr;
  345.  
  346. }
  347.  
  348. char* obtenerNombre(Funcion funcion)
  349. {
  350. int bandera =0;
  351. Montura *pivote=sistema->primero;
  352. while (pivote!=NULL) {
  353. if(!strcmp(funcion.id,pivote->name))
  354. {
  355.  
  356. FILE *fp;
  357. fp = fopen(pivote->path, "rb");
  358.  
  359. if(fp == NULL)
  360. {
  361. printf("\n Error::-> No se encontro el disco\n");
  362. }else {
  363. return pivote->nombre;
  364. fclose(fp);
  365. }
  366.  
  367. bandera=1;
  368. break;
  369. }
  370. pivote=pivote->siguiente;
  371. }
  372. if(bandera==0)
  373. {
  374.  
  375. return "";
  376. }
  377. }
  378.  
  379. char* obtenerPath(Funcion funcion)
  380. {
  381. int bandera =0;
  382. Montura *pivote=sistema->primero;
  383. while (pivote!=NULL) {
  384. if(!strcmp(funcion.id,pivote->name))
  385. {
  386.  
  387. FILE *fp;
  388. fp = fopen(pivote->path, "rb");
  389.  
  390. if(fp == NULL)
  391. {
  392. printf("\n Error::-> No se encontro el disco\n");
  393. }else {
  394. return pivote->path;
  395. fclose(fp);
  396. }
  397.  
  398. bandera=1;
  399. break;
  400. }
  401. pivote=pivote->siguiente;
  402. }
  403. if(bandera==0)
  404. {
  405.  
  406. return "";
  407. }
  408. }
  409.  
  410.  
  411. MbrDisco *BuscarDisco(Funcion funcion)
  412. {
  413. int bandera =0;
  414. Montura *pivote=sistema->primero;
  415. while (pivote!=NULL) {
  416. if(!strcmp(funcion.id,pivote->name))
  417. {
  418. printf("Se encontro la particion montada\n");
  419.  
  420. FILE *fp;
  421. fp = fopen(pivote->path, "rb");
  422.  
  423. if(fp == NULL)
  424. {
  425. printf("\n Error::-> No se encontro el disco\n");
  426. }else {
  427. fread(&mbrG, sizeof(MbrDisco), 1, fp);
  428. fclose(fp);
  429. return &mbrG;
  430. }
  431.  
  432. bandera=1;
  433. break;
  434. }
  435. pivote=pivote->siguiente;
  436. }
  437. if(bandera==0)
  438. {
  439. printf("No se encotro ninguna particion montada con ese nombre\n");
  440. return NULL;
  441. }
  442. }
  443.  
  444.  
  445.  
  446. MbrDisco BuscarDisco2(Funcion funcion)
  447. {
  448. FILE *fp;
  449. fp = fopen(funcion.path, "rb");
  450.  
  451. if(fp == NULL)
  452. {
  453. printf("\n Error::-> No se encontro el disco\n");
  454. }else {
  455. fread(&mbrG, sizeof(MbrDisco), 1, fp);
  456. fclose(fp);
  457. return mbrG;
  458. }
  459.  
  460. }
  461.  
  462. void GraficarSB(Funcion funcion)
  463. {
  464.  
  465. SuperBlock super;
  466.  
  467. char nomb[15];
  468. char path[100];
  469. strcpy(nomb,obtenerNombre(funcion));
  470. strcpy(path,obtenerPath(funcion));
  471.  
  472.  
  473. MbrDisco *mbr=BuscarDisco(funcion);
  474. printf("Graficando...\n");
  475. if(mbr!=NULL)
  476. {
  477. char dot[100]="\0";
  478. char pathauxiliar[200];
  479. char pathauxiliar2[200];
  480. limpiarvar(pathauxiliar2,200);
  481. limpiarvar(pathauxiliar,200);
  482. strcpy(pathauxiliar,funcion.path);
  483. int q=0;
  484. while(pathauxiliar[q]!='.')
  485. {
  486. char nuevoCaracter[1];
  487. nuevoCaracter[0]=pathauxiliar[q];
  488. strncat(pathauxiliar2,nuevoCaracter,1);
  489. q++;
  490. }
  491. strcat(pathauxiliar2,".dot");
  492.  
  493.  
  494. printf("%s\n",funcion.path);
  495. printf("%s\n",pathauxiliar2);
  496.  
  497. char finalizado[300];
  498. limpiarvar(finalizado,300);
  499. strcpy(finalizado,"cd /\n");
  500. int indice=0;
  501. char carpeta[100];
  502. limpiarvar(carpeta,100);
  503.  
  504. while(funcion.path[indice]!='.')
  505. {
  506. if(funcion.path[indice]!='/')
  507. {
  508.  
  509. char nuevoCaracter[1];
  510. nuevoCaracter[0]=funcion.path[indice];
  511. strncat(carpeta,nuevoCaracter,1);
  512. }
  513. else
  514. {
  515. if(carpeta[0]!='\0')
  516. {
  517. strcat(finalizado,"mkdir ");
  518. strcat(finalizado,"\"");
  519. strcat(finalizado,carpeta);
  520. strcat(finalizado,"\"");
  521. strcat(finalizado,"\n");
  522. strcat(finalizado,"cd ");
  523. strcat(finalizado,"\"");
  524. strcat(finalizado,carpeta);
  525. strcat(finalizado,"\"");
  526. strcat(finalizado,"\n");
  527. strcat(carpeta,"");
  528.  
  529. }
  530. limpiarvar(carpeta,100);
  531.  
  532. }
  533. indice++;
  534. }
  535.  
  536.  
  537. printf("\n%s\n",finalizado);
  538.  
  539. system(finalizado);
  540.  
  541. FILE *fptr= fopen(pathauxiliar2,"w");
  542.  
  543. if(fptr == NULL)
  544. {
  545. printf("Error!");
  546. }else {
  547. for(int i=0; i<4; i++)
  548. {
  549. if(!strcmp(nomb,mbr->particiones[i].part_name))
  550. {
  551.  
  552. FILE *fp= fopen(path, "rb");
  553. fseek(fp,sizeof (MbrDisco)+mbr->particiones[i].part_start,SEEK_SET);
  554.  
  555. if(fp == NULL)
  556. {
  557. printf("\n Error::-> No se encontro el disco\n");
  558. }else {
  559. fread(&super,sizeof (SuperBlock), 1, fp);
  560. fclose(fp);
  561. fprintf(fptr,"digraph G{\n");
  562. fprintf(fptr,"aHtmlTable[");
  563. fprintf(fptr,"shape=plaintext ");
  564. fprintf(fptr,"color=\"#2471a3\" ");
  565. fprintf(fptr,"label=<\n");
  566. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  567. fprintf(fptr,"<tr>\n");
  568. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> NOMBRE </td>\n");
  569. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> VALOR </td>\n");
  570. fprintf(fptr,"</tr>\n");
  571. fprintf(fptr,"<tr>\n");
  572. fprintf(fptr,"<td> s_filesystem_type</td>\n");
  573. fprintf(fptr,"<td>");
  574. fprintf(fptr,"%d", super.s_filesystem_type);
  575. fprintf(fptr,"</td>\n");
  576. fprintf(fptr,"</tr>\n");
  577. fprintf(fptr,"<tr>\n");
  578. fprintf(fptr,"<td> s_inodes_count</td>\n");
  579. fprintf(fptr,"<td>");
  580. fprintf(fptr,"%d", super.s_inodes_count);
  581. fprintf(fptr,"</td>\n");
  582. fprintf(fptr,"</tr>\n");
  583. fprintf(fptr,"<tr>\n");
  584. fprintf(fptr,"<td> s_blocks_count</td>\n");
  585. fprintf(fptr,"<td>");
  586. fprintf(fptr,"%d", super.s_blocks_count);
  587. fprintf(fptr,"</td>\n");
  588. fprintf(fptr,"</tr>\n");
  589. fprintf(fptr,"<tr>\n");
  590. fprintf(fptr,"<td> s_free_blocks_count</td>\n");
  591. fprintf(fptr,"<td>");
  592. fprintf(fptr,"%d", super.s_free_blocks_count);
  593. fprintf(fptr,"</td>\n");
  594. fprintf(fptr,"</tr>\n");
  595. fprintf(fptr,"<tr>\n");
  596. fprintf(fptr,"<td> s_free_inodes_count</td>\n");
  597. fprintf(fptr,"<td>");
  598. fprintf(fptr,"%d", super.s_free_inodes_count);
  599. fprintf(fptr,"</td>\n");
  600. fprintf(fptr,"</tr>\n");
  601. fprintf(fptr,"<tr>\n");
  602. fprintf(fptr,"<td> s_mtime</td>\n");
  603. fprintf(fptr,"<td>");
  604. fprintf(fptr,"%s", super.s_mtime);
  605. fprintf(fptr,"</td>\n");
  606. fprintf(fptr,"</tr>\n");
  607. fprintf(fptr,"<tr>\n");
  608. fprintf(fptr,"<td> s_umtime</td>\n");
  609. fprintf(fptr,"<td>");
  610. fprintf(fptr,"%s", super.s_umtime);
  611. fprintf(fptr,"</td>\n");
  612. fprintf(fptr,"</tr>\n");
  613. fprintf(fptr,"<tr>\n");
  614. fprintf(fptr,"<td> s_mnt_count</td>\n");
  615. fprintf(fptr,"<td>");
  616. fprintf(fptr,"%d", super.s_mnt_count);
  617. fprintf(fptr,"</td>\n");
  618. fprintf(fptr,"</tr>\n");
  619. fprintf(fptr,"<tr>\n");
  620. fprintf(fptr,"<td> s_magic</td>\n");
  621. fprintf(fptr,"<td>");
  622. fprintf(fptr,"%d", super.s_magic);
  623. fprintf(fptr,"</td>\n");
  624. fprintf(fptr,"</tr>\n");
  625. fprintf(fptr,"<tr>\n");
  626. fprintf(fptr,"<td> s_inode_size</td>\n");
  627. fprintf(fptr,"<td>");
  628. fprintf(fptr,"%d", super.s_inode_size);
  629. fprintf(fptr,"</td>\n");
  630. fprintf(fptr,"</tr>\n");
  631. fprintf(fptr,"<tr>\n");
  632. fprintf(fptr,"<td> s_block_size</td>\n");
  633. fprintf(fptr,"<td>");
  634. fprintf(fptr,"%d", super.s_block_size);
  635. fprintf(fptr,"</td>\n");
  636. fprintf(fptr,"</tr>\n");
  637. fprintf(fptr,"<tr>\n");
  638. fprintf(fptr,"<td> s_first_ino</td>\n");
  639. fprintf(fptr,"<td>");
  640. fprintf(fptr,"%d", super.s_first_ino);
  641. fprintf(fptr,"</td>\n");
  642. fprintf(fptr,"</tr>\n");
  643. fprintf(fptr,"<tr>\n");
  644. fprintf(fptr,"<td> s_first_blo</td>\n");
  645. fprintf(fptr,"<td>");
  646. fprintf(fptr,"%d", super.s_first_blo);
  647. fprintf(fptr,"</td>\n");
  648. fprintf(fptr,"</tr>\n");
  649. fprintf(fptr,"<tr>\n");
  650. fprintf(fptr,"<td> s_bm_inode_start</td>\n");
  651. fprintf(fptr,"<td>");
  652. fprintf(fptr,"%d", super.s_bm_inode_start);
  653. fprintf(fptr,"</td>\n");
  654. fprintf(fptr,"</tr>\n");
  655. fprintf(fptr,"<tr>\n");
  656. fprintf(fptr,"<td> s_bm_block_start</td>\n");
  657. fprintf(fptr,"<td>");
  658. fprintf(fptr,"%d", super.s_bm_block_start);
  659. fprintf(fptr,"</td>\n");
  660. fprintf(fptr,"</tr>\n");
  661. fprintf(fptr,"<tr>\n");
  662. fprintf(fptr,"<td> s_inode_start</td>\n");
  663. fprintf(fptr,"<td>");
  664. fprintf(fptr,"%d", super.s_inode_start);
  665. fprintf(fptr,"</td>\n");
  666. fprintf(fptr,"</tr>\n");
  667. fprintf(fptr,"<tr>\n");
  668. fprintf(fptr,"<td> s_block_start</td>\n");
  669. fprintf(fptr,"<td>");
  670. fprintf(fptr,"%d", super.s_block_start);
  671. fprintf(fptr,"</td>\n");
  672. fprintf(fptr,"</tr>\n");
  673.  
  674.  
  675.  
  676.  
  677. fprintf(fptr,"</table>\n");
  678. fprintf(fptr,">];\n");
  679.  
  680.  
  681. fprintf(fptr,"}\n");
  682. fclose(fptr);
  683. strcat(dot,"dot -Tpng ");
  684. strcat(dot,pathauxiliar2);
  685. strcat(dot," -o ");
  686. strcat(dot,funcion.path);
  687. printf("%s\n",dot);
  688. system(dot);
  689. ContadorComandosExitosos++;
  690.  
  691.  
  692.  
  693.  
  694. }
  695.  
  696.  
  697.  
  698.  
  699. break;
  700. }
  701. }
  702. }
  703.  
  704. limpiarvar(funcion.path,100);
  705. limpiarvar(pathauxiliar2,200);
  706. limpiarvar(pathauxiliar,200);
  707. limpiarvar(finalizado,300);
  708. limpiarvar(carpeta,100);
  709. limpiarvar(path,100);
  710. limpiarvar(nomb,15);
  711.  
  712.  
  713. }else {
  714. printf("Error::-> Generar reporte\n");
  715. ErrorReporte1++;
  716. }
  717. }
  718.  
  719.  
  720. void GraficarJournal(Funcion funcion)
  721. {
  722. int bandera =0;
  723. SuperBlock super;
  724.  
  725. char nomb[15];
  726. char path[100];
  727. strcpy(nomb,obtenerNombre(funcion));
  728. strcpy(path,obtenerPath(funcion));
  729. MbrDisco mbr=obtenerMBR(funcion);
  730.  
  731. if(mbr.bandera!=-4)
  732. {
  733. char dot[100]="\0";
  734. char pathauxiliar[200];
  735. char pathauxiliar2[200];
  736. limpiarvar(pathauxiliar2,200);
  737. limpiarvar(pathauxiliar,200);
  738. strcpy(pathauxiliar,funcion.path);
  739. int q=0;
  740. while(pathauxiliar[q]!='.')
  741. {
  742. char nuevoCaracter[1];
  743. nuevoCaracter[0]=pathauxiliar[q];
  744. strncat(pathauxiliar2,nuevoCaracter,1);
  745. q++;
  746. }
  747. strcat(pathauxiliar2,".dot");
  748.  
  749.  
  750. printf("%s\n",funcion.path);
  751. printf("%s\n",pathauxiliar2);
  752.  
  753. char finalizado[300];
  754. limpiarvar(finalizado,300);
  755. strcpy(finalizado,"cd /\n");
  756. int indice=0;
  757. char carpeta[100];
  758. limpiarvar(carpeta,100);
  759.  
  760. while(funcion.path[indice]!='.')
  761. {
  762. if(funcion.path[indice]!='/')
  763. {
  764.  
  765. char nuevoCaracter[1];
  766. nuevoCaracter[0]=funcion.path[indice];
  767. strncat(carpeta,nuevoCaracter,1);
  768. }
  769. else
  770. {
  771. if(carpeta[0]!='\0')
  772. {
  773. strcat(finalizado,"mkdir ");
  774. strcat(finalizado,"\"");
  775. strcat(finalizado,carpeta);
  776. strcat(finalizado,"\"");
  777. strcat(finalizado,"\n");
  778. strcat(finalizado,"cd ");
  779. strcat(finalizado,"\"");
  780. strcat(finalizado,carpeta);
  781. strcat(finalizado,"\"");
  782. strcat(finalizado,"\n");
  783. strcat(carpeta,"");
  784.  
  785. }
  786. limpiarvar(carpeta,100);
  787.  
  788. }
  789. indice++;
  790. }
  791.  
  792.  
  793. printf("\n%s\n",finalizado);
  794.  
  795. system(finalizado);
  796.  
  797. FILE *fptr;
  798. fptr = fopen(pathauxiliar2,"w");
  799.  
  800. if(fptr == NULL)
  801. {
  802. printf("Error!");
  803. }else {
  804.  
  805.  
  806.  
  807. for(int i=0; i<4; i++)
  808. {
  809. if(!strcmp(nomb,mbr.particiones[i].part_name))
  810. {
  811.  
  812. FILE *fp;
  813. fp = fopen(path, "rb");
  814. fseek(fp,sizeof (MbrDisco)+mbr.particiones[i].part_start,SEEK_SET);
  815.  
  816. if(fp == NULL)
  817. {
  818. printf("\n Error::-> No se encontro el disco\n");
  819. }else {
  820. fread(&super,sizeof (SuperBlock), 1, fp);
  821. if (super.s_filesystem_type==3) {
  822.  
  823.  
  824. fprintf(fptr,"digraph G{\n");
  825. fprintf(fptr,"aHtmlTable[");
  826. fprintf(fptr,"shape=plaintext ");
  827. fprintf(fptr,"color=\"#2471a3\" ");
  828. fprintf(fptr,"label=<\n");
  829. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  830. fprintf(fptr,"<tr>\n");
  831. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> NO. </td>\n");
  832. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> OPERACION </td>\n");
  833. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> TIPO </td>\n");
  834. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> PATH </td>\n");
  835. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> CONT </td>\n");
  836. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> SIZE </td>\n");
  837. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> FECHA </td>\n");
  838. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> PROPIETARIO </td>\n");
  839. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> PERMISOS </td>\n");
  840. fprintf(fptr,"</tr>\n");
  841. Journal Jactual;
  842. int contador=1;
  843. fseek(fp,mbr.particiones[i].part_start+sizeof (MbrDisco)+sizeof (SuperBlock),SEEK_SET);
  844. fread(&Jactual,sizeof (Journal), 1, fp);
  845. while (Jactual.siguiente!=-1) {
  846. fseek(fp,mbr.particiones[i].part_start+sizeof (MbrDisco)+sizeof (SuperBlock)+Jactual.siguiente,SEEK_SET);
  847. fread(&Jactual,sizeof (Journal), 1, fp);
  848. fprintf(fptr,"<tr>");
  849. fprintf(fptr,"<td>");
  850. fprintf(fptr,"%d", contador);
  851. fprintf(fptr,"</td>\n");
  852. fprintf(fptr,"<td>");
  853. fprintf(fptr,"%c", Jactual.operacion);
  854. fprintf(fptr,"</td>\n");
  855. fprintf(fptr,"<td>");
  856. fprintf(fptr,"%c", Jactual.tipo);
  857. fprintf(fptr,"</td>\n");
  858. fprintf(fptr,"<td>");
  859. fprintf(fptr,"%s", Jactual.path);
  860. fprintf(fptr,"</td>\n");
  861. fprintf(fptr,"<td>");
  862. fprintf(fptr,"%s", Jactual.cont);
  863. fprintf(fptr,"</td>\n");
  864. fprintf(fptr,"<td>");
  865. fprintf(fptr,"-");
  866. fprintf(fptr,"</td>\n");
  867. fprintf(fptr,"<td>");
  868. fprintf(fptr,"%s", Jactual.fecha);
  869. fprintf(fptr,"</td>\n");
  870. fprintf(fptr,"<td>");
  871. fprintf(fptr,"%s", Jactual.propietario);
  872. fprintf(fptr,"</td>\n");
  873. fprintf(fptr,"<td>");
  874. fprintf(fptr,"%s", Jactual.permisos);
  875. fprintf(fptr,"</td>\n");
  876. fprintf(fptr,"</tr>\n");
  877.  
  878. contador++;
  879. }
  880.  
  881.  
  882. fprintf(fptr,"</table>\n");
  883. fprintf(fptr,">];\n");
  884.  
  885.  
  886. fprintf(fptr,"}\n");
  887. fclose(fptr);
  888.  
  889. strcat(dot,"dot -Tpng ");
  890. strcat(dot,pathauxiliar2);
  891. strcat(dot," -o ");
  892. strcat(dot,funcion.path);
  893. printf("%s\n",dot);
  894. system(dot);
  895. }
  896. else {
  897. printf("No es ext3\n");
  898. }
  899. ContadorComandosExitosos++;
  900.  
  901.  
  902. fclose(fp);
  903.  
  904.  
  905. }
  906.  
  907.  
  908.  
  909. break;
  910. }
  911. }
  912. fclose(fptr);
  913. }
  914. limpiarvar(funcion.path,100);
  915. limpiarvar(pathauxiliar2,200);
  916. limpiarvar(pathauxiliar,200);
  917. limpiarvar(finalizado,300);
  918. limpiarvar(carpeta,100);
  919. limpiarvar(dot,100);
  920. limpiarvar(path,100);
  921. limpiarvar(nomb,15);
  922.  
  923. }else {
  924. printf("Error::-> Generar reporte\n");
  925. ErrorReporte1++;
  926. }
  927. }
  928.  
  929. void GraficarInodos (Funcion funcion)
  930. {
  931. int bandera =0;
  932. SuperBlock super;
  933.  
  934.  
  935. char nomb[15];
  936. char path[100];
  937. strcpy(nomb,obtenerNombre(funcion));
  938. strcpy(path,obtenerPath(funcion));
  939. MbrDisco mbr=obtenerMBR(funcion);
  940.  
  941. if(mbr.bandera!=-4)
  942. {
  943. char dot[100]="\0";
  944. char pathauxiliar[200];
  945. char pathauxiliar2[200];
  946. limpiarvar(pathauxiliar2,200);
  947. limpiarvar(pathauxiliar,200);
  948. strcpy(pathauxiliar,funcion.path);
  949. int q=0;
  950. while(pathauxiliar[q]!='.')
  951. {
  952. char nuevoCaracter[1];
  953. nuevoCaracter[0]=pathauxiliar[q];
  954. strncat(pathauxiliar2,nuevoCaracter,1);
  955. q++;
  956. }
  957. strcat(pathauxiliar2,".dot");
  958.  
  959.  
  960. printf("%s\n",funcion.path);
  961. printf("%s\n",pathauxiliar2);
  962.  
  963. char finalizado[300];
  964. limpiarvar(finalizado,300);
  965. strcpy(finalizado,"cd /\n");
  966. int indice=0;
  967. char carpeta[100];
  968. limpiarvar(carpeta,100);
  969.  
  970. while(funcion.path[indice]!='.')
  971. {
  972. if(funcion.path[indice]!='/')
  973. {
  974.  
  975. char nuevoCaracter[1];
  976. nuevoCaracter[0]=funcion.path[indice];
  977. strncat(carpeta,nuevoCaracter,1);
  978. }
  979. else
  980. {
  981. if(carpeta[0]!='\0')
  982. {
  983. strcat(finalizado,"mkdir ");
  984. strcat(finalizado,"\"");
  985. strcat(finalizado,carpeta);
  986. strcat(finalizado,"\"");
  987. strcat(finalizado,"\n");
  988. strcat(finalizado,"cd ");
  989. strcat(finalizado,"\"");
  990. strcat(finalizado,carpeta);
  991. strcat(finalizado,"\"");
  992. strcat(finalizado,"\n");
  993. strcat(carpeta,"");
  994.  
  995. }
  996. limpiarvar(carpeta,100);
  997.  
  998. }
  999. indice++;
  1000. }
  1001.  
  1002.  
  1003. printf("\n%s\n",finalizado);
  1004.  
  1005. system(finalizado);
  1006.  
  1007. int num;
  1008. FILE *fptr;
  1009. fptr = fopen(pathauxiliar2,"w");
  1010.  
  1011. if(fptr == NULL)
  1012. {
  1013. printf("Error!");
  1014. }else {
  1015.  
  1016.  
  1017.  
  1018. for(int i=0; i<4; i++)
  1019. {
  1020. if(!strcmp(nomb,mbr.particiones[i].part_name))
  1021. {
  1022.  
  1023. FILE *fp;
  1024. fp = fopen(path, "rb");
  1025. fseek(fp,sizeof (MbrDisco)+mbr.particiones[i].part_start,SEEK_SET);
  1026.  
  1027. if(fp == NULL)
  1028. {
  1029. printf("\n Error::-> No se encontro el disco\n");
  1030. }else {
  1031. int tamano;
  1032. fread(&super,sizeof (SuperBlock), 1, fp);
  1033. tamano=super.s_inodes_count;
  1034. fprintf(fptr,"digraph html{\n");
  1035. fprintf(fptr,"rankdir=LR\n");
  1036. for (int j=0;j<tamano;j++) {
  1037. char in;
  1038. fseek(fp,super.s_bm_inode_start +j,SEEK_SET);
  1039. fread(&in,1, 1, fp);
  1040. if(in=='1')
  1041. {
  1042. fprintf(fptr,"inodo%d[shape=none, margin=0,label=<\n",j);
  1043. Inodo ino;
  1044. fseek(fp,super.s_inode_start+(j*sizeof (Inodo)),SEEK_SET);
  1045. fread(&ino,sizeof (Inodo), 1, fp);
  1046. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  1047. fprintf(fptr,"<tr>\n");
  1048. fprintf(fptr,"<td colspan=\"2\" bgcolor=\" #5d6d7e \"> INODO_%d </td>\n",j);
  1049. fprintf(fptr,"</tr>\n");
  1050. fprintf(fptr,"<tr>\n");
  1051. fprintf(fptr,"<td> I_uid </td>\n");
  1052. fprintf(fptr,"<td> %d </td>\n",ino.i_uid);
  1053. fprintf(fptr,"</tr>\n");
  1054. fprintf(fptr,"<tr>\n");
  1055. fprintf(fptr,"<td> I_gid </td>\n");
  1056. fprintf(fptr,"<td> %d </td>\n",ino.I_gid);
  1057. fprintf(fptr,"</tr>\n");
  1058. fprintf(fptr,"<tr>\n");
  1059. fprintf(fptr,"<td> I_size </td>\n");
  1060. fprintf(fptr,"<td> %d </td>\n",ino.i_size);
  1061. fprintf(fptr,"</tr>\n");
  1062. fprintf(fptr,"<tr>\n");
  1063. fprintf(fptr,"<td> I_atime </td>\n");
  1064. fprintf(fptr,"<td> %s </td>\n",ino.i_atime);
  1065. fprintf(fptr,"</tr>\n");
  1066. fprintf(fptr,"<tr>\n");
  1067. fprintf(fptr,"<td> I_ctime </td>\n");
  1068. fprintf(fptr,"<td> %s </td>\n",ino.i_ctime);
  1069. fprintf(fptr,"</tr>\n");
  1070. fprintf(fptr,"<tr>\n");
  1071. fprintf(fptr,"<td> I_mtime </td>\n");
  1072. fprintf(fptr,"<td> %s </td>\n",ino.i_mtime);
  1073. fprintf(fptr,"</tr>\n");
  1074. fprintf(fptr,"<tr>\n");
  1075. fprintf(fptr,"<td> I_type </td>\n");
  1076. fprintf(fptr,"<td> %c </td>\n",ino.i_type);
  1077. fprintf(fptr,"</tr>\n");
  1078. fprintf(fptr,"<tr>\n");
  1079. fprintf(fptr,"<td> I_perm </td>\n");
  1080. fprintf(fptr,"<td> %d </td>\n",ino.i_perm);
  1081. fprintf(fptr,"</tr>\n");
  1082. for (int i=0;i<12;i++) {
  1083. fprintf(fptr,"<tr>\n");
  1084. fprintf(fptr,"<td> AD </td>\n");
  1085. fprintf(fptr,"<td> %d </td>\n",ino.i_block[i]);
  1086. fprintf(fptr,"</tr>\n");
  1087. }
  1088. fprintf(fptr,"<tr>\n");
  1089. fprintf(fptr,"<td> AI </td>\n");
  1090. fprintf(fptr,"<td> %d </td>\n",ino.i_block[12]);
  1091. fprintf(fptr,"</tr>\n");
  1092. fprintf(fptr,"<tr>\n");
  1093. fprintf(fptr,"<td> AI </td>\n");
  1094. fprintf(fptr,"<td> %d </td>\n",ino.i_block[13]);
  1095. fprintf(fptr,"</tr>\n");
  1096. fprintf(fptr,"<tr>\n");
  1097. fprintf(fptr,"<td> AI </td>\n");
  1098. fprintf(fptr,"<td> %d </td>\n",ino.i_block[14]);
  1099. fprintf(fptr,"</tr>\n");
  1100. fprintf(fptr,"</table>");
  1101.  
  1102. fprintf(fptr,">];\n");
  1103. //fprintf(fptr,"inodo%d->",j);
  1104. }
  1105.  
  1106. }
  1107.  
  1108.  
  1109. fprintf(fptr,"}\n");
  1110.  
  1111. fclose(fp);
  1112. fclose(fptr);
  1113. strcat(dot,"dot -Tpng ");
  1114. strcat(dot,pathauxiliar2);
  1115. strcat(dot," -o ");
  1116. strcat(dot,funcion.path);
  1117. printf("Inodo->%s\n",dot);
  1118. system(dot);
  1119. ContadorComandosExitosos++;
  1120.  
  1121.  
  1122. }
  1123.  
  1124.  
  1125.  
  1126.  
  1127. break;
  1128. }
  1129. }
  1130. }
  1131. limpiarvar(funcion.path,100);
  1132. limpiarvar(pathauxiliar2,200);
  1133. limpiarvar(pathauxiliar,200);
  1134. limpiarvar(finalizado,300);
  1135. limpiarvar(carpeta,100);
  1136. limpiarvar(dot,100);
  1137. limpiarvar(path,100);
  1138. limpiarvar(nomb,15);
  1139.  
  1140. }else {
  1141. printf("Error::-> Generar reporte\n");
  1142. ErrorReporte1++;
  1143. }
  1144. }
  1145.  
  1146.  
  1147. void GraficarTree (Funcion funcion)
  1148. {
  1149. int bandera =0;
  1150. SuperBlock super;
  1151. char direcciones[5000];
  1152. limpiarvar(direcciones,5000);
  1153.  
  1154.  
  1155. char nomb[15];
  1156. char path[100];
  1157. strcpy(nomb,obtenerNombre(funcion));
  1158. strcpy(path,obtenerPath(funcion));
  1159. MbrDisco mbr=obtenerMBR(funcion);
  1160.  
  1161. if(mbr.bandera!=-4)
  1162. {
  1163. char dot[100]="\0";
  1164. char pathauxiliar[200];
  1165. char pathauxiliar2[200];
  1166. limpiarvar(pathauxiliar2,200);
  1167. limpiarvar(pathauxiliar,200);
  1168. strcpy(pathauxiliar,funcion.path);
  1169. int q=0;
  1170. while(pathauxiliar[q]!='.')
  1171. {
  1172. char nuevoCaracter[1];
  1173. nuevoCaracter[0]=pathauxiliar[q];
  1174. strncat(pathauxiliar2,nuevoCaracter,1);
  1175. q++;
  1176. }
  1177. strcat(pathauxiliar2,".dot");
  1178.  
  1179.  
  1180. printf("%s\n",funcion.path);
  1181. printf("%s\n",pathauxiliar2);
  1182.  
  1183. char finalizado[300];
  1184. limpiarvar(finalizado,300);
  1185. strcpy(finalizado,"cd /\n");
  1186. int indice=0;
  1187. char carpeta[100];
  1188. limpiarvar(carpeta,100);
  1189.  
  1190. while(funcion.path[indice]!='.')
  1191. {
  1192. if(funcion.path[indice]!='/')
  1193. {
  1194.  
  1195. char nuevoCaracter[1];
  1196. nuevoCaracter[0]=funcion.path[indice];
  1197. strncat(carpeta,nuevoCaracter,1);
  1198. }
  1199. else
  1200. {
  1201. if(carpeta[0]!='\0')
  1202. {
  1203. strcat(finalizado,"mkdir ");
  1204. strcat(finalizado,"\"");
  1205. strcat(finalizado,carpeta);
  1206. strcat(finalizado,"\"");
  1207. strcat(finalizado,"\n");
  1208. strcat(finalizado,"cd ");
  1209. strcat(finalizado,"\"");
  1210. strcat(finalizado,carpeta);
  1211. strcat(finalizado,"\"");
  1212. strcat(finalizado,"\n");
  1213. strcat(carpeta,"");
  1214.  
  1215. }
  1216. limpiarvar(carpeta,100);
  1217.  
  1218. }
  1219. indice++;
  1220. }
  1221.  
  1222.  
  1223. printf("\n%s\n",finalizado);
  1224.  
  1225. system(finalizado);
  1226.  
  1227. int num;
  1228. FILE *fptr;
  1229. fptr = fopen(pathauxiliar2,"w");
  1230.  
  1231. if(fptr == NULL)
  1232. {
  1233. printf("Error!");
  1234. }else {
  1235.  
  1236.  
  1237. for(int i=0; i<4; i++)
  1238. {
  1239. if(!strcmp(nomb,mbr.particiones[i].part_name))
  1240. {
  1241.  
  1242. FILE *fp;
  1243. fp = fopen(path, "rb");
  1244. fseek(fp,sizeof (MbrDisco)+mbr.particiones[i].part_start,SEEK_SET);
  1245.  
  1246. if(fp == NULL)
  1247. {
  1248. printf("\n Error::-> No se encontro el disco\n");
  1249. }else {
  1250. int tamano;
  1251. fread(&super,sizeof (SuperBlock), 1, fp);
  1252. tamano=super.s_inodes_count;
  1253. fprintf(fptr,"digraph html{\n");
  1254. fprintf(fptr,"rankdir=LR\n");
  1255. for (int j=0;j<tamano;j++) {
  1256. char in;
  1257. fseek(fp,super.s_bm_inode_start +j,SEEK_SET);
  1258. fread(&in,1, 1, fp);
  1259. if(in=='1')
  1260. {
  1261. fprintf(fptr,"inodo%d[shape=none, margin=0,label=<\n",j);
  1262. Inodo ino;
  1263. fseek(fp,super.s_inode_start+(j*sizeof (Inodo)),SEEK_SET);
  1264. fread(&ino,sizeof (Inodo), 1, fp);
  1265. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  1266. fprintf(fptr,"<tr>\n");
  1267. fprintf(fptr,"<td colspan=\"2\" bgcolor=\" #5d6d7e \"> INODO_%d </td>\n",j);
  1268. fprintf(fptr,"</tr>\n");
  1269. fprintf(fptr,"<tr>\n");
  1270. fprintf(fptr,"<td> I_uid </td>\n");
  1271. fprintf(fptr,"<td> %d </td>\n",ino.i_uid);
  1272. fprintf(fptr,"</tr>\n");
  1273. fprintf(fptr,"<tr>\n");
  1274. fprintf(fptr,"<td> I_gid </td>\n");
  1275. fprintf(fptr,"<td> %d </td>\n",ino.I_gid);
  1276. fprintf(fptr,"</tr>\n");
  1277. fprintf(fptr,"<tr>\n");
  1278. fprintf(fptr,"<td> I_size </td>\n");
  1279. fprintf(fptr,"<td> %d </td>\n",ino.i_size);
  1280. fprintf(fptr,"</tr>\n");
  1281. fprintf(fptr,"<tr>\n");
  1282. fprintf(fptr,"<td> I_atime </td>\n");
  1283. fprintf(fptr,"<td> %s </td>\n",ino.i_atime);
  1284. fprintf(fptr,"</tr>\n");
  1285. fprintf(fptr,"<tr>\n");
  1286. fprintf(fptr,"<td> I_ctime </td>\n");
  1287. fprintf(fptr,"<td> %s </td>\n",ino.i_ctime);
  1288. fprintf(fptr,"</tr>\n");
  1289. fprintf(fptr,"<tr>\n");
  1290. fprintf(fptr,"<td> I_mtime </td>\n");
  1291. fprintf(fptr,"<td> %s </td>\n",ino.i_mtime);
  1292. fprintf(fptr,"</tr>\n");
  1293. fprintf(fptr,"<tr>\n");
  1294. fprintf(fptr,"<td> I_type </td>\n");
  1295. fprintf(fptr,"<td> %c </td>\n",ino.i_type);
  1296. fprintf(fptr,"</tr>\n");
  1297. fprintf(fptr,"<tr>\n");
  1298. fprintf(fptr,"<td> I_perm </td>\n");
  1299. fprintf(fptr,"<td> %d </td>\n",ino.i_perm);
  1300. fprintf(fptr,"</tr>\n");
  1301. for (int h=0;h<12;h++) {
  1302. fprintf(fptr,"<tr>\n");
  1303. fprintf(fptr,"<td> AD </td>\n");
  1304. fprintf(fptr,"<td PORT=\"AD%d\"> %d</td>\n",h,ino.i_block[h]);
  1305. if(ino.i_block[h]!=-1)
  1306. {
  1307. sprintf(direcciones,"%s inodo%d:AD%d->bloque%d\n",direcciones,j,h,ino.i_block[h]);
  1308. }
  1309. fprintf(fptr,"</tr>\n");
  1310. }
  1311.  
  1312. fprintf(fptr,"<tr>\n");
  1313. fprintf(fptr,"<td> AI </td>\n");
  1314. fprintf(fptr,"<td> %d </td>\n",ino.i_block[12]);
  1315. fprintf(fptr,"</tr>\n");
  1316. fprintf(fptr,"<tr>\n");
  1317. fprintf(fptr,"<td> AI </td>\n");
  1318. fprintf(fptr,"<td> %d </td>\n",ino.i_block[13]);
  1319. fprintf(fptr,"</tr>\n");
  1320. fprintf(fptr,"<tr>\n");
  1321. fprintf(fptr,"<td> AI </td>\n");
  1322. fprintf(fptr,"<td> %d </td>\n",ino.i_block[14]);
  1323. fprintf(fptr,"</tr>\n");
  1324. fprintf(fptr,"</table>");
  1325.  
  1326. fprintf(fptr,">];\n");
  1327.  
  1328.  
  1329.  
  1330.  
  1331.  
  1332. for (int i=0;i<12;i++) {
  1333. if(ino.i_type=='0')
  1334. {
  1335. if(ino.i_block[i]!=-1)
  1336. {
  1337. BloqueCarpeta bloqueC;
  1338. fseek(fp,super.s_block_start+(ino.i_block[i]*sizeof (BloqueArchivo)),SEEK_SET);
  1339. fread(&bloqueC,sizeof (BloqueArchivo), 1, fp);
  1340. fprintf(fptr,"bloque%d[shape=none, margin=0,label=<\n",ino.i_block[i]);
  1341. Inodo ino;
  1342. fseek(fp,super.s_inode_start+(j*sizeof (Inodo)),SEEK_SET);
  1343. fread(&ino,sizeof (Inodo), 1, fp);
  1344. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  1345. fprintf(fptr,"<tr>\n");
  1346. fprintf(fptr,"<td colspan=\"2\" bgcolor=\" #5d6d7e \"> BLOQUE_%d </td>\n",ino.i_block[i]);
  1347. fprintf(fptr,"</tr>\n");
  1348. fprintf(fptr,"<tr>\n");
  1349. fprintf(fptr,"<td> %s </td>\n",bloqueC.b_content[0].b_name);
  1350. fprintf(fptr,"<td PORT=\"AD0\"> %d </td>\n",bloqueC.b_content[0].b_inodo);
  1351. if(bloqueC.b_content[0].b_inodo!=-1 && i!=0)
  1352. {
  1353. sprintf(direcciones,"%s bloque%d:AD%d->inodo%d\n",direcciones,ino.i_block[i],0,bloqueC.b_content[0].b_inodo);
  1354. }
  1355. fprintf(fptr,"</tr>\n");
  1356. fprintf(fptr,"<tr>\n");
  1357. fprintf(fptr,"<td> %s </td>\n",bloqueC.b_content[1].b_name);
  1358. fprintf(fptr,"<td PORT=\"AD1\"> %d </td>\n",bloqueC.b_content[1].b_inodo);
  1359. if(bloqueC.b_content[1].b_inodo!=-1 && i!=0)
  1360. {
  1361. sprintf(direcciones,"%s bloque%d:AD%d->inodo%d\n",direcciones,ino.i_block[i],1,bloqueC.b_content[1].b_inodo);
  1362. }
  1363. fprintf(fptr,"</tr>\n");
  1364. fprintf(fptr,"<tr>\n");
  1365. fprintf(fptr,"<td> %s </td>\n",bloqueC.b_content[2].b_name);
  1366. fprintf(fptr,"<td PORT=\"AD2\"> %d </td>\n",bloqueC.b_content[2].b_inodo);
  1367. if(bloqueC.b_content[2].b_inodo!=-1)
  1368. {
  1369. sprintf(direcciones,"%s bloque%d:AD%d->inodo%d\n",direcciones,ino.i_block[i],2,bloqueC.b_content[2].b_inodo);
  1370. }
  1371. fprintf(fptr,"</tr>\n");
  1372. fprintf(fptr,"<tr>\n");
  1373. fprintf(fptr,"<td> %s </td>\n",bloqueC.b_content[3].b_name);
  1374. fprintf(fptr,"<td PORT=\"AD3\"> %d </td>\n",bloqueC.b_content[3].b_inodo);
  1375. if(bloqueC.b_content[3].b_inodo!=-1)
  1376. {
  1377. sprintf(direcciones,"%s bloque%d:AD%d->inodo%d\n",direcciones,ino.i_block[i],3,bloqueC.b_content[3].b_inodo);
  1378. }
  1379. fprintf(fptr,"</tr>\n");
  1380. fprintf(fptr,"</table>");
  1381. fprintf(fptr,">];\n");
  1382.  
  1383. }
  1384. }
  1385.  
  1386. if(ino.i_type=='1')
  1387. {
  1388. if(ino.i_block[i]!=-1)
  1389. {
  1390. BloqueArchivo bloqueC;
  1391. fseek(fp,super.s_block_start+(ino.i_block[i]*sizeof (BloqueArchivo)),SEEK_SET);
  1392. fread(&bloqueC,sizeof (BloqueArchivo), 1, fp);
  1393. fprintf(fptr,"bloque%d[shape=none, margin=0,label=<\n",ino.i_block[i]);
  1394. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  1395. fprintf(fptr,"<tr>\n");
  1396. fprintf(fptr,"<td colspan=\"2\" bgcolor=\" #5d6d7e \"> BLOQUE_%d </td>\n",ino.i_block[i]);
  1397. fprintf(fptr,"</tr>\n");
  1398. fprintf(fptr,"<tr>\n");
  1399. fprintf(fptr,"<td> Contenido </td>\n");
  1400. fprintf(fptr,"<td> %s</td>\n",bloqueC.b_content);
  1401. fprintf(fptr,"</tr>\n");
  1402. fprintf(fptr,"</table>");
  1403. fprintf(fptr,">];\n");
  1404.  
  1405. }
  1406. }
  1407. }
  1408. //fprintf(fptr,"inodo%d->",j);
  1409. }
  1410.  
  1411. }
  1412. fprintf(fptr,"%s",direcciones);
  1413. limpiarvar(direcciones,5000);
  1414.  
  1415. fprintf(fptr,"}\n");
  1416.  
  1417. fclose(fp);
  1418. fclose(fptr);
  1419. strcat(dot,"dot -Tpng ");
  1420. strcat(dot,pathauxiliar2);
  1421. strcat(dot," -o ");
  1422. strcat(dot,funcion.path);
  1423. printf("%s\n",dot);
  1424. system(dot);
  1425. ContadorComandosExitosos++;
  1426.  
  1427.  
  1428. }
  1429.  
  1430.  
  1431.  
  1432.  
  1433. break;
  1434. }
  1435. }
  1436. }
  1437. limpiarvar(funcion.path,100);
  1438. limpiarvar(pathauxiliar2,200);
  1439. limpiarvar(pathauxiliar,200);
  1440. limpiarvar(finalizado,300);
  1441. limpiarvar(carpeta,100);
  1442. limpiarvar(dot,100);
  1443. limpiarvar(path,100);
  1444. limpiarvar(nomb,15);
  1445.  
  1446. }else {
  1447. printf("Error::-> Generar reporte\n");
  1448. ErrorReporte1++;
  1449. }
  1450. }
  1451.  
  1452.  
  1453. void GraficarBloques (Funcion funcion)
  1454. {
  1455. int bandera =0;
  1456. SuperBlock super;
  1457.  
  1458.  
  1459. char nomb[15];
  1460. char path[100];
  1461. strcpy(nomb,obtenerNombre(funcion));
  1462. strcpy(path,obtenerPath(funcion));
  1463. MbrDisco mbr=obtenerMBR(funcion);
  1464.  
  1465. if(mbr.bandera!=-4)
  1466. {
  1467. char dot[100]="\0";
  1468. char pathauxiliar[200];
  1469. char pathauxiliar2[200];
  1470. limpiarvar(pathauxiliar2,200);
  1471. limpiarvar(pathauxiliar,200);
  1472. strcpy(pathauxiliar,funcion.path);
  1473. int q=0;
  1474. while(pathauxiliar[q]!='.')
  1475. {
  1476. char nuevoCaracter[1];
  1477. nuevoCaracter[0]=pathauxiliar[q];
  1478. strncat(pathauxiliar2,nuevoCaracter,1);
  1479. q++;
  1480. }
  1481. strcat(pathauxiliar2,".dot");
  1482.  
  1483.  
  1484. printf("%s\n",funcion.path);
  1485. printf("%s\n",pathauxiliar2);
  1486.  
  1487. char finalizado[300];
  1488. limpiarvar(finalizado,300);
  1489. strcpy(finalizado,"cd /\n");
  1490. int indice=0;
  1491. char carpeta[100];
  1492. limpiarvar(carpeta,100);
  1493.  
  1494. while(funcion.path[indice]!='.')
  1495. {
  1496. if(funcion.path[indice]!='/')
  1497. {
  1498.  
  1499. char nuevoCaracter[1];
  1500. nuevoCaracter[0]=funcion.path[indice];
  1501. strncat(carpeta,nuevoCaracter,1);
  1502. }
  1503. else
  1504. {
  1505. if(carpeta[0]!='\0')
  1506. {
  1507. strcat(finalizado,"mkdir ");
  1508. strcat(finalizado,"\"");
  1509. strcat(finalizado,carpeta);
  1510. strcat(finalizado,"\"");
  1511. strcat(finalizado,"\n");
  1512. strcat(finalizado,"cd ");
  1513. strcat(finalizado,"\"");
  1514. strcat(finalizado,carpeta);
  1515. strcat(finalizado,"\"");
  1516. strcat(finalizado,"\n");
  1517. strcat(carpeta,"");
  1518.  
  1519. }
  1520. limpiarvar(carpeta,100);
  1521.  
  1522. }
  1523. indice++;
  1524. }
  1525.  
  1526.  
  1527. printf("\n%s\n",finalizado);
  1528.  
  1529. system(finalizado);
  1530.  
  1531. int num;
  1532. FILE *fptr;
  1533. fptr = fopen(pathauxiliar2,"w");
  1534.  
  1535. if(fptr == NULL)
  1536. {
  1537. printf("Error!");
  1538. }else {
  1539.  
  1540.  
  1541. for(int i=0; i<4; i++)
  1542.  
  1543. {
  1544. if(!strcmp(nomb,mbr.particiones[i].part_name))
  1545. {
  1546.  
  1547. FILE *fp;
  1548. fp = fopen(path, "rb");
  1549. fseek(fp,sizeof (MbrDisco)+mbr.particiones[i].part_start,SEEK_SET);
  1550.  
  1551. if(fp == NULL)
  1552. {
  1553. printf("\n Error::-> No se encontro el disco\n");
  1554. }else {
  1555. int tamano;
  1556. fread(&super,sizeof (SuperBlock), 1, fp);
  1557. tamano=super.s_inodes_count;
  1558. fprintf(fptr,"digraph html{\n");
  1559. fprintf(fptr,"rankdir=LR\n");
  1560. for (int j=0;j<tamano;j++) {
  1561. char in;
  1562. fseek(fp,super.s_bm_inode_start +j,SEEK_SET);
  1563. fread(&in,1, 1, fp);
  1564. if(in=='1')
  1565. {
  1566. Inodo ino;
  1567. fseek(fp,super.s_inode_start+(j*sizeof (Inodo)),SEEK_SET);
  1568. fread(&ino,sizeof (Inodo), 1, fp);
  1569.  
  1570. for (int i=0;i<12;i++) {
  1571. if(ino.i_type=='0')
  1572. {
  1573. if(ino.i_block[i]!=-1)
  1574. {
  1575. BloqueCarpeta bloqueC;
  1576. fseek(fp,super.s_block_start+(ino.i_block[i]*sizeof (BloqueArchivo)),SEEK_SET);
  1577. fread(&bloqueC,sizeof (BloqueArchivo), 1, fp);
  1578. fprintf(fptr,"bloque%d[shape=none, margin=0,label=<\n",ino.i_block[i]);
  1579. Inodo ino;
  1580. fseek(fp,super.s_inode_start+(j*sizeof (Inodo)),SEEK_SET);
  1581. fread(&ino,sizeof (Inodo), 1, fp);
  1582. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  1583. fprintf(fptr,"<tr>\n");
  1584. fprintf(fptr,"<td colspan=\"2\" bgcolor=\" #5d6d7e \"> BLOQUE_%d </td>\n",ino.i_block[i]);
  1585. fprintf(fptr,"</tr>\n");
  1586. fprintf(fptr,"<tr>\n");
  1587. fprintf(fptr,"<td> %s </td>\n",bloqueC.b_content[0].b_name);
  1588. fprintf(fptr,"<td> %d </td>\n",bloqueC.b_content[0].b_inodo);
  1589. fprintf(fptr,"</tr>\n");
  1590. fprintf(fptr,"<tr>\n");
  1591. fprintf(fptr,"<td> %s </td>\n",bloqueC.b_content[1].b_name);
  1592. fprintf(fptr,"<td> %d </td>\n",bloqueC.b_content[1].b_inodo);
  1593. fprintf(fptr,"</tr>\n");
  1594. fprintf(fptr,"<tr>\n");
  1595. fprintf(fptr,"<td> %s </td>\n",bloqueC.b_content[2].b_name);
  1596. fprintf(fptr,"<td> %d </td>\n",bloqueC.b_content[2].b_inodo);
  1597. fprintf(fptr,"</tr>\n");
  1598. fprintf(fptr,"<tr>\n");
  1599. fprintf(fptr,"<td> %s </td>\n",bloqueC.b_content[3].b_name);
  1600. fprintf(fptr,"<td> %d </td>\n",bloqueC.b_content[3].b_inodo);
  1601. fprintf(fptr,"</tr>\n");
  1602. fprintf(fptr,"</table>");
  1603. fprintf(fptr,">];\n");
  1604.  
  1605. }
  1606. }
  1607.  
  1608. if(ino.i_type=='1')
  1609. {
  1610. if(ino.i_block[i]!=-1)
  1611. {
  1612. BloqueArchivo bloqueC;
  1613. fseek(fp,super.s_block_start+(ino.i_block[i]*sizeof (BloqueArchivo)),SEEK_SET);
  1614. fread(&bloqueC,sizeof (BloqueArchivo), 1, fp);
  1615. fprintf(fptr,"bloque%d[shape=none, margin=0,label=<\n",ino.i_block[i]);
  1616. Inodo ino;
  1617. fseek(fp,super.s_inode_start+(j*sizeof (Inodo)),SEEK_SET);
  1618. fread(&ino,sizeof (Inodo), 1, fp);
  1619. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  1620. fprintf(fptr,"<tr>\n");
  1621. fprintf(fptr,"<td colspan=\"2\" bgcolor=\" #5d6d7e \"> BLOQUE_%d </td>\n",ino.i_block[i]);
  1622. fprintf(fptr,"</tr>\n");
  1623. fprintf(fptr,"<tr>\n");
  1624. fprintf(fptr,"<td> Contenido </td>\n");
  1625. fprintf(fptr,"<td> %s </td>\n",bloqueC.b_content);
  1626. fprintf(fptr,"</tr>\n");
  1627. fprintf(fptr,"</table>");
  1628. fprintf(fptr,">];\n");
  1629.  
  1630. }
  1631. }
  1632. }
  1633.  
  1634.  
  1635. }
  1636.  
  1637. }
  1638.  
  1639.  
  1640. fprintf(fptr,"}\n");
  1641.  
  1642. fclose(fp);
  1643. fclose(fptr);
  1644. strcat(dot,"dot -Tpng ");
  1645. strcat(dot,pathauxiliar2);
  1646. strcat(dot," -o ");
  1647. strcat(dot,funcion.path);
  1648. printf("%s\n",dot);
  1649. system(dot);
  1650. ContadorComandosExitosos++;
  1651.  
  1652.  
  1653. }
  1654.  
  1655.  
  1656.  
  1657.  
  1658. break;
  1659. }
  1660. }
  1661. }
  1662. limpiarvar(funcion.path,100);
  1663. limpiarvar(pathauxiliar2,200);
  1664. limpiarvar(pathauxiliar,200);
  1665. limpiarvar(finalizado,300);
  1666. limpiarvar(carpeta,100);
  1667. limpiarvar(dot,100);
  1668. limpiarvar(path,100);
  1669. limpiarvar(nomb,15);
  1670.  
  1671. }else {
  1672. printf("Error::-> Generar reporte\n");
  1673. ErrorReporte1++;
  1674. }
  1675. }
  1676.  
  1677.  
  1678.  
  1679. void GraficarBitInodo(Funcion funcion)
  1680. {
  1681. int bandera =0;
  1682. SuperBlock super;
  1683.  
  1684. char nomb[15];
  1685. char path[100];
  1686. strcpy(nomb,obtenerNombre(funcion));
  1687. strcpy(path,obtenerPath(funcion));
  1688. MbrDisco mbr=obtenerMBR(funcion);
  1689.  
  1690. if(mbr.bandera!=-4)
  1691. {
  1692. char dot[100]="\0";
  1693. char pathauxiliar[200];
  1694. char pathauxiliar2[200];
  1695. limpiarvar(pathauxiliar2,200);
  1696. limpiarvar(pathauxiliar,200);
  1697. strcpy(pathauxiliar,funcion.path);
  1698. int q=0;
  1699. while(pathauxiliar[q]!='.')
  1700. {
  1701. char nuevoCaracter[1];
  1702. nuevoCaracter[0]=pathauxiliar[q];
  1703. strncat(pathauxiliar2,nuevoCaracter,1);
  1704. q++;
  1705. }
  1706. strcat(pathauxiliar2,".dot");
  1707.  
  1708.  
  1709. printf("%s\n",funcion.path);
  1710. printf("%s\n",pathauxiliar2);
  1711.  
  1712. char finalizado[300];
  1713. limpiarvar(finalizado,300);
  1714. strcpy(finalizado,"cd /\n");
  1715. int indice=0;
  1716. char carpeta[100];
  1717. limpiarvar(carpeta,100);
  1718.  
  1719. while(funcion.path[indice]!='.')
  1720. {
  1721. if(funcion.path[indice]!='/')
  1722. {
  1723.  
  1724. char nuevoCaracter[1];
  1725. nuevoCaracter[0]=funcion.path[indice];
  1726. strncat(carpeta,nuevoCaracter,1);
  1727. }
  1728. else
  1729. {
  1730. if(carpeta[0]!='\0')
  1731. {
  1732. strcat(finalizado,"mkdir ");
  1733. strcat(finalizado,"\"");
  1734. strcat(finalizado,carpeta);
  1735. strcat(finalizado,"\"");
  1736. strcat(finalizado,"\n");
  1737. strcat(finalizado,"cd ");
  1738. strcat(finalizado,"\"");
  1739. strcat(finalizado,carpeta);
  1740. strcat(finalizado,"\"");
  1741. strcat(finalizado,"\n");
  1742. strcat(carpeta,"");
  1743.  
  1744. }
  1745. limpiarvar(carpeta,100);
  1746.  
  1747. }
  1748. indice++;
  1749. }
  1750.  
  1751.  
  1752. printf("\n%s\n",finalizado);
  1753.  
  1754. system(finalizado);
  1755.  
  1756. int num;
  1757. FILE *fptr;
  1758. fptr = fopen(funcion.path,"w");
  1759.  
  1760. if(fptr == NULL)
  1761. {
  1762. printf("Error!");
  1763. }else {
  1764.  
  1765.  
  1766.  
  1767. for(int i=0; i<4; i++)
  1768. {
  1769. if(!strcmp(nomb,mbr.particiones[i].part_name))
  1770. {
  1771.  
  1772. FILE *fp;
  1773. fp = fopen(path, "rb");
  1774. fseek(fp,sizeof (MbrDisco)+mbr.particiones[i].part_start,SEEK_SET);
  1775.  
  1776. if(fp == NULL)
  1777. {
  1778. printf("\n Error::-> No se encontro el disco\n");
  1779. }else {
  1780. fread(&super,sizeof (SuperBlock), 1, fp);
  1781.  
  1782.  
  1783. for (int j=0;j<super.s_inodes_count;j++) {
  1784. char in;
  1785. fseek(fp,super.s_bm_inode_start +j,SEEK_SET);
  1786. fread(&in,1, 1, fp);
  1787. fprintf(fptr,"%c",in);
  1788. if((j+1)%20==0)
  1789. {
  1790. fprintf(fptr,"\n");
  1791. }
  1792. }
  1793. fclose(fp);
  1794.  
  1795. ContadorComandosExitosos++;
  1796.  
  1797.  
  1798. }
  1799.  
  1800.  
  1801.  
  1802.  
  1803. break;
  1804. }
  1805. }
  1806. fclose(fptr);
  1807. }
  1808. limpiarvar(funcion.path,100);
  1809. limpiarvar(pathauxiliar2,200);
  1810. limpiarvar(pathauxiliar,200);
  1811. limpiarvar(finalizado,300);
  1812. limpiarvar(carpeta,100);
  1813. limpiarvar(dot,100);
  1814. limpiarvar(path,100);
  1815. limpiarvar(nomb,15);
  1816.  
  1817. }else {
  1818. printf("Error::-> Generar reporte\n");
  1819. ErrorReporte1++;
  1820. }
  1821. }
  1822.  
  1823.  
  1824. void GraficarBitBloque(Funcion funcion)
  1825. {
  1826. int bandera =0;
  1827. SuperBlock super;
  1828.  
  1829. char nomb[15];
  1830. char path[100];
  1831. strcpy(nomb,obtenerNombre(funcion));
  1832. strcpy(path,obtenerPath(funcion));
  1833. MbrDisco mbr=obtenerMBR(funcion);
  1834.  
  1835. if(mbr.bandera!=-4)
  1836. {
  1837. char dot[100]="\0";
  1838. char pathauxiliar[200];
  1839. char pathauxiliar2[200];
  1840. limpiarvar(pathauxiliar2,200);
  1841. limpiarvar(pathauxiliar,200);
  1842. strcpy(pathauxiliar,funcion.path);
  1843. int q=0;
  1844. while(pathauxiliar[q]!='.')
  1845. {
  1846. char nuevoCaracter[1];
  1847. nuevoCaracter[0]=pathauxiliar[q];
  1848. strncat(pathauxiliar2,nuevoCaracter,1);
  1849. q++;
  1850. }
  1851. strcat(pathauxiliar2,".dot");
  1852.  
  1853.  
  1854. printf("%s\n",funcion.path);
  1855. printf("%s\n",pathauxiliar2);
  1856.  
  1857. char finalizado[300];
  1858. limpiarvar(finalizado,300);
  1859. strcpy(finalizado,"cd /\n");
  1860. int indice=0;
  1861. char carpeta[100];
  1862. limpiarvar(carpeta,100);
  1863.  
  1864. while(funcion.path[indice]!='.')
  1865. {
  1866. if(funcion.path[indice]!='/')
  1867. {
  1868.  
  1869. char nuevoCaracter[1];
  1870. nuevoCaracter[0]=funcion.path[indice];
  1871. strncat(carpeta,nuevoCaracter,1);
  1872. }
  1873. else
  1874. {
  1875. if(carpeta[0]!='\0')
  1876. {
  1877. strcat(finalizado,"mkdir ");
  1878. strcat(finalizado,"\"");
  1879. strcat(finalizado,carpeta);
  1880. strcat(finalizado,"\"");
  1881. strcat(finalizado,"\n");
  1882. strcat(finalizado,"cd ");
  1883. strcat(finalizado,"\"");
  1884. strcat(finalizado,carpeta);
  1885. strcat(finalizado,"\"");
  1886. strcat(finalizado,"\n");
  1887. strcat(carpeta,"");
  1888.  
  1889. }
  1890. limpiarvar(carpeta,100);
  1891.  
  1892. }
  1893. indice++;
  1894. }
  1895.  
  1896.  
  1897. printf("\n%s\n",finalizado);
  1898.  
  1899. system(finalizado);
  1900.  
  1901. int num;
  1902. FILE *fptr;
  1903. fptr = fopen(funcion.path,"w");
  1904.  
  1905. if(fptr == NULL)
  1906. {
  1907. printf("Error!");
  1908. }else {
  1909.  
  1910. for(int i=0; i<4; i++)
  1911. {
  1912. if(!strcmp(nomb,mbr.particiones[i].part_name))
  1913. {
  1914.  
  1915. FILE *fp;
  1916. fp = fopen(path, "rb");
  1917. fseek(fp,sizeof (MbrDisco)+mbr.particiones[i].part_start,SEEK_SET);
  1918.  
  1919. if(fp == NULL)
  1920. {
  1921. printf("\n Error::-> No se encontro el disco\n");
  1922. }else {
  1923. fread(&super,sizeof (SuperBlock), 1, fp);
  1924.  
  1925.  
  1926. for (int j=0;j<super.s_blocks_count;j++) {
  1927. char in;
  1928. fseek(fp,super.s_bm_block_start +j,SEEK_SET);
  1929. fread(&in,1, 1, fp);
  1930. fprintf(fptr,"%c",in);
  1931. if((j+1)%20==0)
  1932. {
  1933. fprintf(fptr,"\n");
  1934. }
  1935. }
  1936. fclose(fp);
  1937.  
  1938. ContadorComandosExitosos++;
  1939.  
  1940.  
  1941.  
  1942. }
  1943.  
  1944.  
  1945.  
  1946.  
  1947. break;
  1948. }
  1949. }
  1950. fclose(fptr);
  1951. }
  1952. limpiarvar(funcion.path,100);
  1953. limpiarvar(pathauxiliar2,200);
  1954. limpiarvar(pathauxiliar,200);
  1955. limpiarvar(finalizado,300);
  1956. limpiarvar(carpeta,100);
  1957. limpiarvar(dot,100);
  1958. limpiarvar(path,100);
  1959. limpiarvar(nomb,15);
  1960.  
  1961. }else {
  1962. printf("Error::-> Generar reporte\n");
  1963. ErrorReporte1++;
  1964. }
  1965. }
  1966.  
  1967.  
  1968.  
  1969. void Graficar2(Funcion funcion)
  1970. {
  1971. MbrDisco *mbr=BuscarDisco(funcion);
  1972. if(mbr!=NULL)
  1973. {
  1974. char dot[100]="\0";
  1975. char pathauxiliar[200];
  1976. char pathauxiliar2[200];
  1977. limpiarvar(pathauxiliar2,200);
  1978. limpiarvar(pathauxiliar,200);
  1979. strcpy(pathauxiliar,funcion.path);
  1980. int q=0;
  1981. while(pathauxiliar[q]!='.')
  1982. {
  1983. char nuevoCaracter[1];
  1984. nuevoCaracter[0]=pathauxiliar[q];
  1985. strncat(pathauxiliar2,nuevoCaracter,1);
  1986. q++;
  1987. }
  1988. strcat(pathauxiliar2,".dot");
  1989.  
  1990.  
  1991. printf("%s\n",funcion.path);
  1992. printf("%s\n",pathauxiliar2);
  1993.  
  1994. char finalizado[300];
  1995. strcpy(finalizado,"cd /\n");
  1996. int indice=0;
  1997. char carpeta[100];
  1998.  
  1999. while(funcion.path[indice]!='.')
  2000. {
  2001. if(funcion.path[indice]!='/')
  2002. {
  2003.  
  2004. char nuevoCaracter[1];
  2005. nuevoCaracter[0]=funcion.path[indice];
  2006. strncat(carpeta,nuevoCaracter,1);
  2007. }
  2008. else
  2009. {
  2010. if(carpeta[0]!='\0')
  2011. {
  2012. strcat(finalizado,"mkdir ");
  2013. strcat(finalizado,"\"");
  2014. strcat(finalizado,carpeta);
  2015. strcat(finalizado,"\"");
  2016. strcat(finalizado,"\n");
  2017. strcat(finalizado,"cd ");
  2018. strcat(finalizado,"\"");
  2019. strcat(finalizado,carpeta);
  2020. strcat(finalizado,"\"");
  2021. strcat(finalizado,"\n");
  2022. strcat(carpeta,"");
  2023.  
  2024. }
  2025. limpiarvar(carpeta,100);
  2026.  
  2027. }
  2028. indice++;
  2029. }
  2030.  
  2031.  
  2032. printf("\n%s\n",finalizado);
  2033.  
  2034. system(finalizado);
  2035.  
  2036. int num;
  2037. FILE *fptr;
  2038. fptr = fopen(pathauxiliar2,"w");
  2039.  
  2040. if(fptr == NULL)
  2041. {
  2042. printf("Error!");
  2043. }else {
  2044.  
  2045.  
  2046.  
  2047. fprintf(fptr,"digraph G{\n");
  2048. fprintf(fptr,"aHtmlTable[");
  2049. fprintf(fptr,"shape=plaintext ");
  2050. fprintf(fptr,"color=\"#2471a3\" ");
  2051. fprintf(fptr,"label=<\n");
  2052. fprintf(fptr,"<table border=\"2px\">\n");
  2053. fprintf(fptr,"<tr>\n");
  2054. fprintf(fptr,"<td rowspan=\"2\">MBR</td>\n");
  2055. int a[4];
  2056. int n=0;
  2057. int e=-1;
  2058. for (int i=0;i<4;i++) {
  2059. if(mbr->particiones[i].part_status=='1')
  2060. {
  2061. a[i]=mbr->particiones[i].part_start;
  2062. if(mbr->particiones[i].part_type=='E' || mbr->particiones[i].part_type=='e')
  2063. {
  2064. e=i;
  2065. }
  2066. n++;
  2067. }
  2068. }
  2069.  
  2070. int i,j,aux;
  2071. for(i=0;i<n;i++)
  2072. {
  2073. printf("%d,",a[i]);
  2074. }
  2075. printf("\n");
  2076. for(i=0;i<=n;i++){
  2077. for(j=0;j<n-1;j++){
  2078. if(a[j]>a[j+1]){
  2079. aux=a[j];
  2080. a[j]=a[j+1];
  2081. a[j+1]=aux;
  2082. }
  2083. }
  2084. }
  2085. printf("\n");
  2086. for(i=0;i<n;i++)
  2087. {
  2088. printf("%d,",a[i]);
  2089. }
  2090. printf("\n");
  2091. for (int j=0;j<4;j++) {
  2092. for (int i=0;i<4;i++) {
  2093.  
  2094. if(a[j]==mbr->particiones[i].part_start)
  2095. {
  2096. printf("Espacio-> %d\n",a[j]);
  2097. int AntVacio=0;
  2098. int Ant=0;
  2099. int SigVacio=0;
  2100. int Sig=0;
  2101. if(j!=0)
  2102. {
  2103. for (int i=0;i<4;i++) {
  2104. if(a[j-1]==mbr->particiones[i].part_start)
  2105. {
  2106. Ant=i;
  2107. AntVacio=1;
  2108. break;
  2109. }
  2110. }
  2111.  
  2112. }
  2113. int Sigvaci=0;
  2114. int sigui=0;
  2115. if(j!=3)
  2116. {
  2117. for (int i=0;i<4;i++) {
  2118. if(a[j+1]==mbr->particiones[i].part_start)
  2119. {
  2120. Sig=i;
  2121. SigVacio=1;
  2122. break;
  2123. }
  2124. }
  2125.  
  2126. }
  2127. if(j==0)
  2128. {
  2129. printf("Entre principio y primero\n");
  2130. printf("Inicio %d\n",1);
  2131. printf("Fin %d\n",mbr->particiones[i].part_start);
  2132. double a=mbr->particiones[i].part_start;
  2133. double b=1;
  2134. double c=mbr->mbr_tamano;
  2135. double po= ((a-b)/c)*100;
  2136. if(po>0)
  2137. {
  2138.  
  2139. fprintf(fptr,"<td rowspan=\"2\">Libre <br/>%.2f%%</td>\n",po);
  2140. }
  2141.  
  2142. if((mbr->particiones[i].part_type=='p'||mbr->particiones[i].part_type=='P') && mbr->particiones[i].part_status=='1')
  2143. {
  2144. double b=mbr->particiones[i].part_size;
  2145. double c=mbr->mbr_tamano;
  2146. double po=(b/c)*100;
  2147. fprintf(fptr,"<td rowspan=\"2\">Primaria <br/>%.2f%%</td>\n",po);
  2148. }
  2149. else if((mbr->particiones[i].part_type=='e'||mbr->particiones[i].part_type=='E') && mbr->particiones[i].part_status=='1')
  2150. {
  2151. double b=mbr->particiones[i].part_size;
  2152. double c=mbr->mbr_tamano;
  2153. double po=(b/c)*100;
  2154.  
  2155. char path[50];
  2156. Montura *pivote=sistema->primero;
  2157. while (pivote!=NULL) {
  2158. if(!strcmp(funcion.id,pivote->name))
  2159. {
  2160. int l=0;
  2161. for(int k=0;k<50;k++)
  2162. {
  2163. path[l++]=pivote->path[k];
  2164. }
  2165. break;
  2166. }
  2167. pivote=pivote->siguiente;
  2168. }
  2169.  
  2170. EBR lec;
  2171. EBR sig;
  2172. int cont=1;
  2173.  
  2174. int inicio= mbr->particiones[e].part_start;
  2175. FILE *fp = fopen(path, "rb");
  2176. printf("Inicio %d\n",inicio+sizeof (MbrDisco));
  2177. fseek(fp,inicio+sizeof (MbrDisco),SEEK_SET);
  2178.  
  2179. if(fp == NULL)
  2180. {
  2181. printf("\n Error::-> No se encontro el disco\n");
  2182. }else {
  2183. fread(&lec, sizeof(EBR), 1, fp);
  2184. fclose(fp);
  2185. }
  2186. int siguiente=lec.part_next;
  2187. sig=lec;
  2188. while (siguiente!=-1) {
  2189. fp = fopen(path, "rb");
  2190. fseek(fp,siguiente+sizeof (MbrDisco)+sizeof (EBR),SEEK_SET);
  2191.  
  2192. if(fp == NULL)
  2193. {
  2194. printf("\n Error::-> No se encontro el disco\n");
  2195. }else {
  2196. fread(&sig, sizeof(EBR), 1, fp);
  2197. fclose(fp);
  2198. }
  2199.  
  2200.  
  2201. cont++;
  2202.  
  2203. siguiente=sig.part_next;
  2204. }
  2205.  
  2206. fprintf(fptr,"<td rowspan=\"1\" colspan=\"%d\">Extendida <br/>%.2f%%</td>\n",cont*2,po);
  2207. }
  2208. if(SigVacio==0)
  2209. {
  2210. printf("Primero y final\n");
  2211. printf("Inicio %d\n",mbr->particiones[i].part_start+mbr->particiones[i].part_size);
  2212. printf("Fin %d\n",mbr->mbr_tamano);
  2213. double a=mbr->mbr_tamano;
  2214. double b=mbr->particiones[i].part_start+mbr->particiones[i].part_size;
  2215. double c=mbr->mbr_tamano;
  2216. double po= ((a-b)/c)*100;
  2217. if(po>0)
  2218. {
  2219.  
  2220. fprintf(fptr,"<td rowspan=\"2\">Libre <br/>%.2f%%</td>\n",po);
  2221. }
  2222. }
  2223.  
  2224. }
  2225. else
  2226. {
  2227. printf("Entre %d y %d\n",j,j+1);
  2228. printf("Inicio %d\n",mbr->particiones[Ant].part_start+mbr->particiones[Ant].part_size);
  2229. printf("Fin %d\n",mbr->particiones[i].part_start);
  2230. double a=mbr->particiones[i].part_start;
  2231. double b=mbr->particiones[Ant].part_start+mbr->particiones[Ant].part_size;
  2232. double c=mbr->mbr_tamano;
  2233. double po= ((a-b)/c)*100;
  2234. if(po>0)
  2235. {
  2236.  
  2237. fprintf(fptr,"<td rowspan=\"2\">Libre <br/>%.2f%%</td>\n",po);
  2238. }
  2239.  
  2240. if((mbr->particiones[i].part_type=='p'||mbr->particiones[i].part_type=='P') && mbr->particiones[i].part_status=='1')
  2241. {
  2242. double b=mbr->particiones[i].part_size;
  2243. double c=mbr->mbr_tamano;
  2244. double po=(b/c)*100;
  2245. fprintf(fptr,"<td rowspan=\"2\">Primaria <br/>%.2f%%</td>\n",po);
  2246. }
  2247. else if((mbr->particiones[i].part_type=='e'||mbr->particiones[i].part_type=='E') && mbr->particiones[i].part_status=='1')
  2248. {
  2249. double b=mbr->particiones[i].part_size;
  2250. double c=mbr->mbr_tamano;
  2251. double po=(b/c)*100;
  2252.  
  2253. char path[50];
  2254. Montura *pivote=sistema->primero;
  2255. while (pivote!=NULL) {
  2256. if(!strcmp(funcion.id,pivote->name))
  2257. {
  2258. int l=0;
  2259. for(int k=0;k<50;k++)
  2260. {
  2261. path[l++]=pivote->path[k];
  2262. }
  2263. break;
  2264. }
  2265. pivote=pivote->siguiente;
  2266. }
  2267.  
  2268. EBR lec;
  2269. EBR sig;
  2270. int cont=1;
  2271. int inicio= mbr->particiones[e].part_start;
  2272. FILE *fp = fopen(path, "rb");
  2273. printf("Inicio %d\n",inicio+sizeof (MbrDisco));
  2274. fseek(fp,inicio+sizeof (MbrDisco),SEEK_SET);
  2275.  
  2276. if(fp == NULL)
  2277. {
  2278. printf("\n Error::-> No se encontro el disco\n");
  2279. }else {
  2280. fread(&lec, sizeof(EBR), 1, fp);
  2281. fclose(fp);
  2282. }
  2283. int siguiente=lec.part_next;
  2284. sig=lec;
  2285. while (siguiente!=-1) {
  2286. fp = fopen(path, "rb");
  2287. fseek(fp,siguiente+sizeof (MbrDisco)+sizeof (EBR),SEEK_SET);
  2288.  
  2289. if(fp == NULL)
  2290. {
  2291. printf("\n Error::-> No se encontro el disco\n");
  2292. }else {
  2293. fread(&sig, sizeof(EBR), 1, fp);
  2294. fclose(fp);
  2295. }
  2296.  
  2297.  
  2298. cont++;
  2299.  
  2300. siguiente=sig.part_next;
  2301. }
  2302.  
  2303. fprintf(fptr,"<td rowspan=\"1\" colspan=\"%d\">Extendida <br/>%.2f%%</td>\n",cont*2,po);
  2304. }
  2305. if(SigVacio==0)
  2306. {
  2307. printf("%d y final\n",j);
  2308. printf("Inicio %d\n",mbr->particiones[i].part_start+mbr->particiones[i].part_size);
  2309. printf("Fin %d\n",mbr->mbr_tamano);
  2310. double a=mbr->mbr_tamano;
  2311. double b=mbr->particiones[i].part_start+mbr->particiones[i].part_size;
  2312. double c=mbr->mbr_tamano;
  2313. double po= ((a-b)/c)*100;
  2314. if(po>0)
  2315. {
  2316.  
  2317. fprintf(fptr,"<td rowspan=\"2\">Libre <br/>%.2f%%</td>\n",po);
  2318. }
  2319. }
  2320.  
  2321. }
  2322.  
  2323.  
  2324. break;
  2325.  
  2326.  
  2327. }
  2328. }
  2329. }
  2330.  
  2331. EBR sig;
  2332. EBR ant;
  2333. fprintf(fptr,"</tr>\n");
  2334. if(e!=-1)
  2335. {
  2336. char path[50];
  2337. Montura *pivote=sistema->primero;
  2338. while (pivote!=NULL) {
  2339. if(!strcmp(funcion.id,pivote->name))
  2340. {
  2341. int l=0;
  2342. for(int k=0;k<50;k++)
  2343. {
  2344. path[l++]=pivote->path[k];
  2345. }
  2346. break;
  2347. }
  2348. pivote=pivote->siguiente;
  2349. }
  2350. printf("%s\n",path);
  2351.  
  2352. EBR lec;
  2353.  
  2354. int inicio= mbr->particiones[e].part_start;
  2355. FILE *fp = fopen(path, "rb");
  2356. printf("Inicio %d\n",inicio+sizeof (MbrDisco));
  2357. fseek(fp,inicio+sizeof (MbrDisco),SEEK_SET);
  2358.  
  2359. if(fp == NULL)
  2360. {
  2361. printf("\n Error::-> No se encontro el disco\n");
  2362. }else {
  2363. fread(&lec, sizeof(EBR), 1, fp);
  2364. fclose(fp);
  2365. }
  2366. printf("Siguiente %d\n",lec.part_next);
  2367. int siguiente=lec.part_next;
  2368. sig=lec;
  2369. ant=lec;
  2370. int contador=0;
  2371. fprintf(fptr,"<tr>\n");
  2372. while (siguiente!=-1) {
  2373.  
  2374. contador++;
  2375. fprintf(fptr," <td>EBR</td>\n");
  2376. ant=sig;
  2377. fp = fopen(path, "rb");
  2378. fseek(fp,siguiente+sizeof (MbrDisco)+sizeof (EBR),SEEK_SET);
  2379.  
  2380. if(fp == NULL)
  2381. {
  2382. printf("\n Error::-> No se encontro el disco\n");
  2383. }else {
  2384. fread(&sig, sizeof(EBR), 1, fp);
  2385. fclose(fp);
  2386. }
  2387.  
  2388. double b=sig.part_size;
  2389. double c=mbr->mbr_tamano;
  2390. double po=(b/c)*100;
  2391. fprintf(fptr,"<td rowspan=\"1\">Logica <br/>%.2f%%</td>\n",po);
  2392.  
  2393.  
  2394. siguiente=sig.part_next;
  2395. printf("Siguiente %d\n",siguiente);
  2396.  
  2397.  
  2398. }
  2399. double b=ant.part_start+ant.part_size;
  2400. printf("Inicio %d\n",ant.part_start+ant.part_size);
  2401. double c=mbr->mbr_tamano;
  2402. double a=mbr->particiones[e].part_size+mbr->particiones[e].part_start;
  2403. printf("Fin %d\n",mbr->particiones[e].part_size+mbr->particiones[e].part_start);
  2404. double po=((a-b)/c)*100;
  2405. if(po>0)
  2406. {
  2407. fprintf(fptr,"<td rowspan=\"1\">Libre <br/>%.2f%%</td>\n",po);
  2408. }
  2409.  
  2410. if(contador==0)
  2411. {
  2412. fprintf(fptr," <td>EBR</td>\n");
  2413. }
  2414.  
  2415. fprintf(fptr," </tr>\n");
  2416. }
  2417.  
  2418.  
  2419.  
  2420.  
  2421. fprintf(fptr,"</table>\n");
  2422. fprintf(fptr,">];\n");
  2423.  
  2424.  
  2425. fprintf(fptr,"}\n");
  2426. fclose(fptr);
  2427. strcat(dot,"dot -Tpng ");
  2428. strcat(dot,pathauxiliar2);
  2429. strcat(dot," -o ");
  2430. strcat(dot,funcion.path);
  2431. printf("%s\n",dot);
  2432. system(dot);
  2433. ContadorComandosExitosos++;
  2434. limpiarvar(funcion.path,100);
  2435. limpiarvar(pathauxiliar2,100);
  2436. }
  2437. }else {
  2438. printf("Error::-> Generar reporte\n");
  2439. }
  2440. }
  2441.  
  2442.  
  2443. void Graficar(Funcion funcion)
  2444. {
  2445. MbrDisco *mbr=BuscarDisco(funcion);
  2446. if(mbr!=NULL)
  2447. {
  2448. char dot[100]="\0";
  2449. char pathauxiliar[200];
  2450. char pathauxiliar2[200];
  2451. strcpy(pathauxiliar,funcion.path);
  2452. int q=0;
  2453. while(pathauxiliar[q]!='.')
  2454. {
  2455. char nuevoCaracter[1];
  2456. nuevoCaracter[0]=pathauxiliar[q];
  2457. strncat(pathauxiliar2,nuevoCaracter,1);
  2458. q++;
  2459. }
  2460. strcat(pathauxiliar2,".dot");
  2461.  
  2462.  
  2463. printf("%s\n",funcion.path);
  2464. printf("%s\n",pathauxiliar2);
  2465.  
  2466. char finalizado[500];
  2467. strcpy(finalizado,"cd /\n");
  2468. int indice=0;
  2469. char carpeta[500];
  2470.  
  2471. while(funcion.path[indice]!='.')
  2472. {
  2473. if(funcion.path[indice]!='/')
  2474. {
  2475.  
  2476. char nuevoCaracter[1];
  2477. nuevoCaracter[0]=funcion.path[indice];
  2478. strncat(carpeta,nuevoCaracter,1);
  2479. }
  2480. else
  2481. {
  2482. if(carpeta[0]!='\0')
  2483. {
  2484. strcat(finalizado,"mkdir ");
  2485. strcat(finalizado,"\"");
  2486. strcat(finalizado,carpeta);
  2487. strcat(finalizado,"\"");
  2488. strcat(finalizado,"\n");
  2489. strcat(finalizado,"cd ");
  2490. strcat(finalizado,"\"");
  2491. strcat(finalizado,carpeta);
  2492. strcat(finalizado,"\"");
  2493. strcat(finalizado,"\n");
  2494. strcat(carpeta,"");
  2495.  
  2496. }
  2497. limpiarvar(carpeta,500);
  2498.  
  2499. }
  2500. indice++;
  2501. }
  2502.  
  2503.  
  2504. printf("\n%s\n",finalizado);
  2505.  
  2506. system(finalizado);
  2507.  
  2508. int num;
  2509. FILE *fptr;
  2510. fptr = fopen(pathauxiliar2,"w");
  2511.  
  2512. if(fptr == NULL)
  2513. {
  2514. printf("Error!");
  2515. }else {
  2516.  
  2517.  
  2518.  
  2519.  
  2520. fprintf(fptr,"digraph G{\n");
  2521. fprintf(fptr,"aHtmlTable[");
  2522. fprintf(fptr,"shape=plaintext ");
  2523. fprintf(fptr,"color=\"#2471a3\" ");
  2524. fprintf(fptr,"label=<\n");
  2525. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  2526. fprintf(fptr,"<tr>\n");
  2527. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> NOMBRE </td>\n");
  2528. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> VALOR </td>\n");
  2529. fprintf(fptr,"</tr>\n");
  2530. fprintf(fptr,"<tr>\n");
  2531. fprintf(fptr,"<td> mbr_tamano</td>\n");
  2532. fprintf(fptr,"<td>");
  2533. fprintf(fptr,"%d", mbr->mbr_tamano);
  2534. fprintf(fptr,"</td>\n");
  2535. fprintf(fptr,"</tr>\n");
  2536. fprintf(fptr,"<tr>\n");
  2537. fprintf(fptr,"<td> mbr_fecha_creacion </td>\n");
  2538. fprintf(fptr,"<td>");
  2539. fprintf(fptr,"%s", mbr->mbr_fecha_creacion);
  2540. fprintf(fptr,"</td>\n");
  2541. fprintf(fptr,"</tr>\n");
  2542. fprintf(fptr,"<tr>\n");
  2543. fprintf(fptr,"<td> mbr_disk_signature </td>\n");
  2544. fprintf(fptr,"<td>");
  2545. fprintf(fptr,"%d", mbr->mbr_disk_signature);
  2546. fprintf(fptr,"</td>\n");
  2547. fprintf(fptr,"</tr>\n");
  2548. fprintf(fptr,"<tr>\n");
  2549. fprintf(fptr,"<td> Disk_fit </td>\n");
  2550. fprintf(fptr,"<td>");
  2551. fprintf(fptr,"%s", mbr->mbr_fit);
  2552. fprintf(fptr,"</td>\n");
  2553. fprintf(fptr,"</tr>\n");
  2554. int a[4];
  2555. int n=0;
  2556. for (int i=0;i<4;i++) {
  2557. if(mbr->particiones[i].part_status=='1')
  2558. {
  2559. a[i]=mbr->particiones[i].part_start;
  2560. n++;
  2561. }
  2562. }
  2563.  
  2564. int i,j,aux;
  2565. for(i=0;i<n;i++)
  2566. {
  2567. printf("%d,",a[i]);
  2568. }
  2569. printf("%d\n");
  2570. for(i=0;i<=n;i++){
  2571. for(j=0;j<n-1;j++){
  2572. if(a[j]>a[j+1]){
  2573. aux=a[j];
  2574. a[j]=a[j+1];
  2575. a[j+1]=aux;
  2576. }
  2577. }
  2578. }
  2579. for(i=0;i<n;i++)
  2580. {
  2581. printf("%d,",a[i]);
  2582. }
  2583. printf("%d\n",a[i]);
  2584. int e=-1;
  2585. for (int j=0;j<4;j++) {
  2586. for (int i=0;i<4;i++) {
  2587. if(a[j]==mbr->particiones[i].part_start)
  2588. {
  2589. if(mbr->particiones[i].part_type=='E' || mbr->particiones[i].part_type=='e')
  2590. {
  2591. e=i;
  2592. }
  2593. fprintf(fptr,"<tr>\n");
  2594. fprintf(fptr,"<td colspan=\"2\" bgcolor=\"#d6dbdf\"> Particion No.%d </td>\n",j+1);
  2595. fprintf(fptr,"</tr>\n");
  2596. fprintf(fptr,"<tr>\n");
  2597. fprintf(fptr,"<td> part_status_%d </td>\n",j+1);
  2598. fprintf(fptr,"<td>");
  2599. fprintf(fptr,"%c", mbr->particiones[i].part_status);
  2600. fprintf(fptr,"</td>\n");
  2601. fprintf(fptr,"</tr>\n");
  2602. fprintf(fptr,"<tr>\n");
  2603. fprintf(fptr,"<td> part_type_%d </td>\n",j+1);
  2604. fprintf(fptr,"<td>");
  2605. fprintf(fptr,"%c", mbr->particiones[i].part_type);
  2606. fprintf(fptr,"</td>\n");
  2607. fprintf(fptr,"</tr>\n");
  2608. fprintf(fptr,"<tr>\n");
  2609. fprintf(fptr,"<td> part_fit_%d </td>\n",j+1);
  2610. fprintf(fptr,"<td>");
  2611. fprintf(fptr,"%s", mbr->particiones[i].part_fit);
  2612. fprintf(fptr,"</td>\n");
  2613. fprintf(fptr,"</tr>\n");
  2614. fprintf(fptr,"<tr>\n");
  2615. fprintf(fptr,"<td> part_start_%d </td>\n",j+1);
  2616. fprintf(fptr,"<td>");
  2617. fprintf(fptr,"%d", mbr->particiones[i].part_start);
  2618. fprintf(fptr,"</td>\n");
  2619. fprintf(fptr,"</tr>\n");
  2620. fprintf(fptr,"<tr>\n");
  2621. fprintf(fptr,"<td> part_size_%d </td>\n",j+1);
  2622. fprintf(fptr,"<td>");
  2623. fprintf(fptr,"%d", mbr->particiones[i].part_size);
  2624. fprintf(fptr,"</td>\n");
  2625. fprintf(fptr,"</tr>\n");
  2626. fprintf(fptr,"<tr>\n");
  2627. fprintf(fptr,"<td> part_name_%d </td>\n",j+1);
  2628. fprintf(fptr,"<td>");
  2629. fprintf(fptr,"%s", mbr->particiones[i].part_name);
  2630. fprintf(fptr,"</td>\n");
  2631. fprintf(fptr,"</tr>\n");
  2632. break;
  2633. }
  2634. }
  2635.  
  2636. }
  2637. if(e!=-1)
  2638. {
  2639. char path[50];
  2640. Montura *pivote=sistema->primero;
  2641. while (pivote!=NULL) {
  2642. if(!strcmp(funcion.id,pivote->name))
  2643. {
  2644. int l=0;
  2645. for(int k=0;k<50;k++)
  2646. {
  2647. path[l++]=pivote->path[k];
  2648. }
  2649. break;
  2650. }
  2651. pivote=pivote->siguiente;
  2652. }
  2653. printf("%s\n",path);
  2654.  
  2655. EBR lec;
  2656. int inicio= mbr->particiones[e].part_start;
  2657. FILE *fp = fopen(path, "rb");
  2658. printf("Inicio %d\n",inicio+sizeof (MbrDisco));
  2659. fseek(fp,inicio+sizeof (MbrDisco),SEEK_SET);
  2660.  
  2661. if(fp == NULL)
  2662. {
  2663. printf("\n Error::-> No se encontro el disco\n");
  2664. }else {
  2665. fread(&lec, sizeof(EBR), 1, fp);
  2666. fclose(fp);
  2667. }
  2668. printf("Siguiente %d\n",lec.part_next);
  2669. int siguiente=lec.part_next;
  2670. EBR sig;
  2671.  
  2672. while (siguiente!=-1) {
  2673.  
  2674. fprintf(fptr,"<tr>\n");
  2675. fprintf(fptr,"<td colspan=\"2\" bgcolor=\"#d6dbdf\"> EBR </td>\n");
  2676. fprintf(fptr,"</tr>\n");
  2677.  
  2678.  
  2679. fp = fopen(path, "rb");
  2680. fseek(fp,siguiente+sizeof (MbrDisco)+sizeof (EBR),SEEK_SET);
  2681.  
  2682. if(fp == NULL)
  2683. {
  2684. printf("\n Error::-> No se encontro el disco\n");
  2685. }else {
  2686. fread(&sig, sizeof(EBR), 1, fp);
  2687. fclose(fp);
  2688. }
  2689.  
  2690. fprintf(fptr,"<tr>\n");
  2691. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> NOMBRE </td>\n");
  2692. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> VALOR </td>\n");
  2693. fprintf(fptr,"</tr>\n");
  2694. fprintf(fptr,"<tr>\n");
  2695. fprintf(fptr,"<td> part_status </td>\n");
  2696. fprintf(fptr,"<td>");
  2697. fprintf(fptr,"%c", sig.part_status);
  2698. fprintf(fptr,"</td>\n");
  2699. fprintf(fptr,"</tr>\n");
  2700. fprintf(fptr,"<tr>\n");
  2701. fprintf(fptr,"<td> part_fit </td>\n");
  2702. fprintf(fptr,"<td>");
  2703. fprintf(fptr,"%s", sig.part_fit);
  2704. fprintf(fptr,"</td>\n");
  2705. fprintf(fptr,"</tr>\n");
  2706. fprintf(fptr,"<tr>\n");
  2707. fprintf(fptr,"<td> part_start </td>\n");
  2708. fprintf(fptr,"<td>");
  2709. fprintf(fptr,"%d", sig.part_start);
  2710. fprintf(fptr,"</td>\n");
  2711. fprintf(fptr,"</tr>\n");
  2712. fprintf(fptr,"<tr>\n");
  2713. fprintf(fptr,"<td> part_size </td>\n");
  2714. fprintf(fptr,"<td>");
  2715. fprintf(fptr,"%d", sig.part_size);
  2716. fprintf(fptr,"</td>\n");
  2717. fprintf(fptr,"</tr>\n");
  2718. fprintf(fptr,"<tr>\n");
  2719. fprintf(fptr,"<td> part_next </td>\n");
  2720. fprintf(fptr,"<td>");
  2721. fprintf(fptr,"%d", sig.part_next);
  2722. fprintf(fptr,"</td>\n");
  2723. fprintf(fptr,"</tr>\n");
  2724. fprintf(fptr,"<tr>\n");
  2725. fprintf(fptr,"<td> part_name </td>\n");
  2726. fprintf(fptr,"<td>");
  2727. fprintf(fptr,"%s", sig.part_name);
  2728. fprintf(fptr,"</td>\n");
  2729. fprintf(fptr,"</tr>\n");
  2730.  
  2731. siguiente=sig.part_next;
  2732. printf("Siguiente %d\n",siguiente);
  2733.  
  2734.  
  2735. }
  2736. }
  2737.  
  2738. fprintf(fptr,"</table>\n");
  2739. fprintf(fptr,">];\n");
  2740.  
  2741.  
  2742. fprintf(fptr,"}\n");
  2743. fclose(fptr);
  2744. strcat(dot,"dot -Tpng ");
  2745. strcat(dot,pathauxiliar2);
  2746. strcat(dot," -o ");
  2747. strcat(dot,funcion.path);
  2748. printf("%s\n",dot);
  2749. system(dot);
  2750. ContadorComandosExitosos++;
  2751. limpiarvar(funcion.path,100);
  2752. limpiarvar(pathauxiliar2,100);
  2753. }
  2754. }else {
  2755. printf("Error::-> Generar reporte\n");
  2756. ErrorReporte1++;
  2757. }
  2758. }
  2759.  
  2760.  
  2761.  
  2762. void CrearDisco(Funcion funcion)
  2763. {
  2764.  
  2765. MbrDisco mbr;
  2766. mbr.mbr_tamano=funcion.size;
  2767.  
  2768. time_t tiempo = time(0);
  2769. struct tm *tlocal = localtime(&tiempo);
  2770. char output[128];
  2771. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  2772. printf("Fecha y Hora de Creacion: %s\n",output);
  2773. int id=funcion.path;
  2774.  
  2775.  
  2776. int k=0;
  2777. int l=0;
  2778. for(k=0;k<25;k++)
  2779. {
  2780. mbr.mbr_fecha_creacion[l++]=output[k];
  2781. }
  2782. l=0;
  2783. for(k=0;k<3;k++)
  2784. {
  2785. mbr.mbr_fit[l++]=funcion.fit[k];
  2786. }
  2787. strcpy(mbr.mbr_fit,funcion.fit);
  2788. mbr.mbr_disk_signature=abs(id);
  2789. mbr.cantParticones=0;
  2790. mbr.bandera=0;
  2791.  
  2792. //tamaño en bytes
  2793. int tamano=0;
  2794. if(funcion.unit=='k'||funcion.unit=='K')
  2795. {
  2796. tamano=funcion.size*1024;
  2797. }
  2798. else
  2799. {
  2800. tamano=funcion.size*(1024*1024);
  2801. }
  2802.  
  2803.  
  2804.  
  2805. //----------------- Quitar "" en la path ------------------------
  2806.  
  2807. char pathauxiliar[500];
  2808. strcpy(pathauxiliar,funcion.path);
  2809. char finalizado[500];
  2810. strcpy(finalizado,"cd /\n");
  2811. if(pathauxiliar[0]=='\"')
  2812. {
  2813. limpiarvar(funcion.path,100);
  2814. int q=1;
  2815. while(pathauxiliar[q]!='\"')
  2816. {
  2817. char nuevoCaracter[1];
  2818. nuevoCaracter[0]=pathauxiliar[q];
  2819. strncat(funcion.path,nuevoCaracter,1);
  2820. q++;
  2821. }
  2822.  
  2823. }
  2824.  
  2825. int con1=0;
  2826. int valExtencion=0;
  2827. while(funcion.path[con1]!=NULL){
  2828.  
  2829. if(funcion.path[con1]=='.'){
  2830.  
  2831. if(funcion.path[con1+1]=='d'&&funcion.path[con1+2]=='i'&&funcion.path[con1+3]=='s' &&funcion.path[con1+4]=='k'){
  2832. valExtencion=1;
  2833. }
  2834.  
  2835. }
  2836. con1++;
  2837. }
  2838.  
  2839.  
  2840. if(valExtencion==0){
  2841. printf("\nError::-> Extencion incorrecta\n");
  2842. ErrorCrearDisco++;
  2843. }else{
  2844.  
  2845.  
  2846. int indice=0;
  2847. char carpeta[500];
  2848. printf("%s\n",funcion.path);
  2849. while(funcion.path[indice]!='.')
  2850. {
  2851. if(funcion.path[indice]!='/')
  2852. {
  2853.  
  2854. char nuevoCaracter[1];
  2855. nuevoCaracter[0]=funcion.path[indice];
  2856. strncat(carpeta,nuevoCaracter,1);
  2857. }
  2858. else
  2859. {
  2860. if(carpeta[0]!='\0')
  2861. {
  2862.  
  2863.  
  2864. strcat(finalizado,"mkdir ");
  2865. strcat(finalizado,"\"");
  2866. strcat(finalizado,carpeta);
  2867. strcat(finalizado,"\"");
  2868. strcat(finalizado,"\n");
  2869. strcat(finalizado,"cd ");
  2870. strcat(finalizado,"\"");
  2871. strcat(finalizado,carpeta);
  2872. strcat(finalizado,"\"");
  2873. strcat(finalizado,"\n");
  2874. strcat(carpeta,"");
  2875. limpiarvar(carpeta,500);
  2876. }
  2877.  
  2878. }
  2879. indice++;
  2880. }
  2881.  
  2882.  
  2883. printf("\n%s\n",finalizado);
  2884.  
  2885. system(finalizado);
  2886.  
  2887.  
  2888. FILE* archivo= fopen(funcion.path, "ab");
  2889. if (archivo==NULL)
  2890. {
  2891. printf("\nError::-> Imposible crear el archivo\n");
  2892. ErrorCrearDisco++;
  2893. }
  2894. else
  2895. {
  2896. int fin=(tamano/1024);
  2897. char buffer[1024];
  2898. int i=0;
  2899. for(i=0;i<1024;i++){
  2900. buffer[i]='\0';
  2901. }
  2902. int j=0;
  2903. while(j!=fin){
  2904. fwrite(&buffer,1024 , 1, archivo);
  2905. j++;
  2906. }
  2907. fclose(archivo);
  2908. }
  2909. //Fin Creacion de Archivo
  2910.  
  2911. //Estableciendo propiedades de la estructura del Mbr del disco
  2912. mbr.mbr_tamano=tamano;
  2913.  
  2914. int i;
  2915. for(i=0;i<4;i++)//recorre el arreglo de las 4 particiones
  2916. {//estableciendo datos por defecto
  2917. mbr.particiones[i].part_start=-1;
  2918. mbr.particiones[i].part_status='0';
  2919. mbr.particiones[i].part_size=0;
  2920. }
  2921.  
  2922. //abriendo el Archivo qe simula el disco virtual
  2923. FILE* file= fopen(funcion.path, "rb+");
  2924. fseek(file,0,SEEK_SET);// estableciendo puntero al inicio
  2925.  
  2926. if (file==NULL)//si el archivo no contiene nada
  2927. {
  2928. printf("\nError::->Imposible escribir en el archivo \n\n");
  2929. ErrorCrearDisco++;
  2930. //fclose(file);
  2931. }
  2932. else
  2933. {
  2934. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  2935. fclose(file);
  2936. printf("'CREACION DE DISCO EXITOSO'\n");
  2937. ContadorComandosExitosos++;
  2938. }
  2939.  
  2940. }
  2941.  
  2942.  
  2943.  
  2944. }
  2945.  
  2946. void ELiminarDisco(Funcion funcion)
  2947. {
  2948.  
  2949. //----------------- Quita "" en la path ------------------------
  2950. char pathauxiliar[500];
  2951. strcpy(pathauxiliar,funcion.path);
  2952. char finalizado[500];
  2953. strcpy(finalizado,"cd /\n");
  2954. if(pathauxiliar[0]=='\"')
  2955. {
  2956. limpiarvar(funcion.path,100);
  2957. int q=1;
  2958. while(pathauxiliar[q]!='\"')
  2959. {
  2960. char nuevoCaracter[1];
  2961. nuevoCaracter[0]=pathauxiliar[q];
  2962. strncat(funcion.path,nuevoCaracter,1);
  2963. q++;
  2964. }
  2965.  
  2966. }
  2967. //----------------------------------------------------------------------
  2968.  
  2969. int con1=0;
  2970. int valExtencion=0;
  2971. while(funcion.path[con1]!=NULL){
  2972.  
  2973. if(funcion.path[con1]=='.'){
  2974.  
  2975. if(funcion.path[con1+1]=='d'&&funcion.path[con1+2]=='i'&&funcion.path[con1+3]=='s' &&funcion.path[con1+4]=='k'){
  2976. valExtencion=1;
  2977. }
  2978.  
  2979. }
  2980. con1++;
  2981. }
  2982.  
  2983. if(valExtencion==0){
  2984. printf("\nError::-> Extencion incorrecta\n");
  2985. ErrorEliminarDisco++;
  2986. }else{
  2987. int encontro=0;
  2988. FILE *fp;
  2989. fp = fopen (funcion.path, "r" );
  2990. if (fp==NULL) {
  2991. printf("\nError::->Disco no encontrado\n");
  2992. ErrorEliminarDisco++;
  2993. }
  2994. else {
  2995. encontro=1;
  2996. fclose ( fp );
  2997. }
  2998.  
  2999.  
  3000.  
  3001. if(encontro==1)
  3002. {
  3003. printf("Eliminando Particion...\n");
  3004.  
  3005.  
  3006. strcpy(finalizado,"\nrm \"");
  3007. strcat(finalizado,funcion.path);
  3008. strcat(finalizado,"\"");
  3009. printf("\n%s\n",finalizado);
  3010. system(finalizado);
  3011. limpiarvar(finalizado,100);
  3012. printf("'EIMINACION DE DISCO EXITOSA'\n");
  3013. ContadorComandosExitosos++;
  3014.  
  3015. int opcion;
  3016. printf("%s\n", "¿Desea eliminar el disco?");
  3017. printf("%s\n", "1. SI");
  3018. printf("%s\n", "2. NO");
  3019.  
  3020. printf("%s\n", "");
  3021. printf(">:~$ ");
  3022. scanf("%d",&opcion);
  3023.  
  3024. if(opcion>0 && opcion<3){
  3025.  
  3026. switch(opcion)
  3027. {
  3028. case 1:
  3029. //-----------------------------------------------EliminarParticion(funcion)-----------------------------------------;
  3030.  
  3031. break;
  3032. case 2:
  3033. printf("-------------------------Eliminacion Cancelada-------------------\n");
  3034. break;
  3035. default:
  3036. printf("Error::-> Opcion Incorrecta \n");
  3037. break;
  3038. }
  3039. }else
  3040. {
  3041. opcion=1;
  3042. printf(" \n");
  3043. printf("%s\n", "Error::-> Opcion incorrecta ");
  3044. }
  3045. }
  3046.  
  3047. }
  3048. }
  3049.  
  3050. void OrdenarEspacios (MbrDisco * mbr)
  3051. {
  3052. Particion aux;
  3053. for (int i=0;i<4;i++) {
  3054. for (int j=0;j<4;j++) {
  3055. if(j!=3)
  3056. {
  3057. if(mbr->particiones[j].part_start>mbr->particiones[j+1].part_start)
  3058. {
  3059. aux=mbr->particiones[j];
  3060. mbr->particiones[j]=mbr->particiones[j+1];
  3061. mbr->particiones[j+1]=aux;
  3062. }
  3063. }
  3064. }
  3065. }
  3066.  
  3067. }
  3068.  
  3069. void Insertar(Espacios * lista,Bloque * nueva)
  3070. {
  3071. if(lista->primero==NULL)
  3072. {
  3073. lista->primero=nueva;
  3074. lista->ultimo=nueva;
  3075.  
  3076. }else {
  3077. nueva->siguiente=lista->primero;
  3078. lista->primero=nueva;
  3079. }
  3080. }
  3081. int Entra(long inicio,long fin,long tamano)
  3082. {
  3083. int espacio=fin-inicio;
  3084.  
  3085. if(espacio>=tamano)
  3086. {
  3087. return 1;
  3088. }else
  3089. {
  3090. return 0;
  3091. }
  3092. }
  3093. void insertarEspacio(Espacios *lista, Bloque *bloque){
  3094.  
  3095. if(lista->primero == NULL){
  3096. lista->primero = bloque;
  3097. lista->ultimo = bloque;
  3098.  
  3099. }
  3100. else
  3101. {
  3102. if(lista->primero->tamano>bloque->tamano)///insertar al inicio
  3103. {
  3104.  
  3105. bloque->siguiente=lista->primero;
  3106. lista->primero->anterior=bloque;
  3107. lista->primero=bloque;
  3108.  
  3109. }
  3110. //printf("entro al insertar cuando no esta vacia \n");
  3111. Bloque *aux = lista->primero;
  3112.  
  3113. while(aux->siguiente!=NULL)
  3114. {
  3115. //printf("el siguiente no es nulo\n");
  3116. Bloque *sigui = aux->siguiente;
  3117. while(sigui->tamano < bloque->tamano)
  3118. {
  3119.  
  3120. if(aux->siguiente==NULL){
  3121. break;
  3122. }
  3123. aux = aux->siguiente;
  3124.  
  3125. if(aux->siguiente==NULL){
  3126. break;
  3127. }
  3128. sigui = aux->siguiente;
  3129. }
  3130.  
  3131. break;
  3132. }
  3133.  
  3134. if(lista->ultimo->tamano < bloque->tamano)///Instertar al final
  3135. {
  3136. lista->ultimo->siguiente = bloque;
  3137. bloque->anterior=lista->ultimo;
  3138. lista->ultimo = bloque;
  3139. }
  3140.  
  3141. else if(lista->primero->tamano>bloque->tamano)///Insertar al inicio
  3142. {
  3143. bloque->siguiente=lista->primero;
  3144. lista->primero->anterior=bloque;
  3145. lista->primero=bloque;
  3146. }
  3147.  
  3148. else///insertar en medio
  3149. {
  3150. Bloque *auxSiguiente = aux->siguiente;
  3151. aux->siguiente=bloque;
  3152. bloque->anterior=aux;
  3153. bloque->siguiente=auxSiguiente;
  3154. auxSiguiente->anterior=bloque;
  3155. }
  3156.  
  3157. }
  3158. }
  3159.  
  3160. int EspacioFF(MbrDisco mbr,int tamano)
  3161. {
  3162. int espacio=-1;
  3163. int encontro=0;
  3164. if(mbr.particiones[0].part_status=='0')
  3165. {
  3166. espacio=1;
  3167. }else{
  3168.  
  3169.  
  3170. int a[4];
  3171. int n=0;
  3172. for (int i=0;i<4;i++) {
  3173. if(mbr.particiones[i].part_status=='1')
  3174. {
  3175. a[i]=mbr.particiones[i].part_start;
  3176. n++;
  3177. }
  3178. }
  3179.  
  3180. int i,j,aux;
  3181. for(i=0;i<n;i++)
  3182. {
  3183. printf("%d,",a[i]);
  3184. }
  3185. printf("\n");
  3186. for(i=0;i<=n;i++){
  3187. for(j=0;j<n-1;j++){
  3188. if(a[j]>a[j+1]){
  3189. aux=a[j];
  3190. a[j]=a[j+1];
  3191. a[j+1]=aux;
  3192. }
  3193. }
  3194. }
  3195. printf("\n");
  3196. for(i=0;i<n;i++)
  3197. {
  3198. printf("%d,",a[i]);
  3199. }
  3200. printf("\n");
  3201. for (int j=0;j<4;j++) {
  3202. if(encontro==0)
  3203. {
  3204. for (int i=0;i<4;i++) {
  3205.  
  3206. if(a[j]==mbr.particiones[i].part_start)
  3207. {
  3208. printf("Espacio-> %d\n",a[j]);
  3209. int AntVacio=0;
  3210. int Ant=0;
  3211. int SigVacio=0;
  3212. int Sig=0;
  3213. if(j!=0)
  3214. {
  3215. for (int i=0;i<4;i++) {
  3216. if(a[j-1]==mbr.particiones[i].part_start)
  3217. {
  3218. Ant=i;
  3219. AntVacio=1;
  3220. break;
  3221. }
  3222. }
  3223.  
  3224. }
  3225. if(j!=3)
  3226. {
  3227. for (int i=0;i<4;i++) {
  3228. if(a[j+1]==mbr.particiones[i].part_start)
  3229. {
  3230. SigVacio=i;
  3231. Sig=1;
  3232. break;
  3233. }
  3234. }
  3235.  
  3236. }
  3237.  
  3238. if(j==0)
  3239. {
  3240. printf("Entre principio y primero\n");
  3241. printf("Inicio %d\n",1);
  3242. printf("Fin %d\n",mbr.particiones[i].part_start);
  3243. int a=mbr.particiones[i].part_start;
  3244. int b=1;
  3245. int po= a-b;
  3246. if(po>0)
  3247. {
  3248.  
  3249.  
  3250. printf("Encontro Espacio\n");
  3251. espacio=b;
  3252. encontro=1;
  3253. break;
  3254. }
  3255. if(SigVacio==0)
  3256. {
  3257. printf("Primero y final\n");
  3258. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  3259. printf("Fin %d\n",mbr.mbr_tamano);
  3260. int a=mbr.mbr_tamano;
  3261. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  3262. int po= a-b;
  3263. if(po>0)
  3264. {
  3265.  
  3266. printf("Encontro Espacio\n");
  3267. espacio=b;
  3268. encontro=1;
  3269. break;
  3270. }
  3271. }
  3272.  
  3273. }
  3274. else
  3275. {
  3276. printf("Entre %d y %d\n",j,j+1);
  3277. printf("Inicio %d\n",mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size);
  3278. printf("Fin %d\n",mbr.particiones[i].part_start);
  3279. int a=mbr.particiones[i].part_start;
  3280. int b=mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size;
  3281. int po= a-b;
  3282. if(po>0)
  3283. {
  3284.  
  3285. printf("Encontro Espacio\n");
  3286. espacio=b;
  3287. encontro=1;
  3288. break;
  3289. }
  3290. if(SigVacio==0)
  3291. {
  3292. printf("%d y final\n",j);
  3293. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  3294. printf("Fin %d\n",mbr.mbr_tamano);
  3295. int a=mbr.mbr_tamano;
  3296. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  3297. int po= a-b;
  3298. if(po>0)
  3299. {
  3300.  
  3301. printf("Encontro Espacio\n");
  3302. espacio=b;
  3303. encontro=1;
  3304. break;
  3305. }
  3306. }
  3307.  
  3308. }
  3309.  
  3310.  
  3311. break;
  3312. }
  3313. }
  3314. }
  3315. }
  3316. }
  3317. return espacio;
  3318. }
  3319. void RecorrerEspacios(Espacios *lista)
  3320. {
  3321. Bloque *pivote=lista->primero;
  3322. while (pivote!=NULL) {
  3323. printf("--------------------------\n");
  3324. printf("Inicio %d\n",pivote->inicio);
  3325. printf("Fin %d\n",pivote->fin);
  3326. printf("Tamano %d\n",pivote->tamano);
  3327. pivote=pivote->siguiente;
  3328. }
  3329. }
  3330.  
  3331. int BuscarMenor(Espacios *lista,int tamano)
  3332. {
  3333. Bloque *pivote=lista->primero;
  3334. while (pivote!=NULL) {
  3335. if(pivote->tamano>=tamano)
  3336. {
  3337. printf("Encontro espacio en %d\n",pivote->inicio);
  3338. return pivote->inicio;
  3339. }
  3340. pivote=pivote->siguiente;
  3341. }
  3342. return -1;
  3343. }
  3344. int BuscarMayor(Espacios *lista,int tamano)
  3345. {
  3346. Bloque *pivote=lista->ultimo;
  3347. while (pivote!=NULL) {
  3348. if(pivote->tamano>=tamano)
  3349. {
  3350. printf("Encontro espacio en %d\n",pivote->inicio);
  3351. return pivote->inicio;
  3352. }
  3353. pivote=pivote->anterior;
  3354. }
  3355. return -1;
  3356. }
  3357.  
  3358. int EspacioBF(MbrDisco mbr,int tamano)
  3359. {
  3360. printf("Buscando el mejor espacio...");
  3361. int espacio=-1;
  3362. Espacios *lista=(Espacios*)malloc(sizeof (Espacios));
  3363. lista->primero=NULL;
  3364. lista->ultimo=NULL;
  3365. if(mbr.particiones[0].part_status=='0')
  3366. {
  3367. espacio=1;
  3368. return espacio;
  3369. }else{
  3370.  
  3371.  
  3372. int a[4];
  3373. int n=0;
  3374. for (int i=0;i<4;i++) {
  3375. if(mbr.particiones[i].part_status=='1')
  3376. {
  3377. a[i]=mbr.particiones[i].part_start;
  3378. n++;
  3379. }
  3380. }
  3381.  
  3382. int i,j,aux;
  3383. for(i=0;i<n;i++)
  3384. {
  3385. printf("%d,",a[i]);
  3386. }
  3387. printf("\n");
  3388. for(i=0;i<=n;i++){
  3389. for(j=0;j<n-1;j++){
  3390. if(a[j]>a[j+1]){
  3391. aux=a[j];
  3392. a[j]=a[j+1];
  3393. a[j+1]=aux;
  3394. }
  3395. }
  3396. }
  3397. printf("\n");
  3398. for(i=0;i<n;i++)
  3399. {
  3400. printf("%d,",a[i]);
  3401. }
  3402. printf("\n");
  3403. for (int j=0;j<4;j++) {
  3404. for (int i=0;i<4;i++) {
  3405.  
  3406. if(a[j]==mbr.particiones[i].part_start)
  3407. {
  3408. printf("Espacio-> %d\n",a[j]);
  3409. int AntVacio=0;
  3410. int Ant=0;
  3411. int SigVacio=0;
  3412. int Sig=0;
  3413. if(j!=0)
  3414. {
  3415. for (int i=0;i<4;i++) {
  3416. if(a[j-1]==mbr.particiones[i].part_start)
  3417. {
  3418. Ant=i;
  3419. AntVacio=1;
  3420. break;
  3421. }
  3422. }
  3423.  
  3424. }
  3425. if(j!=3)
  3426. {
  3427. for (int i=0;i<4;i++) {
  3428. if(a[j+1]==mbr.particiones[i].part_start)
  3429. {
  3430. SigVacio=i;
  3431. Sig=1;
  3432. break;
  3433. }
  3434. }
  3435.  
  3436. }
  3437.  
  3438. if(j==0)
  3439. {
  3440. printf("Entre principio y primero\n");
  3441. printf("Inicio %d\n",1);
  3442. printf("Fin %d\n",mbr.particiones[i].part_start);
  3443. int a=mbr.particiones[i].part_start;
  3444. int b=1;
  3445. int po= a-b;
  3446. if(po>0)
  3447. {
  3448. printf("Encontro Espacio\n");
  3449. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  3450. nuevo->inicio=b;
  3451. nuevo->fin=a;
  3452. nuevo->tamano=po;
  3453. nuevo->siguiente=NULL;
  3454. nuevo->anterior=NULL;
  3455. insertarEspacio(lista,nuevo);
  3456. }
  3457. if(SigVacio==0)
  3458. {
  3459. printf("Primero y final\n");
  3460. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  3461. printf("Fin %d\n",mbr.mbr_tamano);
  3462. int a=mbr.mbr_tamano;
  3463. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  3464. int po= a-b;
  3465. if(po>0)
  3466. {
  3467.  
  3468. printf("Encontro Espacio\n");
  3469. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  3470. nuevo->inicio=b;
  3471. nuevo->fin=a;
  3472. nuevo->tamano=po;
  3473. nuevo->siguiente=NULL;
  3474. nuevo->anterior=NULL;
  3475. insertarEspacio(lista,nuevo);
  3476.  
  3477. }
  3478. }
  3479.  
  3480. }
  3481. else
  3482. {
  3483. printf("Entre %d y %d\n",j,j+1);
  3484. printf("Inicio %d\n",mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size);
  3485. printf("Fin %d\n",mbr.particiones[i].part_start);
  3486. int a=mbr.particiones[i].part_start;
  3487. int b=mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size;
  3488. int po= a-b;
  3489. if(po>0)
  3490. {
  3491.  
  3492. printf("Encontro Espacio\n");
  3493. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  3494. nuevo->inicio=b;
  3495. nuevo->fin=a;
  3496. nuevo->tamano=po;
  3497. nuevo->siguiente=NULL;
  3498. nuevo->anterior=NULL;
  3499. insertarEspacio(lista,nuevo);
  3500. }
  3501. if(SigVacio==0)
  3502. {
  3503. printf("%d y final\n",j);
  3504. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  3505. printf("Fin %d\n",mbr.mbr_tamano);
  3506. int a=mbr.mbr_tamano;
  3507. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  3508. int po= a-b;
  3509. if(po>0)
  3510. {
  3511.  
  3512. printf("Encontro Espacio\n");
  3513. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  3514. nuevo->inicio=b;
  3515. nuevo->fin=a;
  3516. nuevo->tamano=po;
  3517. nuevo->siguiente=NULL;
  3518. nuevo->anterior=NULL;
  3519. insertarEspacio(lista,nuevo);
  3520. }
  3521. }
  3522.  
  3523. }
  3524.  
  3525.  
  3526. break;
  3527. }
  3528. }
  3529.  
  3530. }
  3531. }
  3532.  
  3533. RecorrerEspacios(lista);
  3534. espacio=BuscarMenor(lista,tamano);
  3535. printf("Retornando %d\n",espacio);
  3536.  
  3537.  
  3538.  
  3539. return espacio;
  3540. }
  3541.  
  3542. int EspacioWF(MbrDisco mbr,int tamano)
  3543. {
  3544. printf("Buscando el mejor espacio...");
  3545. int espacio=-1;
  3546. Espacios *lista=(Espacios*)malloc(sizeof (Espacios));
  3547. lista->primero=NULL;
  3548. lista->ultimo=NULL;
  3549. if(mbr.particiones[0].part_status=='0')
  3550. {
  3551. espacio=1;
  3552. return espacio;
  3553. }else{
  3554.  
  3555.  
  3556. int a[4];
  3557. int n=0;
  3558. for (int i=0;i<4;i++) {
  3559. if(mbr.particiones[i].part_status=='1')
  3560. {
  3561. a[i]=mbr.particiones[i].part_start;
  3562. n++;
  3563. }
  3564. }
  3565.  
  3566. int i,j,aux;
  3567. for(i=0;i<n;i++)
  3568. {
  3569. printf("%d,",a[i]);
  3570. }
  3571. printf("\n");
  3572. for(i=0;i<=n;i++){
  3573. for(j=0;j<n-1;j++){
  3574. if(a[j]>a[j+1]){
  3575. aux=a[j];
  3576. a[j]=a[j+1];
  3577. a[j+1]=aux;
  3578. }
  3579. }
  3580. }
  3581. printf("\n");
  3582. for(i=0;i<n;i++)
  3583. {
  3584. printf("%d,",a[i]);
  3585. }
  3586. printf("\n");
  3587. for (int j=0;j<4;j++) {
  3588. for (int i=0;i<4;i++) {
  3589.  
  3590. if(a[j]==mbr.particiones[i].part_start)
  3591. {
  3592. printf("Espacio-> %d\n",a[j]);
  3593. int AntVacio=0;
  3594. int Ant=0;
  3595. int SigVacio=0;
  3596. int Sig=0;
  3597. if(j!=0)
  3598. {
  3599. for (int i=0;i<4;i++) {
  3600. if(a[j-1]==mbr.particiones[i].part_start)
  3601. {
  3602. Ant=i;
  3603. AntVacio=1;
  3604. break;
  3605. }
  3606. }
  3607.  
  3608. }
  3609. if(j!=3)
  3610. {
  3611. for (int i=0;i<4;i++) {
  3612. if(a[j+1]==mbr.particiones[i].part_start)
  3613. {
  3614. SigVacio=i;
  3615. Sig=1;
  3616. break;
  3617. }
  3618. }
  3619.  
  3620. }
  3621.  
  3622. if(j==0)
  3623. {
  3624. printf("Entre principio y primero\n");
  3625. printf("Inicio %d\n",1);
  3626. printf("Fin %d\n",mbr.particiones[i].part_start);
  3627. int a=mbr.particiones[i].part_start;
  3628. int b=1;
  3629. int po= a-b;
  3630. if(po>0)
  3631. {
  3632. printf("Encontro Espacio\n");
  3633. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  3634. nuevo->inicio=b;
  3635. nuevo->fin=a;
  3636. nuevo->tamano=po;
  3637. nuevo->siguiente=NULL;
  3638. nuevo->anterior=NULL;
  3639. insertarEspacio(lista,nuevo);
  3640. }
  3641. if(SigVacio==0)
  3642. {
  3643. printf("Primero y final\n");
  3644. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  3645. printf("Fin %d\n",mbr.mbr_tamano);
  3646. int a=mbr.mbr_tamano;
  3647. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  3648. int po= a-b;
  3649. if(po>0)
  3650. {
  3651.  
  3652. printf("Encontro Espacio\n");
  3653. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  3654. nuevo->inicio=b;
  3655. nuevo->fin=a;
  3656. nuevo->tamano=po;
  3657. nuevo->siguiente=NULL;
  3658. nuevo->anterior=NULL;
  3659. insertarEspacio(lista,nuevo);
  3660.  
  3661. }
  3662. }
  3663.  
  3664. }
  3665. else
  3666. {
  3667. printf("Entre %d y %d\n",j,j+1);
  3668. printf("Inicio %d\n",mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size);
  3669. printf("Fin %d\n",mbr.particiones[i].part_start);
  3670. int a=mbr.particiones[i].part_start;
  3671. int b=mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size;
  3672. int po= a-b;
  3673. if(po>0)
  3674. {
  3675.  
  3676. printf("Encontro Espacio\n");
  3677. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  3678. nuevo->inicio=b;
  3679. nuevo->fin=a;
  3680. nuevo->tamano=po;
  3681. nuevo->siguiente=NULL;
  3682. nuevo->anterior=NULL;
  3683. insertarEspacio(lista,nuevo);
  3684. }
  3685. if(SigVacio==0)
  3686. {
  3687. printf("%d y final\n",j);
  3688. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  3689. printf("Fin %d\n",mbr.mbr_tamano);
  3690. int a=mbr.mbr_tamano;
  3691. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  3692. int po= a-b;
  3693. if(po>0)
  3694. {
  3695.  
  3696. printf("Encontro Espacio\n");
  3697. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  3698. nuevo->inicio=b;
  3699. nuevo->fin=a;
  3700. nuevo->tamano=po;
  3701. nuevo->siguiente=NULL;
  3702. nuevo->anterior=NULL;
  3703. insertarEspacio(lista,nuevo);
  3704. }
  3705. }
  3706.  
  3707. }
  3708.  
  3709.  
  3710. break;
  3711. }
  3712. }
  3713.  
  3714. }
  3715. }
  3716.  
  3717. RecorrerEspacios(lista);
  3718. espacio=BuscarMayor(lista,tamano);
  3719. printf("Retornando %d\n",espacio);
  3720.  
  3721.  
  3722.  
  3723. return espacio;
  3724. }
  3725.  
  3726.  
  3727. int BuscarEspacionBF(MbrDisco mbr,Funcion funcion,int tamano)
  3728. {
  3729. int espacio=EspacioBF(mbr,tamano);
  3730. for (int i=0;i<4;i++) {
  3731.  
  3732.  
  3733. if(mbr.particiones[i].part_status=='0')
  3734. {
  3735. if(espacio!=-1)
  3736. {
  3737.  
  3738. printf("Ingresara particion en espacio %i\n",espacio);
  3739. mbr.particiones[i].part_start=espacio;
  3740. mbr.particiones[i].part_status='1';
  3741. mbr.particiones[i].part_type=funcion.type;
  3742. int l=0;
  3743. for(int k=0;k<3;k++)
  3744. {
  3745. mbr.particiones[i].part_fit[l++]=funcion.fit[k];
  3746. }
  3747. strcpy(mbr.particiones[i].part_name,funcion.name);
  3748. mbr.particiones[i].part_size=tamano;
  3749. printf("part_status: %c\n",mbr.particiones[i].part_status);
  3750. printf("part_type: %c\n",mbr.particiones[i].part_type);
  3751. printf("part_fit: %s\n",mbr.particiones[i].part_fit);
  3752. printf("part_name: %s\n",mbr.particiones[i].part_name);
  3753. printf("part_size: %i\n",mbr.particiones[i].part_size);
  3754. printf("part_start: %i\n",mbr.particiones[i].part_start);
  3755.  
  3756.  
  3757. mbr.cantParticones++;
  3758. printf("particiones: %i\n",mbr.cantParticones);
  3759. if(mbr.particiones[i].part_type=='E' || mbr.particiones[i].part_type=='E' )
  3760. {
  3761. printf("Es una particion extendida\n");
  3762. EBR ebr;
  3763. ebr.part_next=-1;
  3764. ebr.part_size=0;
  3765. ebr.part_start=mbr.particiones[i].part_start;
  3766. ebr.part_status='0';
  3767. FILE* file= fopen(funcion.path, "rb+");
  3768. printf("EBR inicial dir->%d\n",mbr.particiones[i].part_start+sizeof (MbrDisco));
  3769. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  3770.  
  3771. if (file==NULL)
  3772. {
  3773. printf("\nError::->Imposible escribir en el archivo \n\n");
  3774. }
  3775. else
  3776. {
  3777.  
  3778. fwrite(&ebr, sizeof(EBR), 1, file);//escribiendo la estructura del MBR
  3779. fclose(file);
  3780. printf("'EBR CREADO EXITOSAMENTE'\n");
  3781. }
  3782.  
  3783. }
  3784. FILE* file= fopen(funcion.path, "rb+");
  3785. fseek(file,0,SEEK_SET);
  3786.  
  3787. if (file==NULL)
  3788. {
  3789. printf("\nError::->Imposible escribir en el archivo \n\n");
  3790. ErrorCrearParticion++;
  3791. }
  3792. else
  3793. {
  3794. /*Particion aux;
  3795. for(int i=0;i<=mbr.cantParticones;i++){
  3796. for(int j=0;j<mbr.cantParticones-1;j++){
  3797. printf("%s->%d\n",mbr.particiones[j].part_name,mbr.particiones[j].part_start);
  3798. printf("%s-> %d\n",mbr.particiones[j+1].part_name,mbr.particiones[j+1].part_start);
  3799. if(mbr.particiones[j].part_start>mbr.particiones[j+1].part_start){
  3800. aux=mbr.particiones[j];
  3801. mbr.particiones[j]=mbr.particiones[j+1];
  3802. mbr.particiones[j+1]=aux;
  3803. }
  3804. }
  3805. }
  3806. printf("%d\n",mbr.mbr_disk_signature);
  3807. for (int i=0;i<4;i++) {
  3808. printf("%s\n",mbr.particiones[i].part_name);
  3809. }*/
  3810. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  3811. fclose(file);
  3812. printf("'CREACION DE PARTICION EXITOSA'\n");
  3813. ContadorComandosExitosos++;
  3814. }
  3815. }else {
  3816. printf("Error::->No se encontro espacio para la particion\n");
  3817. ErrorCrearParticion++;
  3818. }
  3819. break;
  3820. }
  3821. }
  3822.  
  3823.  
  3824. }
  3825.  
  3826. int BuscarEspacionWF(MbrDisco mbr,Funcion funcion,int tamano)
  3827. {
  3828. int espacio=EspacioWF(mbr,tamano);
  3829. for (int i=0;i<4;i++) {
  3830.  
  3831.  
  3832. if(mbr.particiones[i].part_status=='0')
  3833. {
  3834. if(espacio!=-1)
  3835. {
  3836.  
  3837. printf("Ingresara particion en espacio %i\n",espacio);
  3838. mbr.particiones[i].part_start=espacio;
  3839. mbr.particiones[i].part_status='1';
  3840. mbr.particiones[i].part_type=funcion.type;
  3841. int l=0;
  3842. for(int k=0;k<3;k++)
  3843. {
  3844. mbr.particiones[i].part_fit[l++]=funcion.fit[k];
  3845. }
  3846. strcpy(mbr.particiones[i].part_name,funcion.name);
  3847. mbr.particiones[i].part_size=tamano;
  3848. printf("part_status: %c\n",mbr.particiones[i].part_status);
  3849. printf("part_type: %c\n",mbr.particiones[i].part_type);
  3850. printf("part_fit: %s\n",mbr.particiones[i].part_fit);
  3851. printf("part_name: %s\n",mbr.particiones[i].part_name);
  3852. printf("part_size: %i\n",mbr.particiones[i].part_size);
  3853. printf("part_start: %i\n",mbr.particiones[i].part_start);
  3854.  
  3855.  
  3856. mbr.cantParticones++;
  3857. printf("particiones: %i\n",mbr.cantParticones);
  3858. if(mbr.particiones[i].part_type=='E' || mbr.particiones[i].part_type=='E' )
  3859. {
  3860. printf("Es una particion extendida\n");
  3861. EBR ebr;
  3862. ebr.part_next=-1;
  3863. ebr.part_size=0;
  3864. ebr.part_start=mbr.particiones[i].part_start;
  3865. ebr.part_status='0';
  3866. FILE* file= fopen(funcion.path, "rb+");
  3867. printf("EBR inicial dir->%d\n",mbr.particiones[i].part_start+sizeof (MbrDisco));
  3868. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  3869.  
  3870. if (file==NULL)
  3871. {
  3872. printf("\nError::->Imposible escribir en el archivo \n\n");
  3873. }
  3874. else
  3875. {
  3876.  
  3877. fwrite(&ebr, sizeof(EBR), 1, file);//escribiendo la estructura del MBR
  3878. fclose(file);
  3879. printf("'EBR CREADO EXITOSAMENTE'\n");
  3880. }
  3881.  
  3882. }
  3883. FILE* file= fopen(funcion.path, "rb+");
  3884. fseek(file,0,SEEK_SET);
  3885.  
  3886. if (file==NULL)
  3887. {
  3888. printf("\nError::->Imposible escribir en el archivo \n\n");
  3889. ErrorCrearParticion++;
  3890. }
  3891. else
  3892. {
  3893. /*Particion aux;
  3894. for(int i=0;i<=mbr.cantParticones;i++){
  3895. for(int j=0;j<mbr.cantParticones-1;j++){
  3896. printf("%s->%d\n",mbr.particiones[j].part_name,mbr.particiones[j].part_start);
  3897. printf("%s-> %d\n",mbr.particiones[j+1].part_name,mbr.particiones[j+1].part_start);
  3898. if(mbr.particiones[j].part_start>mbr.particiones[j+1].part_start){
  3899. aux=mbr.particiones[j];
  3900. mbr.particiones[j]=mbr.particiones[j+1];
  3901. mbr.particiones[j+1]=aux;
  3902. }
  3903. }
  3904. }
  3905. printf("%d\n",mbr.mbr_disk_signature);
  3906. for (int i=0;i<4;i++) {
  3907. printf("%s\n",mbr.particiones[i].part_name);
  3908. }*/
  3909. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  3910. fclose(file);
  3911. printf("'CREACION DE PARTICION EXITOSA'\n");
  3912. ContadorComandosExitosos++;
  3913. }
  3914. }else {
  3915. printf("Error::->No se encontro espacio para la particion\n");
  3916. }
  3917. break;
  3918. }
  3919. }
  3920. }
  3921. void BuscarEspacionFF(MbrDisco mbr,Funcion funcion,int tamano)
  3922. {
  3923. int espacio=EspacioFF(mbr,tamano);
  3924. for (int i=0;i<4;i++) {
  3925.  
  3926.  
  3927. if(mbr.particiones[i].part_status=='0')
  3928. {
  3929. if(espacio!=-1)
  3930. {
  3931.  
  3932. printf("Ingresara particion en espacio %i\n",espacio);
  3933. mbr.particiones[i].part_start=espacio;
  3934. mbr.particiones[i].part_status='1';
  3935. mbr.particiones[i].part_type=funcion.type;
  3936. int l=0;
  3937. for(int k=0;k<3;k++)
  3938. {
  3939. mbr.particiones[i].part_fit[l++]=funcion.fit[k];
  3940. }
  3941. strcpy(mbr.particiones[i].part_name,funcion.name);
  3942. mbr.particiones[i].part_size=tamano;
  3943. printf("part_status: %c\n",mbr.particiones[i].part_status);
  3944. printf("part_type: %c\n",mbr.particiones[i].part_type);
  3945. printf("part_fit: %s\n",mbr.particiones[i].part_fit);
  3946. printf("part_name: %s\n",mbr.particiones[i].part_name);
  3947. printf("part_size: %i\n",mbr.particiones[i].part_size);
  3948. printf("part_start: %i\n",mbr.particiones[i].part_start);
  3949.  
  3950.  
  3951. mbr.cantParticones++;
  3952. printf("particiones: %i\n",mbr.cantParticones);
  3953. if(mbr.particiones[i].part_type=='E' || mbr.particiones[i].part_type=='E' )
  3954. {
  3955. printf("Es una particion extendida\n");
  3956. EBR ebr;
  3957. ebr.part_next=-1;
  3958. ebr.part_size=0;
  3959. ebr.part_start=mbr.particiones[i].part_start;
  3960. ebr.part_status='0';
  3961. FILE* file= fopen(funcion.path, "rb+");
  3962. printf("EBR inicial dir->%d\n",mbr.particiones[i].part_start+sizeof (MbrDisco));
  3963. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  3964.  
  3965. if (file==NULL)
  3966. {
  3967. printf("\nError::->Imposible escribir en el archivo \n\n");
  3968. }
  3969. else
  3970. {
  3971.  
  3972. fwrite(&ebr, sizeof(EBR), 1, file);//escribiendo la estructura del MBR
  3973. fclose(file);
  3974. printf("'EBR CREADO EXITOSAMENTE'\n");
  3975. }
  3976.  
  3977. }
  3978. FILE* file= fopen(funcion.path, "rb+");
  3979. fseek(file,0,SEEK_SET);
  3980.  
  3981. if (file==NULL)
  3982. {
  3983. printf("\nError::->Imposible escribir en el archivo \n\n");
  3984. ErrorCrearParticion++;
  3985. }
  3986. else
  3987. {
  3988.  
  3989. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  3990. fclose(file);
  3991. printf("'CREACION DE PARTICION EXITOSA'\n");
  3992. ContadorComandosExitosos++;
  3993. }
  3994. }else {
  3995. printf("Error::->No se encontro espacio para la particion\n");
  3996. ErrorCrearParticion++;
  3997. }
  3998. break;
  3999. }
  4000. }
  4001.  
  4002.  
  4003.  
  4004. }
  4005. void actualizar(Funcion funcion, MbrDisco mbr)
  4006. {
  4007. FILE* file= fopen(funcion.path, "rb+");
  4008. fseek(file,0,SEEK_SET);
  4009.  
  4010. if (file==NULL)
  4011. {
  4012. printf("\nError::->Imposible escribir en el archivo \n\n");
  4013.  
  4014. }
  4015. else
  4016. {
  4017. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  4018. fclose(file);
  4019. printf("'DATOS ACTUALIZADOS'\n");
  4020. ContadorComandosExitosos++;
  4021. }
  4022. }
  4023. void CrearParticion(Funcion funcion)
  4024. {
  4025. int bandera=1;
  4026. MbrDisco mbr;
  4027. FILE *fp;
  4028. fp = fopen(funcion.path, "rb");
  4029.  
  4030. if(fp == NULL)
  4031. {
  4032. printf("\n Error::-> No se encontro el disco\n");
  4033. }else {
  4034. fread(&mbr, sizeof(MbrDisco), 1, fp);
  4035. fclose(fp);
  4036. if(funcion.type!='L')
  4037. {
  4038. if(funcion.type=='p' || funcion.type=='P')
  4039. {
  4040. printf("Creando particion primaria...\n");
  4041. }if(funcion.type=='e' || funcion.type=='E')
  4042. {
  4043. printf("Creando particion extendidas...\n");
  4044. int contador=0;
  4045. for (int i=0;i<4;i++) {
  4046.  
  4047. if(mbr.particiones[i].part_type=='e' || mbr.particiones[i].part_type=='E')
  4048. {
  4049. contador++;
  4050. }
  4051. }
  4052.  
  4053. if(contador>=1)
  4054. {
  4055. bandera=0;
  4056. printf("\nError::-> Limite de particiones extendidas\n");
  4057. ErrorCrearParticion++;
  4058. }
  4059. }
  4060.  
  4061. if(bandera==1)
  4062. {
  4063.  
  4064.  
  4065.  
  4066. if(mbr.cantParticones==4)
  4067. {
  4068. printf("--------%s\n",mbr.mbr_fit);
  4069. printf("\nError::-> Limite de particiones en el disco\n");
  4070. ErrorCrearParticion++;
  4071. }else {
  4072.  
  4073.  
  4074. int tamano=0;
  4075. if(funcion.unit=='k'||funcion.unit=='K')
  4076. {
  4077. tamano=funcion.size*1024;
  4078. }
  4079. else if(funcion.unit=='b'||funcion.unit=='B')
  4080. {
  4081. tamano=funcion.size;
  4082. }
  4083. else
  4084. {
  4085. tamano=funcion.size*(1024*1024);
  4086. }
  4087. if(!strcmp(mbr.mbr_fit,"BF"))
  4088. {
  4089. printf("Creando particion con mejor ajuste...\n");
  4090. BuscarEspacionBF(mbr,funcion,tamano);
  4091. //actualizar(funcion,mbr);
  4092. }
  4093. if(!strcmp(mbr.mbr_fit,"FF"))
  4094. {
  4095.  
  4096. printf("Creando particion con primer ajuste...\n");
  4097. BuscarEspacionFF(mbr,funcion,tamano);
  4098. //actualizar(funcion,mbr);
  4099.  
  4100. }
  4101. if(!strcmp(mbr.mbr_fit,"WF"))
  4102. {
  4103. printf("Creando particion con peor ajuste...\n");
  4104. BuscarEspacionWF(mbr,funcion,tamano);
  4105.  
  4106. // actualizar(funcion,mbr);
  4107. }
  4108. }
  4109. }
  4110. }else {
  4111. printf("Creando particion logica...\n");
  4112. int contador=0;
  4113. for (int i=0;i<4;i++) {
  4114.  
  4115. if(mbr.particiones[i].part_type=='e' || mbr.particiones[i].part_type=='E')
  4116. {
  4117. contador++;
  4118. }
  4119. }
  4120.  
  4121. if(contador==0)
  4122. {
  4123. bandera=0;
  4124. printf("\nError::-> No existen particiones extendidas\n");
  4125. ErrorCrearParticion++;
  4126. }
  4127. }
  4128.  
  4129. }
  4130.  
  4131.  
  4132. }
  4133. void Exec(Funcion funcion)
  4134. {
  4135. FILE *fichero;
  4136. char caracter;
  4137. char comando[500];
  4138.  
  4139. fichero = fopen(funcion.path, "rt");
  4140.  
  4141. if (fichero == NULL) {
  4142. printf("Error::-> No se ha podido abrir en script");
  4143. } else {
  4144. caracter = fgetc(fichero);
  4145. while (feof(fichero) == 0) {
  4146. if(caracter=='\n' )
  4147. {
  4148. printf("\n-> %s\n",comando);
  4149. Interprete(comando);
  4150. limpiarvar(comando,100);
  4151. }else {
  4152. char nuevoCaracter[1];
  4153. nuevoCaracter[0]=caracter;
  4154. strncat(comando,nuevoCaracter,1);
  4155.  
  4156. }
  4157. caracter = fgetc(fichero);
  4158.  
  4159. }
  4160. printf("\n-> %s\n",comando);
  4161. Interprete(comando);
  4162. limpiarvar(comando,100);
  4163.  
  4164. fclose(fichero);
  4165. ContadorComandosExitosos++;
  4166. }
  4167. }
  4168.  
  4169. void Recorrer()
  4170. {
  4171. Montura *pivote=sistema->primero;
  4172. while (pivote!=NULL) {
  4173. printf("--------------------------\n");
  4174. printf("%s\n",pivote->name);
  4175. printf("%s\n",pivote->path);
  4176. pivote=pivote->siguiente;
  4177. }
  4178. }
  4179.  
  4180.  
  4181.  
  4182. Retorno buscarEnSistema(Funcion funcion)
  4183. {
  4184. int bandera=0;
  4185. Retorno r;
  4186. r.disco=0;
  4187. r.particion=0;
  4188. Montura *pivote=sistema->primero;
  4189.  
  4190. while (pivote!=NULL) {
  4191.  
  4192. if(!strcmp(funcion.path,pivote->path) && strcmp(funcion.name,pivote->nombre))
  4193. {
  4194. r.particion++;
  4195. }
  4196. pivote=pivote->siguiente;
  4197. }
  4198.  
  4199. pivote=sistema->primero;
  4200. Montura *anterior=pivote;
  4201. while (pivote!=NULL) {
  4202.  
  4203. if(!strcmp(funcion.path,pivote->path))
  4204. {
  4205. bandera=1;
  4206. break;
  4207. }
  4208.  
  4209. printf("%s\n",pivote->path);
  4210. printf("%s\n",anterior->path);
  4211. if(strcmp(anterior->path,pivote->path)){
  4212. r.disco++;
  4213. }
  4214.  
  4215. anterior=pivote;
  4216. pivote=pivote->siguiente;
  4217. }
  4218. if(bandera==0 && sistema->primero!=NULL)
  4219. {
  4220. r.disco++;
  4221. }
  4222. return r;
  4223. }
  4224.  
  4225. Montura *DeterminarNombre(Funcion funcion)
  4226. {
  4227. Montura *nueva;
  4228. nueva=(Montura*)malloc(sizeof (Montura));
  4229. limpiarvar(nueva->path,250);
  4230. int bandera=0;
  4231. MbrDisco mbr;
  4232. FILE *fp;
  4233. fp = fopen(funcion.path, "rb");
  4234.  
  4235. if(fp == NULL)
  4236. {
  4237. printf("\n Error::-> No se encontro el disco\n");
  4238. }else {
  4239. fread(&mbr, sizeof(MbrDisco), 1, fp);
  4240. fclose(fp);
  4241.  
  4242. for (int i=0;i<4;i++) {
  4243.  
  4244. if(!strcmp(mbr.particiones[i].part_name,funcion.name))
  4245. {
  4246. strcpy(nueva->nombre,mbr.particiones[i].part_name);
  4247. strcpy(nueva->path,funcion.path);
  4248. bandera=1;
  4249. break;
  4250. }
  4251. }
  4252. if(bandera==1)
  4253. {
  4254. printf("Se encontro la particion\n");
  4255. char nom[10];
  4256. Retorno r= buscarEnSistema(funcion);
  4257. printf("Discos: %i\n",r.disco);
  4258. printf("Particiones: %i\n",r.particion);
  4259.  
  4260. char x[1];
  4261. x[0]=r.disco+97;
  4262. int y= r.particion+1;
  4263. char d[3];
  4264. strcat(nom,"vd");
  4265. strncat(nom,x,1);
  4266. sprintf(d, "%d",y);
  4267. strcat(nom,d);
  4268. printf("Id: %s\n",nom);
  4269. nueva->siguiente=NULL;
  4270. strcpy(nueva->name,nom);
  4271. limpiarvar(x,1);
  4272. limpiarvar(d,3);
  4273. limpiarvar(nom,10);
  4274. return nueva;
  4275.  
  4276. }else {
  4277. printf("\n Error::-> No se encontro la particion\n");
  4278. }
  4279.  
  4280.  
  4281. }
  4282. return NULL;
  4283. }
  4284.  
  4285.  
  4286. void montar(Montura * nueva)
  4287. {
  4288. if(sistema->primero==NULL)
  4289. {
  4290. sistema->primero=nueva;
  4291. sistema->ultimo=nueva;
  4292.  
  4293. }else {
  4294. nueva->siguiente=sistema->primero;
  4295. sistema->primero=nueva;
  4296. }
  4297.  
  4298. }
  4299.  
  4300.  
  4301. void desmontar(Funcion funcion)
  4302. {
  4303. int bandera=0;
  4304. Montura *pivote=sistema->primero;
  4305. Montura * anterior=pivote;
  4306. while (pivote!=NULL) {
  4307. if(!strcmp(funcion.id,pivote->name))
  4308. {
  4309. if(!strcmp(pivote->name,sistema->primero->name))
  4310. {
  4311. printf("Primero\n");
  4312. sistema->primero=sistema->primero->siguiente;
  4313. free(pivote);
  4314. }
  4315. else if(!strcmp(pivote->name,sistema->ultimo->name))
  4316. {
  4317. printf("Ultimo\n");
  4318. anterior->siguiente=NULL;
  4319. sistema->ultimo=anterior;
  4320. free(pivote);
  4321. }else
  4322. {
  4323. printf("Medio\n");
  4324. anterior->siguiente=pivote->siguiente;
  4325. pivote->siguiente=NULL;
  4326. free(pivote);
  4327. }
  4328. bandera=1;
  4329. break;
  4330. }
  4331. anterior=pivote;
  4332. pivote=pivote->siguiente;
  4333. }
  4334. if(bandera==0)
  4335. {
  4336. printf("\nNo se encontro ninguna particion montada con ese nombre\n");
  4337. }else {
  4338. printf("\nParticion desmontada\n");
  4339. }
  4340. }
  4341.  
  4342.  
  4343.  
  4344.  
  4345. // HERRAMIENTAS----------------------------------------------------------------------------------------------------------------------------------
  4346.  
  4347.  
  4348. void quitarComillas (char a[100]){
  4349.  
  4350. limpiarvar(sincomillas,1000);
  4351. char pathauxiliar[100];
  4352. strcpy(pathauxiliar,a);
  4353.  
  4354. char finalizado[100];
  4355. strcpy(finalizado,"cd /\n");
  4356.  
  4357. if(pathauxiliar[0]=='\"')
  4358. {
  4359. limpiarvar(a,100);
  4360. int q=1;
  4361. while(pathauxiliar[q]!='\"')
  4362. {
  4363. char nuevaCadena[1];
  4364. nuevaCadena[0]=pathauxiliar[q];
  4365. strncat(a,nuevaCadena,1);
  4366. q++;
  4367. }
  4368.  
  4369. }
  4370.  
  4371. strcpy(sincomillas,a);
  4372.  
  4373. }
  4374. void LimpiarVariables (){
  4375. comentario=0;
  4376. ErrorInterprete=0;
  4377. ErrorComando=0;
  4378. ErrorCrearDisco=0;
  4379. ErrorEliminarDisco=0;
  4380. ErrorCrearParticionLogica=0;
  4381. ErrorEliminarLogica=0;
  4382. ErrorReporte1=0;
  4383. ErrorReporte2=0;
  4384. ContadorInstrucciones=0;
  4385. ContadorComandosExitosos=0;
  4386. fin=0;
  4387.  
  4388. }
  4389.  
  4390. int EsLetra(char caracter)
  4391. {
  4392. if((caracter >= 'a' && caracter <= 'z' ) || (caracter >= 'A' && caracter <= 'Z' ))
  4393. {
  4394. return 1;
  4395. }else
  4396. {
  4397. return 0;
  4398. }
  4399. }
  4400. //0 si la cadena es numero
  4401. int CadenaEsNumero(char entrada[])
  4402. {
  4403. int resultado=0;
  4404. int contador=0;
  4405. while(entrada[contador])
  4406. {
  4407. if(EsNumero(entrada[contador])==0)
  4408. {
  4409. resultado++;
  4410. }
  4411. contador++;
  4412. }
  4413. return resultado;
  4414. }
  4415.  
  4416. int EsNumero (char caracter[])
  4417. {
  4418. if(caracter >= '0' && caracter <= '9')
  4419. {
  4420. return 1;
  4421. }else
  4422. {
  4423. return 0;
  4424. }
  4425.  
  4426. }
  4427.  
  4428.  
  4429. void AgregarEspacio(Funcion funcion)
  4430. {
  4431. MbrDisco mbr;
  4432. int bandera=0;
  4433. FILE *fp;
  4434. fp = fopen(funcion.path, "rb");
  4435.  
  4436. if(fp == NULL)
  4437. {
  4438. printf("\n Error::-> No se encontro el disco\n");
  4439. }else {
  4440. fread(&mbr, sizeof(MbrDisco), 1, fp);
  4441. fclose(fp);
  4442. for (int i=0;i<4;i++) {
  4443. if(!strcmp(funcion.name,mbr.particiones[i].part_name))
  4444. {
  4445. bandera=1;
  4446. long espacio;
  4447. if(i==3)
  4448. {
  4449. espacio= mbr.mbr_tamano-(mbr.particiones[i+1].part_start+mbr.particiones[i+1].part_size);
  4450.  
  4451. }else {
  4452. if(mbr.particiones[i+1].part_status=='1')
  4453. {
  4454. espacio= mbr.particiones[i+1].part_start-(mbr.particiones[i+1].part_start+mbr.particiones[i+1].part_size);
  4455. }else
  4456. {
  4457. espacio= mbr.mbr_tamano-(mbr.particiones[i+1].part_start+mbr.particiones[i+1].part_size);
  4458. }
  4459. }
  4460.  
  4461. if(espacio>funcion.tamano)
  4462. {
  4463. printf("%d\n",mbr.mbr_disk_signature);
  4464. printf("%s\n",mbr.mbr_fit);
  4465. mbr.particiones[i].part_size=mbr.particiones[i].part_size+funcion.tamano;
  4466. FILE* file= fopen(funcion.path, "rb+");
  4467. fseek(file,0,SEEK_SET);
  4468.  
  4469. if (file==NULL)
  4470. {
  4471. printf("\nError::->Imposible escribir en el archivo \n\n");
  4472.  
  4473. }
  4474. else
  4475. {
  4476. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  4477. fclose(file);
  4478. printf("'PARTICION AMPLIADA EXITOSAMENTE'\n");
  4479. ContadorComandosExitosos++;
  4480. }
  4481.  
  4482. }else
  4483. {
  4484. printf("No hay espacio para ampliar la particion\n");
  4485. }
  4486. break;
  4487. }
  4488. }
  4489. if(bandera==0)
  4490. {
  4491. printf("No se encontro la particion\n");
  4492. }
  4493. }
  4494.  
  4495. }
  4496. void QuitarEspacio(Funcion funcion)
  4497. {
  4498. MbrDisco mbr;
  4499. int bandera=0;
  4500. FILE *fp;
  4501. fp = fopen(funcion.path, "rb");
  4502.  
  4503. if(fp == NULL)
  4504. {
  4505. printf("\n Error::-> No se encontro el disco\n");
  4506. }else {
  4507. fread(&mbr, sizeof(MbrDisco), 1, fp);
  4508. fclose(fp);
  4509. for (int i=0;i<4;i++) {
  4510. if(!strcmp(funcion.name,mbr.particiones[i].part_name))
  4511. {
  4512. bandera=1;
  4513.  
  4514.  
  4515. if(mbr.particiones[i].part_size-funcion.tamano>0)
  4516. {
  4517. mbr.particiones[i].part_size=mbr.particiones[i].part_size-funcion.tamano;
  4518. FILE* file= fopen(funcion.path, "rb+");
  4519. fseek(file,0,SEEK_SET);
  4520.  
  4521. if (file==NULL)
  4522. {
  4523. printf("\nError::->Imposible escribir en el archivo \n\n");
  4524. }
  4525. else
  4526. {
  4527. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  4528. fclose(file);
  4529. printf("'PARTICION REDUCIDA EXITOSAMENTE'\n");
  4530. ContadorComandosExitosos++;
  4531. }
  4532.  
  4533. }else
  4534. {
  4535. printf("No se puede reducir\n");
  4536. }
  4537. break;
  4538. }
  4539. }
  4540. if(bandera==0)
  4541. {
  4542. printf("No se encontro la particion\n");
  4543. }
  4544. }
  4545.  
  4546. }
  4547. void EliminarParticion(Funcion funcion)
  4548. {
  4549. MbrDisco mbr;
  4550. int bandera=0;
  4551. FILE *fp;
  4552. fp = fopen(funcion.path, "rb");
  4553.  
  4554. if(fp == NULL)
  4555. {
  4556. printf("\n Error::-> No se encontro el disco\n");
  4557. ErrorEliminarParticion++;
  4558. }else {
  4559. fread(&mbr, sizeof(MbrDisco), 1, fp);
  4560. fclose(fp);
  4561. for (int i=0;i<4;i++) {
  4562. if(!strcmp(funcion.name,mbr.particiones[i].part_name))
  4563. {
  4564. bandera=1;
  4565. switch (i) {
  4566. case 0:
  4567. mbr.particiones[0]=mbr.particiones[1];
  4568. mbr.particiones[1]=mbr.particiones[2];
  4569. mbr.particiones[2]=mbr.particiones[3];
  4570. mbr.particiones[3].part_start=-1;
  4571. mbr.particiones[3].part_status='0';
  4572. mbr.particiones[3].part_size=0;
  4573.  
  4574. break;
  4575. case 1:
  4576. mbr.particiones[1]=mbr.particiones[2];
  4577. mbr.particiones[2]=mbr.particiones[3];
  4578. mbr.particiones[3].part_start=-1;
  4579. mbr.particiones[3].part_status='0';
  4580. mbr.particiones[3].part_size=0;
  4581. break;
  4582. case 2:
  4583. mbr.particiones[2]=mbr.particiones[3];
  4584. mbr.particiones[3].part_start=-1;
  4585. mbr.particiones[3].part_status='0';
  4586. mbr.particiones[3].part_size=0;
  4587. break;
  4588. case 3:
  4589. mbr.particiones[3].part_start=-1;
  4590. mbr.particiones[3].part_status='0';
  4591. mbr.particiones[3].part_size=0;
  4592. break;
  4593. }
  4594. FILE* file= fopen(funcion.path, "rb+");
  4595. fseek(file,0,SEEK_SET);
  4596.  
  4597. if (file==NULL)
  4598. {
  4599. printf("\nError::->Imposible escribir en el archivo \n\n");
  4600. ErrorEliminarParticion++;
  4601. }
  4602. else
  4603. {
  4604. mbr.cantParticones--;
  4605. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  4606. fclose(file);
  4607. printf("'PARTICION ELIMINADA EXITOSAMENTE'\n");
  4608. ContadorComandosExitosos++;
  4609. }
  4610.  
  4611. break;
  4612. }
  4613. }
  4614. if(bandera==0)
  4615. {
  4616. printf("No se encontro la particion\n");
  4617. ErrorEliminarParticion++;
  4618. }
  4619. }
  4620.  
  4621. }
  4622. int BuscarEspacioLogicaFF(EBR ebr,Funcion funcion,int inicio,MbrDisco mbr,EBR ebrNuevo)
  4623. {
  4624. printf("Buscando espacios en particion extendida\n");
  4625. int siguiente=ebr.part_next;
  4626. EBR sig;
  4627. EBR actual=ebr;
  4628. int contador=0;
  4629. while (siguiente!=-1) {
  4630. printf("Siguiente existe\n");
  4631. FILE *fp;
  4632. fp = fopen(funcion.path, "rb");
  4633. fseek(fp,siguiente+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  4634.  
  4635. if(fp == NULL)
  4636. {
  4637. printf("\n Error::-> No se encontro el disco\n");
  4638. }else {
  4639. fread(&sig, sizeof(EBR), 1, fp);
  4640. fclose(fp);
  4641. }
  4642. printf("Siguiente empieza en %d\n",siguiente+206);
  4643. printf("Siguiente es %s\n",sig.part_name);
  4644. if(contador==0)
  4645. {
  4646. printf("Primer particion logica\n");
  4647. printf("Inicio-> %d\n",inicio);
  4648. printf("Actual-> %d\n",actual.part_start+206);
  4649. printf("tamano-> %d\n",funcion.tamano+206);
  4650. if(inicio-actual.part_start>=funcion.tamano)
  4651. {
  4652. printf("Encontro Espacio entre el principio y la primera particion\n");
  4653. FILE* file= fopen(funcion.path, "rb+");
  4654. // estableciendo puntero al inicio
  4655. if (file==NULL)
  4656. {
  4657. printf("\nError::->Imposible escribir en el archivo \n\n");
  4658. }
  4659. else
  4660. {
  4661. EBR ebri;
  4662. ebri.part_next=inicio;
  4663. ebri.part_size=0;
  4664. ebri.part_start=0;
  4665. ebri.part_status='0';
  4666. ebrNuevo.part_start=inicio;
  4667. ebrNuevo.part_next=actual.part_start;
  4668. printf("Nuevo inicia en %d\n",ebrNuevo.part_start+206);
  4669. printf("Nuevo siguiente esta en %d\n\n",ebrNuevo.part_next+206);
  4670. fseek(file,inicio+sizeof (MbrDisco),SEEK_SET);
  4671. fwrite(&ebri, sizeof(EBR), 1, file);
  4672.  
  4673. fseek(file,inicio+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  4674. fwrite(&ebrNuevo, sizeof(EBR), 1, file);
  4675.  
  4676. fclose(file);
  4677. printf("'CREACION DE PARTICION EXITOSA'\n");
  4678. }
  4679. return inicio;
  4680. }
  4681. }
  4682. if(sig.part_start-(actual.part_start+actual.part_size)>=funcion.tamano)
  4683. {
  4684.  
  4685. printf("Encontro Espacio en medio\n");
  4686. FILE* file= fopen(funcion.path, "rb+");
  4687. // estableciendo puntero al inicio
  4688. if (file==NULL)
  4689. {
  4690. printf("\nError::->Imposible escribir en el archivo \n\n");
  4691. }
  4692. else
  4693. {
  4694. actual.part_next=actual.part_start+actual.part_size;
  4695. ebrNuevo.part_start=actual.part_start+actual.part_size;
  4696. ebrNuevo.part_next=sig.part_start;
  4697. printf("Actual inicia en %d\n",actual.part_start+206);
  4698. printf("Actual siguiente esta en %d\n",actual.part_next+206);
  4699. printf("Nuevo inicia en %d\n",ebrNuevo.part_start+206);
  4700. printf("Nuevo siguiente esta en %d\n\n",ebrNuevo.part_next+206);
  4701. fseek(file,actual.part_start+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  4702. fwrite(&actual, sizeof(EBR), 1, file);
  4703.  
  4704. fseek(file,ebrNuevo.part_start+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  4705. fwrite(&ebrNuevo, sizeof(EBR), 1, file);
  4706.  
  4707. fclose(file);
  4708. printf("'CREACION DE PARTICION EXITOSA'\n");
  4709. }
  4710. return actual.part_start+actual.part_size;
  4711. }
  4712. actual=sig;
  4713. siguiente=actual.part_next;
  4714. contador++;
  4715.  
  4716. }
  4717. printf("Encontro Espacio al final\n");
  4718. FILE* file= fopen(funcion.path, "rb+");
  4719. // estableciendo puntero al inicio
  4720. if (file==NULL)
  4721. {
  4722. printf("\nError::->Imposible escribir en el archivo \n\n");
  4723. }
  4724. else
  4725. {
  4726. if(contador==0)
  4727. {
  4728. printf("Primer Insertado\n");
  4729. actual.part_next=actual.part_start+actual.part_size;
  4730. ebrNuevo.part_start=actual.part_start+actual.part_size;
  4731. ebrNuevo.part_next=-1;
  4732. printf("Actual inicia en %d\n",actual.part_start);
  4733. printf("Actual siguiente esta en %d\n",actual.part_next);
  4734. printf("Nuevo inicia en %d\n",ebrNuevo.part_start);
  4735. printf("Nuevo siguiente esta en %d\n\n",ebrNuevo.part_next);
  4736.  
  4737. printf("EBR actual dir->%d\n",actual.part_start);
  4738. fseek(file,actual.part_start+sizeof (MbrDisco),SEEK_SET);
  4739. fwrite(&actual, sizeof(EBR), 1, file);
  4740.  
  4741. printf("EBR nuevo dir->%d\n",ebrNuevo.part_start);
  4742. fseek(file,ebrNuevo.part_start+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  4743. fwrite(&ebrNuevo, sizeof(EBR), 1, file);
  4744.  
  4745. fclose(file);
  4746. printf("'CREACION DE PARTICION EXITOSA'\n");
  4747. }else
  4748. {
  4749. actual.part_next=actual.part_start+actual.part_size;
  4750. ebrNuevo.part_start=actual.part_start+actual.part_size;
  4751. ebrNuevo.part_next=-1;
  4752. printf("Actual inicia en %d\n",actual.part_start);
  4753. printf("Actual siguiente esta en %d\n",actual.part_next);
  4754. printf("Nuevo inicia en %d\n",ebrNuevo.part_start);
  4755. printf("Nuevo siguiente esta en %d\n\n",ebrNuevo.part_next);
  4756.  
  4757. printf("EBR actual dir->%d\n",actual.part_start);
  4758. fseek(file,actual.part_start+sizeof (MbrDisco)+sizeof(EBR),SEEK_SET);
  4759. fwrite(&actual, sizeof(EBR), 1, file);
  4760.  
  4761. printf("EBR nuevo dir->%d\n",ebrNuevo.part_start);
  4762. fseek(file,ebrNuevo.part_start+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  4763. fwrite(&ebrNuevo, sizeof(EBR), 1, file);
  4764.  
  4765. fclose(file);
  4766. printf("'CREACION DE PARTICION EXITOSA'\n");
  4767. }
  4768.  
  4769.  
  4770. }
  4771. return actual.part_start+actual.part_size;
  4772.  
  4773.  
  4774.  
  4775. }
  4776. void CrearParticionLogica(Funcion funcion)
  4777. {
  4778.  
  4779. MbrDisco mbr;
  4780. FILE *fp;
  4781. fp = fopen(funcion.path, "rb");
  4782.  
  4783. if(fp == NULL)
  4784. {
  4785. printf("\n Error::-> No se encontro el disco\n");
  4786. }else {
  4787. fread(&mbr, sizeof(MbrDisco), 1, fp);
  4788. fclose(fp);
  4789. }
  4790.  
  4791. int inicio;
  4792. //Creamos el ebr con sus atributos-------------------------------------------------------
  4793. EBR ebr;
  4794. int l=0;
  4795. for(int k=0;k<3;k++)
  4796. {
  4797. ebr.part_fit[l++]=funcion.fit[k];
  4798. }
  4799. ebr.part_next=-1;
  4800. ebr.part_size=funcion.tamano;
  4801. ebr.part_status='1';
  4802. strcpy(ebr.part_name,funcion.name);
  4803. ebr.part_type=funcion.type;
  4804.  
  4805. for (int i=0;i<4;i++) {
  4806. if(mbr.particiones[i].part_type=='E' || mbr.particiones[i].part_type=='e')
  4807. {
  4808. inicio=mbr.particiones[i].part_start;
  4809. }
  4810. }
  4811. printf("Particion extendida inicia en %d\n",inicio);
  4812. //Leemos el primer ebr de la particion extendida-----------------------------------------------------
  4813. EBR lec;
  4814.  
  4815. fp = fopen(funcion.path, "rb");
  4816. printf("EBR inicial dir->%d\n",inicio+sizeof (MbrDisco));
  4817. fseek(fp,inicio+sizeof (MbrDisco),SEEK_SET);
  4818.  
  4819. if(fp == NULL)
  4820. {
  4821. printf("\n Error::-> No se encontro el disco\n");
  4822. }else {
  4823. printf("Lectura de ebr inicial siguiente-> %d\n",lec.part_next);
  4824. fread(&lec, sizeof(EBR), 1, fp);
  4825. fclose(fp);
  4826. }
  4827. //----------------------------------------------------------------------------------------
  4828. BuscarEspacioLogicaFF(lec,funcion,inicio,mbr,ebr);
  4829.  
  4830.  
  4831.  
  4832. }
  4833.  
  4834. Cadena SepararContenido(char* contenido)
  4835. {
  4836. Cadena cadena;
  4837. cadena.cantidad=-1;
  4838. int indice=0;
  4839. int cont=0;
  4840. int pos=0;
  4841. while(contenido[indice]!='\0')
  4842. {
  4843. if(pos==64)
  4844. {
  4845. pos=0;
  4846. cont++;
  4847.  
  4848. }
  4849. cadena.part[cont].parte[pos]=contenido[indice];
  4850.  
  4851. pos++;
  4852. indice++;
  4853. }
  4854. printf("bloques archivo-> %d\n",cont+1);
  4855. cadena.cantidad=cont;
  4856.  
  4857. return cadena;
  4858. }
  4859.  
  4860. int BuscarApuntadorVacioBloqueCarpeta(int * apuntadores)
  4861. {
  4862. for (int i=0;i<4;i++) {
  4863. if(apuntadores[i]==-1)
  4864. {
  4865. return i;
  4866. }
  4867. }
  4868. }
  4869.  
  4870. int DeterminarTamano(char *nombre)
  4871. {
  4872. int tamano=0;
  4873. for (int i=0;i<1000;i++) {
  4874. if(nombre[i]!='\0')
  4875. {
  4876. tamano++;
  4877. }else {
  4878. return tamano;
  4879. }
  4880. }
  4881. return tamano;
  4882. }
  4883.  
  4884. int crearInodo(Inodo* inodo,int tipo,char*contenido)
  4885. {
  4886.  
  4887. inodo->i_uid=0;
  4888. inodo->I_gid=0;
  4889. inodo->i_size=0;
  4890. limpiarvar(inodo->i_ctime,16);
  4891. limpiarvar(inodo->i_mtime,16);
  4892. limpiarvar(inodo->i_atime,16);
  4893. time_t tiempo = time(0);
  4894. struct tm *tlocal = localtime(&tiempo);
  4895. char output[128];
  4896. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  4897.  
  4898. int l=0;
  4899. for(int k=0;k<16;k++)
  4900. {
  4901. inodo->i_ctime[l++]=output[k];
  4902. }
  4903.  
  4904. for (int i=0;i<15;i++) {
  4905. inodo->i_block[i]=-1;
  4906. }
  4907.  
  4908. if(tipo==0)
  4909. {
  4910. inodo->i_type='0';
  4911. }else {
  4912. inodo->i_type='1';
  4913. inodo->i_size=DeterminarTamano(contenido);
  4914. }
  4915.  
  4916. inodo->i_perm=664;
  4917. printf("Se creo el inodo \n");
  4918.  
  4919.  
  4920.  
  4921.  
  4922. }
  4923. int crearBloque(BloqueCarpeta* carpeta,int padre,int actual,int tipo)
  4924. {
  4925. if(tipo==0)
  4926. {
  4927. strcpy(carpeta->b_content[0].b_name,".");
  4928. carpeta->b_content[0].b_inodo=actual;
  4929. strcpy(carpeta->b_content[1].b_name,"..");
  4930. carpeta->b_content[1].b_inodo=padre;
  4931. carpeta->b_content[2].b_inodo=-1;
  4932. carpeta->b_content[3].b_inodo=-1;
  4933. strcpy(carpeta->b_content[2].b_name,"");
  4934. strcpy(carpeta->b_content[3].b_name,"");
  4935. printf("Se creo el bloque carpeta \n");
  4936. }else{
  4937. strcpy(carpeta->b_content[0].b_name,"");
  4938. carpeta->b_content[0].b_inodo=-1l;
  4939. strcpy(carpeta->b_content[1].b_name,"");
  4940. carpeta->b_content[1].b_inodo=-1;
  4941. carpeta->b_content[2].b_inodo=-1;
  4942. carpeta->b_content[3].b_inodo=-1;
  4943. strcpy(carpeta->b_content[2].b_name,"");
  4944. strcpy(carpeta->b_content[3].b_name,"");
  4945. }
  4946.  
  4947.  
  4948.  
  4949.  
  4950.  
  4951. }
  4952.  
  4953. int ExisteInodo(char* bitmap,int pos)
  4954. {
  4955. for (int i=0;i<pos+1;i++) {
  4956. if(i==pos && bitmap[i]!='1')
  4957. {
  4958. return 1;
  4959. }
  4960. }
  4961. return 0;
  4962. }
  4963.  
  4964. void actualizarBloqueLibre()
  4965. {
  4966. MbrDisco mbr;
  4967. SuperBlock super;
  4968. FILE* file= fopen(pathG, "rb+");
  4969. if (file==NULL)
  4970. {
  4971. printf("\nError::->Imposible escribir en el archivo \n\n");
  4972. }
  4973. else
  4974. {
  4975. fread(&mbr,sizeof (MbrDisco) , 1, file);
  4976. for(int i=0; i<4; i++)
  4977. {
  4978. if(!strcmp(nombG,mbr.particiones[i].part_name))
  4979. {
  4980. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  4981. fread(&super,sizeof (SuperBlock) , 1, file);
  4982. for (int j=0; j<super.s_blocks_count;j++) {
  4983. char v;
  4984. fseek(file,super.s_bm_block_start+j,SEEK_SET);
  4985. fread(&v,1 , 1, file);
  4986. if(v=='0')
  4987. {
  4988. printf("Nuevo bitmap bloque-> %d\n",j);
  4989. super.s_first_blo=j;
  4990. break;
  4991. }
  4992. }
  4993. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  4994. fwrite(&super,sizeof (SuperBlock) , 1, file);
  4995. fclose(file);
  4996.  
  4997. break;
  4998. }
  4999. }
  5000.  
  5001. }
  5002. }
  5003.  
  5004. void actualizarInodoLibre()
  5005. {
  5006. MbrDisco mbr;
  5007. SuperBlock super;
  5008. FILE* file= fopen(pathG, "rb+");
  5009. if (file==NULL)
  5010. {
  5011. printf("\nError::->Imposible escribir en el archivo \n\n");
  5012. }
  5013. else
  5014. {
  5015. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5016. for(int i=0; i<4; i++)
  5017. {
  5018. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5019. {
  5020. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5021. fread(&super,sizeof (SuperBlock) , 1, file);
  5022. for (int j=0; j<super.s_inodes_count;j++) {
  5023. char v;
  5024. fseek(file,super.s_bm_inode_start+j,SEEK_SET);
  5025. fread(&v,1 , 1, file);
  5026. if(v=='0')
  5027. {
  5028. printf("Nuevo inodo libre-> %d\n",j);
  5029. super.s_first_ino=j;
  5030. break;
  5031. }
  5032. }
  5033. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5034. fwrite(&super,sizeof (SuperBlock) , 1, file);
  5035. fclose(file);
  5036.  
  5037. break;
  5038. }
  5039. }
  5040.  
  5041. }
  5042. }
  5043.  
  5044.  
  5045. void cambiarBitmapInodo()
  5046. {
  5047. MbrDisco mbr;
  5048. SuperBlock super;
  5049. FILE* file= fopen(pathG, "rb+");
  5050. if (file==NULL)
  5051. {
  5052. printf("\nError::->Imposible escribir en el archivo \n\n");
  5053. }
  5054. else
  5055. {
  5056. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5057. for(int i=0; i<4; i++)
  5058. {
  5059. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5060. {
  5061. char c='1';
  5062. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5063. fread(&super,sizeof (SuperBlock) , 1, file);
  5064.  
  5065. fseek(file,super.s_bm_inode_start+super.s_first_ino,SEEK_SET);
  5066. fwrite(&c,1 , 1, file);
  5067. printf("bitmap inodo en %d ahora es 1\n",super.s_first_ino);
  5068. fclose(file);
  5069. actualizarInodoLibre();
  5070.  
  5071. break;
  5072. }
  5073. }
  5074.  
  5075. }
  5076. }
  5077.  
  5078. void cambiarBitmapBloque()
  5079. {
  5080. MbrDisco mbr;
  5081. SuperBlock super;
  5082. FILE* file= fopen(pathG, "rb+");
  5083. if (file==NULL)
  5084. {
  5085. printf("\nError::->Imposible escribir en el archivo \n\n");
  5086. }
  5087. else
  5088. {
  5089. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5090. for(int i=0; i<4; i++)
  5091. {
  5092. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5093. {
  5094. char c='1';
  5095. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5096. fread(&super,sizeof (SuperBlock) , 1, file);
  5097.  
  5098. fseek(file,super.s_bm_block_start+super.s_first_blo,SEEK_SET);
  5099. fwrite(&c,1 , 1, file);
  5100. printf("bitmap bloque en %d ahora es 1\n",super.s_first_blo);
  5101. fclose(file);
  5102. actualizarBloqueLibre();
  5103.  
  5104. break;
  5105. }
  5106. }
  5107.  
  5108. }
  5109. }
  5110.  
  5111. void buscarEspacioApuntador(int posActual,char* nombre)
  5112. {
  5113. MbrDisco mbr;
  5114. SuperBlock super;
  5115. FILE* file= fopen(pathG, "rb+");
  5116. if (file==NULL)
  5117. {
  5118. printf("\nError::->Imposible escribir en el archivo \n\n");
  5119. }
  5120. else
  5121. {
  5122. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5123. for(int i=0; i<4; i++)
  5124. {
  5125. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5126. {
  5127. Inodo actual;
  5128. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5129. fread(&super,sizeof (SuperBlock) , 1, file);
  5130.  
  5131. fseek(file,super.s_inode_start+(posActual*sizeof (Inodo)),SEEK_SET);
  5132. fread(&actual,sizeof (Inodo) , 1, file);
  5133.  
  5134. for (int i=0;i<15;i++) {
  5135. if(actual.i_block[i]==-1)
  5136. {
  5137. printf("Apuntador vacio\n");
  5138. if(i<12)
  5139. {
  5140. BloqueCarpeta bloque;
  5141. crearBloque(&bloque,posActual,super.s_first_ino,1);
  5142.  
  5143. actual.i_block[i]=super.s_first_blo;
  5144. fseek(file,super.s_block_start+(super.s_first_blo*sizeof (BloqueCarpeta)),SEEK_SET);
  5145. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5146. fseek(file,super.s_inode_start+(posActual*sizeof (Inodo)),SEEK_SET);
  5147. fwrite(&actual,sizeof (Inodo) , 1, file);
  5148.  
  5149.  
  5150. cambiarBitmapBloque();
  5151.  
  5152.  
  5153. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5154. fread(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5155. for (int j=0;j<4;j++) {
  5156. if (bloque.b_content[j].b_inodo==-1) {
  5157. bloque.b_content[j].b_inodo=super.s_first_ino;
  5158. strcpy(bloque.b_content[j].b_name,nombre);
  5159. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5160. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5161. fclose(file);
  5162. return;
  5163. }
  5164. }
  5165. }if (1==12) {
  5166.  
  5167. }
  5168. if (1==13) {
  5169.  
  5170. }
  5171. if (1==14) {
  5172.  
  5173. }
  5174.  
  5175. }
  5176. if(actual.i_block[i]!=-1)
  5177. {
  5178. printf("Apuntador acupado\n");
  5179. if(i<12)
  5180. {
  5181. BloqueCarpeta bloque;
  5182. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5183. fread(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5184. for (int j=0;j<4;j++) {
  5185. if (bloque.b_content[j].b_inodo==-1) {
  5186. printf("Apuntador del bloque de carpetas vacio-> %d\n",super.s_first_ino);
  5187. bloque.b_content[j].b_inodo=super.s_first_ino;
  5188. printf("Apuntador del bloque de carpetas vacio-> %d\n",bloque.b_content[j].b_inodo);
  5189. strcpy(bloque.b_content[j].b_name,nombre);
  5190. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5191. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5192. fclose(file);
  5193. return;
  5194. }
  5195. }
  5196. }if (1==12) {
  5197.  
  5198. }
  5199. if (1==13) {
  5200.  
  5201. }
  5202. if (1==14) {
  5203.  
  5204. }
  5205.  
  5206. }
  5207. }
  5208. return;
  5209. }
  5210. }
  5211.  
  5212. }
  5213. }
  5214.  
  5215. void CortarPegar(int posActual)
  5216. {
  5217. MbrDisco mbr;
  5218. SuperBlock super;
  5219. FILE* file= fopen(pathG, "rb+");
  5220. if (file==NULL)
  5221. {
  5222. printf("\nError::->Imposible escribir en el archivo \n\n");
  5223. }
  5224. else
  5225. {
  5226. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5227. for(int i=0; i<4; i++)
  5228. {
  5229. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5230. {
  5231. Inodo actual;
  5232. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5233. fread(&super,sizeof (SuperBlock) , 1, file);
  5234.  
  5235. fseek(file,super.s_inode_start+(posActual*sizeof (Inodo)),SEEK_SET);
  5236. fread(&actual,sizeof (Inodo) , 1, file);
  5237.  
  5238. for (int i=0;i<15;i++) {
  5239. if(actual.i_block[i]==-1)
  5240. {
  5241. printf("Apuntador vacio\n");
  5242. if(i<12)
  5243. {
  5244. BloqueCarpeta bloque;
  5245. crearBloque(&bloque,posActual,super.s_first_ino,1);
  5246.  
  5247. actual.i_block[i]=super.s_first_blo;
  5248. fseek(file,super.s_block_start+(super.s_first_blo*sizeof (BloqueCarpeta)),SEEK_SET);
  5249. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5250. fseek(file,super.s_inode_start+(posActual*sizeof (Inodo)),SEEK_SET);
  5251. fwrite(&actual,sizeof (Inodo) , 1, file);
  5252.  
  5253.  
  5254. cambiarBitmapBloque();
  5255.  
  5256.  
  5257. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5258. fread(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5259. for (int j=0;j<4;j++) {
  5260. if (bloque.b_content[j].b_inodo==-1) {
  5261. bloque.b_content[j].b_inodo=cambioCortar;
  5262. strcpy(bloque.b_content[j].b_name,cambioCortarNom);
  5263. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5264. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5265. fclose(file);
  5266. return;
  5267. }
  5268. }
  5269. }if (1==12) {
  5270.  
  5271. }
  5272. if (1==13) {
  5273.  
  5274. }
  5275. if (1==14) {
  5276.  
  5277. }
  5278.  
  5279. }
  5280. if(actual.i_block[i]!=-1)
  5281. {
  5282. printf("Apuntador acupado\n");
  5283. if(i<12)
  5284. {
  5285. BloqueCarpeta bloque;
  5286. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5287. fread(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5288. for (int j=0;j<4;j++) {
  5289. if (bloque.b_content[j].b_inodo==-1) {
  5290. printf("Apuntador del bloque de carpetas vacio-> %d\n",super.s_first_ino);
  5291. bloque.b_content[j].b_inodo=cambioCortar;
  5292. printf("Apuntador del bloque de carpetas vacio-> %d\n",bloque.b_content[j].b_inodo);
  5293. strcpy(bloque.b_content[j].b_name,cambioCortarNom);
  5294. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5295. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5296. fclose(file);
  5297. return;
  5298. }
  5299. }
  5300. }if (1==12) {
  5301.  
  5302. }
  5303. if (1==13) {
  5304.  
  5305. }
  5306. if (1==14) {
  5307.  
  5308. }
  5309.  
  5310. }
  5311. }
  5312. return;
  5313. }
  5314. }
  5315.  
  5316. }
  5317. }
  5318.  
  5319. int BuscarCarpetaEnDirectorio(Inodo actual,char* nombre)
  5320. {
  5321. MbrDisco mbr;
  5322. SuperBlock super;
  5323. FILE* file= fopen(pathG, "rb+");
  5324. if (file==NULL)
  5325. {
  5326. printf("\nError::->Imposible escribir en el archivo \n\n");
  5327. }
  5328. else
  5329. {
  5330. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5331. for(int i=0; i<4; i++)
  5332. {
  5333. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5334. {
  5335. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5336. fread(&super,sizeof (SuperBlock) , 1, file);
  5337.  
  5338. for (int i=0;i<15;i++) {
  5339.  
  5340. if(actual.i_block[i]!=-1)
  5341. {
  5342. if(i<12)
  5343. {
  5344. BloqueCarpeta bloque;
  5345. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5346. fread(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5347. for (int j=0;j<4;j++) {
  5348. if (!strcmp(bloque.b_content[j].b_name,nombre)) {
  5349. return bloque.b_content[j].b_inodo;
  5350. }
  5351. }
  5352. }if (1==12) {
  5353.  
  5354. }
  5355. if (1==13) {
  5356.  
  5357. }
  5358. if (1==14) {
  5359.  
  5360. }
  5361.  
  5362. }
  5363. }
  5364. return -1;
  5365. }
  5366. }
  5367.  
  5368. }
  5369. }
  5370.  
  5371.  
  5372. int BuscarCarpetaEnDirectorioYeliminar(Inodo actual,char* nombre)
  5373. {
  5374. MbrDisco mbr;
  5375. SuperBlock super;
  5376. FILE* file= fopen(pathG, "rb+");
  5377. if (file==NULL)
  5378. {
  5379. printf("\nError::->Imposible escribir en el archivo \n\n");
  5380. }
  5381. else
  5382. {
  5383. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5384. for(int i=0; i<4; i++)
  5385. {
  5386. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5387. {
  5388. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5389. fread(&super,sizeof (SuperBlock) , 1, file);
  5390.  
  5391. for (int i=0;i<15;i++) {
  5392.  
  5393. if(actual.i_block[i]!=-1)
  5394. {
  5395. if(i<12)
  5396. {
  5397. BloqueCarpeta bloque;
  5398. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5399. fread(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5400. for (int j=0;j<4;j++) {
  5401. if (!strcmp(bloque.b_content[j].b_name,nombre)) {
  5402. int r=bloque.b_content[j].b_inodo;
  5403. bloque.b_content[j].b_inodo=-1;
  5404. strcpy(bloque.b_content[j].b_name," ");
  5405. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5406. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5407. fclose(file);
  5408. return r;
  5409. }
  5410. }
  5411. }if (1==12) {
  5412.  
  5413. }
  5414. if (1==13) {
  5415.  
  5416. }
  5417. if (1==14) {
  5418.  
  5419. }
  5420.  
  5421. }
  5422. }
  5423. return -1;
  5424. }
  5425. }
  5426.  
  5427. }
  5428. }
  5429. int BuscarCarpetaEnDirectorioYCambiar(Inodo actual,char* nombre,char * cambio)
  5430. {
  5431. MbrDisco mbr;
  5432. SuperBlock super;
  5433. FILE* file= fopen(pathG, "rb+");
  5434. if (file==NULL)
  5435. {
  5436. printf("\nError::->Imposible escribir en el archivo \n\n");
  5437. }
  5438. else
  5439. {
  5440. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5441. for(int i=0; i<4; i++)
  5442. {
  5443. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5444. {
  5445. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5446. fread(&super,sizeof (SuperBlock) , 1, file);
  5447.  
  5448. for (int i=0;i<15;i++) {
  5449.  
  5450. if(actual.i_block[i]!=-1)
  5451. {
  5452. if(i<12)
  5453. {
  5454. BloqueCarpeta bloque;
  5455. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5456. fread(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5457. for (int j=0;j<4;j++) {
  5458. if (!strcmp(bloque.b_content[j].b_name,nombre)) {
  5459. for(int h=0;h<12;h++) {
  5460. if(bloque.b_content[j].b_name[h]=='.')
  5461. {
  5462. printf("Cambiar Nombre %s->%s\n",bloque.b_content[j].b_name,cambio);
  5463. strcpy(bloque.b_content[j].b_name,cambio);
  5464. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5465. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5466. fclose(file);
  5467. break;
  5468. }
  5469. }
  5470. return bloque.b_content[j].b_inodo;
  5471. }
  5472. }
  5473. }if (1==12) {
  5474.  
  5475. }
  5476. if (1==13) {
  5477.  
  5478. }
  5479. if (1==14) {
  5480.  
  5481. }
  5482.  
  5483. }
  5484. }
  5485. return -1;
  5486. }
  5487. }
  5488.  
  5489. }
  5490. }
  5491. int BuscarCarpetaEnDirectorioYCortar(Inodo actual,char* nombre,char * cambio)
  5492. {
  5493. MbrDisco mbr;
  5494. SuperBlock super;
  5495. FILE* file= fopen(pathG, "rb+");
  5496. if (file==NULL)
  5497. {
  5498. printf("\nError::->Imposible escribir en el archivo \n\n");
  5499. }
  5500. else
  5501. {
  5502. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5503. for(int i=0; i<4; i++)
  5504. {
  5505. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5506. {
  5507. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5508. fread(&super,sizeof (SuperBlock) , 1, file);
  5509.  
  5510. for (int i=0;i<15;i++) {
  5511.  
  5512. if(actual.i_block[i]!=-1)
  5513. {
  5514. if(i<12)
  5515. {
  5516. BloqueCarpeta bloque;
  5517. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5518. fread(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5519. for (int j=0;j<4;j++) {
  5520. if (!strcmp(bloque.b_content[j].b_name,nombre)) {
  5521. cambioCortar=bloque.b_content[j].b_inodo;
  5522. limpiarvar(cambioCortarNom,50);
  5523. strcpy(cambioCortarNom,bloque.b_content[j].b_name);
  5524. strcpy(bloque.b_content[j].b_name,"");
  5525. bloque.b_content[j].b_inodo=-1;
  5526. fseek(file,super.s_block_start+(actual.i_block[i]*sizeof (BloqueCarpeta)),SEEK_SET);
  5527. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  5528. fclose(file);
  5529. return bloque.b_content[j].b_inodo;
  5530. }
  5531. }
  5532. }if (1==12) {
  5533.  
  5534. }
  5535. if (1==13) {
  5536.  
  5537. }
  5538. if (1==14) {
  5539.  
  5540. }
  5541.  
  5542. }
  5543. }
  5544. return -1;
  5545. }
  5546. }
  5547.  
  5548. }
  5549. }
  5550.  
  5551.  
  5552.  
  5553. int ExisteDir2(char* nombre,int posActual,int eliminar,char* cambio)
  5554. {
  5555. //printf("Verificando existencia-> %s\n",nombre);
  5556. MbrDisco mbr;
  5557. SuperBlock super;
  5558. char* bitmapBloques;
  5559. char* bitmapInodos;
  5560. int particion;
  5561. FILE* file= fopen(pathG, "rb+");
  5562. if (file==NULL)
  5563. {
  5564. printf("\nError::->Imposible escribir en el archivo \n\n");
  5565. }
  5566. else
  5567. {
  5568. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5569. for(int i=0; i<4; i++)
  5570. {
  5571. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5572. {
  5573. particion=i;
  5574. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5575. fread(&super,sizeof (SuperBlock) , 1, file);
  5576. char bitmapB[super.s_blocks_count];
  5577. for (int j=0; j<super.s_blocks_count;j++) {
  5578. char v;
  5579. fseek(file,super.s_bm_block_start+j,SEEK_SET);
  5580. fread(&v,1 , 1, file);
  5581. bitmapB[j]=v;
  5582. }
  5583. bitmapBloques=bitmapB;
  5584. char bitmapI[super.s_inodes_count];
  5585. for (int j=0; j<super.s_inodes_count;j++) {
  5586. char v;
  5587. fseek(file,super.s_bm_inode_start+j,SEEK_SET);
  5588. fread(&v,1 , 1, file);
  5589. bitmapI[j]=v;
  5590. }
  5591. bitmapInodos=bitmapI;
  5592.  
  5593. break;
  5594. }
  5595. }
  5596.  
  5597. if(posActual==-1)
  5598. {
  5599. //printf("Verificando raiz\n");
  5600. int existe=ExisteInodo(bitmapInodos,0);
  5601.  
  5602. if(existe!=0)
  5603. {
  5604. return -1;
  5605. }else
  5606. {
  5607. //printf("Raiz existe\n");
  5608. return 0;
  5609. }
  5610.  
  5611. }else
  5612. {
  5613. printf("Verificando no raiz %s\n",nombre);
  5614. Inodo actual;
  5615. fseek(file,super.s_inode_start+(posActual*sizeof (Inodo)),SEEK_SET);
  5616. fread(&actual,sizeof (Inodo) , 1, file);
  5617. if(eliminar==1)
  5618. {
  5619. return BuscarCarpetaEnDirectorioYeliminar(actual,nombre);
  5620. }if(eliminar==2)
  5621. {
  5622. return BuscarCarpetaEnDirectorioYCambiar(actual,nombre,cambio);
  5623. }if(eliminar==3)
  5624. {
  5625. return BuscarCarpetaEnDirectorioYCortar(actual,nombre,cambio);
  5626. }
  5627. return BuscarCarpetaEnDirectorio(actual,nombre);
  5628.  
  5629. }
  5630.  
  5631. }
  5632. return -1;
  5633. }
  5634.  
  5635. int SepararDirectorio2(Funcion funcion)
  5636. {
  5637. int posActual=-1;
  5638. posActual=ExisteDir2("/",posActual,0,"");
  5639. char* nombre=strtok(funcion.ruta,"/");
  5640. while (nombre!=NULL && posActual!=-1) {
  5641. //printf("%d\n",posActual);
  5642. posActual=ExisteDir2(nombre,posActual,0,"");
  5643.  
  5644. if(posActual==-1)
  5645. {
  5646. return -1;
  5647. }
  5648. nombre=strtok(NULL,"/");
  5649. }
  5650.  
  5651. return posActual;
  5652. }
  5653.  
  5654.  
  5655. void GraficarFile(Funcion funcion)
  5656. {
  5657. int existe=SepararDirectorio2(funcion);
  5658. if(existe!=-1)
  5659. {
  5660. int bandera =0;
  5661. SuperBlock super;
  5662.  
  5663. char nomb[15];
  5664. char path[100];
  5665. strcpy(nomb,obtenerNombre(funcion));
  5666. strcpy(path,obtenerPath(funcion));
  5667. MbrDisco mbr=obtenerMBR(funcion);
  5668.  
  5669. if(mbr.bandera!=-4)
  5670. {
  5671. char dot[100]="\0";
  5672. char pathauxiliar[200];
  5673. char pathauxiliar2[200];
  5674. limpiarvar(pathauxiliar2,200);
  5675. limpiarvar(pathauxiliar,200);
  5676. strcpy(pathauxiliar,funcion.path);
  5677. int q=0;
  5678. while(pathauxiliar[q]!='.')
  5679. {
  5680. char nuevoCaracter[1];
  5681. nuevoCaracter[0]=pathauxiliar[q];
  5682. strncat(pathauxiliar2,nuevoCaracter,1);
  5683. q++;
  5684. }
  5685. strcat(pathauxiliar2,".dot");
  5686.  
  5687.  
  5688. printf("%s\n",funcion.path);
  5689. printf("%s\n",pathauxiliar2);
  5690.  
  5691. char finalizado[300];
  5692. limpiarvar(finalizado,300);
  5693. strcpy(finalizado,"cd /\n");
  5694. int indice=0;
  5695. char carpeta[500];
  5696. limpiarvar(carpeta,100);
  5697.  
  5698. while(funcion.path[indice]!='.')
  5699. {
  5700. if(funcion.path[indice]!='/')
  5701. {
  5702.  
  5703. char nuevoCaracter[1];
  5704. nuevoCaracter[0]=funcion.path[indice];
  5705. strncat(carpeta,nuevoCaracter,1);
  5706. }
  5707. else
  5708. {
  5709. if(carpeta[0]!='\0')
  5710. {
  5711. strcat(finalizado,"mkdir ");
  5712. strcat(finalizado,"\"");
  5713. strcat(finalizado,carpeta);
  5714. strcat(finalizado,"\"");
  5715. strcat(finalizado,"\n");
  5716. strcat(finalizado,"cd ");
  5717. strcat(finalizado,"\"");
  5718. strcat(finalizado,carpeta);
  5719. strcat(finalizado,"\"");
  5720. strcat(finalizado,"\n");
  5721. strcat(carpeta,"");
  5722.  
  5723. }
  5724. limpiarvar(carpeta,100);
  5725.  
  5726. }
  5727. indice++;
  5728. }
  5729.  
  5730.  
  5731. printf("\n%s\n",finalizado);
  5732.  
  5733. system(finalizado);
  5734.  
  5735. int num;
  5736. FILE *fptr;
  5737. fptr = fopen(funcion.path,"w");
  5738.  
  5739. if(fptr == NULL)
  5740. {
  5741. printf("Error!");
  5742. }else {
  5743.  
  5744. for(int i=0; i<4; i++)
  5745. {
  5746. if(!strcmp(nomb,mbr.particiones[i].part_name))
  5747. {
  5748. FILE *fp;
  5749. fp = fopen(path, "rb");
  5750. fseek(fp,sizeof (MbrDisco)+mbr.particiones[i].part_start,SEEK_SET);
  5751.  
  5752. if(fp == NULL)
  5753. {
  5754. printf("\n Error::-> No se encontro el disco\n");
  5755. }else {
  5756. fread(&super,sizeof (SuperBlock), 1, fp);
  5757.  
  5758.  
  5759. Inodo inodo;
  5760. fseek(fp,super.s_inode_start+(existe*sizeof (Inodo)),SEEK_SET);
  5761. fread(&inodo,sizeof (Inodo), 1, fp);
  5762. if(inodo.i_type=='1')
  5763. {
  5764. for (int j=0;j<12;j++) {
  5765.  
  5766.  
  5767. if(inodo.i_block[j]!=-1)
  5768. {
  5769. BloqueArchivo bloqueC;
  5770. fseek(fp,super.s_block_start+(inodo.i_block[j]*sizeof (BloqueArchivo)),SEEK_SET);
  5771. fread(&bloqueC,sizeof (BloqueArchivo), 1, fp);
  5772. fprintf(fptr,"%s",bloqueC.b_content);
  5773.  
  5774.  
  5775. }
  5776. }
  5777. }
  5778.  
  5779.  
  5780.  
  5781. fclose(fp);
  5782.  
  5783. ContadorComandosExitosos++;
  5784.  
  5785.  
  5786.  
  5787. }
  5788.  
  5789.  
  5790.  
  5791.  
  5792. break;
  5793. }
  5794. }
  5795. fclose(fptr);
  5796. }
  5797. limpiarvar(funcion.path,100);
  5798. limpiarvar(pathauxiliar2,200);
  5799. limpiarvar(pathauxiliar,200);
  5800. limpiarvar(finalizado,300);
  5801. limpiarvar(carpeta,100);
  5802. limpiarvar(dot,100);
  5803. limpiarvar(path,100);
  5804. limpiarvar(nomb,15);
  5805.  
  5806. }else {
  5807. printf("Error::-> Generar reporte\n");
  5808. ErrorReporte1++;
  5809. }
  5810. }else {
  5811. printf("No existe la ruta\n");
  5812.  
  5813. }
  5814.  
  5815. }
  5816.  
  5817.  
  5818. int esArchivo(char *nombre)
  5819. {
  5820. for (int i=0;i<10;i++) {
  5821. if(nombre[i]=='.')
  5822. {
  5823. return 1;
  5824. }
  5825. if(nombre[i]=='\0')
  5826. {
  5827. break;
  5828. }
  5829. }
  5830. return 0;
  5831. }
  5832.  
  5833. void buscarEspacioApuntadorArchivo(Inodo *inodo)
  5834. {
  5835. MbrDisco mbr;
  5836. SuperBlock super;
  5837. FILE* file= fopen(pathG, "rb+");
  5838. if (file==NULL)
  5839. {
  5840. printf("\nError::->Imposible escribir en el archivo \n\n");
  5841. }
  5842. else
  5843. {
  5844. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5845. for(int i=0; i<4; i++)
  5846. {
  5847. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5848. {
  5849. char c='1';
  5850. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5851. fread(&super,sizeof (SuperBlock) , 1, file);
  5852.  
  5853. break;
  5854. }
  5855. }
  5856. for (int i=0;i<15;i++) {
  5857. if(inodo->i_block[i]==-1)
  5858. {
  5859. if(i<12)
  5860. {
  5861. printf("Encontro Espacio para apuntar a bloque archivo\n");
  5862. inodo->i_block[i]=super.s_first_blo;
  5863. break;
  5864. }if(i==12)
  5865. {
  5866.  
  5867. }
  5868. if(i==13)
  5869. {
  5870.  
  5871. }
  5872. if(i==14)
  5873. {
  5874.  
  5875. }
  5876. }
  5877. }
  5878.  
  5879. }
  5880. }
  5881.  
  5882. void EscribirEnJurnal(char operacion,char tipo,char* path,char *cont,char* fecha,char *propietario,char* permisos)
  5883. {
  5884. MbrDisco mbr;
  5885. SuperBlock super;
  5886. FILE* file= fopen(pathG, "rb+");
  5887. if (file==NULL)
  5888. {
  5889. printf("\nError::->Imposible escribir en el archivo \n\n");
  5890. }
  5891. else
  5892. {
  5893. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5894. for(int i=0; i<4; i++)
  5895. {
  5896. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5897. {
  5898. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5899. fread(&super,sizeof (SuperBlock) , 1, file);
  5900. if(super.s_filesystem_type==3)
  5901. {
  5902.  
  5903.  
  5904.  
  5905. Journal JournalActual;
  5906. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco)+sizeof (SuperBlock),SEEK_SET);
  5907. fread(&JournalActual,sizeof (Journal) , 1, file);
  5908. while (JournalActual.siguiente!=-1) {
  5909. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco)+sizeof (SuperBlock)+JournalActual.siguiente,SEEK_SET);
  5910. fread(&JournalActual,sizeof (Journal) , 1, file);
  5911. }
  5912.  
  5913. JournalActual.siguiente=JournalActual.posicion+sizeof (Journal);
  5914. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco)+sizeof (SuperBlock)+JournalActual.posicion,SEEK_SET);
  5915. fwrite(&JournalActual,sizeof (Journal) , 1, file);
  5916.  
  5917. Journal nuevo;
  5918. nuevo.operacion=operacion;
  5919. nuevo.tipo=tipo;
  5920. strcpy(nuevo.path,path);
  5921. strcpy(nuevo.cont,cont);
  5922. strcpy(nuevo.permisos,permisos);
  5923. strcpy(nuevo.fecha,fecha);
  5924.  
  5925. strcpy(nuevo.propietario,propietario);
  5926. nuevo.siguiente=-1;
  5927. nuevo.posicion=JournalActual.siguiente;
  5928. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco)+sizeof (SuperBlock)+nuevo.posicion,SEEK_SET);
  5929. fwrite(&nuevo,sizeof (Journal) , 1, file);
  5930. }
  5931. fclose(file);
  5932.  
  5933. break;
  5934. }
  5935. }
  5936.  
  5937. }
  5938. }
  5939.  
  5940. int ExisteDir(char* nombre,int posActual,char*contenido,int p)
  5941. {
  5942. printf("Verificando existencia-> %s\n",nombre);
  5943. MbrDisco mbr;
  5944. SuperBlock super;
  5945. char* bitmapBloques;
  5946. char* bitmapInodos;
  5947. int particion;
  5948. FILE* file= fopen(pathG, "rb+");
  5949. if (file==NULL)
  5950. {
  5951. printf("\nError::->Imposible escribir en el archivo \n\n");
  5952. }
  5953. else
  5954. {
  5955. fread(&mbr,sizeof (MbrDisco) , 1, file);
  5956. for(int i=0; i<4; i++)
  5957. {
  5958. if(!strcmp(nombG,mbr.particiones[i].part_name))
  5959. {
  5960. particion=i;
  5961. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  5962. fread(&super,sizeof (SuperBlock) , 1, file);
  5963. char bitmapB[super.s_blocks_count];
  5964. for (int j=0; j<super.s_blocks_count;j++) {
  5965. char v;
  5966. fseek(file,super.s_bm_block_start+j,SEEK_SET);
  5967. fread(&v,1 , 1, file);
  5968. bitmapB[j]=v;
  5969. }
  5970. bitmapBloques=bitmapB;
  5971. char bitmapI[super.s_inodes_count];
  5972. for (int j=0; j<super.s_inodes_count;j++) {
  5973. char v;
  5974. fseek(file,super.s_bm_inode_start+j,SEEK_SET);
  5975. fread(&v,1 , 1, file);
  5976. bitmapI[j]=v;
  5977. }
  5978. bitmapInodos=bitmapI;
  5979.  
  5980. break;
  5981. }
  5982. }
  5983.  
  5984. if(posActual==-1)
  5985. {
  5986. printf("Verificando raiz\n");
  5987. int existe=ExisteInodo(bitmapInodos,0);
  5988. if(existe!=0)
  5989. {
  5990. if(p==0)
  5991. {
  5992. printf("Carpeta no existe no se creara\n");
  5993. return -1;
  5994. }else {
  5995.  
  5996.  
  5997. printf("Raiz no existe \n");
  5998. Inodo inodo;
  5999. BloqueCarpeta bloque;
  6000. crearInodo(&inodo,0,contenido);
  6001. crearBloque(&bloque,0,super.s_first_ino,0);
  6002. inodo.i_block[0]=super.s_first_blo;
  6003. fseek(file,super.s_block_start+(super.s_first_blo*sizeof (BloqueCarpeta)),SEEK_SET);
  6004. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  6005. fseek(file,super.s_inode_start+(super.s_first_ino*sizeof (Inodo)),SEEK_SET);
  6006. fwrite(&inodo,sizeof (inodo) , 1, file);
  6007.  
  6008. fclose(file);
  6009.  
  6010. cambiarBitmapInodo();
  6011. cambiarBitmapBloque();
  6012.  
  6013. return 0;
  6014. }
  6015.  
  6016.  
  6017. }else
  6018. {
  6019. printf("Raiz existe\n");
  6020. return 0;
  6021. }
  6022. }else
  6023. {
  6024. printf("Verificando no raiz %s\n",nombre);
  6025. int bandera= esArchivo(nombre);
  6026. if(bandera==0)
  6027. {
  6028. printf("No es un archivo\n");
  6029. Inodo actual;
  6030. fseek(file,super.s_inode_start+(posActual*sizeof (Inodo)),SEEK_SET);
  6031. fread(&actual,sizeof (Inodo) , 1, file);
  6032. int existe=BuscarCarpetaEnDirectorio(actual,nombre);
  6033. if(existe==-1)
  6034. {
  6035. if(p==0)
  6036. {
  6037. printf("Carpeta no existe no se creara\n");
  6038. return -1;
  6039. }else {
  6040. printf("No se encontro carpeta\n");
  6041. Inodo inodo;
  6042. BloqueCarpeta bloque;
  6043. crearInodo(&inodo,0,contenido);
  6044. crearBloque(&bloque,0,super.s_first_ino,0);
  6045. inodo.i_block[0]=super.s_first_blo;
  6046. fseek(file,super.s_block_start+(super.s_first_blo*sizeof (BloqueCarpeta)),SEEK_SET);
  6047. fwrite(&bloque,sizeof (BloqueCarpeta) , 1, file);
  6048. fseek(file,super.s_inode_start+(super.s_first_ino*sizeof (Inodo)),SEEK_SET);
  6049. fwrite(&inodo,sizeof (inodo) , 1, file);
  6050.  
  6051. fclose(file);
  6052. int nuevo=super.s_first_ino;
  6053.  
  6054. cambiarBitmapBloque();
  6055. printf("Entro\n");
  6056. buscarEspacioApuntador(posActual,nombre);
  6057. printf("Salio\n");
  6058. cambiarBitmapInodo();
  6059.  
  6060. return nuevo;
  6061. }
  6062.  
  6063. }else {
  6064. printf("Se encontro carpeta\n");
  6065. return existe;
  6066. }
  6067. }else{
  6068. printf("Es Archivo\n");
  6069. fclose(file);
  6070. Inodo inodoo;
  6071. crearInodo(&inodoo,1,contenido);
  6072.  
  6073. Cadena* cadena=malloc(sizeof (Cadena));
  6074. for (int i=0;i<64;i++) {
  6075. limpiarvar(cadena->part[i].parte,64);
  6076. }
  6077. cadena->cantidad=-1;
  6078. int indice=0;
  6079. int cont=0;
  6080. int pos=0;
  6081. while(contenido[indice]!='\0')
  6082. {
  6083. if(pos==60)
  6084. {
  6085. pos=0;
  6086. cont++;
  6087. printf("\n");
  6088.  
  6089. }
  6090. printf("%c",contenido[indice]);
  6091. sprintf(cadena->part[cont].parte,"%s%c",cadena->part[cont].parte,contenido[indice]);
  6092.  
  6093.  
  6094. pos++;
  6095. indice++;
  6096. }
  6097. printf("bloques archivo-> %d\n",cont+1);
  6098.  
  6099. cadena->cantidad=cont;
  6100. BloqueArchivo block;
  6101. for (int i=0;i<cadena->cantidad+1;i++) {
  6102. FILE* file= fopen(pathG, "rb+");
  6103. if (file==NULL)
  6104. {
  6105. printf("\nError::->Imposible escribir en el archivo \n\n");
  6106. }
  6107. else
  6108. {
  6109. fread(&mbr,sizeof (MbrDisco) , 1, file);
  6110. for(int j=0; j<4; j++)
  6111. {
  6112. if(!strcmp(nombG,mbr.particiones[j].part_name))
  6113. {
  6114. particion=i;
  6115. fseek(file,mbr.particiones[j].part_start+sizeof (MbrDisco),SEEK_SET);
  6116. fread(&super,sizeof (SuperBlock) , 1, file);
  6117. printf("bloque Contiene-> %s\n",cadena->part[i].parte);
  6118. strcpy(block.b_content,cadena->part[i].parte);
  6119. printf("guardo-> %s en %d\n",block.b_content,super.s_first_blo);
  6120. fseek(file,super.s_block_start+(super.s_first_blo*sizeof (BloqueCarpeta)),SEEK_SET);
  6121. fwrite(&block,sizeof (BloqueArchivo) , 1, file);
  6122. buscarEspacioApuntadorArchivo(&inodoo);
  6123. cambiarBitmapBloque();
  6124. fclose(file);
  6125. break;
  6126. }
  6127. }
  6128. }
  6129.  
  6130.  
  6131. }
  6132. free(cadena);
  6133. FILE* file= fopen(pathG, "rb+");
  6134. if (file==NULL)
  6135. {
  6136. printf("\nError::->Imposible escribir en el archivo \n\n");
  6137. }
  6138. else
  6139. {
  6140. fread(&mbr,sizeof (MbrDisco) , 1, file);
  6141. for(int i=0; i<4; i++)
  6142. {
  6143. if(!strcmp(nombG,mbr.particiones[i].part_name))
  6144. {
  6145. particion=i;
  6146. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  6147. fread(&super,sizeof (SuperBlock) , 1, file);
  6148. fseek(file,super.s_inode_start+(super.s_first_ino*sizeof (Inodo)),SEEK_SET);
  6149. fwrite(&inodoo,sizeof (Inodo) , 1, file);
  6150. fclose(file);
  6151. buscarEspacioApuntador(posActual,nombre);
  6152. cambiarBitmapInodo();
  6153. break;
  6154. }
  6155. }
  6156. }
  6157.  
  6158.  
  6159.  
  6160. }
  6161.  
  6162.  
  6163. }
  6164.  
  6165. }
  6166. return -1;
  6167. }
  6168.  
  6169.  
  6170. void SepararDirectorio(Funcion funcion,char* contenido,int tipo)
  6171. {
  6172. char cont[200];
  6173. strcpy(cont,contenido);
  6174. int posActual=-1;
  6175. posActual=ExisteDir("/",posActual,contenido,funcion.p);
  6176. if(posActual==-1)
  6177. {
  6178. printf("No se creo el archivo\n");
  6179. return;
  6180. }
  6181. char* nombre=strtok(funcion.path,"/");
  6182.  
  6183. while (nombre!=NULL) {
  6184.  
  6185. posActual=ExisteDir(nombre,posActual,cont,funcion.p);
  6186. if(posActual==-1)
  6187. {
  6188. printf("No se creo el archivo\n");
  6189. break;
  6190. }
  6191. nombre=strtok(NULL,"/");
  6192. }
  6193.  
  6194.  
  6195.  
  6196. }
  6197.  
  6198. Retornoo obtenerUsuarios()
  6199. {
  6200. MbrDisco mbr;
  6201. SuperBlock super;
  6202. Retornoo retorno;
  6203. limpiarvar(retorno.cadena,800);
  6204. FILE* file= fopen(pathG, "rb+");
  6205. if (file==NULL)
  6206. {
  6207. printf("\nError::->Imposible escribir en el archivo \n\n");
  6208. }
  6209. else
  6210. {
  6211. fread(&mbr,sizeof (MbrDisco) , 1, file);
  6212. for(int i=0; i<4; i++)
  6213. {
  6214. if(!strcmp(nombG,mbr.particiones[i].part_name))
  6215. {
  6216. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  6217. fread(&super,sizeof (SuperBlock) , 1, file);
  6218.  
  6219. Inodo inodo;
  6220. BloqueArchivo bloque;
  6221.  
  6222. fseek(file,super.s_inode_start+(sizeof (Inodo)),SEEK_SET);
  6223. fread(&inodo,sizeof (Inodo) , 1, file);
  6224.  
  6225. for (int i=0;i<15;i++) {
  6226. if(i<12)
  6227. {
  6228. if(inodo.i_block[i]!=-1)
  6229. {
  6230. fseek(file,super.s_block_start+(inodo.i_block[i]*sizeof (BloqueArchivo)),SEEK_SET);
  6231. fread(&bloque,sizeof (BloqueArchivo) , 1, file);
  6232. strcat(retorno.cadena,bloque.b_content);
  6233. }
  6234. }
  6235. }
  6236.  
  6237. fclose(file);
  6238.  
  6239. break;
  6240. }
  6241. }
  6242. return retorno;
  6243.  
  6244. }
  6245. }
  6246.  
  6247. Retornoo ObtenerCadena(Funcion funcion)
  6248. {
  6249. Retornoo retorno;
  6250. MbrDisco mbr=obtenerMBR2();
  6251. limpiarvar(retorno.cadena,800);
  6252. int existe=SepararDirectorio2(funcion);
  6253. if(existe!=-1)
  6254. {
  6255. SuperBlock super;
  6256. for(int i=0; i<4; i++)
  6257. {
  6258. if(!strcmp(nombG,mbr.particiones[i].part_name))
  6259. {
  6260. FILE *fp;
  6261. fp = fopen(pathG, "rb");
  6262. fseek(fp,sizeof (MbrDisco)+mbr.particiones[i].part_start,SEEK_SET);
  6263.  
  6264. if(fp == NULL)
  6265. {
  6266. printf("\n Error::-> No se encontro el disco\n");
  6267. }else {
  6268. fread(&super,sizeof (SuperBlock), 1, fp);
  6269.  
  6270.  
  6271. Inodo inodo;
  6272. fseek(fp,super.s_inode_start+(existe*sizeof (Inodo)),SEEK_SET);
  6273. fread(&inodo,sizeof (Inodo), 1, fp);
  6274. if(inodo.i_type=='1')
  6275. {
  6276. for (int j=0;j<12;j++) {
  6277.  
  6278.  
  6279. if(inodo.i_block[j]!=-1)
  6280. {
  6281. BloqueArchivo bloqueC;
  6282. fseek(fp,super.s_block_start+(inodo.i_block[j]*sizeof (BloqueArchivo)),SEEK_SET);
  6283. fread(&bloqueC,sizeof (BloqueArchivo), 1, fp);
  6284. //printf("%s\n",bloqueC.b_content);
  6285. strcat(retorno.cadena,bloqueC.b_content);
  6286. }
  6287. }
  6288. }
  6289. fclose(fp);
  6290. }
  6291. break;
  6292. }
  6293. }
  6294. return retorno;
  6295.  
  6296.  
  6297. }else {
  6298. printf("No existe la ruta\n");
  6299.  
  6300. }
  6301. }
  6302.  
  6303. void ELiminarCuerpo(int ind)
  6304. {
  6305. MbrDisco mbr;
  6306. SuperBlock super;
  6307.  
  6308.  
  6309. FILE* file= fopen(pathG, "rb+");
  6310. if (file==NULL)
  6311. {
  6312. printf("\nError::->Imposible escribir en el archivo \n\n");
  6313. }
  6314. else
  6315. {
  6316. fread(&mbr,sizeof (MbrDisco) , 1, file);
  6317. for(int i=0; i<4; i++)
  6318. {
  6319. if(!strcmp(nombG,mbr.particiones[i].part_name))
  6320. {
  6321. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  6322. fread(&super,sizeof (SuperBlock) , 1, file);
  6323.  
  6324. Inodo inodo;
  6325. BloqueArchivo bloque;
  6326.  
  6327. fseek(file,super.s_inode_start+(ind*sizeof (Inodo)),SEEK_SET);
  6328. fread(&inodo,sizeof (Inodo) , 1, file);
  6329. char c='0';
  6330. for (int i=0;i<15;i++) {
  6331. if(i<12)
  6332. {
  6333. if(inodo.i_block[i]!=-1)
  6334. {
  6335. fseek(file,super.s_block_start+(inodo.i_block[i]*sizeof (BloqueArchivo)),SEEK_SET);
  6336. fread(&bloque,sizeof (BloqueArchivo) , 1, file);
  6337.  
  6338. fseek(file,super.s_bm_block_start+inodo.i_block[i],SEEK_SET);
  6339. fwrite(&c,1 , 1, file);
  6340.  
  6341. inodo.i_block[i]=-1;
  6342.  
  6343.  
  6344.  
  6345. }
  6346. }
  6347. }
  6348.  
  6349. fseek(file,super.s_inode_start+(ind*sizeof (Inodo)),SEEK_SET);
  6350. fwrite(&inodo,sizeof (Inodo) , 1, file);
  6351.  
  6352.  
  6353. fclose(file);
  6354. actualizarBloqueLibre();
  6355.  
  6356. break;
  6357. }
  6358. }
  6359.  
  6360. }
  6361. }
  6362.  
  6363. void cargarUser(char* usua)
  6364. {
  6365. SuperBlock super;
  6366. MbrDisco mbr;
  6367. Cadena* cadena=malloc(sizeof (Cadena));
  6368. for (int i=0;i<64;i++) {
  6369. limpiarvar(cadena->part[i].parte,64);
  6370. }
  6371. cadena->cantidad=-1;
  6372. int indice=0;
  6373. int cont=0;
  6374. int pos=0;
  6375. while(usua[indice]!='\0')
  6376. {
  6377. if(pos==60)
  6378. {
  6379. pos=0;
  6380. cont++;
  6381. printf("\n");
  6382.  
  6383. }
  6384. printf("%c",usua[indice]);
  6385. cadena->part[cont].parte[pos]=usua[indice];
  6386.  
  6387.  
  6388. pos++;
  6389. indice++;
  6390. }
  6391. printf("bloques archivo-> %d\n",cont+1);
  6392. Inodo inodo;
  6393. FILE* file= fopen(pathG, "rb+");
  6394. if (file==NULL)
  6395. {
  6396. printf("\nError::->Imposible escribir en el archivo \n\n");
  6397. }
  6398. else
  6399. {
  6400. fread(&mbr,sizeof (MbrDisco) , 1, file);
  6401. for(int j=0; j<4; j++)
  6402. {
  6403. if(!strcmp(nombG,mbr.particiones[j].part_name))
  6404. {
  6405. fseek(file,mbr.particiones[j].part_start+sizeof (MbrDisco),SEEK_SET);
  6406. fread(&super,sizeof (SuperBlock) , 1, file);
  6407. fseek(file,super.s_inode_start+sizeof (Inodo),SEEK_SET);
  6408. fread(&inodo,sizeof (Inodo) , 1, file);
  6409. fclose(file);
  6410. break;
  6411. }
  6412. }
  6413. }
  6414.  
  6415. cadena->cantidad=cont;
  6416. BloqueArchivo block;
  6417. for (int i=0;i<cadena->cantidad+1;i++) {
  6418. FILE* file= fopen(pathG, "rb+");
  6419. if (file==NULL)
  6420. {
  6421. printf("\nError::->Imposible escribir en el archivo \n\n");
  6422. }
  6423. else
  6424. {
  6425. fread(&mbr,sizeof (MbrDisco) , 1, file);
  6426. for(int j=0; j<4; j++)
  6427. {
  6428. if(!strcmp(nombG,mbr.particiones[j].part_name))
  6429. {
  6430. fseek(file,mbr.particiones[j].part_start+sizeof (MbrDisco),SEEK_SET);
  6431. fread(&super,sizeof (SuperBlock) , 1, file);
  6432. //printf("bloque Contiene-> %s\n",cadena->part[i].parte);
  6433. strcpy(block.b_content,cadena->part[i].parte);
  6434. //printf("guardo-> %s en %d\n",block.b_content,super.s_first_blo);
  6435. fseek(file,super.s_block_start+(super.s_first_blo*sizeof (BloqueCarpeta)),SEEK_SET);
  6436. fwrite(&block,sizeof (BloqueArchivo) , 1, file);
  6437. buscarEspacioApuntadorArchivo(&inodo);
  6438. printf("Salio\n");
  6439. cambiarBitmapBloque();
  6440. fclose(file);
  6441. break;
  6442. }
  6443. }
  6444. }
  6445.  
  6446.  
  6447. }
  6448. file= fopen(pathG, "rb+");
  6449. if (file==NULL)
  6450. {
  6451. printf("\nError::->Imposible escribir en el archivo \n\n");
  6452. }
  6453. else
  6454. {
  6455. fread(&mbr,sizeof (MbrDisco) , 1, file);
  6456. for(int j=0; j<4; j++)
  6457. {
  6458. if(!strcmp(nombG,mbr.particiones[j].part_name))
  6459. {
  6460. fseek(file,mbr.particiones[j].part_start+sizeof (MbrDisco),SEEK_SET);
  6461. fread(&super,sizeof (SuperBlock) , 1, file);
  6462. fseek(file,super.s_inode_start+sizeof (Inodo),SEEK_SET);
  6463. fwrite(&inodo,sizeof (Inodo) , 1, file);
  6464. fclose(file);
  6465. break;
  6466. }
  6467. }
  6468. }
  6469. free(cadena);
  6470. }
  6471. void CrearGrupo(Funcion funcion)
  6472. {
  6473. Retornoo usuarios;
  6474. usuarios=obtenerUsuarios();
  6475. char usua[300];
  6476. strcpy(usua,usuarios.cadena);
  6477. char msg[3];
  6478.  
  6479. usuarios.grupos=1;
  6480. int tipo=0;
  6481. int c=1;
  6482. int us=0;
  6483. int con=0;
  6484. int eli=0;
  6485. char* ptr3=strtok(usuarios.cadena,",");
  6486. while (ptr3!=NULL) {
  6487.  
  6488. //printf("-%s-\n",ptr3);
  6489. if(!strcmp(ptr3,"U"))
  6490. {
  6491. tipo=1;
  6492. c=1;
  6493. }
  6494. if(!strcmp(ptr3,"G"))
  6495. {
  6496. tipo=0;
  6497. usuarios.grupos++;
  6498. c=1;
  6499. }
  6500. if(!strcmp(ptr3,"0"))
  6501. {
  6502. eli=1;
  6503. }
  6504. if(tipo==0 && c==2)
  6505. {
  6506. //printf("%s vs %s",ptr3,funcion.usr);
  6507. if(!strcmp(ptr3,funcion.name) && eli==0 )
  6508. {
  6509. us=1;
  6510. }
  6511. }
  6512. if(tipo==0 && c==2)
  6513. {
  6514. eli=0;
  6515. }
  6516. if(tipo==1 && c==4)
  6517. {
  6518. eli=0;
  6519.  
  6520. }
  6521.  
  6522. c++;
  6523.  
  6524.  
  6525. ptr3=strtok(NULL,",");
  6526.  
  6527. }if(us==0)
  6528. {
  6529. sprintf(msg, "%d", usuarios.grupos);
  6530. strcat(usua,msg);
  6531. strcat(usua,",G,");
  6532. strcat(usua,funcion.name);
  6533. strcat(usua,",");
  6534. printf("%s\n",usua);
  6535.  
  6536. ELiminarCuerpo(1);
  6537. cargarUser(usua);
  6538. time_t tiempo = time(0);
  6539. struct tm *tlocal = localtime(&tiempo);
  6540. char output[128];
  6541. char time[16];
  6542. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  6543.  
  6544. int l=0;
  6545. for(int k=0;k<16;k++)
  6546. {
  6547. time[l++]=output[k];
  6548. }
  6549. EscribirEnJurnal('2','1',"-",funcion.name,time,"-","-");
  6550. }else {
  6551.  
  6552. printf("Error::->Nombre del grupo ya existe\n");
  6553. }
  6554.  
  6555.  
  6556. limpiarvar(usua,300);
  6557. }
  6558. void EliminarGrupo(Funcion funcion)
  6559. {
  6560. Retornoo usuarios;
  6561. usuarios=obtenerUsuarios();
  6562. char usua[300];
  6563.  
  6564. char msg[3];
  6565. char concatena[300];
  6566. char a[50];
  6567.  
  6568. usuarios.grupos=0;
  6569. usuarios.usuarios=0;
  6570. int tipo=0;
  6571. int c=0;
  6572. int us=0;
  6573. int con=0;
  6574. int eli=0;
  6575. char n[3];
  6576. char t[3];
  6577. char gr[10];
  6578. char usu[10];
  6579. char cont[10];
  6580. char* ptr3=strtok(usuarios.cadena,",");
  6581. while (ptr3!=NULL) {
  6582. if(c==0)
  6583. {
  6584. strcpy(n,ptr3);
  6585. }else if (c==1) {
  6586. strcpy(t,ptr3);
  6587. }
  6588. else if (c==2) {
  6589. strcpy(gr,ptr3);
  6590. }
  6591. else if (c==3) {
  6592. strcpy(usu,ptr3);
  6593. }
  6594. else if (c==4) {
  6595. strcpy(cont,ptr3);
  6596. }
  6597.  
  6598. if(!strcmp(ptr3,"U"))
  6599. {
  6600. usuarios.usuarios++;
  6601. tipo=1;
  6602. c=1;
  6603. }
  6604. else if(!strcmp(ptr3,"G"))
  6605. {
  6606. tipo=0;
  6607. usuarios.grupos++;
  6608. c=1;
  6609. }
  6610. if(!strcmp(ptr3,"0"))
  6611. {
  6612. eli=1;
  6613. }
  6614. if(tipo==0 && c==2)
  6615. {
  6616. if(!strcmp(ptr3,funcion.name) && eli==0 )
  6617. {
  6618. sprintf(a,"0,G,%s,",funcion.name);
  6619. strcat(concatena,a);
  6620. limpiarvar(a,50);
  6621. us=1;
  6622. }else {
  6623. sprintf(a,"%s,G,%s,",n,gr);
  6624. strcat(concatena,a);
  6625. limpiarvar(a,50);
  6626. }
  6627. eli=0;
  6628. c=-1;
  6629. }
  6630. if(tipo==1 && c==4)
  6631. {
  6632. sprintf(a,"%s,U,%s,%s,%s,",n,gr,usu,cont);
  6633. strcat(concatena,a);
  6634. limpiarvar(a,50);
  6635. eli=0;
  6636. c=-1;
  6637.  
  6638. }
  6639.  
  6640. c++;
  6641.  
  6642. ptr3=strtok(NULL,",");
  6643.  
  6644. }
  6645. if(us==1)
  6646. {
  6647. strcpy(usua,concatena);
  6648. printf("%s\n",usua);
  6649.  
  6650. ELiminarCuerpo(1);
  6651. cargarUser(usua);
  6652. time_t tiempo = time(0);
  6653. struct tm *tlocal = localtime(&tiempo);
  6654. char output[128];
  6655. char time[16];
  6656. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  6657.  
  6658. int l=0;
  6659. for(int k=0;k<16;k++)
  6660. {
  6661. time[l++]=output[k];
  6662. }
  6663. EscribirEnJurnal('3','1',"-",funcion.name,time,"-","-");
  6664. }else {
  6665.  
  6666. printf("Error::->Nombre del grupo no existe\n");
  6667. }
  6668.  
  6669.  
  6670. limpiarvar(usua,300);
  6671. limpiarvar(concatena,300);
  6672. limpiarvar(a,50);
  6673. }
  6674. void CrearUsuario(Funcion funcion)
  6675. {
  6676. Retornoo usuarios;
  6677. usuarios=obtenerUsuarios();
  6678. char usua[300];
  6679. strcpy(usua,usuarios.cadena);
  6680. char msg[3];
  6681. usuarios.usuarios=1;
  6682. usuarios.grupos=1;
  6683. int tipo=0;
  6684. int c=1;
  6685. int us=0;
  6686. int con=0;
  6687. int eli=0;
  6688. char* ptr3=strtok(usuarios.cadena,",");
  6689. while (ptr3!=NULL) {
  6690.  
  6691. //printf("-%s-\n",ptr3);
  6692. if(!strcmp(ptr3,"U"))
  6693. {
  6694. tipo=1;
  6695. c=1;
  6696. usuarios.usuarios++;
  6697. }
  6698. if(!strcmp(ptr3,"G"))
  6699. {
  6700. tipo=0;
  6701. usuarios.grupos++;
  6702. c=1;
  6703. }
  6704. if(!strcmp(ptr3,"0"))
  6705. {
  6706. eli=1;
  6707. }
  6708. if(tipo==1 && c==3)
  6709. {
  6710. //printf("%s vs %s",ptr3,funcion.usr);
  6711. if(!strcmp(ptr3,funcion.usr) && eli==0 )
  6712. {
  6713. us=1;
  6714. }
  6715. }if(tipo==0 && c==2)
  6716. {
  6717. eli=0;
  6718. }
  6719. if(tipo==1 && c==4)
  6720. {
  6721. eli=0;
  6722.  
  6723. }
  6724.  
  6725. c++;
  6726.  
  6727.  
  6728. ptr3=strtok(NULL,",");
  6729.  
  6730. }if(us==0)
  6731. {
  6732. sprintf(msg, "%d", usuarios.usuarios);
  6733. strcat(usua,msg);
  6734. strcat(usua,",U,");
  6735. strcat(usua,funcion.grp);
  6736. strcat(usua,",");
  6737. strcat(usua,funcion.usr);
  6738. strcat(usua,",");
  6739. strcat(usua,funcion.pwd);
  6740. strcat(usua,",");
  6741. printf("%s\n",usua);
  6742.  
  6743. ELiminarCuerpo(1);
  6744. cargarUser(usua);
  6745. time_t tiempo = time(0);
  6746. struct tm *tlocal = localtime(&tiempo);
  6747. char output[128];
  6748. char time[16];
  6749. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  6750.  
  6751. int l=0;
  6752. for(int k=0;k<16;k++)
  6753. {
  6754. time[l++]=output[k];
  6755. }
  6756. EscribirEnJurnal('4','1',funcion.name,funcion.grp,time,funcion.pwd,"-");
  6757. }else {
  6758.  
  6759. printf("Error::->Nombre del grupo ya existe\n");
  6760. }
  6761.  
  6762.  
  6763. limpiarvar(usua,300);
  6764. }
  6765. void EliminarUsuario(Funcion funcion)
  6766. {
  6767. Retornoo usuarios;
  6768. usuarios=obtenerUsuarios();
  6769. char usua[300];
  6770.  
  6771. char msg[3];
  6772. char concatena[300];
  6773. char a[50];
  6774.  
  6775. usuarios.grupos=0;
  6776. usuarios.usuarios=0;
  6777. int tipo=0;
  6778. int c=0;
  6779. int us=0;
  6780. int con=0;
  6781. int eli=0;
  6782. char n[3];
  6783. char t[3];
  6784. char gr[10];
  6785. char usu[10];
  6786. char cont[10];
  6787. char* ptr3=strtok(usuarios.cadena,",");
  6788. while (ptr3!=NULL) {
  6789. if(c==0)
  6790. {
  6791.  
  6792. strcpy(n,ptr3);
  6793. }else if (c==1) {
  6794. strcpy(t,ptr3);
  6795. }
  6796. else if (c==2) {
  6797. strcpy(gr,ptr3);
  6798. }
  6799. else if (c==3) {
  6800. strcpy(usu,ptr3);
  6801. }
  6802. else if (c==4) {
  6803. strcpy(cont,ptr3);
  6804. }
  6805.  
  6806. if(!strcmp(ptr3,"U"))
  6807. {
  6808. usuarios.usuarios++;
  6809. tipo=1;
  6810. c=1;
  6811. }
  6812. else if(!strcmp(ptr3,"G"))
  6813. {
  6814. tipo=0;
  6815. usuarios.grupos++;
  6816. c=1;
  6817. }
  6818. if(!strcmp(ptr3,"0"))
  6819. {
  6820. eli=1;
  6821. }
  6822. if(tipo==0 && c==2)
  6823. {
  6824. sprintf(a,"%s,G,%s,",n,gr);
  6825. strcat(concatena,a);
  6826. limpiarvar(a,50);
  6827. eli=0;
  6828. c=-1;
  6829. }
  6830. if(tipo==1 && c==4)
  6831. {
  6832. if(!strcmp(usu,funcion.usr) && eli==0 )
  6833. {
  6834. sprintf(a,"0,U,%s,%s,%s,",gr,usu,cont);
  6835. strcat(concatena,a);
  6836. limpiarvar(a,50);
  6837. us=1;
  6838. }else {
  6839. sprintf(a,"%s,U,%s,%s,%s,",n,gr,usu,cont);
  6840. strcat(concatena,a);
  6841. limpiarvar(a,50);
  6842. }
  6843. eli=0;
  6844. c=-1;
  6845.  
  6846.  
  6847. }
  6848.  
  6849. c++;
  6850.  
  6851. ptr3=strtok(NULL,",");
  6852.  
  6853. }
  6854. if(us==1)
  6855. {
  6856. strcpy(usua,concatena);
  6857. printf("%s\n",usua);
  6858.  
  6859. ELiminarCuerpo(1);
  6860. cargarUser(usua);
  6861. time_t tiempo = time(0);
  6862. struct tm *tlocal = localtime(&tiempo);
  6863. char output[128];
  6864. char time[16];
  6865. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  6866.  
  6867. int l=0;
  6868. for(int k=0;k<16;k++)
  6869. {
  6870. time[l++]=output[k];
  6871. }
  6872. EscribirEnJurnal('5','1',"-",funcion.usr,time,"-","-");
  6873. }else {
  6874.  
  6875. printf("Error::->Nombre del grupo no existe\n");
  6876. }
  6877.  
  6878.  
  6879. limpiarvar(usua,300);
  6880. limpiarvar(concatena,300);
  6881. limpiarvar(a,50);
  6882. }
  6883.  
  6884.  
  6885.  
  6886. void Login(Funcion funcion)
  6887. {
  6888.  
  6889. strcpy(nombG,obtenerNombre(funcion));
  6890. strcpy(pathG,obtenerPath(funcion));
  6891. MbrDisco *mbr=BuscarDisco(funcion);
  6892. if(mbr!=NULL)
  6893. {
  6894.  
  6895.  
  6896. printf("Nombre: %s\n",nombG);
  6897.  
  6898. for(int i=0; i<4; i++)
  6899. {
  6900. if(!strcmp(nombG,mbr->particiones[i].part_name))
  6901. {
  6902. if(mbr->bandera==1)
  6903. {
  6904. Retornoo usuario;
  6905.  
  6906. usuario=obtenerUsuarios();
  6907. printf("cadena-> %s\n",usuario.cadena);
  6908. int tipo=0;
  6909. int c=1;
  6910. int us=0;
  6911. int con=0;
  6912. int eli=0;
  6913. char* ptr3=strtok(usuario.cadena,",");
  6914.  
  6915. while (ptr3!=NULL) {
  6916.  
  6917. //printf("-%s-\n",ptr3);
  6918. if(!strcmp(ptr3,"U"))
  6919. {
  6920. tipo=1;
  6921. c=1;
  6922. }
  6923. if(!strcmp(ptr3,"G"))
  6924. {
  6925. tipo=0;
  6926. c=1;
  6927. }
  6928. if(!strcmp(ptr3,"0"))
  6929. {
  6930. eli=1;
  6931. }
  6932. if(tipo==1 && c==3)
  6933. {
  6934. //printf("%s vs %s",ptr3,funcion.usr);
  6935. if(!strcmp(ptr3,funcion.usr))
  6936. {
  6937. us=1;
  6938. }
  6939. }
  6940. if(tipo==1 && c==4)
  6941. {
  6942. //printf("%s vs %s\n",ptr3,funcion.pwd);
  6943. if(!strcmp(ptr3,funcion.pwd) && eli==0)
  6944. {
  6945. con=1;
  6946. }
  6947. }
  6948. c++;
  6949. eli=0;
  6950.  
  6951. ptr3=strtok(NULL,",");
  6952.  
  6953. }
  6954. if(us==1 && con==1)
  6955. {
  6956. if(logu==0)
  6957. {
  6958. printf("LOGUEADO\n");
  6959. strcpy(NombreUsuario,funcion.usr);
  6960. logu=1;
  6961. if(!strcmp(funcion.usr,"root"))
  6962. {
  6963. root=1;
  6964. }
  6965. }else {
  6966. printf("Ya existe un usuario logueado\n");
  6967. }
  6968.  
  6969. }else {
  6970. printf("Usuario y/o contrasena incorrectas\n");
  6971. }
  6972.  
  6973.  
  6974. }else {
  6975. printf("Disco no tiene sistema de archivos\n");
  6976. }
  6977. break;
  6978. }
  6979. }
  6980. }
  6981.  
  6982. }
  6983.  
  6984. void formatearParticion(Funcion funcion)
  6985. {
  6986.  
  6987. strcpy(nombG,obtenerNombre(funcion));
  6988. strcpy(pathG,obtenerPath(funcion));
  6989. MbrDisco mbr=obtenerMBR(funcion);
  6990. if(mbr.bandera!=-4)
  6991. {
  6992.  
  6993.  
  6994. printf("Nombre: %s\n",nombG);
  6995.  
  6996. for(int i=0; i<4; i++)
  6997. {
  6998. if(!strcmp(nombG,mbr.particiones[i].part_name))
  6999. {
  7000. printf("Encontro Particion\n");
  7001. if(!strcmp(funcion.typeFormatear,"fast"))
  7002. {
  7003. printf("Formateo fast...\n");
  7004.  
  7005. printf("'FORMATEO FAST REALIZADO EXITOSAMENTE'\n");
  7006.  
  7007.  
  7008. }else
  7009. {
  7010. printf("Formateo full...\n");
  7011. FILE* file= fopen(pathG, "rb+");
  7012. // estableciendo puntero al inicio
  7013. if (file==NULL)
  7014. {
  7015. printf("\nError::->Imposible escribir en el archivo \n\n");
  7016. }
  7017. else
  7018. {
  7019.  
  7020. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  7021. int fin=(mbr.particiones[i].part_size/1024);
  7022. char buffer[1024];
  7023. int i=0;
  7024. for(i=0;i<1024;i++){
  7025. buffer[i]='\0';
  7026. }
  7027. int j=0;
  7028. while(j!=fin){
  7029. fwrite(&buffer,1024 , 1, file);
  7030. j++;
  7031. }
  7032. fclose(file);
  7033. printf("'FORMATEO FULL REALIZADO EXITOSAMENTE'\n");
  7034. }
  7035.  
  7036. }
  7037. if(!strcmp(funcion.fs,"2fs"))
  7038. {
  7039.  
  7040. double tamano=mbr.particiones[i].part_size;
  7041. double super=sizeof (SuperBlock);
  7042. double inodo=sizeof (Inodo);
  7043. double bloque=sizeof (Bloque);
  7044. double nP=(tamano-super)/(1+3+inodo+(3*bloque));
  7045. int n=floor(nP);
  7046. int cInodos=n;
  7047. int cBloques=3*n;
  7048. Inodo inodoNuevo;
  7049.  
  7050. char bitmapI[cInodos];
  7051. for (int i=0; i<cInodos;i++) {
  7052. bitmapI[i]='0';
  7053. }
  7054. char bitmapB[cBloques];
  7055. for (int i=0; i<cBloques;i++) {
  7056. bitmapB[i]='0';
  7057. }
  7058. printf("Estructuras: %d\n",n);
  7059. printf("Inodos %d \n",cInodos);
  7060. printf("Bloques %d \n",cBloques);
  7061.  
  7062. SuperBlock superB;
  7063.  
  7064. superB.s_filesystem_type=2;
  7065. superB.s_inodes_count=cInodos;
  7066. superB.s_blocks_count=cBloques;
  7067. superB.s_free_blocks_count=cBloques;
  7068. superB.s_free_inodes_count=cInodos;
  7069. time_t tiempo = time(0);
  7070. struct tm *tlocal = localtime(&tiempo);
  7071. char output[128];
  7072. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7073.  
  7074. int l=0;
  7075. for(int k=0;k<16;k++)
  7076. {
  7077. superB.s_mtime[l++]=output[k];
  7078. }
  7079. superB.s_umtime[0]='-';
  7080. superB.s_mnt_count=1;
  7081. superB.s_magic=0;
  7082. superB.s_inode_size=sizeof (Inodo);
  7083. superB.s_block_size=sizeof (BloqueCarpeta);
  7084. superB.s_first_ino=0;
  7085. superB.s_first_blo=0;
  7086. superB.s_bm_inode_start=sizeof (MbrDisco)+mbr.particiones[i].part_start+sizeof (SuperBlock);
  7087. superB.s_bm_block_start=superB.s_bm_inode_start+sizeof (bitmapI);
  7088. superB.s_inode_start=superB.s_bm_block_start+sizeof (bitmapB);
  7089. superB.s_block_start=superB.s_inode_start+(sizeof (Inodo)*cInodos);
  7090.  
  7091. FILE* file= fopen(pathG, "rb+");
  7092. // estableciendo puntero al inicio
  7093. if (file==NULL)
  7094. {
  7095. printf("\nError::->Imposible escribir en el archivo \n\n");
  7096. }
  7097. else
  7098. {
  7099.  
  7100. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  7101. fwrite(&superB,sizeof (SuperBlock) , 1, file);
  7102.  
  7103. fseek(file,superB.s_bm_inode_start,SEEK_SET);
  7104. fwrite(&bitmapI,sizeof (bitmapI) , 1, file);
  7105.  
  7106. fseek(file,superB.s_bm_block_start,SEEK_SET);
  7107. fwrite(&bitmapB,sizeof (bitmapB) , 1, file);
  7108.  
  7109. actual=0;
  7110.  
  7111.  
  7112. printf("Se crearon las partes del sistema de archivos\n");
  7113.  
  7114. char contenido[200];
  7115. strcpy(contenido,"1,G,root,1,U,root,root,123,");
  7116. strcpy(funcion.path,"/user.txt");
  7117. funcion.p=1;
  7118. SepararDirectorio(funcion,contenido,2);
  7119. mbr.bandera=1;
  7120. fseek(file,0,SEEK_SET);
  7121. fwrite(&mbr,sizeof (MbrDisco) , 1, file);
  7122. fclose(file);
  7123. limpiarvar(contenido,200);
  7124.  
  7125.  
  7126.  
  7127.  
  7128.  
  7129. printf("'SISTEMA DE ARCHIVOS CREADO SATISFACTORIAMENTE'\n");
  7130. }
  7131.  
  7132.  
  7133.  
  7134. }
  7135. if(!strcmp(funcion.fs,"3fs"))
  7136. {
  7137. printf("ext3\n");
  7138. double tamano=mbr.particiones[i].part_size;
  7139. double super=sizeof (SuperBlock);
  7140. double inodo=sizeof (Inodo);
  7141. double bloque=sizeof (Bloque);
  7142. double journal=sizeof (Journal);
  7143. double nP=(tamano-super)/(1+journal+3+inodo+(3*bloque));
  7144. Inodo inodoNuevo;
  7145. int n=floor(nP);
  7146. int cInodos=n;
  7147. int cBloques=3*n;
  7148.  
  7149. char bitmapI[cInodos];
  7150. for (int i=0; i<cInodos;i++) {
  7151. bitmapI[i]='0';
  7152. }
  7153. char bitmapB[cBloques];
  7154. for (int i=0; i<cBloques;i++) {
  7155. bitmapB[i]='0';
  7156. }
  7157. printf("Estructuras: %d\n",n);
  7158. printf("Inodos %d \n",cInodos);
  7159. printf("Bloques %d \n",cBloques);
  7160.  
  7161. SuperBlock superB;
  7162.  
  7163. superB.s_filesystem_type=3;
  7164. superB.s_inodes_count=cInodos;
  7165. superB.s_blocks_count=cBloques;
  7166. superB.s_free_blocks_count=cBloques;
  7167. superB.s_free_inodes_count=cInodos;
  7168. time_t tiempo = time(0);
  7169. struct tm *tlocal = localtime(&tiempo);
  7170. char output[128];
  7171. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7172.  
  7173. int l=0;
  7174. for(int k=0;k<16;k++)
  7175. {
  7176. superB.s_mtime[l++]=output[k];
  7177. }
  7178. superB.s_umtime[0]='-';
  7179. superB.s_mnt_count=1;
  7180. superB.s_magic=0;
  7181. superB.s_inode_size=sizeof (Inodo);
  7182. superB.s_block_size=sizeof (BloqueCarpeta);
  7183. superB.s_first_ino=0;
  7184. superB.s_first_blo=0;
  7185. superB.s_bm_inode_start=sizeof (MbrDisco)+(sizeof (Journal)*400)+mbr.particiones[i].part_start+sizeof (SuperBlock);
  7186. superB.s_bm_block_start=superB.s_bm_inode_start+sizeof (bitmapI);
  7187. superB.s_inode_start=superB.s_bm_block_start+sizeof (bitmapB);
  7188. superB.s_block_start=superB.s_inode_start+(sizeof (Inodo)*cInodos);
  7189.  
  7190. FILE* file= fopen(pathG, "rb+");
  7191. // estableciendo puntero al inicio
  7192. if (file==NULL)
  7193. {
  7194. printf("\nError::->Imposible escribir en el archivo \n\n");
  7195. }
  7196. else
  7197. {
  7198. Journal j;
  7199. j.siguiente=-1;
  7200. j.posicion=0;
  7201. j.operacion='-';
  7202.  
  7203. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco)+sizeof (SuperBlock),SEEK_SET);
  7204. fwrite(&j,sizeof (Journal) , 1, file);
  7205.  
  7206. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  7207. fwrite(&superB,sizeof (SuperBlock) , 1, file);
  7208.  
  7209. fseek(file,superB.s_bm_inode_start,SEEK_SET);
  7210. fwrite(&bitmapI,sizeof (bitmapI) , 1, file);
  7211.  
  7212. fseek(file,superB.s_bm_block_start,SEEK_SET);
  7213. fwrite(&bitmapB,sizeof (bitmapB) , 1, file);
  7214.  
  7215. mbr.bandera=1;
  7216. fseek(file,0,SEEK_SET);
  7217. fwrite(&mbr,sizeof (MbrDisco) , 1, file);
  7218.  
  7219. printf("Se crearon las partes del sistema de archivos\n");
  7220. char contenido[200];
  7221. strcpy(contenido,"1,G,root,1,U,root,root,123,");
  7222. strcpy(funcion.path,"/user.txt");
  7223. funcion.p=1;
  7224. SepararDirectorio(funcion,contenido,3);
  7225. mbr.bandera=1;
  7226. fseek(file,0,SEEK_SET);
  7227. fwrite(&mbr,sizeof (MbrDisco) , 1, file);
  7228. fclose(file);
  7229. limpiarvar(contenido,200);
  7230.  
  7231.  
  7232.  
  7233.  
  7234.  
  7235. printf("'SISTEMA DE ARCHIVOS CREADO SATISFACTORIAMENTE'\n");
  7236. }
  7237.  
  7238.  
  7239.  
  7240. }
  7241.  
  7242. break;
  7243. }
  7244. }
  7245. }
  7246.  
  7247. }
  7248. void CrearArchivo(Funcion funcion)
  7249. {
  7250. char contenido[600];
  7251. limpiarvar(contenido,600);
  7252. int caracter=0;
  7253. char car[10];
  7254. for (int i=0;i<funcion.size;i++) {
  7255. sprintf(car,"%d",caracter);
  7256. strcat(contenido,car);
  7257. caracter++;
  7258. if(caracter==10)
  7259. {
  7260. caracter=0;
  7261. }
  7262.  
  7263. }
  7264. time_t tiempo = time(0);
  7265. struct tm *tlocal = localtime(&tiempo);
  7266. char output[128];
  7267. char time[16];
  7268. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7269.  
  7270. int l=0;
  7271. for(int k=0;k<16;k++)
  7272. {
  7273. time[l++]=output[k];
  7274. }
  7275. char p;
  7276. if(funcion.p==1)
  7277. {
  7278. p='1';
  7279. }else {
  7280. p='0';
  7281. }
  7282. char s[3];
  7283. sprintf(s,"%d",funcion.size);
  7284. EscribirEnJurnal('6',p,funcion.path,s,time,"-","-");
  7285. SepararDirectorio(funcion,contenido,2);
  7286. }
  7287.  
  7288. void CrearDireccion(Funcion funcion)
  7289. {
  7290. char contenido[600];
  7291. limpiarvar(contenido,600);
  7292. time_t tiempo = time(0);
  7293. struct tm *tlocal = localtime(&tiempo);
  7294. char output[128];
  7295. char time[16];
  7296. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7297.  
  7298. int l=0;
  7299. for(int k=0;k<16;k++)
  7300. {
  7301. time[l++]=output[k];
  7302. }
  7303. char p;
  7304. if(funcion.p==1)
  7305. {
  7306. p='1';
  7307. }else {
  7308. p='0';
  7309. }
  7310. EscribirEnJurnal('B',p,funcion.path,"-",time,"-","-");
  7311. SepararDirectorio(funcion,contenido,2);
  7312. }
  7313. void CrearArchivoCont(Funcion funcion)
  7314. {
  7315. char contenido[600];
  7316. limpiarvar(contenido,600);
  7317. char caracter;
  7318. FILE *archivo;
  7319. archivo = fopen(funcion.cont,"r");
  7320. if (archivo == NULL)
  7321. {
  7322. printf("\nError de apertura del archivo. \n\n");
  7323. }
  7324. else
  7325. {
  7326. printf("\nEl contenido del archivo de prueba es \n\n");
  7327. int c=0;
  7328. while((caracter = fgetc(archivo)) != EOF)
  7329. {
  7330. contenido[c]=caracter;
  7331. c++;
  7332. }
  7333. }
  7334. fclose(archivo);
  7335. printf("%s\n",contenido);
  7336. time_t tiempo = time(0);
  7337. struct tm *tlocal = localtime(&tiempo);
  7338. char output[128];
  7339. char time[16];
  7340. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7341.  
  7342. int l=0;
  7343. for(int k=0;k<16;k++)
  7344. {
  7345. time[l++]=output[k];
  7346. }
  7347. char p;
  7348. if(funcion.p==1)
  7349. {
  7350. p='1';
  7351. }else {
  7352. p='0';
  7353. }
  7354. EscribirEnJurnal('7',p,funcion.path,funcion.cont,time,"-","-");
  7355. SepararDirectorio(funcion,contenido,2);
  7356. }
  7357.  
  7358. void ModificarArchivo(Funcion funcion)
  7359. {
  7360. char contenido[600];
  7361. limpiarvar(contenido,600);
  7362. int caracter=0;
  7363. char car[10];
  7364. for (int i=0;i<funcion.size;i++) {
  7365. sprintf(car,"%d",caracter);
  7366. strcat(contenido,car);
  7367. caracter++;
  7368. if(caracter==10)
  7369. {
  7370. caracter=0;
  7371. }
  7372.  
  7373. }
  7374. time_t tiempo = time(0);
  7375. struct tm *tlocal = localtime(&tiempo);
  7376. char output[128];
  7377. char time[16];
  7378. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7379.  
  7380. int l=0;
  7381. for(int k=0;k<16;k++)
  7382. {
  7383. time[l++]=output[k];
  7384. }
  7385. char s[3];
  7386. sprintf(s,"%d",funcion.size);
  7387. EscribirEnJurnal('9','0',"-",s,time,"-","-");
  7388. SepararDirectorio(funcion,contenido,2);
  7389. }
  7390. void ModificarArchivoCont(Funcion funcion)
  7391. {
  7392. char contenido[600];
  7393. limpiarvar(contenido,600);
  7394. char caracter;
  7395. FILE *archivo;
  7396. archivo = fopen(funcion.cont,"r");
  7397. if (archivo == NULL)
  7398. {
  7399. printf("\nError de apertura del archivo. \n\n");
  7400. }
  7401. else
  7402. {
  7403. printf("\nEl contenido del archivo de prueba es \n\n");
  7404. int c=0;
  7405. while((caracter = fgetc(archivo)) != EOF)
  7406. {
  7407. contenido[c]=caracter;
  7408. c++;
  7409. }
  7410. }
  7411. fclose(archivo);
  7412. printf("%s\n",contenido);
  7413.  
  7414. SepararDirectorio(funcion,contenido,2);
  7415. }
  7416.  
  7417.  
  7418.  
  7419. void MostrarCat(Funcion funcion,int c)
  7420. {
  7421. for (int i=0;i<c;i++) {
  7422. Funcion nuevaF;
  7423. limpiarvar(nuevaF.ruta,100);
  7424. strcpy(nuevaF.ruta,funcion.fileN[i].nombre);
  7425. Retornoo ret;
  7426. limpiarvar(ret.cadena,800);
  7427. ret=ObtenerCadena(nuevaF);
  7428. printf("->%s\n\n",ret.cadena);
  7429.  
  7430.  
  7431. }
  7432. }
  7433.  
  7434. void EliminarArchivoCarpeta(Funcion funcion)
  7435. {
  7436. int posActual=-1;
  7437. posActual=ExisteDir2("/",posActual,1,"");
  7438. printf("%d\n",posActual);
  7439. char* nombre=strtok(funcion.path,"/");
  7440. while (nombre!=NULL && posActual!=-1) {
  7441.  
  7442. posActual=ExisteDir2(nombre,posActual,1,"");
  7443. printf("%d\n",posActual);
  7444.  
  7445. if(posActual==-1)
  7446. {
  7447. break;
  7448. }
  7449. nombre=strtok(NULL,"/");
  7450. }
  7451. time_t tiempo = time(0);
  7452. struct tm *tlocal = localtime(&tiempo);
  7453. char output[128];
  7454. char time[16];
  7455. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7456.  
  7457. int l=0;
  7458. for(int k=0;k<16;k++)
  7459. {
  7460. time[l++]=output[k];
  7461. }
  7462.  
  7463. EscribirEnJurnal('8','1',funcion.path,"-",time,"-","-");
  7464.  
  7465. }
  7466.  
  7467. void CambiarNombre(Funcion funcion)
  7468. {
  7469. int cont=0;
  7470. char pathh[100];
  7471. strcpy(pathh,funcion.path);
  7472. char pathH[100];
  7473. strcpy(pathH,funcion.path);
  7474. char* nombre=strtok(pathh,"/");
  7475. while (nombre!=NULL) {
  7476. cont++;
  7477.  
  7478.  
  7479. nombre=strtok(NULL,"/");
  7480. }
  7481. printf("%d\n",cont);
  7482. int c=0;
  7483. int posActual=-1;
  7484. posActual=ExisteDir2("/",posActual,4,funcion.name);
  7485. printf("%d\n",posActual);
  7486. char* nombre2=strtok(funcion.path,"/");
  7487. while (nombre2!=NULL && posActual!=-1) {
  7488.  
  7489. c++;
  7490. printf("%d-%d\n",c,cont);
  7491. if(c==cont)
  7492. {
  7493. posActual=ExisteDir2(nombre2,posActual,2,funcion.name);
  7494. }else {
  7495. posActual=ExisteDir2(nombre2,posActual,4,funcion.name);
  7496. }
  7497. printf("%d\n",posActual);
  7498.  
  7499. if(posActual==-1)
  7500. {
  7501. break;
  7502. }
  7503. nombre2=strtok(NULL,"/");
  7504. }
  7505. time_t tiempo = time(0);
  7506. struct tm *tlocal = localtime(&tiempo);
  7507. char output[128];
  7508. char time[16];
  7509. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7510.  
  7511. int l=0;
  7512. for(int k=0;k<16;k++)
  7513. {
  7514. time[l++]=output[k];
  7515. }
  7516.  
  7517. EscribirEnJurnal('A','0',pathH,funcion.name,time,"-","-");
  7518.  
  7519.  
  7520. }
  7521. void Cortar(Funcion funcion)
  7522. {
  7523. int cont=0;
  7524. char pathh[100];
  7525. strcpy(pathh,funcion.path);
  7526. char patH[100];
  7527. strcpy(patH,funcion.path);
  7528. char* nombre=strtok(pathh,"/");
  7529. while (nombre!=NULL) {
  7530. cont++;
  7531.  
  7532.  
  7533. nombre=strtok(NULL,"/");
  7534. }
  7535. printf("%d\n",cont);
  7536. int c=0;
  7537. int posActual=-1;
  7538. posActual=ExisteDir2("/",posActual,4,funcion.name);
  7539. printf("%d\n",posActual);
  7540. char *nombre2=strtok(funcion.path,"/");
  7541. while (nombre2!=NULL && posActual!=-1) {
  7542. c++;
  7543. if(c==cont)
  7544. {
  7545. posActual=ExisteDir2(nombre2,posActual,3,funcion.name);
  7546. }else {
  7547. posActual=ExisteDir2(nombre2,posActual,4,funcion.name);
  7548. }
  7549. printf("%d\n",posActual);
  7550.  
  7551. if(posActual==-1)
  7552. {
  7553. break;
  7554. }
  7555. nombre2=strtok(NULL,"/");
  7556. }
  7557. char destH[100];
  7558. strcpy(destH,funcion.dest);
  7559. posActual=-1;
  7560. posActual=ExisteDir2("/",posActual,4,funcion.name);
  7561. printf("%d\n",posActual);
  7562. nombre=strtok(funcion.dest,"/");
  7563. while (nombre!=NULL && posActual!=-1) {
  7564.  
  7565. posActual=ExisteDir2(nombre,posActual,4,funcion.name);
  7566. printf("%d\n",posActual);
  7567.  
  7568. if(posActual==-1)
  7569. {
  7570. break;
  7571. }
  7572. nombre=strtok(NULL,"/");
  7573. }
  7574. CortarPegar(posActual);
  7575. time_t tiempo = time(0);
  7576. struct tm *tlocal = localtime(&tiempo);
  7577. char output[128];
  7578. char time[16];
  7579. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7580.  
  7581. int l=0;
  7582. for(int k=0;k<16;k++)
  7583. {
  7584. time[l++]=output[k];
  7585. }
  7586. char s[3];
  7587. sprintf(s,"%d",funcion.size);
  7588. EscribirEnJurnal('C','0',patH,destH,time,"-","-");
  7589.  
  7590. }
  7591. void Loss()
  7592. {
  7593. MbrDisco mbr;
  7594. SuperBlock super;
  7595. FILE* file= fopen(pathG, "rb+");
  7596. if (file==NULL)
  7597. {
  7598. printf("\nError::->Imposible escribir en el archivo \n\n");
  7599. }
  7600. else
  7601. {
  7602. fread(&mbr,sizeof (MbrDisco) , 1, file);
  7603. for(int i=0; i<4; i++)
  7604. {
  7605. if(!strcmp(nombG,mbr.particiones[i].part_name))
  7606. {
  7607. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  7608. fread(&super,sizeof (SuperBlock) , 1, file);
  7609. super.s_first_blo=0;
  7610. super.s_first_ino=0;
  7611. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  7612. fwrite(&super,sizeof (SuperBlock) , 1, file);
  7613. fseek(file,sizeof (MbrDisco)+(sizeof (Journal)*400)+mbr.particiones[i].part_start+sizeof (SuperBlock),SEEK_SET);
  7614. int inicio=sizeof (MbrDisco)+(sizeof (Journal)*400)+mbr.particiones[i].part_start+sizeof (SuperBlock);
  7615. int fin1=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  7616. int tamano=fin1-inicio;
  7617. int fin=(tamano/1024);
  7618. char buffer[1024];
  7619. int i=0;
  7620. for(i=0;i<1024;i++){
  7621. buffer[i]='\0';
  7622. }
  7623. int j=0;
  7624. while(j!=fin){
  7625. fwrite(&buffer,1024 , 1, file);
  7626. j++;
  7627. }
  7628. fclose(file);
  7629.  
  7630. break;
  7631. }
  7632. }
  7633.  
  7634. }
  7635.  
  7636. }
  7637.  
  7638. void Recovery()
  7639. {
  7640. Funcion funcion;
  7641. MbrDisco mbr=obtenerMBR2();
  7642. for(int i=0; i<4; i++)
  7643. {
  7644. if(!strcmp(nombG,mbr.particiones[i].part_name))
  7645. {
  7646. printf("ext3\n");
  7647. double tamano=mbr.particiones[i].part_size;
  7648. double super=sizeof (SuperBlock);
  7649. double inodo=sizeof (Inodo);
  7650. double bloque=sizeof (Bloque);
  7651. double journal=sizeof (Journal);
  7652. double nP=(tamano-super)/(1+journal+3+inodo+(3*bloque));
  7653. Inodo inodoNuevo;
  7654. int n=floor(nP);
  7655. int cInodos=n;
  7656. int cBloques=3*n;
  7657.  
  7658. char bitmapI[cInodos];
  7659. for (int i=0; i<cInodos;i++) {
  7660. bitmapI[i]='0';
  7661. }
  7662. char bitmapB[cBloques];
  7663. for (int i=0; i<cBloques;i++) {
  7664. bitmapB[i]='0';
  7665. }
  7666. printf("Estructuras: %d\n",n);
  7667. printf("Inodos %d \n",cInodos);
  7668. printf("Bloques %d \n",cBloques);
  7669.  
  7670. SuperBlock superB;
  7671.  
  7672. superB.s_filesystem_type=3;
  7673. superB.s_inodes_count=cInodos;
  7674. superB.s_blocks_count=cBloques;
  7675. superB.s_free_blocks_count=cBloques;
  7676. superB.s_free_inodes_count=cInodos;
  7677. time_t tiempo = time(0);
  7678. struct tm *tlocal = localtime(&tiempo);
  7679. char output[128];
  7680. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  7681.  
  7682. int l=0;
  7683. for(int k=0;k<16;k++)
  7684. {
  7685. superB.s_mtime[l++]=output[k];
  7686. }
  7687. superB.s_umtime[0]='-';
  7688. superB.s_mnt_count=1;
  7689. superB.s_magic=0;
  7690. superB.s_inode_size=sizeof (Inodo);
  7691. superB.s_block_size=sizeof (BloqueCarpeta);
  7692. superB.s_first_ino=0;
  7693. superB.s_first_blo=0;
  7694. superB.s_bm_inode_start=sizeof (MbrDisco)+(sizeof (Journal)*400)+mbr.particiones[i].part_start+sizeof (SuperBlock);
  7695. superB.s_bm_block_start=superB.s_bm_inode_start+sizeof (bitmapI);
  7696. superB.s_inode_start=superB.s_bm_block_start+sizeof (bitmapB);
  7697. superB.s_block_start=superB.s_inode_start+(sizeof (Inodo)*cInodos);
  7698.  
  7699. FILE* file= fopen(pathG, "rb+");
  7700. // estableciendo puntero al inicio
  7701. if (file==NULL)
  7702. {
  7703. printf("\nError::->Imposible escribir en el archivo \n\n");
  7704. }
  7705. else
  7706. {
  7707.  
  7708. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  7709. fwrite(&superB,sizeof (SuperBlock) , 1, file);
  7710.  
  7711. fseek(file,superB.s_bm_inode_start,SEEK_SET);
  7712. fwrite(&bitmapI,sizeof (bitmapI) , 1, file);
  7713.  
  7714. fseek(file,superB.s_bm_block_start,SEEK_SET);
  7715. fwrite(&bitmapB,sizeof (bitmapB) , 1, file);
  7716.  
  7717. mbr.bandera=1;
  7718. fseek(file,0,SEEK_SET);
  7719. fwrite(&mbr,sizeof (MbrDisco) , 1, file);
  7720.  
  7721. printf("Se crearon las partes del sistema de archivos\n");
  7722. char contenido[200];
  7723. strcpy(contenido,"1,G,root,1,U,root,root,123,");
  7724. strcpy(funcion.path,"/user.txt");
  7725. funcion.p=1;
  7726. SepararDirectorio(funcion,contenido,3);
  7727. mbr.bandera=1;
  7728. fseek(file,0,SEEK_SET);
  7729. fwrite(&mbr,sizeof (MbrDisco) , 1, file);
  7730. fclose(file);
  7731. limpiarvar(contenido,200);
  7732.  
  7733.  
  7734.  
  7735.  
  7736.  
  7737. printf("'SISTEMA DE ARCHIVOS CREADO SATISFACTORIAMENTE'\n");
  7738. }
  7739. break;
  7740. }
  7741. }
  7742.  
  7743.  
  7744.  
  7745.  
  7746. SuperBlock super;
  7747. mbr=obtenerMBR2();
  7748. for(int i=0; i<4; i++)
  7749. {
  7750. if(!strcmp(nombG,mbr.particiones[i].part_name))
  7751. {
  7752.  
  7753. FILE *fp;
  7754. fp = fopen(pathG, "rb");
  7755. fseek(fp,sizeof (MbrDisco)+mbr.particiones[i].part_start,SEEK_SET);
  7756.  
  7757. if(fp == NULL)
  7758. {
  7759. printf("\n Error::-> No se encontro el disco\n");
  7760. }else {
  7761. fread(&super,sizeof (SuperBlock), 1, fp);
  7762. if (super.s_filesystem_type==3) {
  7763. Journal Jactual;
  7764. fseek(fp,mbr.particiones[i].part_start+sizeof (MbrDisco)+sizeof (SuperBlock),SEEK_SET);
  7765. fread(&Jactual,sizeof (Journal), 1, fp);
  7766.  
  7767.  
  7768. while (Jactual.siguiente!=-1) {
  7769. fseek(fp,mbr.particiones[i].part_start+sizeof (MbrDisco)+sizeof (SuperBlock)+Jactual.siguiente,SEEK_SET);
  7770. fread(&Jactual,sizeof (Journal), 1, fp);
  7771. Funcion nuevaFuncion;
  7772. if(Jactual.operacion=='2')
  7773. {
  7774. printf("---------------------Crear Grupo-----------------------------\n");
  7775.  
  7776. strcpy(nuevaFuncion.name,Jactual.cont);
  7777. printf("name->%s\n",nuevaFuncion.name);
  7778. CrearGrupo(nuevaFuncion);
  7779. printf("-------------------------------------------------------------\n");
  7780. }if(Jactual.operacion=='3')
  7781. {
  7782. strcpy(nuevaFuncion.name,Jactual.cont);
  7783. printf("name->%s\n",nuevaFuncion.name);
  7784. EliminarGrupo(nuevaFuncion);
  7785. printf("-------------------------------------------------------------\n");
  7786. }if(Jactual.operacion=='4')
  7787. {
  7788. printf("--------------------Crear Usuario----------------------------\n");
  7789. strcpy(nuevaFuncion.grp,Jactual.cont);
  7790. strcpy(nuevaFuncion.pwd,Jactual.propietario);
  7791. strcpy(nuevaFuncion.name,Jactual.path);
  7792. printf("grp->%s\n",nuevaFuncion.grp);
  7793. printf("pwd->%s\n",nuevaFuncion.pwd);
  7794. printf("name->%s\n",nuevaFuncion.name);
  7795. CrearUsuario(nuevaFuncion);
  7796. printf("-------------------------------------------------------------\n");
  7797. }if(Jactual.operacion=='5')
  7798. {
  7799. printf("--------------------Eliminar Usuario-------------------------\n");
  7800. strcpy(nuevaFuncion.usr,Jactual.cont);
  7801. printf("usr->%s\n",nuevaFuncion.usr);
  7802. EliminarUsuario(nuevaFuncion);
  7803. printf("-------------------------------------------------------------\n");
  7804. }if(Jactual.operacion=='6')
  7805. {
  7806. printf("--------------------Crear Archivo----------------------------\n");
  7807. nuevaFuncion.size=atoi(Jactual.cont);
  7808. nuevaFuncion.p=Jactual.tipo-'0';
  7809. strcpy(nuevaFuncion.path,Jactual.path);
  7810. printf("size->%d\n",nuevaFuncion.size);
  7811. printf("p->%d\n",nuevaFuncion.p);
  7812. printf("path->%s\n",nuevaFuncion.path);
  7813. CrearArchivo(nuevaFuncion);
  7814. printf("-------------------------------------------------------------\n");
  7815. }if(Jactual.operacion=='7')
  7816. {
  7817. printf("------------------Crear Archivo Cont-------------------------\n");
  7818. strcpy(nuevaFuncion.cont,Jactual.cont);
  7819. nuevaFuncion.p=Jactual.tipo-'0';
  7820. strcpy(nuevaFuncion.path,Jactual.path);
  7821. printf("cont->%s\n",nuevaFuncion.cont);
  7822. printf("path->%s\n",nuevaFuncion.path);
  7823. printf("p->%d\n",nuevaFuncion.p);
  7824. CrearArchivoCont(nuevaFuncion);
  7825.  
  7826. }if(Jactual.operacion=='A')
  7827. {
  7828. printf("------------------Cambiar Nombre-----------------------------\n");
  7829. strcpy(nuevaFuncion.path,Jactual.path);
  7830. strcpy(nuevaFuncion.name,Jactual.cont);
  7831. printf("path->%s\n",nuevaFuncion.path);
  7832. printf("name->%s\n",nuevaFuncion.name);
  7833. CambiarNombre(nuevaFuncion);
  7834. printf("-------------------------------------------------------------\n");
  7835. }if(Jactual.operacion=='B')
  7836. {
  7837. printf("------------------Crear Direccion-----------------------------\n");
  7838. strcpy(nuevaFuncion.path,Jactual.path);
  7839. printf("path->%s\n",nuevaFuncion.path);
  7840. CrearDireccion(nuevaFuncion);
  7841. printf("-------------------------------------------------------------\n");
  7842. }if(Jactual.operacion=='C')
  7843. {
  7844. printf("------------------Cortar-------------------------------------\n");
  7845. strcpy(nuevaFuncion.path,Jactual.path);
  7846. strcpy(nuevaFuncion.dest,Jactual.cont);
  7847. printf("path->%s\n",nuevaFuncion.path);
  7848. printf("dest->%s\n",nuevaFuncion.dest);
  7849. Cortar(nuevaFuncion);
  7850. printf("-------------------------------------------------------------\n");
  7851. }
  7852.  
  7853.  
  7854.  
  7855. }
  7856.  
  7857. }
  7858. else {
  7859. printf("No es ext3\n");
  7860. }
  7861. ContadorComandosExitosos++;
  7862. fclose(fp);
  7863. }
  7864. }
  7865. }
  7866. }
  7867.  
  7868. void Interprete(char entrada[])
  7869. {
  7870.  
  7871. Funcion nuevafuncion;
  7872. nuevafuncion.size=0;
  7873. int size=0;
  7874. int Files=0;
  7875. int unit=0;
  7876. int path=0;
  7877. int type=0;
  7878. int name=0;
  7879. int contenido=0;
  7880. int delete_=0;
  7881. int add=0;
  7882. int dest=0;
  7883. int fit=0;
  7884. int fs=0;
  7885. int grp=0;
  7886. int id=0;
  7887. int pwd=0;
  7888. int usr=0;
  7889. int numeroparametros=0;
  7890. int contador=0;
  7891. int p=0;
  7892. int cont=0;
  7893. int count=0;
  7894. int activarmount=0;
  7895. int contadorParametrosObligatorios=0;
  7896. char instruccion[100];
  7897. limpiarvar(instruccion,100);
  7898. char nombreparametro[100];
  7899. limpiarvar(nombreparametro,100);
  7900. char parametro[1000];
  7901. limpiarvar(parametro,1000);
  7902. nuevafuncion.count2=0;
  7903. int pa=0;
  7904.  
  7905.  
  7906.  
  7907. printf("Reconociendo comando...\n");
  7908. printf("---------------------Lectura Comando--------------------\n");
  7909. //INICIO----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  7910.  
  7911. while(entrada[contador]!=NULL){//While Comando NULO
  7912.  
  7913. if(entrada[contador]=='#')//------------------------->COMENTARIO-----------------------------------------------------------------------------------------------------------
  7914. {
  7915. //printf("Reconocio: COMENTARIO\n");
  7916. while(entrada[contador]!='\n' && entrada[contador]!='\0')
  7917. {
  7918. comentario=1;
  7919. contador++;
  7920. }
  7921. printf("Comentario");
  7922. }
  7923. else if(entrada[contador]==' ')//-------------------->ESPACIO EN BLANCO--------------------------------------------------------------------------------------------------------------------------
  7924. {
  7925.  
  7926. //printf("Reconocio(): ESPACIO\n");
  7927. contador++;
  7928.  
  7929. }else if(EsLetra(entrada[contador])==1){//------------>LETRA--------------------------------------------------------------------------------------------------------------------------------------
  7930.  
  7931. while(EsLetra(entrada[contador])==1)
  7932. {
  7933. char nuevoCaracter[1];
  7934. nuevoCaracter[0]=entrada[contador];
  7935. strncat(instruccion,nuevoCaracter,1);
  7936. contador++;
  7937. }
  7938.  
  7939. size=0;
  7940. dest=0;
  7941. unit=0;
  7942. path=0;
  7943. type=0;
  7944. fit=0;
  7945. grp=0;
  7946. Files=0;
  7947. pwd=0;
  7948. usr=0;
  7949. p=0;
  7950. delete_=0;
  7951. name=0;
  7952. add=0;
  7953. numeroparametros=0;
  7954. id=0;
  7955. cont=0;
  7956. contenido=0;
  7957. fs=0;
  7958.  
  7959. //Quitar Mayusculas----------------------------------------------------------------------------------------------------------------------------------------
  7960. int contadormay=0;
  7961. while(instruccion[contadormay])
  7962. {
  7963. instruccion[contadormay]=tolower(instruccion[contadormay]);
  7964. contadormay++;
  7965. }
  7966.  
  7967.  
  7968. strcpy(nuevafuncion.nombre,instruccion);
  7969. printf("----%s----\n", nuevafuncion.nombre);
  7970.  
  7971. }else if((entrada[contador]=='-' || entrada[contador]=='\–')){//--------------------------->Parametro--------------------------------------------------------------------------------------
  7972.  
  7973. numeroparametros++;
  7974. contador++;
  7975. while(entrada[contador]!='~' && entrada[contador]!=' ' && entrada[contador]!='\n'&& entrada[contador]!='\0'&& entrada[contador]!='1'&& entrada[contador]!='2'&& entrada[contador]!='3'&& entrada[contador]!='4'&& entrada[contador]!='5'&& entrada[contador]!='6'&& entrada[contador]!='7'&& entrada[contador]!='8'&& entrada[contador]!='9')//limite del parametro(-Size~:~3000)
  7976. {
  7977. //Guardar nombre parametro
  7978. char nuevoCaracter[1];
  7979. nuevoCaracter[0]=entrada[contador];
  7980. strncat(nombreparametro,nuevoCaracter,1);
  7981. contador++;
  7982. }
  7983. //tomar valor del parametro (~:~)
  7984. if(strcmp(nombreparametro,"p") && strcmp(nombreparametro,"P")){
  7985.  
  7986. if(entrada[contador]=='~' && entrada[contador+1]==':' && entrada[contador+2]=='~'){
  7987. //si encuentra los simbolos
  7988. //pa=1;
  7989. contador=contador+3;//saltarse la flecha
  7990. int contadorpar=0;
  7991. while(nombreparametro[contadorpar])// cambiar a minusculas el nombre del parametro
  7992. {
  7993. nombreparametro[contadorpar]=tolower(nombreparametro[contadorpar]);
  7994. contadorpar++;
  7995. }
  7996. printf("%s::= ",nombreparametro);
  7997.  
  7998.  
  7999.  
  8000. char prueba;
  8001. if(entrada[contador]!='\"')//si no hay comillas en el contenido del parametro
  8002. {
  8003. while(entrada[contador]!=' ' && entrada[contador]!='\n' && entrada[contador]!='#' && entrada[contador]!=NULL)
  8004. {
  8005. char nuevoCaracter[1];
  8006. nuevoCaracter[0]=entrada[contador];
  8007. strncat(parametro,nuevoCaracter,1);
  8008. contador++;
  8009. }
  8010.  
  8011. printf(" %s\n",parametro);
  8012. char fn[1];
  8013. fn[0]='\0';
  8014. strncat(parametro,fn,1);
  8015.  
  8016. }else //si existieran comillas en el parametro
  8017. {
  8018. char nuevoCaracter[1];
  8019. nuevoCaracter[0]=entrada[contador];
  8020. strncat(parametro,nuevoCaracter,1);
  8021. contador++;
  8022. while(entrada[contador]!='\"') //&& entrada[contador]!=' ' esto se quita si truena
  8023. {
  8024. prueba=entrada[contador];
  8025. char nuevoCaracter[1];
  8026. nuevoCaracter[0]=entrada[contador];
  8027. strncat(parametro,nuevoCaracter,1);
  8028.  
  8029. contador++;
  8030. }
  8031. char y6[1];
  8032. y6[0]=entrada[contador];
  8033. strncat(parametro,y6,1);
  8034. contador++;
  8035. char fn[1];
  8036. fn[0]='\0';
  8037. strncat(parametro,fn,1);
  8038. printf(" con Comillas -> %s\n",parametro);
  8039. }
  8040. //pa=0;
  8041. }
  8042. if(entrada[contador+1]=='~' && entrada[contador+2]==':' && entrada[contador+3]=='~'){
  8043. //si encuentra los simbolos
  8044. //pa=1;
  8045. contador=contador+4;//saltarse la flecha
  8046. int contadorpar=0;
  8047. while(nombreparametro[contadorpar])// cambiar a minusculas el nombre del parametro
  8048. {
  8049. nombreparametro[contadorpar]=tolower(nombreparametro[contadorpar]);
  8050. contadorpar++;
  8051. }
  8052. printf("%s::= ",nombreparametro);
  8053.  
  8054.  
  8055.  
  8056. char prueba;
  8057. if(entrada[contador]!='\"')//si no hay comillas en el contenido del parametro
  8058. {
  8059. while(entrada[contador]!=' ' && entrada[contador]!='\n' && entrada[contador]!='#' && entrada[contador]!=NULL)
  8060. {
  8061. char nuevoCaracter[1];
  8062. nuevoCaracter[0]=entrada[contador];
  8063. strncat(parametro,nuevoCaracter,1);
  8064. contador++;
  8065. }
  8066.  
  8067. printf(" %s\n",parametro);
  8068. char fn[1];
  8069. fn[0]='\0';
  8070. strncat(parametro,fn,1);
  8071.  
  8072. }else //si existieran comillas en el parametro
  8073. {
  8074. char nuevoCaracter[1];
  8075. nuevoCaracter[0]=entrada[contador];
  8076. strncat(parametro,nuevoCaracter,1);
  8077. contador++;
  8078. while(entrada[contador]!='\"') //&& entrada[contador]!=' ' esto se quita si truena
  8079. {
  8080. prueba=entrada[contador];
  8081. char nuevoCaracter[1];
  8082. nuevoCaracter[0]=entrada[contador];
  8083. strncat(parametro,nuevoCaracter,1);
  8084.  
  8085. contador++;
  8086. }
  8087. char y6[1];
  8088. y6[0]=entrada[contador];
  8089. strncat(parametro,y6,1);
  8090. contador++;
  8091. char fn[1];
  8092. fn[0]='\0';
  8093. strncat(parametro,fn,1);
  8094. printf(" con Comillas -> %s\n",parametro);
  8095. }
  8096. //pa=0;
  8097. }
  8098. }else{
  8099. printf("P::= Activo\n");
  8100. }
  8101.  
  8102.  
  8103. //Inicia el Reconocimiento de los Parametros
  8104. if(!strcmp(nombreparametro,"size"))//---------------Reconocio size----------------------------------------------------------------------
  8105. {
  8106. //Validar mayor que >0
  8107. size=1;
  8108. if(EsNumero(parametro)==0)
  8109. {
  8110. nuevafuncion.size=atoi(parametro);
  8111.  
  8112.  
  8113. limpiarvar(parametro,1000);
  8114. limpiarvar(nombreparametro,100);
  8115. limpiarvar(parametro,1000);
  8116. limpiarvar(nombreparametro,100);
  8117.  
  8118. }else{
  8119. printf("\nError::-> Parametro de 'size' Invalido \n\n");
  8120. ErrorInterprete++;
  8121. size=0;
  8122. }
  8123. }else if(!strcmp(nombreparametro,"path"))//------------Reconocio path----------------------------------------------------------------------------------------------
  8124. {
  8125.  
  8126. path=1;
  8127. char env[1000];
  8128. strcpy(env,parametro);
  8129. quitarComillas(env);
  8130. strcpy(nuevafuncion.path,sincomillas);
  8131. limpiarvar(parametro,1000);
  8132. limpiarvar(nombreparametro,100);
  8133.  
  8134. }else if(!strcmp(nombreparametro,"dest"))//------------Reconocio dest----------------------------------------------------------------------------------------------
  8135. {
  8136.  
  8137. dest=1;
  8138. char env[1000];
  8139. strcpy(env,parametro);
  8140. quitarComillas(env);
  8141. strcpy(nuevafuncion.dest,sincomillas);
  8142. limpiarvar(parametro,1000);
  8143. limpiarvar(nombreparametro,100);
  8144.  
  8145. }else if(!strcmp(nombreparametro,"cont"))//------------Reconocio cont----------------------------------------------------------------------------------------------
  8146. {
  8147.  
  8148. cont=1;
  8149. char env[1000];
  8150. strcpy(env,parametro);
  8151. quitarComillas(env);
  8152. strcpy(nuevafuncion.cont,sincomillas);
  8153. limpiarvar(parametro,1000);
  8154. limpiarvar(nombreparametro,100);
  8155.  
  8156. }else if(!strcmp(nombreparametro,"file"))//------------Reconocio file----------------------------------------------------------------------------------------------
  8157. {
  8158.  
  8159.  
  8160. char env[1000];
  8161. strcpy(env,parametro);
  8162. quitarComillas(env);
  8163. strcpy(nuevafuncion.fileN[Files].nombre,sincomillas);
  8164. Files++;
  8165. limpiarvar(parametro,1000);
  8166. limpiarvar(nombreparametro,100);
  8167.  
  8168. }else if(!strcmp(nombreparametro,"ruta"))//------------Reconocio ruta----------------------------------------------------------------------------------------------
  8169. {
  8170.  
  8171. cont=1;
  8172. char env[1000];
  8173. strcpy(env,parametro);
  8174. quitarComillas(env);
  8175. strcpy(nuevafuncion.ruta,sincomillas);
  8176. limpiarvar(parametro,1000);
  8177. limpiarvar(nombreparametro,100);
  8178.  
  8179. }else if(!strcmp(nombreparametro,"p"))//------------p----------------------------------------------------------------------------------------------
  8180. {
  8181.  
  8182.  
  8183. p=1;
  8184. limpiarvar(parametro,1000);
  8185. limpiarvar(nombreparametro,100);
  8186.  
  8187. }else if(!strcmp(nombreparametro,"usr"))//------------Reconocio usr----------------------------------------------------------------------------------------------
  8188. {
  8189.  
  8190. usr=1;
  8191. char env[1000];
  8192. strcpy(env,parametro);
  8193. quitarComillas(env);
  8194. strcpy(nuevafuncion.usr,sincomillas);
  8195. limpiarvar(parametro,1000);
  8196. limpiarvar(nombreparametro,100);
  8197.  
  8198. }else if(!strcmp(nombreparametro,"pwd"))//------------Reconocio pwd----------------------------------------------------------------------------------------------
  8199. {
  8200.  
  8201. pwd=1;
  8202. char env[1000];
  8203. strcpy(env,parametro);
  8204. quitarComillas(env);
  8205. strcpy(nuevafuncion.pwd,sincomillas);
  8206. limpiarvar(parametro,1000);
  8207. limpiarvar(nombreparametro,100);
  8208.  
  8209. }else if(!strcmp(nombreparametro,"grp"))//------------Reconocio grp----------------------------------------------------------------------------------------------
  8210. {
  8211.  
  8212. grp=1;
  8213. char env[1000];
  8214. strcpy(env,parametro);
  8215. quitarComillas(env);
  8216. strcpy(nuevafuncion.grp,sincomillas);
  8217. limpiarvar(parametro,1000);
  8218. limpiarvar(nombreparametro,100);
  8219.  
  8220. }else if(!strcmp(nombreparametro,"id"))//------------Reconocio id----------------------------------------------------------------------------------------------
  8221. {
  8222.  
  8223. id=1;
  8224. strcpy(nuevafuncion.id,parametro);
  8225. limpiarvar(parametro,1000);
  8226. limpiarvar(nombreparametro,100);
  8227.  
  8228. }else if(!strcmp(nombreparametro,"unit"))//------------Reconocio unit-------------------------------------------------------------------------------------------------
  8229. {
  8230. unit=2;
  8231. // solo my k valores correctos
  8232. if(parametro[0]=='m' || parametro[0]=='k'||parametro[0]=='M' || parametro[0]=='K'||parametro[0]=='b' || parametro[0]=='B')
  8233. {
  8234. nuevafuncion.unit=parametro[0];
  8235. limpiarvar(parametro,1000);
  8236. limpiarvar(nombreparametro,100);
  8237. }
  8238. else
  8239. {
  8240. unit=0;
  8241. printf("\nError::-> Parametro 'unit' Invalido \n\n");
  8242. ErrorInterprete++;
  8243. }
  8244. }else if(!strcmp(nombreparametro,"fit"))//--------------Reconocio fit-------------------------------------------------------------------------------------------------
  8245. {
  8246. fit=2;
  8247. if(!strcmp(parametro,"bf") || !strcmp(parametro,"ff") || !strcmp(parametro,"wf")||!strcmp(parametro,"BF") || !strcmp(parametro,"FF") || !strcmp(parametro,"WF") )
  8248. {
  8249. strcpy(nuevafuncion.fit,parametro);
  8250. limpiarvar(parametro,1000);
  8251. limpiarvar(nombreparametro,100);
  8252. }
  8253. else
  8254. {
  8255. fit=0;
  8256. printf("\nError::-> Parametro 'fit' Invalido \n\n");
  8257. ErrorInterprete++;
  8258. }
  8259. }else if(!strcmp(nombreparametro,"name"))//---------------Reconocio name--------------------------------------------------------------------------------------------------
  8260. {
  8261.  
  8262. name=1;
  8263. char env[1000];
  8264. strcpy(env,parametro);
  8265. quitarComillas(env);
  8266. strcpy(nuevafuncion.name,sincomillas);
  8267. limpiarvar(parametro,1000);
  8268. limpiarvar(nombreparametro,100);
  8269.  
  8270. }else if(!strcmp(nombreparametro,"fs"))//---------------Reconocio fs--------------------------------------------------------------------------------------------------
  8271. {
  8272.  
  8273. if(!strcmp(parametro,"2fs") || !strcmp(parametro,"3fs"))
  8274. {
  8275. strcpy(nuevafuncion.fs,parametro);
  8276. limpiarvar(parametro,1000);
  8277. limpiarvar(nombreparametro,100);
  8278. fs=1;
  8279. }
  8280. else
  8281. {
  8282. fs=0;
  8283. printf("\nError::-> Parametro 'fs' Invalido \n\n");
  8284. ErrorInterprete++;
  8285. }
  8286.  
  8287. }else if(!strcmp(nombreparametro,"type"))//------------------reconoce type
  8288. {
  8289.  
  8290. type=2;
  8291. if(parametro[0]=='p' || parametro[0]=='e' || parametro[0]=='l'||parametro[0]=='P' || parametro[0]=='E' || parametro[0]=='L'){
  8292. nuevafuncion.type=parametro[0];
  8293. limpiarvar(parametro,1000);
  8294. limpiarvar(nombreparametro,100);
  8295. }else if(!strcmp(parametro,"fast") || !strcmp(parametro,"full")){
  8296.  
  8297. strcpy(nuevafuncion.typeFormatear,parametro);
  8298. limpiarvar(parametro,1000);
  8299. limpiarvar(nombreparametro,100);
  8300. }
  8301. else{
  8302. type=0;
  8303. printf("\nError::-> Parametro 'type' Invalido \n\n");
  8304. ErrorInterprete++;
  8305. }
  8306.  
  8307. }else if(!strcmp(nombreparametro,"delete"))//------------------reconoce delete
  8308. {
  8309. delete_=2;
  8310. if((!strcmp(parametro,"fast")) || (!strcmp(parametro,"full"))||(!strcmp(parametro,"FULL")) || (!strcmp(parametro,"FAST")) )
  8311. {
  8312. strcpy(nuevafuncion.delete_,parametro);
  8313. limpiarvar(parametro,1000);
  8314. limpiarvar(nombreparametro,100);
  8315. }
  8316. else
  8317. {
  8318. delete_=0;
  8319. printf("\nError::-> Parametro 'delete' Invalido \n\n");
  8320. ErrorInterprete++;
  8321. }
  8322. }else if(!strcmp(nombreparametro,"add"))//--------------------reconoce add
  8323. {
  8324. add=2;
  8325. if(CadenaEsNumero(parametro)==0)
  8326. {
  8327. nuevafuncion.add=atoi(parametro);
  8328. limpiarvar(parametro,1000);
  8329. limpiarvar(nombreparametro,100);
  8330. }
  8331. else if(parametro[0]=='-')
  8332. {
  8333.  
  8334. nuevafuncion.add=atoi(parametro)*-1;
  8335. limpiarvar(parametro,1000);
  8336. limpiarvar(nombreparametro,100);
  8337. add=1;
  8338.  
  8339. }
  8340. else{
  8341. printf("\nError::-> Parametro 'add' Invalido\n\n");
  8342. ErrorInterprete++;
  8343. add=0;
  8344. }
  8345. }else{
  8346. printf("Error::-> Parametro Opcional Invalido \n\n");
  8347. ErrorInterprete++;
  8348. }
  8349.  
  8350.  
  8351. }else if(entrada[contador]=='\n'){//--------------------------->Salto de Linea------------------------------------------------------------------------------------------
  8352.  
  8353. }//Fin Salto Linea
  8354. else{ //------------------------------------------------------->SEGUIR AVANZANDO LA CADENA
  8355. contador++;
  8356. }
  8357.  
  8358. }//Fin While Detectar comando
  8359. printf("--------------------Ejecucion Comando-------------------\n");
  8360. printf("Ejecutando comando...\n");
  8361.  
  8362. //Verifica que sea el fin y no Existan errores en el interprete
  8363. if(ErrorInterprete==0 && fin==0){
  8364.  
  8365. if(instruccion!=NULL||instruccion[0]!='\0'){
  8366.  
  8367. if(!strcmp(instruccion,"mkdisk")){//----------------------------->mkdisk--------------------------------------------------------
  8368.  
  8369.  
  8370. printf("////MKDISK////\n");
  8371.  
  8372.  
  8373. if(unit==0){
  8374. printf("Colocando unit megas...\n");
  8375. nuevafuncion.unit='m';
  8376. }else{
  8377.  
  8378. if(nuevafuncion.unit=='b'){
  8379. printf("\nError::-> Unidad no permitida para Mkdisk\n\n");
  8380. printf("Colocando unit megas...\n");
  8381. nuevafuncion.unit='m';
  8382. }else{
  8383. }
  8384. }
  8385. if(fit==0){
  8386. printf("Colocando fit primer ajuste...\n");
  8387. strcpy(nuevafuncion.fit,"FF");
  8388. }
  8389.  
  8390.  
  8391.  
  8392.  
  8393. if(unit==0 && numeroparametros==3 && path==1 && fit==2 && size==1)
  8394. {
  8395. printf("Creando disco...\n\n");
  8396. CrearDisco(nuevafuncion);
  8397. limpiarvar(instruccion,100);
  8398.  
  8399. }
  8400. else if(unit==2 && numeroparametros==4 && path==1 && fit==2 && size==1)
  8401. {
  8402. printf("Creando disco... \n\n");
  8403. CrearDisco(nuevafuncion);
  8404. limpiarvar(instruccion,100);
  8405.  
  8406. }
  8407. else if(unit==2 && numeroparametros==3 && path==1 && fit==0 && size==1)
  8408. {
  8409. printf("Creando disco... \n\n");
  8410. CrearDisco(nuevafuncion);
  8411. limpiarvar(instruccion,100);
  8412.  
  8413. }
  8414. else if(unit==0 && numeroparametros==2 && path==1 && fit==0 && size==1)
  8415. {
  8416. printf("Creando disco... \n\n");
  8417. CrearDisco(nuevafuncion);
  8418. limpiarvar(instruccion,100);
  8419.  
  8420. }
  8421. else
  8422. {
  8423. printf("Error::-> Parametros 'mkdisk' Invalidos\n\n");
  8424. ErrorComando++;
  8425. }
  8426.  
  8427. ContadorInstrucciones++;
  8428. limpiarvar(instruccion,100);
  8429. //fin del mkdisk
  8430. }else if(!strcmp(instruccion,"fdisk")){//------------------------------------------->fdisk-------------------------------------------------------------------
  8431.  
  8432. printf("////FDISK////\n");
  8433.  
  8434. ContadorInstrucciones++;
  8435. if((name==1 && path==1 && delete_==0 && add==0 && size==1) ||(name==1 && path==1 && delete_!=0 && add==0) || (name==1 && path==1 && delete_==0 && add!=0 ) ||(name==1 && path==1 && delete_!=0 && add!=0 && size==1) )
  8436. {
  8437.  
  8438. if(unit==0){
  8439. printf("Colocando unit en kilobytes...\n");
  8440. nuevafuncion.unit='k';
  8441. }
  8442. if(type==0){
  8443. printf("Colocando type primaria...\n");
  8444. nuevafuncion.type='p';
  8445. }
  8446. if(fit==0){
  8447. printf("Colocando fit peor ajuste...\n");
  8448. strcpy(nuevafuncion.fit,"wf");
  8449. }
  8450. /*if(allocation==0){
  8451. printf("Colocando allocation Aleatorio...\n");
  8452. strcpy(nuevafuncion.allocation,"IX");
  8453. }*/
  8454.  
  8455. if(nuevafuncion.unit=='b' || nuevafuncion.unit=='B')
  8456. {
  8457. nuevafuncion.tamano=nuevafuncion.add;
  8458. }else if(nuevafuncion.unit=='k' || nuevafuncion.unit=='K')
  8459. {
  8460. nuevafuncion.tamano=nuevafuncion.add*1024;
  8461. }else
  8462. {
  8463. nuevafuncion.tamano=nuevafuncion.add*(1024*1024);
  8464. }
  8465.  
  8466. if((add==1 && delete_==1)||(add==2 && delete_==2)||(add==1 && delete_==2)||(add==2 && delete_==1))
  8467. {
  8468. printf("\nError::-> Parametros 'fdisk' Invalidos(add y delete estan juntos)\n\n");
  8469. ErrorComando++;
  8470. }else if(add==2 && delete_==0||add==1 && delete_==0){//---------AUMENTAR TAMAÑO
  8471.  
  8472.  
  8473. if(add==2){// agrega espacio
  8474. printf("Aumentando...\n");
  8475. AgregarEspacio(nuevafuncion);
  8476. }else
  8477. if(add==1){ //quita espacio
  8478. printf("Reduciendo...\n");
  8479. QuitarEspacio(nuevafuncion);
  8480.  
  8481. }else{
  8482. printf("\nError::-> Parametros 'fdisk' Invalidos error en add\n\n");
  8483. ErrorComando++;
  8484. }
  8485. limpiarvar(instruccion,100);
  8486. }else if(add==0 && delete_==2){//_----------------------------------->Elimnar Particion-----------------------------------------------
  8487.  
  8488. if(nuevafuncion.type=='p' || nuevafuncion.type=='e'||nuevafuncion.type=='P' || nuevafuncion.type=='E')
  8489. {
  8490. printf("Eliminando Particion...\n");
  8491. EliminarParticion(nuevafuncion);
  8492. limpiarvar(instruccion,100);
  8493.  
  8494. int opcion;
  8495. printf("%s\n", "¿Desea eliminar esta Particion?");
  8496. printf("%s\n", "1.-SI");
  8497. printf("%s\n", "2.-NO");
  8498.  
  8499. printf("%s\n", "");
  8500. printf(">:~$ ");
  8501. scanf("%d",&opcion);
  8502.  
  8503. if(opcion>0 && opcion<3){
  8504.  
  8505. switch(opcion)
  8506. {
  8507. case 1:
  8508. //-----------------------------------------------EliminarParticion(funcion)-----------------------------------------;
  8509.  
  8510. break;
  8511. case 2:
  8512. printf("-------------------------Eliminacion Cancelada-------------------\n");
  8513. break;
  8514. default:
  8515. printf("Error::-> Opcion Incorrecta \n");
  8516. break;
  8517. }
  8518. }else
  8519. {
  8520. opcion=1;
  8521. printf(" \n");
  8522. printf("%s\n", "Error::-> Opcion incorrecta ");
  8523. }
  8524.  
  8525. }
  8526. else
  8527. {
  8528. //--------------------------------------------------EliminarParticionLogica(funcion);
  8529. printf("Eliminando Particion Logica...\n");
  8530. limpiarvar(instruccion,100);
  8531. }
  8532.  
  8533. }else if (add==0 && delete_==0 && size==1){//--------------------------Crear Particion---------------------
  8534.  
  8535. if(nuevafuncion.type=='p' || nuevafuncion.type=='e'||nuevafuncion.type=='P' || nuevafuncion.type=='E')
  8536. {
  8537. printf("Creando Particion...\n\n");
  8538. //--------------------------------------------------CrearParticion(nuevafuncion);
  8539. CrearParticion(nuevafuncion);
  8540. limpiarvar(instruccion,100);
  8541.  
  8542. }
  8543. else
  8544. {
  8545. printf("Creando Particion Logica...\n");
  8546. //--------------------------------------------------CrearParticionLogica(nuevafuncion);
  8547. if(nuevafuncion.unit=='b' || nuevafuncion.unit=='B')
  8548. {
  8549. nuevafuncion.tamano=nuevafuncion.size;
  8550. }else if(nuevafuncion.unit=='k' || nuevafuncion.unit=='K')
  8551. {
  8552. nuevafuncion.tamano=nuevafuncion.size*1024;
  8553. }else
  8554. {
  8555. nuevafuncion.tamano=nuevafuncion.size*(1024*1024);
  8556. }
  8557. CrearParticionLogica(nuevafuncion);
  8558. limpiarvar(instruccion,100);
  8559.  
  8560. }
  8561.  
  8562. }else{
  8563. printf("\nError::-> Crear Particion\n\n");
  8564. ErrorComando++;
  8565.  
  8566. }
  8567.  
  8568.  
  8569. }else{
  8570. printf("\nError::-> Parametros Obligatorios 'fdisk' no ingresados\n\n");
  8571. ErrorComando++;
  8572. }
  8573.  
  8574. }else if(!strcmp(instruccion,"mount")){//--------------------------------------------------------MOUNT-----------------------------------------
  8575. printf("////MOUNT////\n");
  8576. ContadorInstrucciones++;
  8577. //montar una particion del disco en el sistema
  8578. if(path==1 && name==1 && numeroparametros==2 )
  8579. {
  8580. printf("Montando Particion... \n");
  8581. Montura *particion= DeterminarNombre(nuevafuncion);
  8582. if(particion!=NULL)
  8583. {
  8584. montar(particion);
  8585.  
  8586. ContadorComandosExitosos++;
  8587. Recorrer();
  8588. }
  8589.  
  8590. limpiarvar(instruccion,100);
  8591.  
  8592. }else if(numeroparametros!=1)
  8593. {
  8594. printf("\nError::-> Parametros 'Mount' invalidos\n\n");
  8595. ErrorComando++;
  8596. }else{
  8597. printf("\nError::-> Parametros Obligatorios 'Mount' no ingresados\n\n");
  8598. ErrorComando++;
  8599. }
  8600. }else if(!strcmp(instruccion,"logout")){//--------------------------------------------------------LOGOUT-----------------------------------------
  8601. printf("////LOGOUT////\n");
  8602. ContadorInstrucciones++;
  8603. //montar una particion del disco en el sistema
  8604. if(numeroparametros==0 )
  8605. {
  8606. if(logu==0)
  8607. {
  8608. printf("Error::-> No existe usuario logueado\n");
  8609. }else {
  8610. printf("Cerrando sesion...\n");
  8611. logu=0;
  8612. root=0;
  8613. }
  8614.  
  8615.  
  8616. }else{
  8617. printf("\nError::-> Parametros\n\n");
  8618. ErrorComando++;
  8619. }
  8620. }else if(!strcmp(instruccion,"pause")){//--------------------------------------------------------pause-----------------------------------------
  8621. printf("////PAUSA////\n");
  8622. ContadorInstrucciones++;
  8623. //montar una particion del disco en el sistema
  8624. if(numeroparametros==0 )
  8625. {
  8626. char i[50];
  8627. scanf("%s",i);
  8628. scanf("%s",i);
  8629.  
  8630.  
  8631. }else{
  8632. printf("\nError::-> Parametros\n\n");
  8633. ErrorComando++;
  8634. }
  8635. }else if(!strcmp(instruccion,"edit")){//--------------------------------------------------------EDIT-----------------------------------------
  8636. printf("////EDIT////\n");
  8637. ContadorInstrucciones++;
  8638. //montar una particion del disco en el sistema
  8639. if(path==1)
  8640. {
  8641. nuevafuncion.p=p;
  8642. if(logu==0)
  8643. {
  8644. printf("Error::-> No hay usuario logueado\n");
  8645. }else {
  8646. if(1==1)
  8647. {
  8648. if(cont==0)
  8649. {
  8650. if(nuevafuncion.size<0)
  8651. {
  8652. printf("Error::-> Size no puede ser negativo\n");
  8653. }else {
  8654. printf("Creando Archivo...\n");
  8655. ModificarArchivo(nuevafuncion);
  8656. }
  8657. }else {
  8658. ModificarArchivoCont(nuevafuncion);
  8659. }
  8660. }else {
  8661. printf("Error::-> Usuario no tiene permisos\n");
  8662. }
  8663. }
  8664.  
  8665. }else{
  8666. printf("\nError::-> Parametros\n\n");
  8667. ErrorComando++;
  8668. }
  8669. }else if(!strcmp(instruccion,"mkgrp")){//--------------------------------------------------------MKGRP-----------------------------------------
  8670. printf("////MKGRP////\n");
  8671. ContadorInstrucciones++;
  8672. //montar una particion del disco en el sistema
  8673. if(numeroparametros==1 && name==1 )
  8674. {
  8675. if(root==0)
  8676. {
  8677. printf("Error::-> Usuario root no esta logueado\n");
  8678. }else {
  8679. printf("Creando grupo...\n");
  8680. CrearGrupo(nuevafuncion);
  8681. }
  8682.  
  8683.  
  8684. }else{
  8685. printf("\nError::-> Parametros\n\n");
  8686. ErrorComando++;
  8687. }
  8688. }else if(!strcmp(instruccion,"mkfile")){//--------------------------------------------------------MKFILE-----------------------------------------
  8689. printf("////MKFILE////\n");
  8690. ContadorInstrucciones++;
  8691. //montar una particion del disco en el sistema
  8692. if(path==1)
  8693. {
  8694. nuevafuncion.p=p;
  8695. if(logu==0)
  8696. {
  8697. printf("Error::-> No hay usuario logueado\n");
  8698. }else {
  8699. if(1==1)
  8700. {
  8701. if(cont==0)
  8702. {
  8703. if(nuevafuncion.size<0)
  8704. {
  8705. printf("Error::-> Size no puede ser negativo\n");
  8706. }else {
  8707. printf("Creando Archivo...\n");
  8708. CrearArchivo(nuevafuncion);
  8709. }
  8710. }else {
  8711. CrearArchivoCont(nuevafuncion);
  8712. }
  8713. }else {
  8714. printf("Error::-> Usuario no tiene permisos\n");
  8715. }
  8716. }
  8717.  
  8718.  
  8719. }else{
  8720. printf("\nError::-> Parametros\n\n");
  8721. ErrorComando++;
  8722. }
  8723. }else if(!strcmp(instruccion,"rmgrp")){//--------------------------------------------------------RMGRP-----------------------------------------
  8724. printf("////RMGRP////\n");
  8725. ContadorInstrucciones++;
  8726. //montar una particion del disco en el sistema
  8727. if(numeroparametros==1 && name==1 )
  8728. {
  8729. if(root==0)
  8730. {
  8731. printf("Error::-> Usuario root no esta logueado\n");
  8732. }else {
  8733. printf("ELiminando grupo...\n");
  8734. EliminarGrupo(nuevafuncion);
  8735. }
  8736.  
  8737.  
  8738. }else{
  8739. printf("\nError::-> Parametros\n\n");
  8740. ErrorComando++;
  8741. }
  8742. }else if(!strcmp(instruccion,"mkusr")){//--------------------------------------------------------MKUSR-----------------------------------------
  8743. printf("////MKUSR////\n");
  8744. ContadorInstrucciones++;
  8745. //montar una particion del disco en el sistema
  8746. if(numeroparametros==3 && usr==1 && pwd==1 && grp==1 )
  8747. {
  8748. if(root==0)
  8749. {
  8750. printf("Error::-> Usuario root no esta logueado\n");
  8751. }else {
  8752. printf("Creando Usuario...\n");
  8753. CrearUsuario(nuevafuncion);
  8754. }
  8755.  
  8756.  
  8757. }else{
  8758. printf("\nError::-> Parametros\n\n");
  8759. ErrorComando++;
  8760. }
  8761. }else if(!strcmp(instruccion,"mkdir")){//--------------------------------------------------------MKDIR-----------------------------------------
  8762. printf("////MKFILE////\n");
  8763. ContadorInstrucciones++;
  8764. //montar una particion del disco en el sistema
  8765. if(path==1)
  8766. {
  8767. nuevafuncion.p=p;
  8768. if(logu==0)
  8769. {
  8770. printf("Error::-> No hay usuario logueado\n");
  8771. }else {
  8772. if(1==1)
  8773. {
  8774.  
  8775.  
  8776. printf("Creando Archivo...\n");
  8777. CrearDireccion(nuevafuncion);
  8778.  
  8779.  
  8780. }else {
  8781. printf("Error::-> Usuario no tiene permisos\n");
  8782. }
  8783. }
  8784.  
  8785.  
  8786. }else{
  8787. printf("\nError::-> Parametros\n\n");
  8788. ErrorComando++;
  8789. }
  8790. }else if(!strcmp(instruccion,"rmusr")){//--------------------------------------------------------RMUSR-----------------------------------------
  8791. printf("////RMUSR////\n");
  8792. ContadorInstrucciones++;
  8793. //montar una particion del disco en el sistema
  8794. if(numeroparametros==1 && usr==1)
  8795. {
  8796. if(root==0)
  8797. {
  8798. printf("Error::-> Usuario root no esta logueado\n");
  8799. }else {
  8800. printf("Eliminando usuario...\n");
  8801. EliminarUsuario(nuevafuncion);
  8802. }
  8803.  
  8804.  
  8805. }else{
  8806. printf("\nError::-> Parametros\n\n");
  8807. ErrorComando++;
  8808. }
  8809. }else if(!strcmp(instruccion,"mkfs")){//--------------------------------------------------------MKFS-----------------------------------------
  8810. printf("////MKFS////\n");
  8811. ContadorInstrucciones++;
  8812. //formateando particion
  8813. if(id==1)
  8814. {
  8815. if(type==0)
  8816. {
  8817. printf("SE colocara formateo completo\n");
  8818. strcpy(nuevafuncion.typeFormatear,"full");
  8819. }
  8820. if(fs==0)
  8821. {
  8822. printf("Se colocara ext2\n");
  8823. strcpy(nuevafuncion.fs,"2fs");
  8824. }
  8825. formatearParticion(nuevafuncion);
  8826. }else {
  8827. printf("\nError::-> Parametros Obligatorios 'mkfs' no ingresados\n\n");
  8828. ErrorComando++;
  8829. }
  8830.  
  8831. }else if(!strcmp(instruccion,"login")){//--------------------------------------------------------LOGIN-----------------------------------------
  8832. printf("////LOGIN////\n");
  8833. ContadorInstrucciones++;
  8834. //formateando particion
  8835. if(usr==1 && pwd==1 && id==1)
  8836. {
  8837. Login(nuevafuncion);
  8838. }else {
  8839. printf("\nError::-> Parametros Obligatorios 'login' no ingresados\n\n");
  8840. ErrorComando++;
  8841. }
  8842.  
  8843.  
  8844. }else if(!strcmp(instruccion,"rem")){//--------------------------------------------------------REM-----------------------------------------
  8845. printf("////REM////\n");
  8846. ContadorInstrucciones++;
  8847. if(path==1)
  8848. {
  8849. EliminarArchivoCarpeta(nuevafuncion);
  8850. }else {
  8851. printf("\nError::-> Parametros Obligatorios 'rem' no ingresados\n\n");
  8852. ErrorComando++;
  8853. }
  8854.  
  8855.  
  8856. }else if(!strcmp(instruccion,"ren")){//--------------------------------------------------------REN-----------------------------------------
  8857. printf("////REN////\n");
  8858. ContadorInstrucciones++;
  8859. if(path==1)
  8860. {
  8861. CambiarNombre(nuevafuncion);
  8862. }else {
  8863. printf("\nError::-> Parametros Obligatorios 'ren' no ingresados\n\n");
  8864. ErrorComando++;
  8865. }
  8866.  
  8867.  
  8868. }else if(!strcmp(instruccion,"mv")){//--------------------------------------------------------MV-----------------------------------------
  8869. printf("////MV////\n");
  8870. ContadorInstrucciones++;
  8871. if(path==1 && dest==1)
  8872. {
  8873. Cortar(nuevafuncion);
  8874. }else {
  8875. printf("\nError::-> Parametros Obligatorios 'ren' no ingresados\n\n");
  8876. ErrorComando++;
  8877. }
  8878.  
  8879.  
  8880. }else if(!strcmp(instruccion,"loss")){//--------------------------------------------------------LOSS-----------------------------------------
  8881. printf("////LOSS////\n");
  8882. Loss();
  8883. }else if(!strcmp(instruccion,"recovery")){//--------------------------------------------------------RECOVERY-----------------------------------------
  8884. printf("////RECOVERY////\n");
  8885. Recovery();
  8886. }else if(!strcmp(instruccion,"unmount")){//--------------------------------------------------------UNMOUNT-----------------------------------------
  8887. printf("////UNMOUNT////\n");
  8888. ContadorInstrucciones++;
  8889. //montar una particion del disco en el sistema
  8890. if(id==1 && numeroparametros==1 )
  8891. {
  8892. printf("Desmontando Particion... \n");
  8893. desmontar(nuevafuncion);
  8894. ContadorComandosExitosos++;
  8895. Recorrer();
  8896. limpiarvar(instruccion,100);
  8897.  
  8898. }else if(numeroparametros!=1)
  8899. {
  8900. printf("\nError::-> Parametros 'Unmount' invalidos\n\n");
  8901. ErrorComando++;
  8902. }else{
  8903. printf("\nError::-> Parametros Obligatorios 'Mount' no ingresados\n\n");
  8904. ErrorComando++;
  8905. }
  8906. }else if(!strcmp(instruccion,"rmdisk")){//--------------------------------------------------------RMDISK-----------------------------------------
  8907. printf("////RMDISK////\n");
  8908. ContadorInstrucciones++;
  8909. //eliminar archivo que representa a un disco duro
  8910. if(path==1 && numeroparametros==1 )
  8911. {
  8912. printf("Eliminando representacion de disco... \n");
  8913. ELiminarDisco(nuevafuncion);
  8914. limpiarvar(instruccion,100);
  8915.  
  8916. }else if(numeroparametros!=1)
  8917. {
  8918. printf("\nError::-> Parametros 'Rmdisk' invalidos\n\n");
  8919. ErrorComando++;
  8920. }
  8921. else{
  8922. printf("\nError::-> Parametros Obligatorios 'Mount' no ingresados\n\n");
  8923. ErrorComando++;
  8924. }
  8925. }else if(!strcmp(instruccion,"cat")){//--------------------------------------------------------CAT-----------------------------------------
  8926. printf("////CAT////\n");
  8927. ContadorInstrucciones++;
  8928. //eliminar archivo que representa a un disco duro
  8929. if(Files>0)
  8930. {
  8931. printf("Mostrando archivos... \n");
  8932. MostrarCat(nuevafuncion,Files);
  8933. limpiarvar(instruccion,100);
  8934.  
  8935. }
  8936. else{
  8937. printf("\nError::-> No se ingreso ninguna direccion\n\n");
  8938. ErrorComando++;
  8939. }
  8940. }else if(!strcmp(instruccion,"exec")){//--------------------------------------------------------exec-----------------------------------------
  8941. printf("////EXEC////\n");
  8942. ContadorInstrucciones++;
  8943. //eliminar archivo que representa a un disco duro
  8944. if(path==1 && numeroparametros==1 )
  8945. {
  8946. printf("Ejecuando script... \n");
  8947. Exec(nuevafuncion);
  8948. limpiarvar(instruccion,100);
  8949.  
  8950. }else if(numeroparametros!=1)
  8951. {
  8952. printf("\nError::-> Parametros 'exec' invalidos\n\n");
  8953. ErrorComando++;
  8954. }
  8955. else{
  8956. printf("\nError::-> Parametros Obligatorios 'exec' no ingresados\n\n");
  8957. ErrorComando++;
  8958. }
  8959. }else if(!strcmp(instruccion,"rep")){//--------------------------------------------------------rep-----------------------------------------
  8960. printf("////REP////\n");
  8961. ContadorInstrucciones++;
  8962. //eliminar archivo que representa a un disco duro
  8963. if(path==1 && name==1 && id==1)
  8964. {
  8965. if(!strcmp(nuevafuncion.name,"mbr"))
  8966. {
  8967. printf("Generando Reporte MBR... \n");
  8968. Graficar(nuevafuncion);
  8969. }
  8970. else if(!strcmp(nuevafuncion.name,"disk"))
  8971. {
  8972. printf("Generando Reporte Disk...\n");
  8973. Graficar2(nuevafuncion);
  8974. }
  8975.  
  8976. else if(!strcmp(nuevafuncion.name,"inode"))
  8977. {
  8978. printf("Generando Reporte Inodos...\n");
  8979. GraficarInodos(nuevafuncion);
  8980. }
  8981.  
  8982. else if(!strcmp(nuevafuncion.name,"journaling"))
  8983. {
  8984. printf("Generando Reporte Journal...\n");
  8985. GraficarJournal(nuevafuncion);
  8986. }
  8987.  
  8988. else if(!strcmp(nuevafuncion.name,"block"))
  8989. {
  8990. printf("Generando Reporte bloques...\n");
  8991. GraficarBloques(nuevafuncion);
  8992. }
  8993.  
  8994. else if(!strcmp(nuevafuncion.name,"bm_inode"))
  8995. {
  8996. printf("Generando Reporte bm_inode... \n");
  8997. GraficarBitInodo(nuevafuncion);
  8998. }
  8999.  
  9000. else if(!strcmp(nuevafuncion.name,"bm_block"))
  9001. {
  9002. printf("Generando Reporte bm_block... \n");
  9003. GraficarBitBloque(nuevafuncion);
  9004. }
  9005.  
  9006. else if(!strcmp(nuevafuncion.name,"tree"))
  9007. {
  9008. printf("Generando Reporte tree... \n");
  9009. GraficarTree(nuevafuncion);
  9010. }
  9011.  
  9012. else if(!strcmp(nuevafuncion.name,"sb"))
  9013. {
  9014. printf("Generando Reporte SB... \n");
  9015. GraficarSB(nuevafuncion);
  9016. }
  9017.  
  9018. else if(!strcmp(nuevafuncion.name,"file"))
  9019. {
  9020. printf("Generando Reporte file... \n");
  9021. GraficarFile(nuevafuncion);
  9022. }
  9023.  
  9024. else if(!strcmp(nuevafuncion.name,"ls"))
  9025. {
  9026.  
  9027. }else {
  9028. printf("Error::-> Nombre imcorrecto");
  9029. }
  9030. limpiarvar(instruccion,100);
  9031.  
  9032.  
  9033.  
  9034. }
  9035. else{
  9036. printf("\nError::-> Parametros Obligatorios 'rep' no ingresados\n\n");
  9037. ErrorComando++;
  9038. }
  9039. }else{
  9040. printf("\nError::-> Instruccion no encontrada \n\n");
  9041. ErrorInterprete++;
  9042. }
  9043.  
  9044. }
  9045.  
  9046. }else{
  9047. printf("\nError-> Fallo en el interprete\n");
  9048. //printf("\n ->Errores Encontrados En Interprete : '%i' \n", ErrorInterprete);
  9049. }
  9050.  
  9051.  
  9052. }
  9053.  
  9054. int menu_principal (){
  9055.  
  9056. char comando[150];
  9057. printf("%s\n", "________________________________________________________");
  9058. printf(" %s\n", "PROYECTO NO. 1/ FASE NO. 1");
  9059. printf("%s\n", "________________________________________________________");
  9060. printf("%s\n", "");
  9061. printf("%s\n", "");
  9062. printf(">:~$ ");
  9063. while(strcmp(comando,"salir")!=0)
  9064. {
  9065. scanf(" %[^\n]", comando);
  9066. comentario=0;
  9067. fin=0;
  9068. ErrorInterprete=0;
  9069.  
  9070. printf("--------------------------------------------------------\n");
  9071.  
  9072. printf("%s\n", "");
  9073. printf("%s\n", "");
  9074. printf("Linea ->%s\n",comando);
  9075.  
  9076.  
  9077. Interprete(comando);
  9078.  
  9079.  
  9080.  
  9081.  
  9082. /*----------------------------------------------------------------------*/
  9083.  
  9084.  
  9085.  
  9086. }
  9087.  
  9088.  
  9089. }
  9090.  
  9091.  
  9092. int main()
  9093. {
  9094. ContadorInstrucciones=0;
  9095. ContadorComandosExitosos=0;
  9096. logu=0;
  9097. ErrorInterprete=0;
  9098. ErrorComando=0;
  9099. ErrorCrearDisco=0;
  9100. ErrorEliminarDisco=0;
  9101. ErrorCrearParticion=0;
  9102. ErrorEliminarParticion=0;
  9103. ErrorCrearParticionLogica=0;
  9104. ErrorEliminarLogica=0;
  9105. ErrorReporte1=0;
  9106. ErrorReporte2=0;
  9107. comentario=0;
  9108.  
  9109. int fin=0;
  9110.  
  9111. sincomillas[1000];// se usa en el Metodo quitarComillas
  9112.  
  9113. sistema = (Lista*)malloc(sizeof (Lista));
  9114. sistema->primero=NULL;
  9115. sistema->ultimo=NULL;
  9116. //inicia El lanzador del programa
  9117. menu_principal();
  9118. printf("No. Instrucciones -> %d\n",ContadorInstrucciones);
  9119. printf("No. Comandos Existosos -> %d\n",ContadorComandosExitosos);
  9120.  
  9121. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!