API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 22nd, 2019
107
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 118.79 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. int ContadorInstrucciones;
  8. int ContadorComandosExitosos;
  9.  
  10. int ErrorInterprete;
  11. int ErrorComando;
  12. int ErrorCrearDisco;
  13. int ErrorEliminarDisco;
  14. int ErrorCrearParticion;
  15. int ErrorEliminarParticion;
  16. int ErrorCrearParticionLogica;
  17. int ErrorEliminarLogica;
  18. int ErrorReporte1;
  19. int ErrorReporte2;
  20.  
  21.  
  22.  
  23. int comentario;
  24.  
  25. int fin=0;
  26.  
  27. char sincomillas[1000];// se usa en el Metodo quitarComillas
  28.  
  29. typedef struct
  30. {
  31.  
  32. int esnuevonodo;
  33. char nombre[100];
  34. char name2[100];
  35. int contador;
  36. char nombreparametro[100];
  37. char parametro[100];
  38. int size;
  39. char size2[100];
  40. char unit;
  41. char path[100];
  42. char type;
  43. char typeFormatear[100];
  44. char delete_[100];
  45. char name[100];
  46. char Contenido[1000];
  47. char id[100];
  48. char fileid[100];
  49. int add;
  50. char fit[30];
  51. char allocation[100];
  52. char idvector[6];
  53. int p;
  54. char fs[100];
  55. int tamano;
  56. char count[100];
  57. int count2;
  58.  
  59. }Funcion;
  60.  
  61. typedef struct
  62. {
  63. char part_status;
  64. char part_type;
  65. char part_fit[3];
  66. int part_start;
  67. int part_size;
  68. char part_name[16];
  69.  
  70. }Particion;
  71. typedef struct
  72. {
  73. char part_status;
  74. char part_type;
  75. char part_fit[3];
  76. int part_start;
  77. int part_size;
  78. int part_next;
  79. char part_name[16];
  80.  
  81. }EBR;
  82. struct retorno
  83. {
  84. int disco;
  85. int particion;
  86. };
  87. typedef struct retorno Retorno;
  88.  
  89. struct montura
  90. {
  91. char path[100];
  92. char name[15];
  93. char nombre[15];
  94. struct montura *siguiente;
  95. };
  96. typedef struct montura Montura;
  97.  
  98. struct lista
  99. {
  100. struct montura *primero;
  101. struct montura *ultimo;
  102. };
  103. typedef struct lista Lista;
  104.  
  105. struct bloque
  106. {
  107. int inicio;
  108. int fin;
  109. int tamano;
  110. struct bloque *siguiente;
  111. struct bloque *anterior;
  112. };
  113. typedef struct bloque Bloque;
  114.  
  115. struct espacios
  116. {
  117. struct bloque *primero;
  118. struct bloque *ultimo;
  119. };
  120. typedef struct espacios Espacios;
  121.  
  122. Lista *sistema;
  123.  
  124.  
  125. typedef struct
  126. {
  127. int mbr_tamano;
  128. char mbr_fecha_creacion[25];
  129. int mbr_disk_signature;
  130. char mbr_fit[3];
  131. Particion particiones[4];
  132. int cantParticones;
  133.  
  134. }MbrDisco;
  135. MbrDisco mbrG;
  136. MbrDisco *BuscarDisco(Funcion funcion)
  137. {
  138. int bandera =0;
  139. Montura *pivote=sistema->primero;
  140. while (pivote!=NULL) {
  141. if(!strcmp(funcion.id,pivote->name))
  142. {
  143. printf("Se encontro la particion montada\n");
  144.  
  145. FILE *fp;
  146. fp = fopen(pivote->path, "rb");
  147.  
  148. if(fp == NULL)
  149. {
  150. printf("\n Error::-> No se encontro el disco\n");
  151. }else {
  152. fread(&mbrG, sizeof(MbrDisco), 1, fp);
  153. fclose(fp);
  154. return &mbrG;
  155. }
  156.  
  157. bandera=1;
  158. break;
  159. }
  160. pivote=pivote->siguiente;
  161. }
  162. if(bandera==0)
  163. {
  164. printf("No se encotro ninguna particion montada con ese nombre\n");
  165. return NULL;
  166. }
  167. }
  168.  
  169. MbrDisco BuscarDisco2(Funcion funcion)
  170. {
  171. FILE *fp;
  172. fp = fopen(funcion.path, "rb");
  173.  
  174. if(fp == NULL)
  175. {
  176. printf("\n Error::-> No se encontro el disco\n");
  177. }else {
  178. fread(&mbrG, sizeof(MbrDisco), 1, fp);
  179. fclose(fp);
  180. return mbrG;
  181. }
  182.  
  183. }
  184.  
  185. void Graficar2(Funcion funcion)
  186. {
  187. MbrDisco *mbr=BuscarDisco(funcion);
  188. if(mbr!=NULL)
  189. {
  190. char dot[100]="\0";
  191. char pathauxiliar[200];
  192. char pathauxiliar2[200];
  193. strcpy(pathauxiliar,funcion.path);
  194. int q=0;
  195. while(pathauxiliar[q]!='.')
  196. {
  197. char nuevoCaracter[1];
  198. nuevoCaracter[0]=pathauxiliar[q];
  199. strncat(pathauxiliar2,nuevoCaracter,1);
  200. q++;
  201. }
  202. strcat(pathauxiliar2,".dot");
  203.  
  204.  
  205. printf("%s\n",funcion.path);
  206. printf("%s\n",pathauxiliar2);
  207.  
  208. char finalizado[500];
  209. strcpy(finalizado,"cd /\n");
  210. int indice=0;
  211. char carpeta[500];
  212.  
  213. while(funcion.path[indice]!='.')
  214. {
  215. if(funcion.path[indice]!='/')
  216. {
  217.  
  218. char nuevoCaracter[1];
  219. nuevoCaracter[0]=funcion.path[indice];
  220. strncat(carpeta,nuevoCaracter,1);
  221. }
  222. else
  223. {
  224. if(carpeta[0]!='\0')
  225. {
  226. strcat(finalizado,"mkdir ");
  227. strcat(finalizado,"\"");
  228. strcat(finalizado,carpeta);
  229. strcat(finalizado,"\"");
  230. strcat(finalizado,"\n");
  231. strcat(finalizado,"cd ");
  232. strcat(finalizado,"\"");
  233. strcat(finalizado,carpeta);
  234. strcat(finalizado,"\"");
  235. strcat(finalizado,"\n");
  236. strcat(carpeta,"");
  237.  
  238. }
  239. limpiarvar(carpeta,500);
  240.  
  241. }
  242. indice++;
  243. }
  244.  
  245.  
  246. printf("\n%s\n",finalizado);
  247.  
  248. system(finalizado);
  249.  
  250. int num;
  251. FILE *fptr;
  252. fptr = fopen(pathauxiliar2,"w");
  253.  
  254. if(fptr == NULL)
  255. {
  256. printf("Error!");
  257. }
  258.  
  259. fprintf(fptr,"digraph G{\n");
  260. fprintf(fptr,"aHtmlTable[");
  261. fprintf(fptr,"shape=plaintext ");
  262. fprintf(fptr,"color=\"#2471a3\" ");
  263. fprintf(fptr,"label=<\n");
  264. fprintf(fptr,"<table border=\"2px\">\n");
  265. fprintf(fptr,"<tr>\n");
  266. fprintf(fptr,"<td rowspan=\"2\">MBR</td>\n");
  267. int a[4];
  268. int n=0;
  269. for (int i=0;i<4;i++) {
  270. if(mbr->particiones[i].part_status=='1')
  271. {
  272. a[i]=mbr->particiones[i].part_start;
  273. n++;
  274. }
  275. }
  276.  
  277. int i,j,aux;
  278. for(i=0;i<n;i++)
  279. {
  280. printf("%d,",a[i]);
  281. }
  282. printf("\n");
  283. for(i=0;i<=n;i++){
  284. for(j=0;j<n-1;j++){
  285. if(a[j]>a[j+1]){
  286. aux=a[j];
  287. a[j]=a[j+1];
  288. a[j+1]=aux;
  289. }
  290. }
  291. }
  292. printf("\n");
  293. for(i=0;i<n;i++)
  294. {
  295. printf("%d,",a[i]);
  296. }
  297. printf("\n");
  298. for (int j=0;j<4;j++) {
  299. for (int i=0;i<4;i++) {
  300.  
  301. if(a[j]==mbr->particiones[i].part_start)
  302. {
  303. printf("Espacio-> %d\n",a[j]);
  304. int AntVacio=0;
  305. int Ant=0;
  306. int SigVacio=0;
  307. int Sig=0;
  308. if(j!=0)
  309. {
  310. for (int i=0;i<4;i++) {
  311. if(a[j-1]==mbr->particiones[i].part_start)
  312. {
  313. Ant=i;
  314. AntVacio=1;
  315. break;
  316. }
  317. }
  318.  
  319. }
  320. int Sigvaci=0;
  321. int sigui=0;
  322. if(j!=3)
  323. {
  324. for (int i=0;i<4;i++) {
  325. if(a[j+1]==mbr->particiones[i].part_start)
  326. {
  327. Sig=i;
  328. SigVacio=1;
  329. break;
  330. }
  331. }
  332.  
  333. }
  334. if(j==0)
  335. {
  336. printf("Entre principio y primero\n");
  337. printf("Inicio %d\n",1);
  338. printf("Fin %d\n",mbr->particiones[i].part_start);
  339. double a=mbr->particiones[i].part_start;
  340. double b=1;
  341. double c=mbr->mbr_tamano;
  342. double po= ((a-b)/c)*100;
  343. if(po>0)
  344. {
  345.  
  346. fprintf(fptr,"<td rowspan=\"2\">Libre <br/>%.2f%%</td>\n",po);
  347. }
  348.  
  349. if((mbr->particiones[i].part_type=='p'||mbr->particiones[i].part_type=='P') && mbr->particiones[i].part_status=='1')
  350. {
  351. double b=mbr->particiones[i].part_size;
  352. double c=mbr->mbr_tamano;
  353. double po=(b/c)*100;
  354. fprintf(fptr,"<td rowspan=\"2\">Primaria <br/>%.2f%%</td>\n",po);
  355. }
  356. else if((mbr->particiones[i].part_type=='e'||mbr->particiones[i].part_type=='E') && mbr->particiones[i].part_status=='1')
  357. {
  358. double b=mbr->particiones[i].part_size;
  359. double c=mbr->mbr_tamano;
  360. double po=(b/c)*100;
  361. fprintf(fptr,"<td rowspan=\"1\">Extendida <br/>%.2f%%o</td>\n",po);
  362. }
  363. if(SigVacio==0)
  364. {
  365. printf("Primero y final\n");
  366. printf("Inicio %d\n",mbr->particiones[i].part_start+mbr->particiones[i].part_size);
  367. printf("Fin %d\n",mbr->mbr_tamano);
  368. double a=mbr->mbr_tamano;
  369. double b=mbr->particiones[i].part_start+mbr->particiones[i].part_size;
  370. double c=mbr->mbr_tamano;
  371. double po= ((a-b)/c)*100;
  372. if(po>0)
  373. {
  374.  
  375. fprintf(fptr,"<td rowspan=\"2\">Libre <br/>%.2f%%</td>\n",po);
  376. }
  377. }
  378.  
  379. }
  380. else
  381. {
  382. printf("Entre %d y %d\n",j,j+1);
  383. printf("Inicio %d\n",mbr->particiones[Ant].part_start+mbr->particiones[Ant].part_size);
  384. printf("Fin %d\n",mbr->particiones[i].part_start);
  385. double a=mbr->particiones[i].part_start;
  386. double b=mbr->particiones[Ant].part_start+mbr->particiones[Ant].part_size;
  387. double c=mbr->mbr_tamano;
  388. double po= ((a-b)/c)*100;
  389. if(po>0)
  390. {
  391.  
  392. fprintf(fptr,"<td rowspan=\"2\">Libre <br/>%.2f%%</td>\n",po);
  393. }
  394.  
  395. if((mbr->particiones[i].part_type=='p'||mbr->particiones[i].part_type=='P') && mbr->particiones[i].part_status=='1')
  396. {
  397. double b=mbr->particiones[i].part_size;
  398. double c=mbr->mbr_tamano;
  399. double po=(b/c)*100;
  400. fprintf(fptr,"<td rowspan=\"2\">Primaria <br/>%.2f%%</td>\n",po);
  401. }
  402. else if((mbr->particiones[i].part_type=='e'||mbr->particiones[i].part_type=='E') && mbr->particiones[i].part_status=='1')
  403. {
  404. double b=mbr->particiones[i].part_size;
  405. double c=mbr->mbr_tamano;
  406. double po=(b/c)*100;
  407. fprintf(fptr,"<td rowspan=\"1\">Extendida <br/>%.2f%%</td>\n",po);
  408. }
  409. if(SigVacio==0)
  410. {
  411. printf("%d y final\n",j);
  412. printf("Inicio %d\n",mbr->particiones[i].part_start+mbr->particiones[i].part_size);
  413. printf("Fin %d\n",mbr->mbr_tamano);
  414. double a=mbr->mbr_tamano;
  415. double b=mbr->particiones[i].part_start+mbr->particiones[i].part_size;
  416. double c=mbr->mbr_tamano;
  417. double po= ((a-b)/c)*100;
  418. if(po>0)
  419. {
  420.  
  421. fprintf(fptr,"<td rowspan=\"2\">Libre <br/>%.2f%%</td>\n",po);
  422. }
  423. }
  424.  
  425. }
  426.  
  427.  
  428. break;
  429.  
  430.  
  431. }
  432. }
  433. }
  434.  
  435.  
  436. fprintf(fptr,"</tr>\n");
  437. fprintf(fptr," <tr>\n");
  438. fprintf(fptr," <td>EBR</td>\n");
  439. fprintf(fptr," </tr>\n");
  440.  
  441.  
  442.  
  443. fprintf(fptr,"</table>\n");
  444. fprintf(fptr,">];\n");
  445.  
  446.  
  447. fprintf(fptr,"}\n");
  448. fclose(fptr);
  449. strcat(dot,"dot -Tpng ");
  450. strcat(dot,pathauxiliar2);
  451. strcat(dot," -o ");
  452. strcat(dot,funcion.path);
  453. printf("%s\n",dot);
  454. system(dot);
  455. ContadorComandosExitosos++;
  456. limpiarvar(funcion.path,100);
  457. limpiarvar(pathauxiliar2,100);
  458. }else {
  459. printf("Error::-> Generar reporte\n");
  460. }
  461. }
  462.  
  463.  
  464. void Graficar(Funcion funcion)
  465. {
  466. MbrDisco *mbr=BuscarDisco(funcion);
  467. if(mbr!=NULL)
  468. {
  469. char dot[100]="\0";
  470. char pathauxiliar[200];
  471. char pathauxiliar2[200];
  472. strcpy(pathauxiliar,funcion.path);
  473. int q=0;
  474. while(pathauxiliar[q]!='.')
  475. {
  476. char nuevoCaracter[1];
  477. nuevoCaracter[0]=pathauxiliar[q];
  478. strncat(pathauxiliar2,nuevoCaracter,1);
  479. q++;
  480. }
  481. strcat(pathauxiliar2,".dot");
  482.  
  483.  
  484. printf("%s\n",funcion.path);
  485. printf("%s\n",pathauxiliar2);
  486.  
  487. char finalizado[500];
  488. strcpy(finalizado,"cd /\n");
  489. int indice=0;
  490. char carpeta[500];
  491.  
  492. while(funcion.path[indice]!='.')
  493. {
  494. if(funcion.path[indice]!='/')
  495. {
  496.  
  497. char nuevoCaracter[1];
  498. nuevoCaracter[0]=funcion.path[indice];
  499. strncat(carpeta,nuevoCaracter,1);
  500. }
  501. else
  502. {
  503. if(carpeta[0]!='\0')
  504. {
  505. strcat(finalizado,"mkdir ");
  506. strcat(finalizado,"\"");
  507. strcat(finalizado,carpeta);
  508. strcat(finalizado,"\"");
  509. strcat(finalizado,"\n");
  510. strcat(finalizado,"cd ");
  511. strcat(finalizado,"\"");
  512. strcat(finalizado,carpeta);
  513. strcat(finalizado,"\"");
  514. strcat(finalizado,"\n");
  515. strcat(carpeta,"");
  516.  
  517. }
  518. limpiarvar(carpeta,500);
  519.  
  520. }
  521. indice++;
  522. }
  523.  
  524.  
  525. printf("\n%s\n",finalizado);
  526.  
  527. system(finalizado);
  528.  
  529. int num;
  530. FILE *fptr;
  531. fptr = fopen(pathauxiliar2,"w");
  532.  
  533. if(fptr == NULL)
  534. {
  535. printf("Error!");
  536. }
  537.  
  538.  
  539. fprintf(fptr,"digraph G{\n");
  540. fprintf(fptr,"aHtmlTable[");
  541. fprintf(fptr,"shape=plaintext ");
  542. fprintf(fptr,"color=\"#2471a3\" ");
  543. fprintf(fptr,"label=<\n");
  544. fprintf(fptr,"<table border='1' cellborder='1'>\n");
  545. fprintf(fptr,"<tr>\n");
  546. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> NOMBRE </td>\n");
  547. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> VALOR </td>\n");
  548. fprintf(fptr,"</tr>\n");
  549. fprintf(fptr,"<tr>\n");
  550. fprintf(fptr,"<td> mbr_tamano</td>\n");
  551. fprintf(fptr,"<td>");
  552. fprintf(fptr,"%d", mbr->mbr_tamano);
  553. fprintf(fptr,"</td>\n");
  554. fprintf(fptr,"</tr>\n");
  555. fprintf(fptr,"<tr>\n");
  556. fprintf(fptr,"<td> mbr_fecha_creacion </td>\n");
  557. fprintf(fptr,"<td>");
  558. fprintf(fptr,"%s", mbr->mbr_fecha_creacion);
  559. fprintf(fptr,"</td>\n");
  560. fprintf(fptr,"</tr>\n");
  561. fprintf(fptr,"<tr>\n");
  562. fprintf(fptr,"<td> mbr_disk_signature </td>\n");
  563. fprintf(fptr,"<td>");
  564. fprintf(fptr,"%d", mbr->mbr_disk_signature);
  565. fprintf(fptr,"</td>\n");
  566. fprintf(fptr,"</tr>\n");
  567. fprintf(fptr,"<tr>\n");
  568. fprintf(fptr,"<td> Disk_fit </td>\n");
  569. fprintf(fptr,"<td>");
  570. fprintf(fptr,"%s", mbr->mbr_fit);
  571. fprintf(fptr,"</td>\n");
  572. fprintf(fptr,"</tr>\n");
  573. int a[4];
  574. int n=0;
  575. for (int i=0;i<4;i++) {
  576. if(mbr->particiones[i].part_status=='1')
  577. {
  578. a[i]=mbr->particiones[i].part_start;
  579. n++;
  580. }
  581. }
  582.  
  583. int i,j,aux;
  584. for(i=0;i<n;i++)
  585. {
  586. printf("%d,",a[i]);
  587. }
  588. printf("%d\n");
  589. for(i=0;i<=n;i++){
  590. for(j=0;j<n-1;j++){
  591. if(a[j]>a[j+1]){
  592. aux=a[j];
  593. a[j]=a[j+1];
  594. a[j+1]=aux;
  595. }
  596. }
  597. }
  598. for(i=0;i<n;i++)
  599. {
  600. printf("%d,",a[i]);
  601. }
  602. printf("%d\n",a[i]);
  603. int e=-1;
  604. for (int j=0;j<4;j++) {
  605. for (int i=0;i<4;i++) {
  606. if(a[j]==mbr->particiones[i].part_start)
  607. {
  608. if(mbr->particiones[i].part_type=='E' || mbr->particiones[i].part_type=='e')
  609. {
  610. e=i;
  611. }
  612. fprintf(fptr,"<tr>\n");
  613. fprintf(fptr,"<td colspan=\"2\" bgcolor=\"#d6dbdf\"> Particion No.%d </td>\n",j+1);
  614. fprintf(fptr,"</tr>\n");
  615. fprintf(fptr,"<tr>\n");
  616. fprintf(fptr,"<td> part_status_%d </td>\n",j+1);
  617. fprintf(fptr,"<td>");
  618. fprintf(fptr,"%c", mbr->particiones[i].part_status);
  619. fprintf(fptr,"</td>\n");
  620. fprintf(fptr,"</tr>\n");
  621. fprintf(fptr,"<tr>\n");
  622. fprintf(fptr,"<td> part_type_%d </td>\n",j+1);
  623. fprintf(fptr,"<td>");
  624. fprintf(fptr,"%c", mbr->particiones[i].part_type);
  625. fprintf(fptr,"</td>\n");
  626. fprintf(fptr,"</tr>\n");
  627. fprintf(fptr,"<tr>\n");
  628. fprintf(fptr,"<td> part_fit_%d </td>\n",j+1);
  629. fprintf(fptr,"<td>");
  630. fprintf(fptr,"%s", mbr->particiones[i].part_fit);
  631. fprintf(fptr,"</td>\n");
  632. fprintf(fptr,"</tr>\n");
  633. fprintf(fptr,"<tr>\n");
  634. fprintf(fptr,"<td> part_start_%d </td>\n",j+1);
  635. fprintf(fptr,"<td>");
  636. fprintf(fptr,"%d", mbr->particiones[i].part_start);
  637. fprintf(fptr,"</td>\n");
  638. fprintf(fptr,"</tr>\n");
  639. fprintf(fptr,"<tr>\n");
  640. fprintf(fptr,"<td> part_size_%d </td>\n",j+1);
  641. fprintf(fptr,"<td>");
  642. fprintf(fptr,"%d", mbr->particiones[i].part_size);
  643. fprintf(fptr,"</td>\n");
  644. fprintf(fptr,"</tr>\n");
  645. fprintf(fptr,"<tr>\n");
  646. fprintf(fptr,"<td> part_name_%d </td>\n",j+1);
  647. fprintf(fptr,"<td>");
  648. fprintf(fptr,"%s", mbr->particiones[i].part_name);
  649. fprintf(fptr,"</td>\n");
  650. fprintf(fptr,"</tr>\n");
  651. break;
  652. }
  653. }
  654.  
  655. }
  656. if(e!=-1)
  657. {
  658. char path[50];
  659. Montura *pivote=sistema->primero;
  660. while (pivote!=NULL) {
  661. if(!strcmp(funcion.id,pivote->name))
  662. {
  663. int l=0;
  664. for(int k=0;k<50;k++)
  665. {
  666. path[l++]=pivote->path[k];
  667. }
  668. break;
  669. }
  670. pivote=pivote->siguiente;
  671. }
  672. printf("%s\n",path);
  673.  
  674. EBR lec;
  675. int inicio= mbr->particiones[e].part_start;
  676. FILE *fp = fopen(path, "rb");
  677. printf("Inicio %d\n",inicio+sizeof (MbrDisco));
  678. fseek(fp,inicio+sizeof (MbrDisco),SEEK_SET);
  679.  
  680. if(fp == NULL)
  681. {
  682. printf("\n Error::-> No se encontro el disco\n");
  683. }else {
  684. fread(&lec, sizeof(EBR), 1, fp);
  685. fclose(fp);
  686. }
  687. printf("Siguiente %d\n",lec.part_next);
  688. int siguiente=lec.part_next;
  689. EBR sig;
  690. int contador=0;
  691. while (siguiente!=-1) {
  692. if(contador==0)
  693. {
  694. fprintf(fptr,"<tr>\n");
  695. fprintf(fptr,"<td colspan=\"2\" bgcolor=\"#d6dbdf\"> EBR </td>\n");
  696. fprintf(fptr,"</tr>\n");
  697.  
  698. }
  699. fp = fopen(path, "rb");
  700. fseek(fp,siguiente,SEEK_SET);
  701.  
  702. if(fp == NULL)
  703. {
  704. printf("\n Error::-> No se encontro el disco\n");
  705. }else {
  706. fread(&sig, sizeof(EBR), 1, fp);
  707. fclose(fp);
  708. }
  709.  
  710. fprintf(fptr,"<tr>\n");
  711. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> NOMBRE </td>\n");
  712. fprintf(fptr,"<td bgcolor=\" #5d6d7e \"> VALOR </td>\n");
  713. fprintf(fptr,"</tr>\n");
  714. fprintf(fptr,"<tr>\n");
  715. fprintf(fptr,"<td> part_status </td>\n");
  716. fprintf(fptr,"<td>");
  717. fprintf(fptr,"%c", sig.part_status);
  718. fprintf(fptr,"</td>\n");
  719. fprintf(fptr,"</tr>\n");
  720. fprintf(fptr,"<tr>\n");
  721. fprintf(fptr,"<td> part_fit </td>\n");
  722. fprintf(fptr,"<td>");
  723. fprintf(fptr,"%s", sig.part_fit);
  724. fprintf(fptr,"</td>\n");
  725. fprintf(fptr,"</tr>\n");
  726. fprintf(fptr,"<tr>\n");
  727. fprintf(fptr,"<td> part_start </td>\n");
  728. fprintf(fptr,"<td>");
  729. fprintf(fptr,"%d", sig.part_start);
  730. fprintf(fptr,"</td>\n");
  731. fprintf(fptr,"</tr>\n");
  732. fprintf(fptr,"<tr>\n");
  733. fprintf(fptr,"<td> part_size </td>\n");
  734. fprintf(fptr,"<td>");
  735. fprintf(fptr,"%d", sig.part_size);
  736. fprintf(fptr,"</td>\n");
  737. fprintf(fptr,"</tr>\n");
  738. fprintf(fptr,"<tr>\n");
  739. fprintf(fptr,"<td> part_next </td>\n");
  740. fprintf(fptr,"<td>");
  741. fprintf(fptr,"%d", sig.part_next);
  742. fprintf(fptr,"</td>\n");
  743. fprintf(fptr,"</tr>\n");
  744. fprintf(fptr,"<tr>\n");
  745. fprintf(fptr,"<td> part_name </td>\n");
  746. fprintf(fptr,"<td>");
  747. fprintf(fptr,"%s", sig.part_name);
  748. fprintf(fptr,"</td>\n");
  749. fprintf(fptr,"</tr>\n");
  750.  
  751.  
  752. contador++;
  753. siguiente=sig.part_next;
  754. printf("Siguiente %d\n",siguiente);
  755.  
  756.  
  757. }
  758. }
  759.  
  760. fprintf(fptr,"</table>\n");
  761. fprintf(fptr,">];\n");
  762.  
  763.  
  764. fprintf(fptr,"}\n");
  765. fclose(fptr);
  766. strcat(dot,"dot -Tpng ");
  767. strcat(dot,pathauxiliar2);
  768. strcat(dot," -o ");
  769. strcat(dot,funcion.path);
  770. printf("%s\n",dot);
  771. system(dot);
  772. ContadorComandosExitosos++;
  773. limpiarvar(funcion.path,100);
  774. limpiarvar(pathauxiliar2,100);
  775.  
  776. }else {
  777. printf("Error::-> Generar reporte\n");
  778. ErrorReporte1++;
  779. }
  780. }
  781.  
  782.  
  783.  
  784. void CrearDisco(Funcion funcion)
  785. {
  786.  
  787. MbrDisco mbr;
  788. mbr.mbr_tamano=funcion.size;
  789.  
  790. time_t tiempo = time(0);
  791. struct tm *tlocal = localtime(&tiempo);
  792. char output[128];
  793. strftime(output,128,"%d/%m/%y %H:%M:%S",tlocal);
  794. printf("Fecha y Hora de Creacion: %s\n",output);
  795. int id=funcion.path;
  796.  
  797.  
  798. int k=0;
  799. int l=0;
  800. for(k=0;k<25;k++)
  801. {
  802. mbr.mbr_fecha_creacion[l++]=output[k];
  803. }
  804. l=0;
  805. for(k=0;k<3;k++)
  806. {
  807. mbr.mbr_fit[l++]=funcion.fit[k];
  808. }
  809. strcpy(mbr.mbr_fit,funcion.fit);
  810. mbr.mbr_disk_signature=abs(id);
  811. mbr.cantParticones=0;
  812.  
  813. //tamaño en bytes
  814. int tamano=0;
  815. if(funcion.unit=='k'||funcion.unit=='K')
  816. {
  817. tamano=funcion.size*1024;
  818. }
  819. else
  820. {
  821. tamano=funcion.size*(1024*1024);
  822. }
  823.  
  824.  
  825.  
  826. //----------------- Quitar "" en la path ------------------------
  827.  
  828. char pathauxiliar[500];
  829. strcpy(pathauxiliar,funcion.path);
  830. char finalizado[500];
  831. strcpy(finalizado,"cd /\n");
  832. if(pathauxiliar[0]=='\"')
  833. {
  834. limpiarvar(funcion.path,100);
  835. int q=1;
  836. while(pathauxiliar[q]!='\"')
  837. {
  838. char nuevoCaracter[1];
  839. nuevoCaracter[0]=pathauxiliar[q];
  840. strncat(funcion.path,nuevoCaracter,1);
  841. q++;
  842. }
  843.  
  844. }
  845.  
  846. int con1=0;
  847. int valExtencion=0;
  848. while(funcion.path[con1]!=NULL){
  849.  
  850. if(funcion.path[con1]=='.'){
  851.  
  852. if(funcion.path[con1+1]=='d'&&funcion.path[con1+2]=='i'&&funcion.path[con1+3]=='s' &&funcion.path[con1+4]=='k'){
  853. valExtencion=1;
  854. }
  855.  
  856. }
  857. con1++;
  858. }
  859.  
  860.  
  861. if(valExtencion==0){
  862. printf("\nError::-> Extencion incorrecta\n");
  863. ErrorCrearDisco++;
  864. }else{
  865.  
  866.  
  867. int indice=0;
  868. char carpeta[500];
  869. printf("%s\n",funcion.path);
  870. while(funcion.path[indice]!='.')
  871. {
  872. if(funcion.path[indice]!='/')
  873. {
  874.  
  875. char nuevoCaracter[1];
  876. nuevoCaracter[0]=funcion.path[indice];
  877. strncat(carpeta,nuevoCaracter,1);
  878. }
  879. else
  880. {
  881. if(carpeta[0]!='\0')
  882. {
  883.  
  884.  
  885. strcat(finalizado,"mkdir ");
  886. strcat(finalizado,"\"");
  887. strcat(finalizado,carpeta);
  888. strcat(finalizado,"\"");
  889. strcat(finalizado,"\n");
  890. strcat(finalizado,"cd ");
  891. strcat(finalizado,"\"");
  892. strcat(finalizado,carpeta);
  893. strcat(finalizado,"\"");
  894. strcat(finalizado,"\n");
  895. strcat(carpeta,"");
  896. limpiarvar(carpeta,500);
  897. }
  898.  
  899. }
  900. indice++;
  901. }
  902.  
  903.  
  904. printf("\n%s\n",finalizado);
  905.  
  906. system(finalizado);
  907.  
  908.  
  909. FILE* archivo= fopen(funcion.path, "ab");
  910. if (archivo==NULL)
  911. {
  912. printf("\nError::-> Imposible crear el archivo\n");
  913. ErrorCrearDisco++;
  914. }
  915. else
  916. {
  917. int fin=(tamano/1024);
  918. char buffer[1024];
  919. int i=0;
  920. for(i=0;i<1024;i++){
  921. buffer[i]='\0';
  922. }
  923. int j=0;
  924. while(j!=fin){
  925. fwrite(&buffer,1024 , 1, archivo);
  926. j++;
  927. }
  928. fclose(archivo);
  929. }
  930. //Fin Creacion de Archivo
  931.  
  932. //Estableciendo propiedades de la estructura del Mbr del disco
  933. mbr.mbr_tamano=tamano;
  934.  
  935. int i;
  936. for(i=0;i<4;i++)//recorre el arreglo de las 4 particiones
  937. {//estableciendo datos por defecto
  938. mbr.particiones[i].part_start=-1;
  939. mbr.particiones[i].part_status='0';
  940. mbr.particiones[i].part_size=0;
  941. }
  942.  
  943. //abriendo el Archivo qe simula el disco virtual
  944. FILE* file= fopen(funcion.path, "rb+");
  945. fseek(file,0,SEEK_SET);// estableciendo puntero al inicio
  946.  
  947. if (file==NULL)//si el archivo no contiene nada
  948. {
  949. printf("\nError::->Imposible escribir en el archivo \n\n");
  950. ErrorCrearDisco++;
  951. //fclose(file);
  952. }
  953. else
  954. {
  955. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  956. fclose(file);
  957. printf("'CREACION DE DISCO EXITOSO'\n");
  958. ContadorComandosExitosos++;
  959. }
  960.  
  961. }
  962.  
  963.  
  964.  
  965. }
  966.  
  967. void ELiminarDisco(Funcion funcion)
  968. {
  969.  
  970. //----------------- Quita "" en la path ------------------------
  971. char pathauxiliar[500];
  972. strcpy(pathauxiliar,funcion.path);
  973. char finalizado[500];
  974. strcpy(finalizado,"cd /\n");
  975. if(pathauxiliar[0]=='\"')
  976. {
  977. limpiarvar(funcion.path,100);
  978. int q=1;
  979. while(pathauxiliar[q]!='\"')
  980. {
  981. char nuevoCaracter[1];
  982. nuevoCaracter[0]=pathauxiliar[q];
  983. strncat(funcion.path,nuevoCaracter,1);
  984. q++;
  985. }
  986.  
  987. }
  988. //----------------------------------------------------------------------
  989.  
  990. int con1=0;
  991. int valExtencion=0;
  992. while(funcion.path[con1]!=NULL){
  993.  
  994. if(funcion.path[con1]=='.'){
  995.  
  996. if(funcion.path[con1+1]=='d'&&funcion.path[con1+2]=='i'&&funcion.path[con1+3]=='s' &&funcion.path[con1+4]=='k'){
  997. valExtencion=1;
  998. }
  999.  
  1000. }
  1001. con1++;
  1002. }
  1003.  
  1004. if(valExtencion==0){
  1005. printf("\nError::-> Extencion incorrecta\n");
  1006. ErrorEliminarDisco++;
  1007. }else{
  1008. int encontro=0;
  1009. FILE *fp;
  1010. fp = fopen (funcion.path, "r" );
  1011. if (fp==NULL) {
  1012. printf("\nError::->Disco no encontrado\n");
  1013. ErrorEliminarDisco++;
  1014. }
  1015. else {
  1016. encontro=1;
  1017. fclose ( fp );
  1018. }
  1019.  
  1020.  
  1021.  
  1022. if(encontro==1)
  1023. {
  1024. int opcion;
  1025. printf("%s\n", "¿Desea eliminar el disco?");
  1026. printf("%s\n", "1. SI");
  1027. printf("%s\n", "2. NO");
  1028.  
  1029. printf("%s\n", "");
  1030. printf(">:~$ ");
  1031. scanf("%d",&opcion);
  1032.  
  1033. if(opcion>0 && opcion<3){
  1034.  
  1035. switch(opcion)
  1036. {
  1037. case 1:
  1038. //-----------------------------------------------EliminarParticion(funcion)-----------------------------------------;
  1039. printf("Eliminando Particion...\n");
  1040.  
  1041.  
  1042. strcpy(finalizado,"\nrm \"");
  1043. strcat(finalizado,funcion.path);
  1044. strcat(finalizado,"\"");
  1045. printf("\n%s\n",finalizado);
  1046. system(finalizado);
  1047. limpiarvar(finalizado,100);
  1048. printf("'EIMINACION DE DISCO EXITOSA'\n");
  1049. ContadorComandosExitosos++;
  1050. break;
  1051. case 2:
  1052. printf("-------------------------Eliminacion Cancelada-------------------\n");
  1053. break;
  1054. default:
  1055. printf("Error::-> Opcion Incorrecta \n");
  1056. break;
  1057. }
  1058. }else
  1059. {
  1060. opcion=1;
  1061. printf(" \n");
  1062. printf("%s\n", "Error::-> Opcion incorrecta ");
  1063. }
  1064. }
  1065.  
  1066. }
  1067. }
  1068.  
  1069. void OrdenarEspacios (MbrDisco * mbr)
  1070. {
  1071. Particion aux;
  1072. for (int i=0;i<4;i++) {
  1073. for (int j=0;j<4;j++) {
  1074. if(j!=3)
  1075. {
  1076. if(mbr->particiones[j].part_start>mbr->particiones[j+1].part_start)
  1077. {
  1078. aux=mbr->particiones[j];
  1079. mbr->particiones[j]=mbr->particiones[j+1];
  1080. mbr->particiones[j+1]=aux;
  1081. }
  1082. }
  1083. }
  1084. }
  1085.  
  1086. }
  1087.  
  1088. void Insertar(Espacios * lista,Bloque * nueva)
  1089. {
  1090. if(lista->primero==NULL)
  1091. {
  1092. lista->primero=nueva;
  1093. lista->ultimo=nueva;
  1094.  
  1095. }else {
  1096. nueva->siguiente=lista->primero;
  1097. lista->primero=nueva;
  1098. }
  1099. }
  1100. int Entra(long inicio,long fin,long tamano)
  1101. {
  1102. int espacio=fin-inicio;
  1103.  
  1104. if(espacio>=tamano)
  1105. {
  1106. return 1;
  1107. }else
  1108. {
  1109. return 0;
  1110. }
  1111. }
  1112. void insertarEspacio(Espacios *lista, Bloque *bloque){
  1113.  
  1114. if(lista->primero == NULL){
  1115. lista->primero = bloque;
  1116. lista->ultimo = bloque;
  1117.  
  1118. }
  1119. else
  1120. {
  1121. if(lista->primero->tamano>bloque->tamano)///insertar al inicio
  1122. {
  1123.  
  1124. bloque->siguiente=lista->primero;
  1125. lista->primero->anterior=bloque;
  1126. lista->primero=bloque;
  1127.  
  1128. }
  1129. //printf("entro al insertar cuando no esta vacia \n");
  1130. Bloque *aux = lista->primero;
  1131.  
  1132. while(aux->siguiente!=NULL)
  1133. {
  1134. //printf("el siguiente no es nulo\n");
  1135. Bloque *sigui = aux->siguiente;
  1136. while(sigui->tamano < bloque->tamano)
  1137. {
  1138.  
  1139. if(aux->siguiente==NULL){
  1140. break;
  1141. }
  1142. aux = aux->siguiente;
  1143.  
  1144. if(aux->siguiente==NULL){
  1145. break;
  1146. }
  1147. sigui = aux->siguiente;
  1148. }
  1149.  
  1150. break;
  1151. }
  1152.  
  1153. if(lista->ultimo->tamano < bloque->tamano)///Instertar al final
  1154. {
  1155. lista->ultimo->siguiente = bloque;
  1156. bloque->anterior=lista->ultimo;
  1157. lista->ultimo = bloque;
  1158. }
  1159.  
  1160. else if(lista->primero->tamano>bloque->tamano)///Insertar al inicio
  1161. {
  1162. bloque->siguiente=lista->primero;
  1163. lista->primero->anterior=bloque;
  1164. lista->primero=bloque;
  1165. }
  1166.  
  1167. else///insertar en medio
  1168. {
  1169. Bloque *auxSiguiente = aux->siguiente;
  1170. aux->siguiente=bloque;
  1171. bloque->anterior=aux;
  1172. bloque->siguiente=auxSiguiente;
  1173. auxSiguiente->anterior=bloque;
  1174. }
  1175.  
  1176. }
  1177. }
  1178.  
  1179. int EspacioFF(MbrDisco mbr,int tamano)
  1180. {
  1181. int espacio=-1;
  1182. int encontro=0;
  1183. if(mbr.particiones[0].part_status=='0')
  1184. {
  1185. espacio=1;
  1186. }else{
  1187.  
  1188.  
  1189. int a[4];
  1190. int n=0;
  1191. for (int i=0;i<4;i++) {
  1192. if(mbr.particiones[i].part_status=='1')
  1193. {
  1194. a[i]=mbr.particiones[i].part_start;
  1195. n++;
  1196. }
  1197. }
  1198.  
  1199. int i,j,aux;
  1200. for(i=0;i<n;i++)
  1201. {
  1202. printf("%d,",a[i]);
  1203. }
  1204. printf("\n");
  1205. for(i=0;i<=n;i++){
  1206. for(j=0;j<n-1;j++){
  1207. if(a[j]>a[j+1]){
  1208. aux=a[j];
  1209. a[j]=a[j+1];
  1210. a[j+1]=aux;
  1211. }
  1212. }
  1213. }
  1214. printf("\n");
  1215. for(i=0;i<n;i++)
  1216. {
  1217. printf("%d,",a[i]);
  1218. }
  1219. printf("\n");
  1220. for (int j=0;j<4;j++) {
  1221. if(encontro==0)
  1222. {
  1223. for (int i=0;i<4;i++) {
  1224.  
  1225. if(a[j]==mbr.particiones[i].part_start)
  1226. {
  1227. printf("Espacio-> %d\n",a[j]);
  1228. int AntVacio=0;
  1229. int Ant=0;
  1230. int SigVacio=0;
  1231. int Sig=0;
  1232. if(j!=0)
  1233. {
  1234. for (int i=0;i<4;i++) {
  1235. if(a[j-1]==mbr.particiones[i].part_start)
  1236. {
  1237. Ant=i;
  1238. AntVacio=1;
  1239. break;
  1240. }
  1241. }
  1242.  
  1243. }
  1244. if(j!=3)
  1245. {
  1246. for (int i=0;i<4;i++) {
  1247. if(a[j+1]==mbr.particiones[i].part_start)
  1248. {
  1249. SigVacio=i;
  1250. Sig=1;
  1251. break;
  1252. }
  1253. }
  1254.  
  1255. }
  1256.  
  1257. if(j==0)
  1258. {
  1259. printf("Entre principio y primero\n");
  1260. printf("Inicio %d\n",1);
  1261. printf("Fin %d\n",mbr.particiones[i].part_start);
  1262. int a=mbr.particiones[i].part_start;
  1263. int b=1;
  1264. int po= a-b;
  1265. if(po>0)
  1266. {
  1267.  
  1268.  
  1269. printf("Encontro Espacio\n");
  1270. espacio=b;
  1271. encontro=1;
  1272. break;
  1273. }
  1274. if(SigVacio==0)
  1275. {
  1276. printf("Primero y final\n");
  1277. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  1278. printf("Fin %d\n",mbr.mbr_tamano);
  1279. int a=mbr.mbr_tamano;
  1280. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  1281. int po= a-b;
  1282. if(po>0)
  1283. {
  1284.  
  1285. printf("Encontro Espacio\n");
  1286. espacio=b;
  1287. encontro=1;
  1288. break;
  1289. }
  1290. }
  1291.  
  1292. }
  1293. else
  1294. {
  1295. printf("Entre %d y %d\n",j,j+1);
  1296. printf("Inicio %d\n",mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size);
  1297. printf("Fin %d\n",mbr.particiones[i].part_start);
  1298. int a=mbr.particiones[i].part_start;
  1299. int b=mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size;
  1300. int po= a-b;
  1301. if(po>0)
  1302. {
  1303.  
  1304. printf("Encontro Espacio\n");
  1305. espacio=b;
  1306. encontro=1;
  1307. break;
  1308. }
  1309. if(SigVacio==0)
  1310. {
  1311. printf("%d y final\n",j);
  1312. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  1313. printf("Fin %d\n",mbr.mbr_tamano);
  1314. int a=mbr.mbr_tamano;
  1315. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  1316. int po= a-b;
  1317. if(po>0)
  1318. {
  1319.  
  1320. printf("Encontro Espacio\n");
  1321. espacio=b;
  1322. encontro=1;
  1323. break;
  1324. }
  1325. }
  1326.  
  1327. }
  1328.  
  1329.  
  1330. break;
  1331. }
  1332. }
  1333. }
  1334. }
  1335. }
  1336. return espacio;
  1337. }
  1338. void RecorrerEspacios(Espacios *lista)
  1339. {
  1340. Bloque *pivote=lista->primero;
  1341. while (pivote!=NULL) {
  1342. printf("--------------------------\n");
  1343. printf("Inicio %d\n",pivote->inicio);
  1344. printf("Fin %d\n",pivote->fin);
  1345. printf("Tamano %d\n",pivote->tamano);
  1346. pivote=pivote->siguiente;
  1347. }
  1348. }
  1349.  
  1350. int BuscarMenor(Espacios *lista,int tamano)
  1351. {
  1352. Bloque *pivote=lista->primero;
  1353. while (pivote!=NULL) {
  1354. if(pivote->tamano>=tamano)
  1355. {
  1356. printf("Encontro espacio en %d\n",pivote->inicio);
  1357. return pivote->inicio;
  1358. }
  1359. pivote=pivote->siguiente;
  1360. }
  1361. return -1;
  1362. }
  1363. int BuscarMayor(Espacios *lista,int tamano)
  1364. {
  1365. Bloque *pivote=lista->ultimo;
  1366. while (pivote!=NULL) {
  1367. if(pivote->tamano>=tamano)
  1368. {
  1369. printf("Encontro espacio en %d\n",pivote->inicio);
  1370. return pivote->inicio;
  1371. }
  1372. pivote=pivote->anterior;
  1373. }
  1374. return -1;
  1375. }
  1376.  
  1377. int EspacioBF(MbrDisco mbr,int tamano)
  1378. {
  1379. printf("Buscando el mejor espacio...");
  1380. int espacio=-1;
  1381. Espacios *lista=(Espacios*)malloc(sizeof (Espacios));
  1382. lista->primero=NULL;
  1383. lista->ultimo=NULL;
  1384. if(mbr.particiones[0].part_status=='0')
  1385. {
  1386. espacio=1;
  1387. return espacio;
  1388. }else{
  1389.  
  1390.  
  1391. int a[4];
  1392. int n=0;
  1393. for (int i=0;i<4;i++) {
  1394. if(mbr.particiones[i].part_status=='1')
  1395. {
  1396. a[i]=mbr.particiones[i].part_start;
  1397. n++;
  1398. }
  1399. }
  1400.  
  1401. int i,j,aux;
  1402. for(i=0;i<n;i++)
  1403. {
  1404. printf("%d,",a[i]);
  1405. }
  1406. printf("\n");
  1407. for(i=0;i<=n;i++){
  1408. for(j=0;j<n-1;j++){
  1409. if(a[j]>a[j+1]){
  1410. aux=a[j];
  1411. a[j]=a[j+1];
  1412. a[j+1]=aux;
  1413. }
  1414. }
  1415. }
  1416. printf("\n");
  1417. for(i=0;i<n;i++)
  1418. {
  1419. printf("%d,",a[i]);
  1420. }
  1421. printf("\n");
  1422. for (int j=0;j<4;j++) {
  1423. for (int i=0;i<4;i++) {
  1424.  
  1425. if(a[j]==mbr.particiones[i].part_start)
  1426. {
  1427. printf("Espacio-> %d\n",a[j]);
  1428. int AntVacio=0;
  1429. int Ant=0;
  1430. int SigVacio=0;
  1431. int Sig=0;
  1432. if(j!=0)
  1433. {
  1434. for (int i=0;i<4;i++) {
  1435. if(a[j-1]==mbr.particiones[i].part_start)
  1436. {
  1437. Ant=i;
  1438. AntVacio=1;
  1439. break;
  1440. }
  1441. }
  1442.  
  1443. }
  1444. if(j!=3)
  1445. {
  1446. for (int i=0;i<4;i++) {
  1447. if(a[j+1]==mbr.particiones[i].part_start)
  1448. {
  1449. SigVacio=i;
  1450. Sig=1;
  1451. break;
  1452. }
  1453. }
  1454.  
  1455. }
  1456.  
  1457. if(j==0)
  1458. {
  1459. printf("Entre principio y primero\n");
  1460. printf("Inicio %d\n",1);
  1461. printf("Fin %d\n",mbr.particiones[i].part_start);
  1462. int a=mbr.particiones[i].part_start;
  1463. int b=1;
  1464. int po= a-b;
  1465. if(po>0)
  1466. {
  1467. printf("Encontro Espacio\n");
  1468. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  1469. nuevo->inicio=b;
  1470. nuevo->fin=a;
  1471. nuevo->tamano=po;
  1472. nuevo->siguiente=NULL;
  1473. nuevo->anterior=NULL;
  1474. insertarEspacio(lista,nuevo);
  1475. }
  1476. if(SigVacio==0)
  1477. {
  1478. printf("Primero y final\n");
  1479. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  1480. printf("Fin %d\n",mbr.mbr_tamano);
  1481. int a=mbr.mbr_tamano;
  1482. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  1483. int po= a-b;
  1484. if(po>0)
  1485. {
  1486.  
  1487. printf("Encontro Espacio\n");
  1488. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  1489. nuevo->inicio=b;
  1490. nuevo->fin=a;
  1491. nuevo->tamano=po;
  1492. nuevo->siguiente=NULL;
  1493. nuevo->anterior=NULL;
  1494. insertarEspacio(lista,nuevo);
  1495.  
  1496. }
  1497. }
  1498.  
  1499. }
  1500. else
  1501. {
  1502. printf("Entre %d y %d\n",j,j+1);
  1503. printf("Inicio %d\n",mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size);
  1504. printf("Fin %d\n",mbr.particiones[i].part_start);
  1505. int a=mbr.particiones[i].part_start;
  1506. int b=mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size;
  1507. int po= a-b;
  1508. if(po>0)
  1509. {
  1510.  
  1511. printf("Encontro Espacio\n");
  1512. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  1513. nuevo->inicio=b;
  1514. nuevo->fin=a;
  1515. nuevo->tamano=po;
  1516. nuevo->siguiente=NULL;
  1517. nuevo->anterior=NULL;
  1518. insertarEspacio(lista,nuevo);
  1519. }
  1520. if(SigVacio==0)
  1521. {
  1522. printf("%d y final\n",j);
  1523. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  1524. printf("Fin %d\n",mbr.mbr_tamano);
  1525. int a=mbr.mbr_tamano;
  1526. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  1527. int po= a-b;
  1528. if(po>0)
  1529. {
  1530.  
  1531. printf("Encontro Espacio\n");
  1532. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  1533. nuevo->inicio=b;
  1534. nuevo->fin=a;
  1535. nuevo->tamano=po;
  1536. nuevo->siguiente=NULL;
  1537. nuevo->anterior=NULL;
  1538. insertarEspacio(lista,nuevo);
  1539. }
  1540. }
  1541.  
  1542. }
  1543.  
  1544.  
  1545. break;
  1546. }
  1547. }
  1548.  
  1549. }
  1550. }
  1551.  
  1552. RecorrerEspacios(lista);
  1553. espacio=BuscarMenor(lista,tamano);
  1554. printf("Retornando %d\n",espacio);
  1555.  
  1556.  
  1557.  
  1558. return espacio;
  1559. }
  1560.  
  1561. int EspacioWF(MbrDisco mbr,int tamano)
  1562. {
  1563. printf("Buscando el mejor espacio...");
  1564. int espacio=-1;
  1565. Espacios *lista=(Espacios*)malloc(sizeof (Espacios));
  1566. lista->primero=NULL;
  1567. lista->ultimo=NULL;
  1568. if(mbr.particiones[0].part_status=='0')
  1569. {
  1570. espacio=1;
  1571. return espacio;
  1572. }else{
  1573.  
  1574.  
  1575. int a[4];
  1576. int n=0;
  1577. for (int i=0;i<4;i++) {
  1578. if(mbr.particiones[i].part_status=='1')
  1579. {
  1580. a[i]=mbr.particiones[i].part_start;
  1581. n++;
  1582. }
  1583. }
  1584.  
  1585. int i,j,aux;
  1586. for(i=0;i<n;i++)
  1587. {
  1588. printf("%d,",a[i]);
  1589. }
  1590. printf("\n");
  1591. for(i=0;i<=n;i++){
  1592. for(j=0;j<n-1;j++){
  1593. if(a[j]>a[j+1]){
  1594. aux=a[j];
  1595. a[j]=a[j+1];
  1596. a[j+1]=aux;
  1597. }
  1598. }
  1599. }
  1600. printf("\n");
  1601. for(i=0;i<n;i++)
  1602. {
  1603. printf("%d,",a[i]);
  1604. }
  1605. printf("\n");
  1606. for (int j=0;j<4;j++) {
  1607. for (int i=0;i<4;i++) {
  1608.  
  1609. if(a[j]==mbr.particiones[i].part_start)
  1610. {
  1611. printf("Espacio-> %d\n",a[j]);
  1612. int AntVacio=0;
  1613. int Ant=0;
  1614. int SigVacio=0;
  1615. int Sig=0;
  1616. if(j!=0)
  1617. {
  1618. for (int i=0;i<4;i++) {
  1619. if(a[j-1]==mbr.particiones[i].part_start)
  1620. {
  1621. Ant=i;
  1622. AntVacio=1;
  1623. break;
  1624. }
  1625. }
  1626.  
  1627. }
  1628. if(j!=3)
  1629. {
  1630. for (int i=0;i<4;i++) {
  1631. if(a[j+1]==mbr.particiones[i].part_start)
  1632. {
  1633. SigVacio=i;
  1634. Sig=1;
  1635. break;
  1636. }
  1637. }
  1638.  
  1639. }
  1640.  
  1641. if(j==0)
  1642. {
  1643. printf("Entre principio y primero\n");
  1644. printf("Inicio %d\n",1);
  1645. printf("Fin %d\n",mbr.particiones[i].part_start);
  1646. int a=mbr.particiones[i].part_start;
  1647. int b=1;
  1648. int po= a-b;
  1649. if(po>0)
  1650. {
  1651. printf("Encontro Espacio\n");
  1652. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  1653. nuevo->inicio=b;
  1654. nuevo->fin=a;
  1655. nuevo->tamano=po;
  1656. nuevo->siguiente=NULL;
  1657. nuevo->anterior=NULL;
  1658. insertarEspacio(lista,nuevo);
  1659. }
  1660. if(SigVacio==0)
  1661. {
  1662. printf("Primero y final\n");
  1663. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  1664. printf("Fin %d\n",mbr.mbr_tamano);
  1665. int a=mbr.mbr_tamano;
  1666. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  1667. int po= a-b;
  1668. if(po>0)
  1669. {
  1670.  
  1671. printf("Encontro Espacio\n");
  1672. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  1673. nuevo->inicio=b;
  1674. nuevo->fin=a;
  1675. nuevo->tamano=po;
  1676. nuevo->siguiente=NULL;
  1677. nuevo->anterior=NULL;
  1678. insertarEspacio(lista,nuevo);
  1679.  
  1680. }
  1681. }
  1682.  
  1683. }
  1684. else
  1685. {
  1686. printf("Entre %d y %d\n",j,j+1);
  1687. printf("Inicio %d\n",mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size);
  1688. printf("Fin %d\n",mbr.particiones[i].part_start);
  1689. int a=mbr.particiones[i].part_start;
  1690. int b=mbr.particiones[Ant].part_start+mbr.particiones[Ant].part_size;
  1691. int po= a-b;
  1692. if(po>0)
  1693. {
  1694.  
  1695. printf("Encontro Espacio\n");
  1696. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  1697. nuevo->inicio=b;
  1698. nuevo->fin=a;
  1699. nuevo->tamano=po;
  1700. nuevo->siguiente=NULL;
  1701. nuevo->anterior=NULL;
  1702. insertarEspacio(lista,nuevo);
  1703. }
  1704. if(SigVacio==0)
  1705. {
  1706. printf("%d y final\n",j);
  1707. printf("Inicio %d\n",mbr.particiones[i].part_start+mbr.particiones[i].part_size);
  1708. printf("Fin %d\n",mbr.mbr_tamano);
  1709. int a=mbr.mbr_tamano;
  1710. int b=mbr.particiones[i].part_start+mbr.particiones[i].part_size;
  1711. int po= a-b;
  1712. if(po>0)
  1713. {
  1714.  
  1715. printf("Encontro Espacio\n");
  1716. Bloque *nuevo= (Bloque*)malloc(sizeof (Bloque));
  1717. nuevo->inicio=b;
  1718. nuevo->fin=a;
  1719. nuevo->tamano=po;
  1720. nuevo->siguiente=NULL;
  1721. nuevo->anterior=NULL;
  1722. insertarEspacio(lista,nuevo);
  1723. }
  1724. }
  1725.  
  1726. }
  1727.  
  1728.  
  1729. break;
  1730. }
  1731. }
  1732.  
  1733. }
  1734. }
  1735.  
  1736. RecorrerEspacios(lista);
  1737. espacio=BuscarMayor(lista,tamano);
  1738. printf("Retornando %d\n",espacio);
  1739.  
  1740.  
  1741.  
  1742. return espacio;
  1743. }
  1744.  
  1745.  
  1746. int BuscarEspacionBF(MbrDisco mbr,Funcion funcion,int tamano)
  1747. {
  1748. int espacio=EspacioBF(mbr,tamano);
  1749. for (int i=0;i<4;i++) {
  1750.  
  1751.  
  1752. if(mbr.particiones[i].part_status=='0')
  1753. {
  1754. if(espacio!=-1)
  1755. {
  1756.  
  1757. printf("Ingresara particion en espacio %i\n",espacio);
  1758. mbr.particiones[i].part_start=espacio;
  1759. mbr.particiones[i].part_status='1';
  1760. mbr.particiones[i].part_type=funcion.type;
  1761. int l=0;
  1762. for(int k=0;k<3;k++)
  1763. {
  1764. mbr.particiones[i].part_fit[l++]=funcion.fit[k];
  1765. }
  1766. strcpy(mbr.particiones[i].part_name,funcion.name);
  1767. mbr.particiones[i].part_size=tamano;
  1768. printf("part_status: %c\n",mbr.particiones[i].part_status);
  1769. printf("part_type: %c\n",mbr.particiones[i].part_type);
  1770. printf("part_fit: %s\n",mbr.particiones[i].part_fit);
  1771. printf("part_name: %s\n",mbr.particiones[i].part_name);
  1772. printf("part_size: %i\n",mbr.particiones[i].part_size);
  1773. printf("part_start: %i\n",mbr.particiones[i].part_start);
  1774.  
  1775.  
  1776. mbr.cantParticones++;
  1777. printf("particiones: %i\n",mbr.cantParticones);
  1778. if(mbr.particiones[i].part_type=='E' || mbr.particiones[i].part_type=='E' )
  1779. {
  1780. printf("Es una particion extendida\n");
  1781. EBR ebr;
  1782. ebr.part_next=-1;
  1783. ebr.part_size=0;
  1784. ebr.part_start=mbr.particiones[i].part_start;
  1785. ebr.part_status='0';
  1786. FILE* file= fopen(funcion.path, "rb+");
  1787. printf("EBR inicial dir->%d\n",mbr.particiones[i].part_start+sizeof (MbrDisco));
  1788. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  1789.  
  1790. if (file==NULL)
  1791. {
  1792. printf("\nError::->Imposible escribir en el archivo \n\n");
  1793. }
  1794. else
  1795. {
  1796.  
  1797. fwrite(&ebr, sizeof(EBR), 1, file);//escribiendo la estructura del MBR
  1798. fclose(file);
  1799. printf("'EBR CREADO EXITOSAMENTE'\n");
  1800. }
  1801.  
  1802. }
  1803. FILE* file= fopen(funcion.path, "rb+");
  1804. fseek(file,0,SEEK_SET);
  1805.  
  1806. if (file==NULL)
  1807. {
  1808. printf("\nError::->Imposible escribir en el archivo \n\n");
  1809. ErrorCrearParticion++;
  1810. }
  1811. else
  1812. {
  1813. /*Particion aux;
  1814. for(int i=0;i<=mbr.cantParticones;i++){
  1815. for(int j=0;j<mbr.cantParticones-1;j++){
  1816. printf("%s->%d\n",mbr.particiones[j].part_name,mbr.particiones[j].part_start);
  1817. printf("%s-> %d\n",mbr.particiones[j+1].part_name,mbr.particiones[j+1].part_start);
  1818. if(mbr.particiones[j].part_start>mbr.particiones[j+1].part_start){
  1819. aux=mbr.particiones[j];
  1820. mbr.particiones[j]=mbr.particiones[j+1];
  1821. mbr.particiones[j+1]=aux;
  1822. }
  1823. }
  1824. }
  1825. printf("%d\n",mbr.mbr_disk_signature);
  1826. for (int i=0;i<4;i++) {
  1827. printf("%s\n",mbr.particiones[i].part_name);
  1828. }*/
  1829. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  1830. fclose(file);
  1831. printf("'CREACION DE PARTICION EXITOSA'\n");
  1832. ContadorComandosExitosos++;
  1833. }
  1834. }else {
  1835. printf("Error::->No se encontro espacio para la particion\n");
  1836. ErrorCrearParticion++;
  1837. }
  1838. break;
  1839. }
  1840. }
  1841.  
  1842.  
  1843. }
  1844.  
  1845. int BuscarEspacionWF(MbrDisco mbr,Funcion funcion,int tamano)
  1846. {
  1847. int espacio=EspacioWF(mbr,tamano);
  1848. for (int i=0;i<4;i++) {
  1849.  
  1850.  
  1851. if(mbr.particiones[i].part_status=='0')
  1852. {
  1853. if(espacio!=-1)
  1854. {
  1855.  
  1856. printf("Ingresara particion en espacio %i\n",espacio);
  1857. mbr.particiones[i].part_start=espacio;
  1858. mbr.particiones[i].part_status='1';
  1859. mbr.particiones[i].part_type=funcion.type;
  1860. int l=0;
  1861. for(int k=0;k<3;k++)
  1862. {
  1863. mbr.particiones[i].part_fit[l++]=funcion.fit[k];
  1864. }
  1865. strcpy(mbr.particiones[i].part_name,funcion.name);
  1866. mbr.particiones[i].part_size=tamano;
  1867. printf("part_status: %c\n",mbr.particiones[i].part_status);
  1868. printf("part_type: %c\n",mbr.particiones[i].part_type);
  1869. printf("part_fit: %s\n",mbr.particiones[i].part_fit);
  1870. printf("part_name: %s\n",mbr.particiones[i].part_name);
  1871. printf("part_size: %i\n",mbr.particiones[i].part_size);
  1872. printf("part_start: %i\n",mbr.particiones[i].part_start);
  1873.  
  1874.  
  1875. mbr.cantParticones++;
  1876. printf("particiones: %i\n",mbr.cantParticones);
  1877. if(mbr.particiones[i].part_type=='E' || mbr.particiones[i].part_type=='E' )
  1878. {
  1879. printf("Es una particion extendida\n");
  1880. EBR ebr;
  1881. ebr.part_next=-1;
  1882. ebr.part_size=0;
  1883. ebr.part_start=mbr.particiones[i].part_start;
  1884. ebr.part_status='0';
  1885. FILE* file= fopen(funcion.path, "rb+");
  1886. printf("EBR inicial dir->%d\n",mbr.particiones[i].part_start+sizeof (MbrDisco));
  1887. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  1888.  
  1889. if (file==NULL)
  1890. {
  1891. printf("\nError::->Imposible escribir en el archivo \n\n");
  1892. }
  1893. else
  1894. {
  1895.  
  1896. fwrite(&ebr, sizeof(EBR), 1, file);//escribiendo la estructura del MBR
  1897. fclose(file);
  1898. printf("'EBR CREADO EXITOSAMENTE'\n");
  1899. }
  1900.  
  1901. }
  1902. FILE* file= fopen(funcion.path, "rb+");
  1903. fseek(file,0,SEEK_SET);
  1904.  
  1905. if (file==NULL)
  1906. {
  1907. printf("\nError::->Imposible escribir en el archivo \n\n");
  1908. ErrorCrearParticion++;
  1909. }
  1910. else
  1911. {
  1912. /*Particion aux;
  1913. for(int i=0;i<=mbr.cantParticones;i++){
  1914. for(int j=0;j<mbr.cantParticones-1;j++){
  1915. printf("%s->%d\n",mbr.particiones[j].part_name,mbr.particiones[j].part_start);
  1916. printf("%s-> %d\n",mbr.particiones[j+1].part_name,mbr.particiones[j+1].part_start);
  1917. if(mbr.particiones[j].part_start>mbr.particiones[j+1].part_start){
  1918. aux=mbr.particiones[j];
  1919. mbr.particiones[j]=mbr.particiones[j+1];
  1920. mbr.particiones[j+1]=aux;
  1921. }
  1922. }
  1923. }
  1924. printf("%d\n",mbr.mbr_disk_signature);
  1925. for (int i=0;i<4;i++) {
  1926. printf("%s\n",mbr.particiones[i].part_name);
  1927. }*/
  1928. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  1929. fclose(file);
  1930. printf("'CREACION DE PARTICION EXITOSA'\n");
  1931. ContadorComandosExitosos++;
  1932. }
  1933. }else {
  1934. printf("Error::->No se encontro espacio para la particion\n");
  1935. }
  1936. break;
  1937. }
  1938. }
  1939. }
  1940. void BuscarEspacionFF(MbrDisco mbr,Funcion funcion,int tamano)
  1941. {
  1942. int espacio=EspacioFF(mbr,tamano);
  1943. for (int i=0;i<4;i++) {
  1944.  
  1945.  
  1946. if(mbr.particiones[i].part_status=='0')
  1947. {
  1948. if(espacio!=-1)
  1949. {
  1950.  
  1951. printf("Ingresara particion en espacio %i\n",espacio);
  1952. mbr.particiones[i].part_start=espacio;
  1953. mbr.particiones[i].part_status='1';
  1954. mbr.particiones[i].part_type=funcion.type;
  1955. int l=0;
  1956. for(int k=0;k<3;k++)
  1957. {
  1958. mbr.particiones[i].part_fit[l++]=funcion.fit[k];
  1959. }
  1960. strcpy(mbr.particiones[i].part_name,funcion.name);
  1961. mbr.particiones[i].part_size=tamano;
  1962. printf("part_status: %c\n",mbr.particiones[i].part_status);
  1963. printf("part_type: %c\n",mbr.particiones[i].part_type);
  1964. printf("part_fit: %s\n",mbr.particiones[i].part_fit);
  1965. printf("part_name: %s\n",mbr.particiones[i].part_name);
  1966. printf("part_size: %i\n",mbr.particiones[i].part_size);
  1967. printf("part_start: %i\n",mbr.particiones[i].part_start);
  1968.  
  1969.  
  1970. mbr.cantParticones++;
  1971. printf("particiones: %i\n",mbr.cantParticones);
  1972. if(mbr.particiones[i].part_type=='E' || mbr.particiones[i].part_type=='E' )
  1973. {
  1974. printf("Es una particion extendida\n");
  1975. EBR ebr;
  1976. ebr.part_next=-1;
  1977. ebr.part_size=0;
  1978. ebr.part_start=mbr.particiones[i].part_start;
  1979. ebr.part_status='0';
  1980. FILE* file= fopen(funcion.path, "rb+");
  1981. printf("EBR inicial dir->%d\n",mbr.particiones[i].part_start+sizeof (MbrDisco));
  1982. fseek(file,mbr.particiones[i].part_start+sizeof (MbrDisco),SEEK_SET);
  1983.  
  1984. if (file==NULL)
  1985. {
  1986. printf("\nError::->Imposible escribir en el archivo \n\n");
  1987. }
  1988. else
  1989. {
  1990.  
  1991. fwrite(&ebr, sizeof(EBR), 1, file);//escribiendo la estructura del MBR
  1992. fclose(file);
  1993. printf("'EBR CREADO EXITOSAMENTE'\n");
  1994. }
  1995.  
  1996. }
  1997. FILE* file= fopen(funcion.path, "rb+");
  1998. fseek(file,0,SEEK_SET);
  1999.  
  2000. if (file==NULL)
  2001. {
  2002. printf("\nError::->Imposible escribir en el archivo \n\n");
  2003. ErrorCrearParticion++;
  2004. }
  2005. else
  2006. {
  2007.  
  2008. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  2009. fclose(file);
  2010. printf("'CREACION DE PARTICION EXITOSA'\n");
  2011. ContadorComandosExitosos++;
  2012. }
  2013. }else {
  2014. printf("Error::->No se encontro espacio para la particion\n");
  2015. ErrorCrearParticion++;
  2016. }
  2017. break;
  2018. }
  2019. }
  2020.  
  2021.  
  2022.  
  2023. }
  2024. void actualizar(Funcion funcion, MbrDisco mbr)
  2025. {
  2026. FILE* file= fopen(funcion.path, "rb+");
  2027. fseek(file,0,SEEK_SET);
  2028.  
  2029. if (file==NULL)
  2030. {
  2031. printf("\nError::->Imposible escribir en el archivo \n\n");
  2032.  
  2033. }
  2034. else
  2035. {
  2036. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  2037. fclose(file);
  2038. printf("'DATOS ACTUALIZADOS'\n");
  2039. ContadorComandosExitosos++;
  2040. }
  2041. }
  2042. void CrearParticion(Funcion funcion)
  2043. {
  2044. int bandera=1;
  2045. MbrDisco mbr;
  2046. FILE *fp;
  2047. fp = fopen(funcion.path, "rb");
  2048.  
  2049. if(fp == NULL)
  2050. {
  2051. printf("\n Error::-> No se encontro el disco\n");
  2052. }else {
  2053. fread(&mbr, sizeof(MbrDisco), 1, fp);
  2054. fclose(fp);
  2055. if(funcion.type!='L')
  2056. {
  2057. if(funcion.type=='p' || funcion.type=='P')
  2058. {
  2059. printf("Creando particion primaria...\n");
  2060. }if(funcion.type=='e' || funcion.type=='E')
  2061. {
  2062. printf("Creando particion extendidas...\n");
  2063. int contador=0;
  2064. for (int i=0;i<4;i++) {
  2065.  
  2066. if(mbr.particiones[i].part_type=='e' || mbr.particiones[i].part_type=='E')
  2067. {
  2068. contador++;
  2069. }
  2070. }
  2071.  
  2072. if(contador>=1)
  2073. {
  2074. bandera=0;
  2075. printf("\nError::-> Limite de particiones extendidas\n");
  2076. ErrorCrearParticion++;
  2077. }
  2078. }
  2079.  
  2080. if(bandera==1)
  2081. {
  2082.  
  2083.  
  2084.  
  2085. if(mbr.cantParticones==4)
  2086. {
  2087. printf("--------%s\n",mbr.mbr_fit);
  2088. printf("\nError::-> Limite de particiones en el disco\n");
  2089. ErrorCrearParticion++;
  2090. }else {
  2091.  
  2092.  
  2093. int tamano=0;
  2094. if(funcion.unit=='k'||funcion.unit=='K')
  2095. {
  2096. tamano=funcion.size*1024;
  2097. }
  2098. else if(funcion.unit=='b'||funcion.unit=='B')
  2099. {
  2100. tamano=funcion.size;
  2101. }
  2102. else
  2103. {
  2104. tamano=funcion.size*(1024*1024);
  2105. }
  2106. if(!strcmp(mbr.mbr_fit,"BF"))
  2107. {
  2108. printf("Creando particion con mejor ajuste...\n");
  2109. BuscarEspacionBF(mbr,funcion,tamano);
  2110. //actualizar(funcion,mbr);
  2111. }
  2112. if(!strcmp(mbr.mbr_fit,"FF"))
  2113. {
  2114.  
  2115. printf("Creando particion con primer ajuste...\n");
  2116. BuscarEspacionFF(mbr,funcion,tamano);
  2117. //actualizar(funcion,mbr);
  2118.  
  2119. }
  2120. if(!strcmp(mbr.mbr_fit,"WF"))
  2121. {
  2122. printf("Creando particion con peor ajuste...\n");
  2123. BuscarEspacionWF(mbr,funcion,tamano);
  2124.  
  2125. // actualizar(funcion,mbr);
  2126. }
  2127. }
  2128. }
  2129. }else {
  2130. printf("Creando particion logica...\n");
  2131. int contador=0;
  2132. for (int i=0;i<4;i++) {
  2133.  
  2134. if(mbr.particiones[i].part_type=='e' || mbr.particiones[i].part_type=='E')
  2135. {
  2136. contador++;
  2137. }
  2138. }
  2139.  
  2140. if(contador==0)
  2141. {
  2142. bandera=0;
  2143. printf("\nError::-> No existen particiones extendidas\n");
  2144. ErrorCrearParticion++;
  2145. }
  2146. }
  2147.  
  2148. }
  2149.  
  2150.  
  2151. }
  2152. void Exec(Funcion funcion)
  2153. {
  2154. FILE *fichero;
  2155. char caracter;
  2156. char comando[500];
  2157.  
  2158. fichero = fopen(funcion.path, "rt");
  2159.  
  2160. if (fichero == NULL) {
  2161. printf("Error::-> No se ha podido abrir en script");
  2162. } else {
  2163. caracter = fgetc(fichero);
  2164. while (feof(fichero) == 0) {
  2165. if(caracter=='\n' )
  2166. {
  2167. printf("\n-> %s\n",comando);
  2168. Interprete(comando);
  2169. limpiarvar(comando,100);
  2170. }else {
  2171. char nuevoCaracter[1];
  2172. nuevoCaracter[0]=caracter;
  2173. strncat(comando,nuevoCaracter,1);
  2174.  
  2175. }
  2176. caracter = fgetc(fichero);
  2177.  
  2178. }
  2179. printf("\n-> %s\n",comando);
  2180. Interprete(comando);
  2181. limpiarvar(comando,100);
  2182.  
  2183. fclose(fichero);
  2184. ContadorComandosExitosos++;
  2185. }
  2186. }
  2187.  
  2188. void Recorrer()
  2189. {
  2190. Montura *pivote=sistema->primero;
  2191. while (pivote!=NULL) {
  2192. printf("--------------------------\n");
  2193. printf("%s\n",pivote->name);
  2194. printf("%s\n",pivote->path);
  2195. pivote=pivote->siguiente;
  2196. }
  2197. }
  2198.  
  2199.  
  2200.  
  2201. Retorno buscarEnSistema(Funcion funcion)
  2202. {
  2203. int bandera=0;
  2204. Retorno r;
  2205. r.disco=0;
  2206. r.particion=0;
  2207. Montura *pivote=sistema->primero;
  2208.  
  2209. while (pivote!=NULL) {
  2210.  
  2211. if(!strcmp(funcion.path,pivote->path) && strcmp(funcion.name,pivote->nombre))
  2212. {
  2213. r.particion++;
  2214. }
  2215. pivote=pivote->siguiente;
  2216. }
  2217.  
  2218. pivote=sistema->primero;
  2219. Montura *anterior=pivote;
  2220. while (pivote!=NULL) {
  2221.  
  2222. if(!strcmp(funcion.path,pivote->path))
  2223. {
  2224. bandera=1;
  2225. break;
  2226. }
  2227.  
  2228. printf("%s\n",pivote->path);
  2229. printf("%s\n",anterior->path);
  2230. if(strcmp(anterior->path,pivote->path)){
  2231. r.disco++;
  2232. }
  2233.  
  2234. anterior=pivote;
  2235. pivote=pivote->siguiente;
  2236. }
  2237. if(bandera==0 && sistema->primero!=NULL)
  2238. {
  2239. r.disco++;
  2240. }
  2241. return r;
  2242. }
  2243.  
  2244. Montura *DeterminarNombre(Funcion funcion)
  2245. {
  2246. Montura *nueva;
  2247. nueva=(Montura*)malloc(sizeof (Montura));
  2248. int bandera=0;
  2249. MbrDisco mbr;
  2250. FILE *fp;
  2251. fp = fopen(funcion.path, "rb");
  2252.  
  2253. if(fp == NULL)
  2254. {
  2255. printf("\n Error::-> No se encontro el disco\n");
  2256. }else {
  2257. fread(&mbr, sizeof(MbrDisco), 1, fp);
  2258. fclose(fp);
  2259.  
  2260. for (int i=0;i<4;i++) {
  2261.  
  2262. if(!strcmp(mbr.particiones[i].part_name,funcion.name))
  2263. {
  2264. strcpy(nueva->nombre,mbr.particiones[i].part_name);
  2265. strcpy(nueva->path,funcion.path);
  2266. bandera=1;
  2267. break;
  2268. }
  2269. }
  2270. if(bandera==1)
  2271. {
  2272. printf("Se encontro la particion\n");
  2273. char nom[10];
  2274. Retorno r= buscarEnSistema(funcion);
  2275. printf("Discos: %i\n",r.disco);
  2276. printf("Particiones: %i\n",r.particion);
  2277.  
  2278. char x[1];
  2279. x[0]=r.disco+97;
  2280. int y= r.particion+1;
  2281. char d[3];
  2282. strcat(nom,"vd");
  2283. strncat(nom,x,1);
  2284. sprintf(d, "%d",y);
  2285. strcat(nom,d);
  2286. printf("Id: %s\n",nom);
  2287. nueva->siguiente=NULL;
  2288. strcpy(nueva->name,nom);
  2289. limpiarvar(x,1);
  2290. limpiarvar(d,3);
  2291. limpiarvar(nom,10);
  2292. return nueva;
  2293.  
  2294. }else {
  2295. printf("\n Error::-> No se encontro la particion\n");
  2296. }
  2297.  
  2298.  
  2299. }
  2300. return NULL;
  2301. }
  2302.  
  2303.  
  2304. void montar(Montura * nueva)
  2305. {
  2306. if(sistema->primero==NULL)
  2307. {
  2308. sistema->primero=nueva;
  2309. sistema->ultimo=nueva;
  2310.  
  2311. }else {
  2312. nueva->siguiente=sistema->primero;
  2313. sistema->primero=nueva;
  2314. }
  2315. }
  2316.  
  2317.  
  2318.  
  2319.  
  2320. void desmontar(Funcion funcion)
  2321. {
  2322. int bandera=0;
  2323. Montura *pivote=sistema->primero;
  2324. Montura * anterior=pivote;
  2325. while (pivote!=NULL) {
  2326. if(!strcmp(funcion.id,pivote->name))
  2327. {
  2328. if(!strcmp(pivote->name,sistema->primero->name))
  2329. {
  2330. printf("Primero\n");
  2331. sistema->primero=sistema->primero->siguiente;
  2332. free(pivote);
  2333. }
  2334. else if(!strcmp(pivote->name,sistema->ultimo->name))
  2335. {
  2336. printf("Ultimo\n");
  2337. anterior->siguiente=NULL;
  2338. sistema->ultimo=anterior;
  2339. free(pivote);
  2340. }else
  2341. {
  2342. printf("Medio\n");
  2343. anterior->siguiente=pivote->siguiente;
  2344. pivote->siguiente=NULL;
  2345. free(pivote);
  2346. }
  2347. bandera=1;
  2348. break;
  2349. }
  2350. anterior=pivote;
  2351. pivote=pivote->siguiente;
  2352. }
  2353. if(bandera==0)
  2354. {
  2355. printf("\nNo se encontro ninguna particion montada con ese nombre\n");
  2356. }else {
  2357. printf("\nParticion desmontada\n");
  2358. }
  2359. }
  2360.  
  2361.  
  2362.  
  2363.  
  2364. // HERRAMIENTAS----------------------------------------------------------------------------------------------------------------------------------
  2365.  
  2366. void limpiarvar(char aux[], int n) {
  2367. int i;
  2368. for (i = 0; i < n; i++) {
  2369. aux[i] = '\0';
  2370. }
  2371. }
  2372. void quitarComillas (char a[100]){
  2373.  
  2374. limpiarvar(sincomillas,1000);
  2375. char pathauxiliar[100];
  2376. strcpy(pathauxiliar,a);
  2377.  
  2378. char finalizado[100];
  2379. strcpy(finalizado,"cd /\n");
  2380.  
  2381. if(pathauxiliar[0]=='\"')
  2382. {
  2383. limpiarvar(a,100);
  2384. int q=1;
  2385. while(pathauxiliar[q]!='\"')
  2386. {
  2387. char nuevaCadena[1];
  2388. nuevaCadena[0]=pathauxiliar[q];
  2389. strncat(a,nuevaCadena,1);
  2390. q++;
  2391. }
  2392.  
  2393. }
  2394.  
  2395. strcpy(sincomillas,a);
  2396.  
  2397. }
  2398. void LimpiarVariables (){
  2399. comentario=0;
  2400. ErrorInterprete=0;
  2401. ErrorComando=0;
  2402. ErrorCrearDisco=0;
  2403. ErrorEliminarDisco=0;
  2404. ErrorCrearParticionLogica=0;
  2405. ErrorEliminarLogica=0;
  2406. ErrorReporte1=0;
  2407. ErrorReporte2=0;
  2408. ContadorInstrucciones=0;
  2409. ContadorComandosExitosos=0;
  2410. fin=0;
  2411.  
  2412. }
  2413.  
  2414. int EsLetra(char caracter)
  2415. {
  2416. if((caracter >= 'a' && caracter <= 'z' ) || (caracter >= 'A' && caracter <= 'Z' ))
  2417. {
  2418. return 1;
  2419. }else
  2420. {
  2421. return 0;
  2422. }
  2423. }
  2424. //0 si la cadena es numero
  2425. int CadenaEsNumero(char entrada[])
  2426. {
  2427. int resultado=0;
  2428. int contador=0;
  2429. while(entrada[contador])
  2430. {
  2431. if(EsNumero(entrada[contador])==0)
  2432. {
  2433. resultado++;
  2434. }
  2435. contador++;
  2436. }
  2437. return resultado;
  2438. }
  2439.  
  2440. int EsNumero (char caracter[])
  2441. {
  2442. if(caracter >= '0' && caracter <= '9')
  2443. {
  2444. return 1;
  2445. }else
  2446. {
  2447. return 0;
  2448. }
  2449.  
  2450. }
  2451.  
  2452.  
  2453. void AgregarEspacio(Funcion funcion)
  2454. {
  2455. MbrDisco mbr;
  2456. int bandera=0;
  2457. FILE *fp;
  2458. fp = fopen(funcion.path, "rb");
  2459.  
  2460. if(fp == NULL)
  2461. {
  2462. printf("\n Error::-> No se encontro el disco\n");
  2463. }else {
  2464. fread(&mbr, sizeof(MbrDisco), 1, fp);
  2465. fclose(fp);
  2466. for (int i=0;i<4;i++) {
  2467. if(!strcmp(funcion.name,mbr.particiones[i].part_name))
  2468. {
  2469. bandera=1;
  2470. long espacio;
  2471. if(i==3)
  2472. {
  2473. espacio= mbr.mbr_tamano-(mbr.particiones[i+1].part_start+mbr.particiones[i+1].part_size);
  2474.  
  2475. }else {
  2476. if(mbr.particiones[i+1].part_status=='1')
  2477. {
  2478. espacio= mbr.particiones[i+1].part_start-(mbr.particiones[i+1].part_start+mbr.particiones[i+1].part_size);
  2479. }else
  2480. {
  2481. espacio= mbr.mbr_tamano-(mbr.particiones[i+1].part_start+mbr.particiones[i+1].part_size);
  2482. }
  2483. }
  2484.  
  2485. if(espacio>funcion.tamano)
  2486. {
  2487. printf("%d\n",mbr.mbr_disk_signature);
  2488. printf("%s\n",mbr.mbr_fit);
  2489. mbr.particiones[i].part_size=mbr.particiones[i].part_size+funcion.tamano;
  2490. FILE* file= fopen(funcion.path, "rb+");
  2491. fseek(file,0,SEEK_SET);
  2492.  
  2493. if (file==NULL)
  2494. {
  2495. printf("\nError::->Imposible escribir en el archivo \n\n");
  2496.  
  2497. }
  2498. else
  2499. {
  2500. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  2501. fclose(file);
  2502. printf("'PARTICION AMPLIADA EXITOSAMENTE'\n");
  2503. ContadorComandosExitosos++;
  2504. }
  2505.  
  2506. }else
  2507. {
  2508. printf("No hay espacio para ampliar la particion\n");
  2509. }
  2510. break;
  2511. }
  2512. }
  2513. if(bandera==0)
  2514. {
  2515. printf("No se encontro la particion\n");
  2516. }
  2517. }
  2518.  
  2519. }
  2520. void QuitarEspacio(Funcion funcion)
  2521. {
  2522. MbrDisco mbr;
  2523. int bandera=0;
  2524. FILE *fp;
  2525. fp = fopen(funcion.path, "rb");
  2526.  
  2527. if(fp == NULL)
  2528. {
  2529. printf("\n Error::-> No se encontro el disco\n");
  2530. }else {
  2531. fread(&mbr, sizeof(MbrDisco), 1, fp);
  2532. fclose(fp);
  2533. for (int i=0;i<4;i++) {
  2534. if(!strcmp(funcion.name,mbr.particiones[i].part_name))
  2535. {
  2536. bandera=1;
  2537.  
  2538.  
  2539. if(mbr.particiones[i].part_size-funcion.tamano>0)
  2540. {
  2541. mbr.particiones[i].part_size=mbr.particiones[i].part_size-funcion.tamano;
  2542. FILE* file= fopen(funcion.path, "rb+");
  2543. fseek(file,0,SEEK_SET);
  2544.  
  2545. if (file==NULL)
  2546. {
  2547. printf("\nError::->Imposible escribir en el archivo \n\n");
  2548. }
  2549. else
  2550. {
  2551. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  2552. fclose(file);
  2553. printf("'PARTICION REDUCIDA EXITOSAMENTE'\n");
  2554. ContadorComandosExitosos++;
  2555. }
  2556.  
  2557. }else
  2558. {
  2559. printf("No se puede reducir\n");
  2560. }
  2561. break;
  2562. }
  2563. }
  2564. if(bandera==0)
  2565. {
  2566. printf("No se encontro la particion\n");
  2567. }
  2568. }
  2569.  
  2570. }
  2571. void EliminarParticion(Funcion funcion)
  2572. {
  2573. MbrDisco mbr;
  2574. int bandera=0;
  2575. FILE *fp;
  2576. fp = fopen(funcion.path, "rb");
  2577.  
  2578. if(fp == NULL)
  2579. {
  2580. printf("\n Error::-> No se encontro el disco\n");
  2581. ErrorEliminarParticion++;
  2582. }else {
  2583. fread(&mbr, sizeof(MbrDisco), 1, fp);
  2584. fclose(fp);
  2585. for (int i=0;i<4;i++) {
  2586. if(!strcmp(funcion.name,mbr.particiones[i].part_name))
  2587. {
  2588. bandera=1;
  2589. switch (i) {
  2590. case 0:
  2591. mbr.particiones[0]=mbr.particiones[1];
  2592. mbr.particiones[1]=mbr.particiones[2];
  2593. mbr.particiones[2]=mbr.particiones[3];
  2594. mbr.particiones[3].part_start=-1;
  2595. mbr.particiones[3].part_status='0';
  2596. mbr.particiones[3].part_size=0;
  2597.  
  2598. break;
  2599. case 1:
  2600. mbr.particiones[1]=mbr.particiones[2];
  2601. mbr.particiones[2]=mbr.particiones[3];
  2602. mbr.particiones[3].part_start=-1;
  2603. mbr.particiones[3].part_status='0';
  2604. mbr.particiones[3].part_size=0;
  2605. break;
  2606. case 2:
  2607. mbr.particiones[2]=mbr.particiones[3];
  2608. mbr.particiones[3].part_start=-1;
  2609. mbr.particiones[3].part_status='0';
  2610. mbr.particiones[3].part_size=0;
  2611. break;
  2612. case 3:
  2613. mbr.particiones[3].part_start=-1;
  2614. mbr.particiones[3].part_status='0';
  2615. mbr.particiones[3].part_size=0;
  2616. break;
  2617. }
  2618. FILE* file= fopen(funcion.path, "rb+");
  2619. fseek(file,0,SEEK_SET);
  2620.  
  2621. if (file==NULL)
  2622. {
  2623. printf("\nError::->Imposible escribir en el archivo \n\n");
  2624. ErrorEliminarParticion++;
  2625. }
  2626. else
  2627. {
  2628. mbr.cantParticones--;
  2629. fwrite(&mbr, sizeof(MbrDisco), 1, file);//escribiendo la estructura del MBR
  2630. fclose(file);
  2631. printf("'PARTICION ELIMINADA EXITOSAMENTE'\n");
  2632. ContadorComandosExitosos++;
  2633. }
  2634.  
  2635. break;
  2636. }
  2637. }
  2638. if(bandera==0)
  2639. {
  2640. printf("No se encontro la particion\n");
  2641. ErrorEliminarParticion++;
  2642. }
  2643. }
  2644.  
  2645. }
  2646. int BuscarEspacioLogicaFF(EBR ebr,Funcion funcion,int inicio,MbrDisco mbr,EBR ebrNuevo)
  2647. {
  2648. printf("Buscando espacios en particion extendida\n");
  2649. int siguiente=ebr.part_next;
  2650. EBR sig;
  2651. EBR actual=ebr;
  2652. int contador=0;
  2653. while (siguiente!=-1) {
  2654. printf("Siguiente existe\n");
  2655. FILE *fp;
  2656. fp = fopen(funcion.path, "rb");
  2657. fseek(fp,siguiente+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  2658.  
  2659. if(fp == NULL)
  2660. {
  2661. printf("\n Error::-> No se encontro el disco\n");
  2662. }else {
  2663. fread(&sig, sizeof(EBR), 1, fp);
  2664. fclose(fp);
  2665. }
  2666. printf("Siguiente empieza en %d\n",siguiente+206);
  2667. printf("Siguiente es %s\n",sig.part_name);
  2668. if(contador==0)
  2669. {
  2670. printf("Primer particion logica\n");
  2671. printf("Inicio-> %d\n",inicio);
  2672. printf("Actual-> %d\n",actual.part_start+206);
  2673. printf("tamano-> %d\n",funcion.tamano+206);
  2674. if(inicio-actual.part_start>=funcion.tamano)
  2675. {
  2676. printf("Encontro Espacio entre el principio y la primera particion\n");
  2677. FILE* file= fopen(funcion.path, "rb+");
  2678. // estableciendo puntero al inicio
  2679. if (file==NULL)
  2680. {
  2681. printf("\nError::->Imposible escribir en el archivo \n\n");
  2682. }
  2683. else
  2684. {
  2685. EBR ebri;
  2686. ebri.part_next=inicio;
  2687. ebri.part_size=0;
  2688. ebri.part_start=0;
  2689. ebri.part_status='0';
  2690. ebrNuevo.part_start=inicio;
  2691. ebrNuevo.part_next=actual.part_start;
  2692. printf("Nuevo inicia en %d\n",ebrNuevo.part_start+206);
  2693. printf("Nuevo siguiente esta en %d\n\n",ebrNuevo.part_next+206);
  2694. fseek(file,inicio+sizeof (MbrDisco),SEEK_SET);
  2695. fwrite(&ebri, sizeof(EBR), 1, file);
  2696.  
  2697. fseek(file,inicio+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  2698. fwrite(&ebrNuevo, sizeof(EBR), 1, file);
  2699.  
  2700. fclose(file);
  2701. printf("'CREACION DE PARTICION EXITOSA'\n");
  2702. }
  2703. return inicio;
  2704. }
  2705. }
  2706. if(sig.part_start-(actual.part_start+actual.part_size)>=funcion.tamano)
  2707. {
  2708.  
  2709. printf("Encontro Espacio en medio\n");
  2710. FILE* file= fopen(funcion.path, "rb+");
  2711. // estableciendo puntero al inicio
  2712. if (file==NULL)
  2713. {
  2714. printf("\nError::->Imposible escribir en el archivo \n\n");
  2715. }
  2716. else
  2717. {
  2718. actual.part_next=actual.part_start+actual.part_size;
  2719. ebrNuevo.part_start=actual.part_start+actual.part_size;
  2720. ebrNuevo.part_next=sig.part_start;
  2721. printf("Actual inicia en %d\n",actual.part_start+206);
  2722. printf("Actual siguiente esta en %d\n",actual.part_next+206);
  2723. printf("Nuevo inicia en %d\n",ebrNuevo.part_start+206);
  2724. printf("Nuevo siguiente esta en %d\n\n",ebrNuevo.part_next+206);
  2725. fseek(file,actual.part_start+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  2726. fwrite(&actual, sizeof(EBR), 1, file);
  2727.  
  2728. fseek(file,ebrNuevo.part_start+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  2729. fwrite(&ebrNuevo, sizeof(EBR), 1, file);
  2730.  
  2731. fclose(file);
  2732. printf("'CREACION DE PARTICION EXITOSA'\n");
  2733. }
  2734. return actual.part_start+actual.part_size;
  2735. }
  2736. actual=sig;
  2737. siguiente=actual.part_next;
  2738. contador++;
  2739.  
  2740. }
  2741. printf("Encontro Espacio al final\n");
  2742. FILE* file= fopen(funcion.path, "rb+");
  2743. // estableciendo puntero al inicio
  2744. if (file==NULL)
  2745. {
  2746. printf("\nError::->Imposible escribir en el archivo \n\n");
  2747. }
  2748. else
  2749. {
  2750. actual.part_next=actual.part_start+actual.part_size;
  2751. ebrNuevo.part_start=actual.part_start+actual.part_size;
  2752. ebrNuevo.part_next=-1;
  2753. printf("Actual inicia en %d\n",actual.part_start+206);
  2754. printf("Actual siguiente esta en %d\n",actual.part_next+206);
  2755. printf("Nuevo inicia en %d\n",ebrNuevo.part_start+206);
  2756. printf("Nuevo siguiente esta en %d\n\n",ebrNuevo.part_next+206);
  2757.  
  2758. printf("EBR actual dir->%d\n",actual.part_start+sizeof (MbrDisco));
  2759. fseek(file,actual.part_start+sizeof (MbrDisco),SEEK_SET);
  2760. fwrite(&actual, sizeof(EBR), 1, file);
  2761.  
  2762. printf("EBR nuevo dir->%d\n",ebrNuevo.part_start+sizeof(EBR)+sizeof (MbrDisco));
  2763. fseek(file,ebrNuevo.part_start+sizeof(EBR)+sizeof (MbrDisco),SEEK_SET);
  2764. fwrite(&ebrNuevo, sizeof(EBR), 1, file);
  2765.  
  2766. fclose(file);
  2767. printf("'CREACION DE PARTICION EXITOSA'\n");
  2768. }
  2769. return actual.part_start+actual.part_size;
  2770.  
  2771.  
  2772.  
  2773. }
  2774. CrearParticionLogica(Funcion funcion)
  2775. {
  2776.  
  2777. MbrDisco mbr;
  2778. FILE *fp;
  2779. fp = fopen(funcion.path, "rb");
  2780.  
  2781. if(fp == NULL)
  2782. {
  2783. printf("\n Error::-> No se encontro el disco\n");
  2784. }else {
  2785. fread(&mbr, sizeof(MbrDisco), 1, fp);
  2786. fclose(fp);
  2787. }
  2788.  
  2789. int inicio;
  2790. //Creamos el ebr con sus atributos-------------------------------------------------------
  2791. EBR ebr;
  2792. int l=0;
  2793. for(int k=0;k<3;k++)
  2794. {
  2795. ebr.part_fit[l++]=funcion.fit[k];
  2796. }
  2797. ebr.part_next=-1;
  2798. ebr.part_size=funcion.tamano;
  2799. ebr.part_status='1';
  2800. strcpy(ebr.part_name,funcion.name);
  2801. ebr.part_type=funcion.type;
  2802.  
  2803. for (int i=0;i<4;i++) {
  2804. if(mbr.particiones[i].part_type=='E' || mbr.particiones[i].part_type=='e')
  2805. {
  2806. inicio=mbr.particiones[i].part_start;
  2807. }
  2808. }
  2809. printf("Particion extendida inicia en %d\n",inicio);
  2810. //Leemos el primer ebr de la particion extendida-----------------------------------------------------
  2811. EBR lec;
  2812.  
  2813. fp = fopen(funcion.path, "rb");
  2814. printf("EBR inicial dir->%d\n",inicio+sizeof (MbrDisco));
  2815. fseek(fp,inicio+sizeof (MbrDisco),SEEK_SET);
  2816.  
  2817. if(fp == NULL)
  2818. {
  2819. printf("\n Error::-> No se encontro el disco\n");
  2820. }else {
  2821. printf("Lectura de ebr inicial siguiente-> %d\n",lec.part_next+sizeof(EBR)+sizeof (MbrDisco));
  2822. fread(&lec, sizeof(EBR), 1, fp);
  2823. fclose(fp);
  2824. }
  2825. //----------------------------------------------------------------------------------------
  2826. BuscarEspacioLogicaFF(lec,funcion,inicio,mbr,ebr);
  2827.  
  2828.  
  2829.  
  2830. }
  2831. void Interprete(char entrada[])
  2832. {
  2833.  
  2834. Funcion nuevafuncion;
  2835. int size=0;
  2836. int unit=0;
  2837. int path=0;
  2838. int type=0;
  2839. int name=0;
  2840. int contenido=0;
  2841. int delete_=0;
  2842. int add=0;
  2843. int fit=0;
  2844. int fs=0;
  2845. int id=0;
  2846. int numeroparametros=0;
  2847. int contador=0;
  2848. int p=0;
  2849. int count=0;
  2850. int activarmount=0;
  2851. int contadorParametrosObligatorios=0;
  2852. char instruccion[100];
  2853. limpiarvar(instruccion,100);
  2854. char nombreparametro[100];
  2855. limpiarvar(nombreparametro,100);
  2856. char parametro[1000];
  2857. limpiarvar(parametro,1000);
  2858. nuevafuncion.count2=0;
  2859. int pa=0;
  2860.  
  2861.  
  2862.  
  2863. printf("Reconociendo comando...\n");
  2864. printf("---------------------Lectura Comando--------------------\n");
  2865. //INICIO----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  2866.  
  2867. while(entrada[contador]!=NULL){//While Comando NULO
  2868.  
  2869. if(entrada[contador]=='#')//------------------------->COMENTARIO-----------------------------------------------------------------------------------------------------------
  2870. {
  2871. //printf("Reconocio: COMENTARIO\n");
  2872. while(entrada[contador]!='\n' && entrada[contador]!='\0')
  2873. {
  2874. comentario=1;
  2875. contador++;
  2876. }
  2877. printf("Comentario");
  2878. }
  2879. else if(entrada[contador]==' ')//-------------------->ESPACIO EN BLANCO--------------------------------------------------------------------------------------------------------------------------
  2880. {
  2881.  
  2882. //printf("Reconocio(): ESPACIO\n");
  2883. contador++;
  2884.  
  2885. }else if(EsLetra(entrada[contador])==1){//------------>LETRA--------------------------------------------------------------------------------------------------------------------------------------
  2886.  
  2887. while(EsLetra(entrada[contador])==1)
  2888. {
  2889. char nuevoCaracter[1];
  2890. nuevoCaracter[0]=entrada[contador];
  2891. strncat(instruccion,nuevoCaracter,1);
  2892. contador++;
  2893. }
  2894.  
  2895. size=0;
  2896. unit=0;
  2897. path=0;
  2898. type=0;
  2899. fit=0;
  2900. delete_=0;
  2901. name=0;
  2902. add=0;
  2903. numeroparametros=0;
  2904. id=0;
  2905. contenido=0;
  2906. fs=0;
  2907.  
  2908. //Quitar Mayusculas----------------------------------------------------------------------------------------------------------------------------------------
  2909. int contadormay=0;
  2910. while(instruccion[contadormay])
  2911. {
  2912. instruccion[contadormay]=tolower(instruccion[contadormay]);
  2913. contadormay++;
  2914. }
  2915.  
  2916.  
  2917. strcpy(nuevafuncion.nombre,instruccion);
  2918. printf("----%s----\n", nuevafuncion.nombre);
  2919.  
  2920. }else if((entrada[contador]=='-' || entrada[contador]=='\–')){//--------------------------->Parametro--------------------------------------------------------------------------------------
  2921.  
  2922. numeroparametros++;
  2923. contador++;
  2924. while(entrada[contador]!='~')//limite del parametro(-Size~:~3000)
  2925. {
  2926. //Guardar nombre parametro
  2927. char nuevoCaracter[1];
  2928. nuevoCaracter[0]=entrada[contador];
  2929. strncat(nombreparametro,nuevoCaracter,1);
  2930. contador++;
  2931. }
  2932.  
  2933. //tomar valor del parametro (~:~)
  2934. if(entrada[contador]=='~' && entrada[contador+1]==':' && entrada[contador+2]=='~'){
  2935. //si encuentra los simbolos
  2936. //pa=1;
  2937. contador=contador+3;//saltarse la flecha
  2938. int contadorpar=0;
  2939. while(nombreparametro[contadorpar])// cambiar a minusculas el nombre del parametro
  2940. {
  2941. nombreparametro[contadorpar]=tolower(nombreparametro[contadorpar]);
  2942. contadorpar++;
  2943. }
  2944. printf("%s::= ",nombreparametro);
  2945.  
  2946.  
  2947. char prueba;
  2948. if(entrada[contador]!='\"')//si no hay comillas en el contenido del parametro
  2949. {
  2950. while(entrada[contador]!=' ' && entrada[contador]!='\n' && entrada[contador]!='#' && entrada[contador]!=NULL)
  2951. {
  2952. char nuevoCaracter[1];
  2953. nuevoCaracter[0]=entrada[contador];
  2954. strncat(parametro,nuevoCaracter,1);
  2955. contador++;
  2956. }
  2957.  
  2958. printf(" %s\n",parametro);
  2959. char fn[1];
  2960. fn[0]='\0';
  2961. strncat(parametro,fn,1);
  2962.  
  2963. }else //si existieran comillas en el parametro
  2964. {
  2965. char nuevoCaracter[1];
  2966. nuevoCaracter[0]=entrada[contador];
  2967. strncat(parametro,nuevoCaracter,1);
  2968. contador++;
  2969. while(entrada[contador]!='\"') //&& entrada[contador]!=' ' esto se quita si truena
  2970. {
  2971. prueba=entrada[contador];
  2972. char nuevoCaracter[1];
  2973. nuevoCaracter[0]=entrada[contador];
  2974. strncat(parametro,nuevoCaracter,1);
  2975.  
  2976. contador++;
  2977. }
  2978. char y6[1];
  2979. y6[0]=entrada[contador];
  2980. strncat(parametro,y6,1);
  2981. contador++;
  2982. char fn[1];
  2983. fn[0]='\0';
  2984. strncat(parametro,fn,1);
  2985. printf(" con Comillas -> %s\n",parametro);
  2986. }
  2987. //pa=0;
  2988. }else{
  2989. printf("Error::-> Sintaxis Incorrecta Esperaba '->' \n");
  2990. ErrorInterprete++;
  2991. }
  2992.  
  2993.  
  2994. //Inicia el Reconocimiento de los Parametros
  2995. if(!strcmp(nombreparametro,"size"))//---------------Reconocio size----------------------------------------------------------------------
  2996. {
  2997. //Validar mayor que >0
  2998. size=1;
  2999. if(EsNumero(parametro)==0)
  3000. {
  3001. nuevafuncion.size=atoi(parametro);
  3002.  
  3003.  
  3004. limpiarvar(parametro,1000);
  3005. limpiarvar(nombreparametro,100);
  3006. limpiarvar(parametro,1000);
  3007. limpiarvar(nombreparametro,100);
  3008.  
  3009. }else{
  3010. printf("\nError::-> Parametro de 'size' Invalido \n\n");
  3011. ErrorInterprete++;
  3012. size=0;
  3013. }
  3014. }else if(!strcmp(nombreparametro,"path"))//------------Reconocio path----------------------------------------------------------------------------------------------
  3015. {
  3016.  
  3017. path=1;
  3018. strcpy(nuevafuncion.path,parametro);
  3019. limpiarvar(parametro,1000);
  3020. limpiarvar(nombreparametro,100);
  3021.  
  3022. }else if(!strcmp(nombreparametro,"id"))//------------Reconocio id----------------------------------------------------------------------------------------------
  3023. {
  3024.  
  3025. id=1;
  3026. strcpy(nuevafuncion.id,parametro);
  3027. limpiarvar(parametro,1000);
  3028. limpiarvar(nombreparametro,100);
  3029.  
  3030. }else if(!strcmp(nombreparametro,"unit"))//------------Reconocio unit-------------------------------------------------------------------------------------------------
  3031. {
  3032. unit=2;
  3033. // solo my k valores correctos
  3034. if(parametro[0]=='m' || parametro[0]=='k'||parametro[0]=='M' || parametro[0]=='K'||parametro[0]=='b' || parametro[0]=='B')
  3035. {
  3036. nuevafuncion.unit=parametro[0];
  3037. limpiarvar(parametro,1000);
  3038. limpiarvar(nombreparametro,100);
  3039. }
  3040. else
  3041. {
  3042. unit=0;
  3043. printf("\nError::-> Parametro 'unit' Invalido \n\n");
  3044. ErrorInterprete++;
  3045. }
  3046. }else if(!strcmp(nombreparametro,"fit"))//--------------Reconocio fit-------------------------------------------------------------------------------------------------
  3047. {
  3048. fit=2;
  3049. if(!strcmp(parametro,"bf") || !strcmp(parametro,"ff") || !strcmp(parametro,"wf")||!strcmp(parametro,"BF") || !strcmp(parametro,"FF") || !strcmp(parametro,"WF") )
  3050. {
  3051. strcpy(nuevafuncion.fit,parametro);
  3052. limpiarvar(parametro,1000);
  3053. limpiarvar(nombreparametro,100);
  3054. }
  3055. else
  3056. {
  3057. fit=0;
  3058. printf("\nError::-> Parametro 'fit' Invalido \n\n");
  3059. ErrorInterprete++;
  3060. }
  3061. }else if(!strcmp(nombreparametro,"name"))//---------------Reconocio name--------------------------------------------------------------------------------------------------
  3062. {
  3063.  
  3064. name=1;
  3065. char env[1000];
  3066. strcpy(env,parametro);
  3067. quitarComillas(env);
  3068. strcpy(nuevafuncion.name,sincomillas);
  3069. limpiarvar(parametro,1000);
  3070. limpiarvar(nombreparametro,100);
  3071.  
  3072. }else if(!strcmp(nombreparametro,"type"))//------------------reconoce type
  3073. {
  3074.  
  3075. type=2;
  3076. if(parametro[0]=='p' || parametro[0]=='e' || parametro[0]=='l'||parametro[0]=='P' || parametro[0]=='E' || parametro[0]=='L'){
  3077. nuevafuncion.type=parametro[0];
  3078. limpiarvar(parametro,1000);
  3079. limpiarvar(nombreparametro,100);
  3080. }/*else if(!strcmp(parametro,"fast") || !strcmp(parametro,"full")){
  3081.  
  3082. strcpy(nuevafuncion.typeFormatear,parametro);
  3083. limpiarvar(parametro,1000);
  3084. limpiarvar(nombreparametro,100);
  3085. }*/
  3086. else{
  3087. type=0;
  3088. printf("\nError::-> Parametro 'type' Invalido \n\n");
  3089. ErrorInterprete++;
  3090. }
  3091.  
  3092. }else if(!strcmp(nombreparametro,"delete"))//------------------reconoce delete
  3093. {
  3094. delete_=2;
  3095. if((!strcmp(parametro,"fast")) || (!strcmp(parametro,"full"))||(!strcmp(parametro,"FULL")) || (!strcmp(parametro,"FAST")) )
  3096. {
  3097. strcpy(nuevafuncion.delete_,parametro);
  3098. limpiarvar(parametro,1000);
  3099. limpiarvar(nombreparametro,100);
  3100. }
  3101. else
  3102. {
  3103. delete_=0;
  3104. printf("\nError::-> Parametro 'delete' Invalido \n\n");
  3105. ErrorInterprete++;
  3106. }
  3107. }else if(!strcmp(nombreparametro,"add"))//--------------------reconoce add
  3108. {
  3109. add=2;
  3110. if(CadenaEsNumero(parametro)==0)
  3111. {
  3112. nuevafuncion.add=atoi(parametro);
  3113. limpiarvar(parametro,1000);
  3114. limpiarvar(nombreparametro,100);
  3115. }
  3116. else if(parametro[0]=='-')
  3117. {
  3118.  
  3119. nuevafuncion.add=atoi(parametro)*-1;
  3120. limpiarvar(parametro,1000);
  3121. limpiarvar(nombreparametro,100);
  3122. add=1;
  3123.  
  3124. }
  3125. else{
  3126. printf("\nError::-> Parametro 'add' Invalido\n\n");
  3127. ErrorInterprete++;
  3128. add=0;
  3129. }
  3130. }else{
  3131. printf("Error::-> Parametro Opcional Invalido \n\n");
  3132. ErrorInterprete++;
  3133. }
  3134.  
  3135.  
  3136. }else if(entrada[contador]=='\n'){//--------------------------->Salto de Linea------------------------------------------------------------------------------------------
  3137.  
  3138. }//Fin Salto Linea
  3139. else{ //------------------------------------------------------->SEGUIR AVANZANDO LA CADENA
  3140. contador++;
  3141. }
  3142.  
  3143. }//Fin While Detectar comando
  3144. printf("--------------------Ejecucion Comando-------------------\n");
  3145. printf("Ejecutando comando...\n");
  3146.  
  3147. //Verifica que sea el fin y no Existan errores en el interprete
  3148. if(ErrorInterprete==0 && fin==0){
  3149.  
  3150. if(instruccion!=NULL||instruccion[0]!='\0'){
  3151.  
  3152. if(!strcmp(instruccion,"mkdisk")){//----------------------------->mkdisk--------------------------------------------------------
  3153.  
  3154.  
  3155. printf("////MKDISK////\n");
  3156.  
  3157.  
  3158. if(unit==0){
  3159. printf("Colocando unit megas...\n");
  3160. nuevafuncion.unit='m';
  3161. }else{
  3162.  
  3163. if(nuevafuncion.unit=='b'){
  3164. printf("\nError::-> Unidad no permitida para Mkdisk\n\n");
  3165. printf("Colocando unit megas...\n");
  3166. nuevafuncion.unit='m';
  3167. }else{
  3168. }
  3169. }
  3170. if(fit==0){
  3171. printf("Colocando fit primer ajuste...\n");
  3172. strcpy(nuevafuncion.fit,"FF");
  3173. }
  3174.  
  3175.  
  3176.  
  3177.  
  3178. if(unit==0 && numeroparametros==3 && path==1 && fit==2 && size==1)
  3179. {
  3180. printf("Creando disco...\n\n");
  3181. CrearDisco(nuevafuncion);
  3182. limpiarvar(instruccion,100);
  3183.  
  3184. }
  3185. else if(unit==2 && numeroparametros==4 && path==1 && fit==2 && size==1)
  3186. {
  3187. printf("Creando disco... \n\n");
  3188. CrearDisco(nuevafuncion);
  3189. limpiarvar(instruccion,100);
  3190.  
  3191. }
  3192. else if(unit==2 && numeroparametros==3 && path==1 && fit==0 && size==1)
  3193. {
  3194. printf("Creando disco... \n\n");
  3195. CrearDisco(nuevafuncion);
  3196. limpiarvar(instruccion,100);
  3197.  
  3198. }
  3199. else if(unit==0 && numeroparametros==2 && path==1 && fit==0 && size==1)
  3200. {
  3201. printf("Creando disco... \n\n");
  3202. CrearDisco(nuevafuncion);
  3203. limpiarvar(instruccion,100);
  3204.  
  3205. }
  3206. else
  3207. {
  3208. printf("Error::-> Parametros 'mkdisk' Invalidos\n\n");
  3209. ErrorComando++;
  3210. }
  3211.  
  3212. ContadorInstrucciones++;
  3213. limpiarvar(instruccion,100);
  3214. //fin del mkdisk
  3215. }else if(!strcmp(instruccion,"fdisk")){//------------------------------------------->fdisk-------------------------------------------------------------------
  3216.  
  3217. printf("////FDISK////\n");
  3218.  
  3219. ContadorInstrucciones++;
  3220. 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) )
  3221. {
  3222.  
  3223. if(unit==0){
  3224. printf("Colocando unit en kilobytes...\n");
  3225. nuevafuncion.unit='k';
  3226. }
  3227. if(type==0){
  3228. printf("Colocando type primaria...\n");
  3229. nuevafuncion.type='p';
  3230. }
  3231. if(fit==0){
  3232. printf("Colocando fit peor ajuste...\n");
  3233. strcpy(nuevafuncion.fit,"wf");
  3234. }
  3235. /*if(allocation==0){
  3236. printf("Colocando allocation Aleatorio...\n");
  3237. strcpy(nuevafuncion.allocation,"IX");
  3238. }*/
  3239.  
  3240. if(nuevafuncion.unit=='b' || nuevafuncion.unit=='B')
  3241. {
  3242. nuevafuncion.tamano=nuevafuncion.add;
  3243. }else if(nuevafuncion.unit=='k' || nuevafuncion.unit=='K')
  3244. {
  3245. nuevafuncion.tamano=nuevafuncion.add*1024;
  3246. }else
  3247. {
  3248. nuevafuncion.tamano=nuevafuncion.add*(1024*1024);
  3249. }
  3250.  
  3251. if((add==1 && delete_==1)||(add==2 && delete_==2)||(add==1 && delete_==2)||(add==2 && delete_==1))
  3252. {
  3253. printf("\nError::-> Parametros 'fdisk' Invalidos(add y delete estan juntos)\n\n");
  3254. ErrorComando++;
  3255. }else if(add==2 && delete_==0||add==1 && delete_==0){//---------AUMENTAR TAMAÑO
  3256.  
  3257.  
  3258. if(add==2){// agrega espacio
  3259. printf("Aumentando...\n");
  3260. AgregarEspacio(nuevafuncion);
  3261. }else
  3262. if(add==1){ //quita espacio
  3263. printf("Reduciendo...\n");
  3264. QuitarEspacio(nuevafuncion);
  3265.  
  3266. }else{
  3267. printf("\nError::-> Parametros 'fdisk' Invalidos error en add\n\n");
  3268. ErrorComando++;
  3269. }
  3270. limpiarvar(instruccion,100);
  3271. }else if(add==0 && delete_==2){//_----------------------------------->Elimnar Particion-----------------------------------------------
  3272.  
  3273. if(nuevafuncion.type=='p' || nuevafuncion.type=='e'||nuevafuncion.type=='P' || nuevafuncion.type=='E')
  3274. {
  3275.  
  3276. int opcion;
  3277. printf("%s\n", "¿Desea eliminar esta Particion?");
  3278. printf("%s\n", "1.-SI");
  3279. printf("%s\n", "2.-NO");
  3280.  
  3281. printf("%s\n", "");
  3282. printf(">:~$ ");
  3283. scanf("%d",&opcion);
  3284.  
  3285. if(opcion>0 && opcion<3){
  3286.  
  3287. switch(opcion)
  3288. {
  3289. case 1:
  3290. //-----------------------------------------------EliminarParticion(funcion)-----------------------------------------;
  3291. printf("Eliminando Particion...\n");
  3292. EliminarParticion(nuevafuncion);
  3293. limpiarvar(instruccion,100);
  3294. break;
  3295. case 2:
  3296. printf("-------------------------Eliminacion Cancelada-------------------\n");
  3297. break;
  3298. default:
  3299. printf("Error::-> Opcion Incorrecta \n");
  3300. break;
  3301. }
  3302. }else
  3303. {
  3304. opcion=1;
  3305. printf(" \n");
  3306. printf("%s\n", "Error::-> Opcion incorrecta ");
  3307. }
  3308.  
  3309. }
  3310. else
  3311. {
  3312. //--------------------------------------------------EliminarParticionLogica(funcion);
  3313. printf("Eliminando Particion Logica...\n");
  3314. limpiarvar(instruccion,100);
  3315. }
  3316.  
  3317. }else if (add==0 && delete_==0 && size==1){//--------------------------Crear Particion---------------------
  3318.  
  3319. if(nuevafuncion.type=='p' || nuevafuncion.type=='e'||nuevafuncion.type=='P' || nuevafuncion.type=='E')
  3320. {
  3321. printf("Creando Particion...\n\n");
  3322. //--------------------------------------------------CrearParticion(nuevafuncion);
  3323. CrearParticion(nuevafuncion);
  3324. limpiarvar(instruccion,100);
  3325.  
  3326. }
  3327. else
  3328. {
  3329. printf("Creando Particion Logica...\n");
  3330. //--------------------------------------------------CrearParticionLogica(nuevafuncion);
  3331. if(nuevafuncion.unit=='b' || nuevafuncion.unit=='B')
  3332. {
  3333. nuevafuncion.tamano=nuevafuncion.size;
  3334. }else if(nuevafuncion.unit=='k' || nuevafuncion.unit=='K')
  3335. {
  3336. nuevafuncion.tamano=nuevafuncion.size*1024;
  3337. }else
  3338. {
  3339. nuevafuncion.tamano=nuevafuncion.size*(1024*1024);
  3340. }
  3341. CrearParticionLogica(nuevafuncion);
  3342. limpiarvar(instruccion,100);
  3343.  
  3344. }
  3345.  
  3346. }else{
  3347. printf("\nError::-> Crear Particion\n\n");
  3348. ErrorComando++;
  3349.  
  3350. }
  3351.  
  3352.  
  3353. }else{
  3354. printf("\nError::-> Parametros Obligatorios 'fdisk' no ingresados\n\n");
  3355. ErrorComando++;
  3356. }
  3357.  
  3358. }else if(!strcmp(instruccion,"mount")){//--------------------------------------------------------MOUNT-----------------------------------------
  3359. printf("////MOUNT////\n");
  3360. ContadorInstrucciones++;
  3361. //montar una particion del disco en el sistema
  3362. if(path==1 && name==1 && numeroparametros==2 )
  3363. {
  3364. printf("Montando Particion... \n");
  3365. Montura *particion= DeterminarNombre(nuevafuncion);
  3366. if(particion!=NULL)
  3367. {
  3368. montar(particion);
  3369. ContadorComandosExitosos++;
  3370. Recorrer();
  3371. }
  3372.  
  3373. limpiarvar(instruccion,100);
  3374.  
  3375. }else if(numeroparametros!=1)
  3376. {
  3377. printf("\nError::-> Parametros 'Mount' invalidos\n\n");
  3378. ErrorComando++;
  3379. }else{
  3380. printf("\nError::-> Parametros Obligatorios 'Mount' no ingresados\n\n");
  3381. ErrorComando++;
  3382. }
  3383. }else if(!strcmp(instruccion,"unmount")){//--------------------------------------------------------UNMOUNT-----------------------------------------
  3384. printf("////UNMOUNT////\n");
  3385. ContadorInstrucciones++;
  3386. //montar una particion del disco en el sistema
  3387. if(id==1 && numeroparametros==1 )
  3388. {
  3389. printf("Desmontando Particion... \n");
  3390. desmontar(nuevafuncion);
  3391. ContadorComandosExitosos++;
  3392. Recorrer();
  3393. limpiarvar(instruccion,100);
  3394.  
  3395. }else if(numeroparametros!=1)
  3396. {
  3397. printf("\nError::-> Parametros 'Unmount' invalidos\n\n");
  3398. ErrorComando++;
  3399. }else{
  3400. printf("\nError::-> Parametros Obligatorios 'Mount' no ingresados\n\n");
  3401. ErrorComando++;
  3402. }
  3403. }else if(!strcmp(instruccion,"rmdisk")){//--------------------------------------------------------RMDISK-----------------------------------------
  3404. printf("////RMDISK////\n");
  3405. ContadorInstrucciones++;
  3406. //eliminar archivo que representa a un disco duro
  3407. if(path==1 && numeroparametros==1 )
  3408. {
  3409. printf("Eliminando representacion de disco... \n");
  3410. ELiminarDisco(nuevafuncion);
  3411. limpiarvar(instruccion,100);
  3412.  
  3413. }else if(numeroparametros!=1)
  3414. {
  3415. printf("\nError::-> Parametros 'Rmdisk' invalidos\n\n");
  3416. ErrorComando++;
  3417. }
  3418. else{
  3419. printf("\nError::-> Parametros Obligatorios 'Mount' no ingresados\n\n");
  3420. ErrorComando++;
  3421. }
  3422. }else if(!strcmp(instruccion,"exec")){//--------------------------------------------------------exec-----------------------------------------
  3423. printf("////EXEC////\n");
  3424. ContadorInstrucciones++;
  3425. //eliminar archivo que representa a un disco duro
  3426. if(path==1 && numeroparametros==1 )
  3427. {
  3428. printf("Ejecuando script... \n");
  3429. Exec(nuevafuncion);
  3430. limpiarvar(instruccion,100);
  3431.  
  3432. }else if(numeroparametros!=1)
  3433. {
  3434. printf("\nError::-> Parametros 'exec' invalidos\n\n");
  3435. ErrorComando++;
  3436. }
  3437. else{
  3438. printf("\nError::-> Parametros Obligatorios 'exec' no ingresados\n\n");
  3439. ErrorComando++;
  3440. }
  3441. }else if(!strcmp(instruccion,"rep")){//--------------------------------------------------------rep-----------------------------------------
  3442. printf("////REP////\n");
  3443. ContadorInstrucciones++;
  3444. //eliminar archivo que representa a un disco duro
  3445. if(path==1 && name==1 && id==1 && numeroparametros==3 )
  3446. {
  3447. if((nuevafuncion.name[0]=='m' && nuevafuncion.name[1]=='b' && nuevafuncion.name[2]=='r') || (nuevafuncion.name[0]=='d' && nuevafuncion.name[1]=='i' && nuevafuncion.name[2]=='s' && nuevafuncion.name[3]=='k'))
  3448. {
  3449. if(nuevafuncion.name[0]=='m')
  3450. {
  3451. printf("Generando Reporte MBR... \n");
  3452. Graficar(nuevafuncion);
  3453. }else {
  3454. printf("Generando Reporte Disk...\n");
  3455. Graficar2(nuevafuncion);
  3456. }
  3457. limpiarvar(instruccion,100);
  3458. }else {
  3459. printf("Error::-> Nombre imcorrecto");
  3460. }
  3461.  
  3462.  
  3463. }else if(numeroparametros!=3)
  3464. {
  3465. printf("\nError::-> Parametros 'rep' invalidos\n\n");
  3466. ErrorComando++;
  3467. }
  3468. else{
  3469. printf("\nError::-> Parametros Obligatorios 'rep' no ingresados\n\n");
  3470. ErrorComando++;
  3471. }
  3472. }else{
  3473. printf("\nError::-> Instruccion no encontrada \n\n");
  3474. ErrorInterprete++;
  3475. }
  3476.  
  3477. }
  3478.  
  3479. }else{
  3480. printf("\nError-> Fallo en el interprete\n");
  3481. //printf("\n ->Errores Encontrados En Interprete : '%i' \n", ErrorInterprete);
  3482. }
  3483.  
  3484.  
  3485. }
  3486.  
  3487. int menu_principal (){
  3488.  
  3489. int opcion=1;
  3490. char comando[100];
  3491. char * ptr3;
  3492. printf("%s\n", "________________________________________________________");
  3493. printf(" %s\n", "PROYECTO NO. 1/ FASE NO. 1");
  3494. printf("%s\n", "________________________________________________________");
  3495. printf("%s\n", "");
  3496. printf("%s\n", "");
  3497. printf(">:~$ ");
  3498. while(strcmp(comando,"salir")!=0)
  3499. {
  3500. scanf(" %[^\n]", comando);
  3501. ptr3=strtok(comando,"\n");
  3502. comentario=0;
  3503. fin=0;
  3504. ErrorInterprete=0;
  3505. while(ptr3!=NULL){
  3506. printf("--------------------------------------------------------\n");
  3507.  
  3508. printf("%s\n", "");
  3509. printf("%s\n", "");
  3510. printf("Linea ->%s\n",ptr3);
  3511.  
  3512. if(!strcmp(ptr3,"exit"))
  3513. {
  3514.  
  3515. }else {
  3516. Interprete(ptr3);
  3517. }
  3518.  
  3519. ptr3=strtok(NULL,"\n");
  3520.  
  3521. }
  3522.  
  3523.  
  3524. /*----------------------------------------------------------------------*/
  3525.  
  3526.  
  3527.  
  3528. }
  3529.  
  3530.  
  3531. }
  3532.  
  3533.  
  3534. int main()
  3535. {
  3536. ContadorInstrucciones=0;
  3537. ContadorComandosExitosos=0;
  3538.  
  3539. ErrorInterprete=0;
  3540. ErrorComando=0;
  3541. ErrorCrearDisco=0;
  3542. ErrorEliminarDisco=0;
  3543. ErrorCrearParticion=0;
  3544. ErrorEliminarParticion=0;
  3545. ErrorCrearParticionLogica=0;
  3546. ErrorEliminarLogica=0;
  3547. ErrorReporte1=0;
  3548. ErrorReporte2=0;
  3549. comentario=0;
  3550.  
  3551. int fin=0;
  3552.  
  3553. sincomillas[1000];// se usa en el Metodo quitarComillas
  3554.  
  3555. sistema = (Lista*)malloc(sizeof (Lista));
  3556. sistema->primero=NULL;
  3557. sistema->ultimo=NULL;
  3558. //inicia El lanzador del programa
  3559. menu_principal();
  3560. printf("No. Instrucciones -> %d\n",ContadorInstrucciones);
  3561. printf("No. Comandos Existosos -> %d\n",ContadorComandosExitosos);
  3562.  
  3563. }
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!