API tools faq
paste
Advertisement
techno-

p3 17:30

techno-
Dec 15th, 2022
113
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 63.49 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.     Javier Sobrino González
  3.     Javier Loureiro Pérez
  4. */
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <unistd.h>
  10. #include <time.h>
  11. #include <sys/types.h>
  12. #include <limits.h>
  13. #include <sys/stat.h>
  14. #include <errno.h>
  15. #include <sys/utsname.h>
  16. #include <pwd.h>
  17. #include <grp.h>
  18. #include <dirent.h>
  19. #include <sys/shm.h>
  20. #include <sys/mman.h>
  21. #include <fcntl.h>
  22. #include <sys/wait.h>
  23. #include <stdbool.h>
  24. #include <sys/resource.h>
  25. #include <ctype.h>
  26. #include "ListaHistorial.h"
  27. #include "ListaBloques.h"
  28. #include "ListaShared.h"
  29. #include "ListaMmap.h"
  30. #include "ListaProcesos.h"
  31.  
  32. void cmdCambiarVar();
  33. void MostrarEntorno();
  34. void cmdEntorno();
  35. int CambiarVariable();
  36. int BuscarVariable (char * var, char *e[]);
  37. void ejecutarComando2(char *linea);
  38.  
  39. char **entorno;
  40. extern char **environ;
  41.  
  42. struct SEN{
  43.         char *nombre;
  44.         int senal;
  45. };
  46. static struct SEN sigstrnum[]={
  47.     {"HUP", SIGHUP},
  48.     {"INT", SIGINT},
  49.     {"QUIT", SIGQUIT},
  50.     {"ILL", SIGILL},
  51.     {"TRAP", SIGTRAP},
  52.     {"ABRT", SIGABRT},
  53.     {"IOT", SIGIOT},
  54.     {"BUS", SIGBUS},
  55.     {"FPE", SIGFPE},
  56.     {"KILL", SIGKILL},
  57.     {"USR1", SIGUSR1},
  58.     {"SEGV", SIGSEGV},
  59.     {"USR2", SIGUSR2},
  60.     {"PIPE", SIGPIPE},
  61.     {"ALRM", SIGALRM},
  62.     {"TERM", SIGTERM},
  63.     {"CHLD", SIGCHLD},
  64.     {"CONT", SIGCONT},
  65.     {"STOP", SIGSTOP},
  66.     {"TSTP", SIGTSTP},
  67.     {"TTIN", SIGTTIN},
  68.     {"TTOU", SIGTTOU},
  69.     {"URG", SIGURG},
  70.     {"XCPU", SIGXCPU},
  71.     {"XFSZ", SIGXFSZ},
  72.     {"VTALRM", SIGVTALRM},
  73.     {"PROF", SIGPROF},
  74.     {"WINCH", SIGWINCH},
  75.     {"IO", SIGIO},
  76.     {"SYS", SIGSYS},
  77. /*senales que no hay en todas partes*/
  78. #ifdef SIGPOLL
  79.     {"POLL", SIGPOLL},
  80. #endif
  81. #ifdef SIGPWR
  82.     {"PWR", SIGPWR},
  83. #endif
  84. #ifdef SIGEMT
  85.     {"EMT", SIGEMT},
  86. #endif
  87. #ifdef SIGINFO
  88.     {"INFO", SIGINFO},
  89. #endif
  90. #ifdef SIGSTKFLT
  91.     {"STKFLT", SIGSTKFLT},
  92. #endif
  93. #ifdef SIGCLD
  94.     {"CLD", SIGCLD},
  95. #endif
  96. #ifdef SIGLOST
  97.     {"LOST", SIGLOST},
  98. #endif
  99. #ifdef SIGCANCEL
  100.     {"CANCEL", SIGCANCEL},
  101. #endif
  102. #ifdef SIGTHAW
  103.     {"THAW", SIGTHAW},
  104. #endif
  105. #ifdef SIGFREEZE
  106.     {"FREEZE", SIGFREEZE},
  107. #endif
  108. #ifdef SIGLWP
  109.     {"LWP", SIGLWP},
  110. #endif
  111. #ifdef SIGWAITING
  112.     {"WAITING", SIGWAITING},
  113. #endif
  114.     {NULL,-1},
  115.     };    /*fin array sigstrnum */
  116.  
  117.  
  118. #define MaxTrozos 512
  119. #define MaxHist 4096
  120. #define TAMANO 2048
  121.  
  122.  
  123. char linea[4096];
  124. char *trozos[MaxTrozos];
  125. int numtrozos;
  126. int pidglobal;
  127.  
  128. int EntraEnBloque=0;
  129. int EntraEnShared=0;
  130. int EntraEnMmap=0;
  131.  
  132. static int varMem;
  133. static int varMem2;
  134. static int varMem3;
  135.  
  136. void ejecutarComando(char *linea);
  137.  
  138. int TrocearCadena(char * cadena, char * trozos[]){
  139.     int i=1;
  140.     if ((trozos[0]=strtok(cadena," \n\t"))==NULL)
  141.     return 0;
  142.     while ((trozos[i]=strtok(NULL," \n\t"))!=NULL)
  143.         i++;
  144.     return i;
  145. }
  146.  
  147.  
  148. //Comandos del shell
  149.  
  150. //Comando autores
  151. void cmdAutores(){
  152.  
  153.     char flagLogin= 1, flagNombre=1;
  154.  
  155.     if(numtrozos > 1 && strcmp(trozos[1], "-l") == 0)
  156.         flagNombre= 0;
  157.     if(numtrozos > 1 && strcmp(trozos[1], "-n") == 0)
  158.         flagLogin = 0;
  159.  
  160.     if(flagLogin){
  161.         printf("Login: j.loureirop\n");
  162.         printf("Login: javier.sobrino\n");
  163.     }
  164.     if(flagNombre){
  165.         printf("Nombre: Javier Loureiro\n");
  166.         printf("Nombre: Javier Sobrino\n");
  167.     }
  168. }
  169.  
  170. //Comando Fin (sale del shell)
  171. void cmdFin(){
  172.     exit(0);
  173. }
  174.  
  175. //Comando Pid
  176. void cmdPid(){
  177.  
  178.     if(numtrozos == 1)
  179.         printf("Pid del shell: %d\n", getpid());
  180.     else if (numtrozos > 1)
  181.         printf("Pid del padre del shell: %d\n", getppid());
  182. }
  183.  
  184.  
  185. //Comando Carpeta
  186. void cmdCarpeta(){
  187.     char ruta[PATH_MAX];
  188.  
  189.     if(numtrozos == 1){
  190.         if(getcwd(ruta, PATH_MAX) == NULL){
  191.             perror("getcwd");
  192.             return;
  193.         }
  194.         else{
  195.             printf("%s\n", ruta);
  196.             return;
  197.         }
  198.     }
  199.     else if(numtrozos > 1){
  200.         if (chdir(trozos[1]) == -1) {perror("chdir"); return;}
  201.         else
  202.             chdir(trozos[1]);
  203.     }
  204. }
  205.  
  206. //Comando comandoN
  207. void cmdComandoN(){
  208.     int n;
  209.  
  210.     if(numtrozos == 1) {printf("Falta número de comando \n"); return;}
  211.     n = atoi(trozos[1]);
  212.  
  213.     if(n < 0 || n >= histNumElementos()) {printf("Número de comando fuera de rango \n"); return;}
  214.     else {
  215.         printf(" %s",histElemento(n));
  216.     }
  217. }
  218.  
  219. //Comando fecha
  220. void cmdFecha(){
  221.  
  222.     struct tm *t;
  223.     time_t tiempo;
  224.  
  225.     if(time(&tiempo) == -1) {perror("time"); return;}
  226.     t = localtime(&tiempo);
  227.  
  228.     if(numtrozos > 1 && strcmp(trozos[1], "-d") == 0)
  229.         printf("%d/%d/%d\n", t->tm_mday, t->tm_mon, t->tm_year+1900);
  230.     else if(numtrozos > 1 && strcmp(trozos[1], "-h") == 0)
  231.         printf("%d:%d:%d\n", t->tm_hour, t->tm_min, t->tm_sec);
  232.     else{
  233.         printf("%d:%d:%d\n", t->tm_hour, t->tm_min, t->tm_sec);
  234.         printf("%d/%d/%d\n", t->tm_mday, t->tm_mon, t->tm_year+1900);
  235.     }
  236.  
  237. }
  238.  
  239. //Comando historial
  240. void histImprimeN(){
  241.     int i;
  242.  
  243.     for(i = 0; i <= trozos[1][1] - 48; i++){
  244.         printf("%d->%s", i, histElemento(i));
  245.     }
  246. }
  247.  
  248. void cmdHist(){
  249.     int i;
  250.  
  251.     if(numtrozos == 1){
  252.         for(i = 0; i < histNumElementos() ; i++){
  253.         printf("%d->%s", i, histElemento(i));
  254.         }
  255.     }
  256.     else if(numtrozos > 1 && strcmp(trozos[1], "-c") == 0){
  257.         histBorrar();
  258.         return;
  259.     }
  260.     else if(numtrozos > 1)
  261.         histImprimeN();
  262. }
  263.  
  264. //Comando infosis
  265. void cmdInfosis(){
  266.     struct utsname system;
  267.     uname(&system);
  268.  
  269.     printf("%s (%s), OS: %s %s-%s\n", system.nodename, system.machine, system.sysname,
  270.                                                                 system.release, system.version);
  271. }
  272.  
  273. /*PRACTICA 1*/
  274.  
  275. //Comando create
  276. void cmdCreate(){
  277.     char ruta[PATH_MAX];
  278.     if (numtrozos==1){
  279.         getcwd(ruta, PATH_MAX);
  280.         printf("%s\n", ruta);
  281.         return;
  282.     }else if(numtrozos==2){
  283.         if(strcmp(trozos[1],"-f")==0){
  284.         getcwd(ruta, PATH_MAX);
  285.         printf("%s\n", ruta);
  286.         return;
  287.         }else{
  288.         mkdir(trozos[1],0777);
  289.         if(errno != 0){
  290.         printf("Imposible crear: %s\n",strerror(errno));
  291.         }
  292.     }
  293.  
  294.     }else if(numtrozos==3){
  295.         if(strcmp(trozos[1], "-f")==0){
  296.         getcwd(ruta, PATH_MAX);
  297.         strcat(ruta,"/");
  298.         strcat(ruta,trozos[2]);
  299.  
  300.         FILE *fp;
  301.         fp = fopen(trozos[2],"w");
  302.         if(fp != NULL){
  303.         fclose(fp);
  304.         }
  305.         if(errno != 0){
  306.         printf("Imposible crear: %s\n",strerror(errno));
  307.         }
  308.  
  309.       }
  310.     }
  311.  
  312. }
  313. //Comando borrar
  314.  
  315. void cmdDelete(){
  316.     int i;
  317.     for(i=1;i<numtrozos;i++){
  318.  
  319.         if(errno != 0){
  320.         printf("%s\n",strerror(errno));
  321.         }
  322.         remove(trozos[i]);
  323.         if(errno != 0){
  324.         printf("%s\n",strerror(errno));
  325.         }
  326.         }
  327.  
  328.     }
  329.  
  330.  
  331.  
  332. //
  333.  
  334.  
  335. void st_mode_to_str(mode_t st_mode, char *mode){
  336.     mode[0]= ' '; //(S_ISDIR(fileStat.st_mode)) ? 'd' : '-';
  337.     mode[1]= (st_mode & S_IRUSR) ? 'r' : '-';
  338.     mode[2]= (st_mode & S_IWUSR) ? 'w' : '-';
  339.     mode[3]= (st_mode & S_IXUSR) ? 'x' : '-';
  340.     mode[4]= (st_mode & S_IRGRP) ? 'r' : '-';
  341.     mode[5]= (st_mode & S_IWGRP) ? 'w' : '-';
  342.     mode[6]= (st_mode & S_IXGRP) ? 'x' : '-';
  343.     mode[7]= (st_mode & S_IROTH) ? 'r' : '-';
  344.     mode[8]= (st_mode & S_IWOTH) ? 'w' : '-';
  345.     mode[9]= (st_mode & S_IXOTH) ? 'x' : '-';
  346.     mode[10]= 0;
  347.     }
  348.  
  349. //Comando stat
  350. void cmdStat(){
  351.  
  352.     struct stat *statbuf;
  353.     statbuf = malloc(sizeof(struct stat));
  354.  
  355.  
  356.     char ruta[PATH_MAX];
  357.     int flagLong=0, flagAcc=0, flagLink=0; //flags para detectar las opciones que se pasan
  358.     struct passwd *pws; //Id dispositivo
  359.     struct group *grp; //Id grupo
  360.     struct tm dtc, dta;
  361.  
  362.     //Introducen stat
  363.     if (numtrozos == 1)
  364.         cmdCarpeta();
  365.  
  366.     //Introducen stat (algo)
  367.     if(numtrozos == 2){
  368.  
  369.         getcwd(ruta, PATH_MAX);
  370.         strcat(ruta, "/");
  371.         strcat(ruta, trozos[1]);
  372.  
  373.         if(lstat(ruta, statbuf)== -1){
  374.             printf("Ha habido un error: %s\n", strerror(errno));
  375.         }
  376.         else{
  377.             printf("%ld %s\n", statbuf->st_size, trozos[1]);
  378.         }
  379.     }
  380.  
  381.     if(numtrozos>2){
  382.         //Obtenemos los flags que se pasan
  383.         for(int i = 1; i < numtrozos && trozos[i][0] == '-' ; i++){
  384.             if(strcmp(trozos[i], "-long") == 0) flagLong = 1;
  385.             else if(strcmp(trozos[i],"-link") == 0) flagLink = 1;
  386.             else if(strcmp(trozos[i], "-acc") == 0) flagAcc = 1;
  387.         }
  388.  
  389.         getcwd(ruta, PATH_MAX);
  390.         strcat(ruta, "/");
  391.         strcat(ruta, trozos[numtrozos-1]);
  392.  
  393.         if(lstat(ruta, statbuf)== -1){
  394.             printf("Ha habido un error: %s\n", strerror(errno));
  395.         }
  396.         else{
  397.             pws = getpwuid(statbuf->st_uid);
  398.             grp = getgrgid(statbuf->st_gid);
  399.  
  400.             dtc = *(gmtime(&statbuf->st_ctime));
  401.             dta = *(gmtime(&statbuf->st_atime));
  402.  
  403.  
  404.             if(flagAcc == 1 && flagLong==0){
  405.                 printf("%d/%d/%d-%d:%.2d  ", dta.tm_year + 1900, dta.tm_mon+1, dta.tm_mday,
  406.                 dta.tm_hour+2, dta.tm_min);
  407.             }
  408.             if(flagLong==1){
  409.                 //strmode(st_mode, statbuf->st_mode);
  410.                 char mode[11];
  411.                 st_mode_to_str(statbuf->st_mode,mode);
  412.                 printf("%d/%d/%d-%d:%.2d %ld, ( %ld)    %s %s %s ", dtc.tm_year + 1900, dtc.tm_mon+1, dtc.tm_mday,
  413.                 dtc.tm_hour+2, dtc.tm_min,statbuf->st_nlink, statbuf->st_ino, pws->pw_name, grp->gr_name, mode);
  414.             }
  415.             if(flagLink==1){
  416.                 //hacer links
  417.             }
  418.             printf("%ld %s\n", statbuf->st_size, trozos[numtrozos-1]);
  419.         }
  420.     }
  421.  
  422. }
  423.  
  424.  
  425.  
  426. //Stat 2 (para list)
  427.  
  428. void cmdStat2(const char d_name[],int flagLong, int flagAcc, char ruta[], int REC){
  429.     struct stat *statbuf;
  430.     statbuf = malloc(sizeof(struct stat));
  431.  
  432.  
  433.  
  434.     struct passwd *pws; //Id dispositivo
  435.     struct group *grp; //Id grupo
  436.     struct tm dtc, dta;
  437.  
  438.  
  439.  
  440.     if(numtrozos>2){
  441.  
  442. if(REC==1){
  443.  
  444.         if(lstat(ruta, statbuf)== -1){
  445.         }
  446.         else{
  447.             pws = getpwuid(statbuf->st_uid);
  448.             grp = getgrgid(statbuf->st_gid);
  449.  
  450.             dtc = *(gmtime(&statbuf->st_ctime));
  451.             dta = *(gmtime(&statbuf->st_atime));
  452.  
  453.  
  454.             if(flagAcc == 1 && flagLong==0){
  455.                 printf("%d/%d/%d-%d:%.2d  ", dta.tm_year + 1900, dta.tm_mon+1, dta.tm_mday,
  456.                 dta.tm_hour+2, dta.tm_min);
  457.             }
  458.  
  459.             if(flagLong==1){
  460.                 //strmode(st_mode, statbuf->st_mode);
  461.                 char mode[11];
  462.                 st_mode_to_str(statbuf->st_mode,mode);
  463.                 printf("%d/%d/%d-%d:%.2d %ld, ( %ld)    %s %s %s ", dtc.tm_year + 1900, dtc.tm_mon+1, dtc.tm_mday,
  464.                 dtc.tm_hour+2, dtc.tm_min,statbuf->st_nlink, statbuf->st_ino, pws->pw_name, grp->gr_name, mode);
  465.             }
  466.             printf("%ld %s\n", statbuf->st_size, d_name);
  467.         }
  468.  
  469.       }
  470.  
  471.       else if(REC==0){
  472.  
  473.            if(lstat(d_name, statbuf)== -1){
  474.         }
  475.         else{
  476.             pws = getpwuid(statbuf->st_uid);
  477.             grp = getgrgid(statbuf->st_gid);
  478.  
  479.             dtc = *(gmtime(&statbuf->st_ctime));
  480.             dta = *(gmtime(&statbuf->st_atime));
  481.  
  482.  
  483.             if(flagAcc == 1 && flagLong==0){
  484.                 printf("%d/%d/%d-%d:%.2d  ", dta.tm_year + 1900, dta.tm_mon+1, dta.tm_mday,
  485.                 dta.tm_hour+2, dta.tm_min);
  486.             }
  487.  
  488.             if(flagLong==1){
  489.                 //strmode(st_mode, statbuf->st_mode);
  490.                 char mode[11];
  491.                 st_mode_to_str(statbuf->st_mode,mode);
  492.                 printf("%d/%d/%d-%d:%.2d %ld, ( %ld)    %s %s %s ", dtc.tm_year + 1900, dtc.tm_mon+1, dtc.tm_mday,
  493.                 dtc.tm_hour+2, dtc.tm_min,statbuf->st_nlink, statbuf->st_ino, pws->pw_name, grp->gr_name, mode);
  494.             }
  495.             printf("%ld %s\n", statbuf->st_size, ruta);
  496.         }
  497.  
  498.           }
  499.     }
  500.  
  501. }
  502.  
  503.  
  504. void cmdListaREC(const char *dirname,int fun, int flagHid, int flagLong){
  505.     if(fun==0){
  506.  
  507.     DIR* dir = opendir(dirname);
  508.  
  509.     struct dirent* dirent;
  510.     dirent = readdir(dir);
  511.     char path[100];
  512.  
  513.  
  514.  
  515.  
  516.   if (dir == NULL) {
  517.         return;
  518.     }
  519.  
  520.     printf("************%s\n",dirname);
  521.  
  522.  
  523.     while (dirent != NULL) {
  524.         strcpy(path, dirname);
  525.         strcat(path, "/");
  526.         strcat(path, dirent->d_name);
  527.  
  528.         if(dirent->d_name[0] != '.' || flagHid == 1){
  529.             if(flagLong==1){
  530.                 cmdStat2(dirent->d_name,1,1,path,1);
  531.                 }else{
  532.                     printf("%hhd %s\n", dirent->d_type, dirent->d_name);
  533.                     }
  534.         }
  535.  
  536.         dirent = readdir(dir);
  537.     }
  538.  
  539.     closedir(dir);
  540.  
  541.  
  542.     dir = opendir(dirname);
  543.     if (dir == NULL) {
  544.         return;
  545.     }
  546.  
  547.  
  548.     dirent = readdir(dir);
  549.     while (dirent != NULL) {
  550.  
  551.  
  552.  
  553.        if (dirent->d_type == DT_DIR && strcmp(dirent->d_name, ".") != 0 && strcmp(dirent->d_name, "..") != 0 && (dirent->d_name[0] != '.'|| flagHid==1)){
  554.  
  555.            char path[100];
  556.             strcpy(path, dirname);
  557.             strcat(path, "/");
  558.             strcat(path, dirent->d_name);
  559.             cmdListaREC(path,0,flagHid,flagLong);
  560.         }
  561.         dirent = readdir(dir);
  562.     }
  563.  
  564.     closedir(dir);
  565.  
  566.     }
  567.  
  568.     else if (fun==1){
  569.  
  570.  
  571.  
  572.     DIR* dir = opendir(dirname);
  573.  
  574.     struct dirent* dirent;
  575.     dirent = readdir(dir);
  576.  
  577.  
  578.     if (dir == NULL) {
  579.         return;
  580.     }
  581.  
  582.  
  583.     while (dirent != NULL) {
  584.  
  585.         if (dirent->d_type == DT_DIR && strcmp(dirent->d_name, ".") != 0 && strcmp(dirent->d_name, "..") != 0 && (dirent->d_name[0] != '.' || flagHid ==1)) {
  586.             char path[100];
  587.             printf("************%s/%s\n",dirname,dirent->d_name);
  588.             strcpy(path, dirname);
  589.             strcat(path, "/");
  590.             strcat(path, dirent->d_name);
  591.             cmdListaREC(path,1,flagHid,flagLong);
  592.             printf("************%s\n",dirname);
  593.         }
  594.  
  595.         dirent = readdir(dir);
  596.     }
  597.  
  598.     closedir(dir);
  599.  
  600.  
  601.     dir = opendir(dirname);
  602.     if (dir == NULL) {
  603.         return;
  604.     }
  605.  
  606.  
  607.     dirent = readdir(dir);
  608.     while (dirent != NULL) {
  609.         char path[100];
  610.         strcpy(path, dirname);
  611.         strcat(path, "/");
  612.         strcat(path, dirent->d_name);
  613.  
  614.        if(dirent->d_name[0] != '.' || flagHid == 1){
  615.             if(flagLong==1){
  616.                 cmdStat2(dirent->d_name,1,1,path,1);
  617.                 }else{
  618.                     printf("%hhd %s\n", dirent->d_type, dirent->d_name);
  619.                     }
  620.         }
  621.  
  622.         dirent = readdir(dir);
  623.     }
  624.  
  625.     closedir(dir);
  626.  
  627.     }
  628. }
  629.  
  630. //Comando list
  631. void cmdList(){
  632.  
  633.  
  634.     char ruta[PATH_MAX];
  635.     int flagHid=0,flagLong=0, flagAcc=0, flagReca=0, flagRecb=0; //flags para detectar las opciones que se pasan
  636.  
  637.  
  638.     DIR *d;
  639.     struct dirent *dirent;
  640.     getcwd(ruta, PATH_MAX);
  641.     strcat(ruta, "/");
  642.     strcat(ruta, trozos[numtrozos-1]);
  643.  
  644.     if(numtrozos==1)
  645.         cmdCarpeta();
  646.  
  647.     if(numtrozos==2){
  648.  
  649.  
  650.         if((d=opendir(ruta)) == NULL){perror("opendir"); return;}
  651.         printf("************%s\n",trozos[numtrozos-1]);
  652.         while((dirent = readdir(d))!= NULL){
  653.             if(dirent->d_name[0] != '.'){
  654.             printf("%s\n", dirent->d_name);
  655.         }
  656.        }
  657.     }
  658.  
  659.  
  660.     if(numtrozos>2){
  661.  
  662.  
  663.  
  664.         //Obtenemos los flags que se pasan
  665.         for(int i = 1; i < numtrozos && trozos[i][0] == '-' ; i++){
  666.             if(strcmp(trozos[i],"-hid")==0) flagHid = 1;
  667.             else if(strcmp(trozos[i], "-long") == 0) flagLong = 1;
  668.             else if(strcmp(trozos[i], "-acc") == 0) flagAcc = 1;
  669.             else if(strcmp(trozos[i], "-reca") == 0) flagReca = 1;
  670.             else if(strcmp(trozos[i], "-recb") == 0) flagRecb = 1;
  671.         }
  672.  
  673.  
  674.     if((d=opendir(ruta)) == NULL){perror("opendir"); return;}
  675.  
  676.  
  677.  
  678.         if(flagAcc==1 && flagLong==0 && flagHid==0){
  679.             printf("************%s\n",trozos[numtrozos-1]);
  680.             while((dirent = readdir(d))!= NULL){
  681.             getcwd(ruta, PATH_MAX);
  682.             strcat(ruta,"/");
  683.             strcat(ruta,trozos[numtrozos-1]);
  684.             strcat(ruta,"/");
  685.             strcat(ruta,dirent->d_name);
  686.             if(dirent->d_name[0] != '.'){
  687.             cmdStat2(ruta,0,1,dirent->d_name,0);
  688.         }
  689.        }
  690.     }//
  691.  
  692.         if(flagAcc==1 && flagLong==0 && flagHid==1){
  693.             printf("************%s\n",trozos[numtrozos-1]);
  694.             while((dirent = readdir(d))!= NULL){
  695.             getcwd(ruta, PATH_MAX);
  696.             strcat(ruta,"/");
  697.             strcat(ruta,trozos[numtrozos-1]);
  698.             strcat(ruta,"/");
  699.             strcat(ruta,dirent->d_name);
  700.             cmdStat2(ruta,0,1,dirent->d_name,0);
  701.        }
  702.     }//
  703.  
  704.         if(flagHid==1 && flagLong==0 && flagAcc==0 && flagReca==0 && flagRecb==0){
  705.             printf("************%s\n",trozos[numtrozos-1]);
  706.             while((dirent = readdir(d))!= NULL){
  707.             printf("%s\n", dirent->d_name);
  708.         }
  709.       }
  710.  
  711.       if(flagLong==1 && flagHid == 0 && flagAcc==0 && flagReca==0 && flagRecb==0){
  712.  
  713.  
  714.           printf("************%s\n",trozos[numtrozos-1]);
  715.             while((dirent = readdir(d))!= NULL){
  716.             getcwd(ruta, PATH_MAX);
  717.             strcat(ruta,"/");
  718.             strcat(ruta,trozos[numtrozos-1]);
  719.             strcat(ruta,"/");
  720.             strcat(ruta,dirent->d_name);
  721.             if(dirent->d_name[0] != '.'){
  722.             cmdStat2(ruta,1,0,dirent->d_name,0);
  723.         }
  724.        }
  725.       }
  726.  
  727.  
  728.       if(flagLong==1 && flagHid == 1 && flagReca ==0 && flagRecb==0){
  729.           printf("************%s\n",trozos[numtrozos-1]);
  730.             while((dirent = readdir(d))!= NULL){
  731.             getcwd(ruta, PATH_MAX);
  732.             strcat(ruta,"/");
  733.             strcat(ruta,trozos[numtrozos-1]);
  734.             strcat(ruta,"/");
  735.             strcat(ruta,dirent->d_name);
  736.             cmdStat2(ruta,1,0,dirent->d_name,0);
  737.        }
  738.       }
  739.  
  740.  
  741.       if(flagReca==1){
  742.         cmdListaREC(trozos[numtrozos-1],0,flagHid, flagLong);
  743.       }else if(flagRecb==1){
  744.         cmdListaREC(trozos[numtrozos-1],1,flagHid, flagLong);
  745.       }
  746.  
  747.  
  748.     }
  749. }
  750.  
  751. // PRÁCTICA 2
  752.  
  753. char * nombreMes(int mes){
  754.     static char* meses[12]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
  755.     return meses[mes-1];
  756. }
  757.  
  758. void * ObtenerMemoriaShmget (key_t clave, size_t tam)
  759. {
  760.     void * p;
  761.     int aux,id,flags=0777;
  762.     struct shmid_ds s;
  763.     time_t t = time(NULL);
  764.     struct tm tm = *localtime(&t);
  765.  
  766.     if (tam)     /*tam distito de 0 indica crear */
  767.         flags=flags | IPC_CREAT | IPC_EXCL;
  768.     if (clave==IPC_PRIVATE)  /*no nos vale*/
  769.         {errno=EINVAL; return NULL;}
  770.     if ((id=shmget(clave, tam, flags))==-1)
  771.         return (NULL);
  772.     if ((p=shmat(id,NULL,0))==(void*) -1){
  773.         aux=errno;
  774.         if (tam)
  775.              shmctl(id,IPC_RMID,NULL);
  776.         errno=aux;
  777.         return (NULL);
  778.     }
  779.     shmctl (id,IPC_STAT,&s);
  780.     histSharedInsert(p, s.shm_segsz,tm.tm_mon + 1,tm.tm_mday,tm.tm_hour,tm.tm_min,"shared",clave);
  781.     return (p);
  782. }
  783.  
  784.  
  785. void * ObtenerMemoriaShmget2 (key_t clave, size_t tam)
  786. {
  787.     void * p;
  788.     int aux,id;
  789.     struct shmid_ds s;
  790.     time_t t = time(NULL);
  791.     struct tm tm = *localtime(&t);
  792.     if (clave==IPC_PRIVATE)  /*no nos vale*/
  793.         {
  794.         errno=EINVAL; return NULL;
  795.         }
  796.     if ((id=shmget(clave, tam, 0))==-1){
  797.         return (NULL);
  798.         }
  799.     if ((p=shmat(id,NULL,0))==(void*) -1){
  800.         aux=errno;
  801.         if (tam)
  802.              shmctl(id,IPC_RMID,NULL);
  803.         errno=aux;
  804.         return (NULL);
  805.     }
  806.     shmctl (id,IPC_STAT,&s);
  807.     histSharedInsert(p, s.shm_segsz,tm.tm_mon + 1,tm.tm_mday,tm.tm_hour,tm.tm_min,"shared",clave);
  808.     return (p);
  809. }
  810.  
  811. void * MapearFichero (char * fichero, int protection)
  812. {
  813.     int df, map=MAP_PRIVATE,modo=O_RDONLY;
  814.     struct stat s;
  815.     void *p;
  816.     time_t t = time(NULL);
  817.     struct tm tm = *localtime(&t);
  818.  
  819.     if (protection&PROT_WRITE)
  820.           modo=O_RDWR;
  821.     if (stat(fichero,&s)==-1 || (df=open(fichero, modo))==-1)
  822.           return NULL;
  823.     if ((p=mmap (NULL,s.st_size, protection,map,df,0))==MAP_FAILED)
  824.            return NULL;
  825.     histMmapInsert(p, s.st_size,tm.tm_mon + 1,tm.tm_mday,tm.tm_hour,tm.tm_min,trozos[2],df);
  826.     return p;
  827. }
  828.  
  829.  
  830. void cmdAllocate(){
  831.         int *p;
  832.         int i;
  833.         time_t t = time(NULL);
  834.         struct tm tm = *localtime(&t);
  835.  
  836.         if(numtrozos==1){
  837.             printf("******Lista de bloques asignados para el proceso %d\n", getpid());
  838.             for(i=0;i<nbloq;i++){
  839.                 printf("%p \t %d  %s  %d  %d:%02d  %s\n",histBloqElemento(i)->dir,histBloqElemento(i)->Bytes, nombreMes(histBloqElemento(i)->month), histBloqElemento(i)->dia, histBloqElemento(i)->hora, histBloqElemento(i)->min, histBloqElemento(i)->tipo);
  840.             }
  841.             for(i=0;i<nshared;i++){
  842.                 printf("%p \t %d  %s  %d  %d:%02d  %s (key %d)\n",histSharedElemento(i)->dir,histSharedElemento(i)->Bytes, nombreMes(histSharedElemento(i)->month), histSharedElemento(i)->dia, histSharedElemento(i)->hora, histSharedElemento(i)->min, histSharedElemento(i)->tipo, histSharedElemento(i)->key);
  843.             }
  844.             for(i=0;i<nmmap;i++){
  845.                 printf("%p \t %d  %s  %d  %d:%02d  %s (descriptor %d)\n",histMmapElemento(i)->dir,histMmapElemento(i)->Bytes, nombreMes(histMmapElemento(i)->month), histMmapElemento(i)->dia, histMmapElemento(i)->hora, histMmapElemento(i)->min, histMmapElemento(i)->nombre, histMmapElemento(i)->filedescriptor);
  846.             }
  847.             //////////IMPRIMIR RESTO DE LISTAS
  848.         }
  849.         else if(numtrozos>1 && strcmp(trozos[1],"-malloc")==0){
  850.             if(numtrozos==2){
  851.                 printf("******Lista de bloques asignados malloc para el proceso %d\n", getpid());
  852.             for(i=0;i<nbloq;i++){
  853.                 printf("%p \t %d  %s  %d  %d:%02d  %s\n",histBloqElemento(i)->dir,histBloqElemento(i)->Bytes, nombreMes(histBloqElemento(i)->month), histBloqElemento(i)->dia, histBloqElemento(i)->hora, histBloqElemento(i)->min, histBloqElemento(i)->tipo);
  854.              }
  855.             }
  856.             else if(strcmp(trozos[2],"0")==0){
  857.                 printf("No se asignan bloques de 0 bytes\n");
  858.             }else{
  859.                 p=malloc(atoi(trozos[2]));
  860.                 printf("Asignados %s bytes en %p\n",trozos[2],p);
  861.                 histBloqInsert(p,atoi(trozos[2]),tm.tm_mon + 1,tm.tm_mday,tm.tm_hour,tm.tm_min,"malloc");
  862.                 }
  863.         }
  864.         else if(numtrozos>1 && strcmp(trozos[1],"-createshared")==0){
  865.  
  866.         key_t cl;
  867.         size_t tam;
  868.         void *p;
  869.  
  870.         if(numtrozos==2 || numtrozos==3){
  871.             printf("******Lista de bloques asignados shared para el proceso %d\n", getpid());
  872.             for(i=0;i<nshared;i++){
  873.                 printf("%p \t %d  %s  %d  %d:%02d  %s (key %d)\n",histSharedElemento(i)->dir,histSharedElemento(i)->Bytes, nombreMes(histSharedElemento(i)->month), histSharedElemento(i)->dia, histSharedElemento(i)->hora, histSharedElemento(i)->min, histSharedElemento(i)->tipo, histSharedElemento(i)->key);
  874.             }
  875.         }else{
  876.  
  877.         cl=(key_t)  strtoul(trozos[2],NULL,10);
  878.         tam=(size_t) strtoul(trozos[3],NULL,10);
  879.         if (tam==0) {
  880.             printf ("No se asignan bloques de 0 bytes\n");
  881.             return;
  882.         }
  883.         if ((p=ObtenerMemoriaShmget(cl,tam))!=NULL)
  884.             printf ("Asignados %lu bytes en %p\n",(unsigned long) tam, p);
  885.         else
  886.             printf ("Imposible asignar memoria compartida clave %lu:%s\n",(unsigned long) cl,strerror(errno));
  887.     }
  888. }
  889.  
  890.         else if(numtrozos>1 && strcmp(trozos[1],"-shared")==0){
  891.  
  892.             if(numtrozos==2){
  893.             printf("******Lista de bloques asignados shared para el proceso %d\n", getpid());
  894.             for(i=0;i<nshared;i++){
  895.                 printf("%p \t %d  %s  %d  %d:%02d  %s (key %d)\n",histSharedElemento(i)->dir,histSharedElemento(i)->Bytes, nombreMes(histSharedElemento(i)->month), histSharedElemento(i)->dia, histSharedElemento(i)->hora, histSharedElemento(i)->min, histSharedElemento(i)->tipo, histSharedElemento(i)->key);
  896.             }
  897.         }else{
  898.  
  899.         key_t cl;
  900.         size_t tam;
  901.         void *p;
  902.  
  903.         for(i=0;i<nshared && histSharedElemento(i)->key!=atoi(trozos[2]);i++);
  904.  
  905.  
  906.         cl=(key_t)  strtoul(trozos[2],NULL,10);
  907.         tam=(size_t) (i<nshared) ? histSharedElemento(i)->Bytes : 10;
  908.         if (tam==0) {
  909.             printf ("No se asignan bloques de 0 bytes\n");
  910.             return;
  911.         }
  912.  
  913.         if ((p=ObtenerMemoriaShmget2(cl,tam))!=NULL)
  914.             printf ("Memoria compartida de clave %d en %p\n",histSharedElemento(i)->key, p);
  915.         else
  916.             printf ("Imposible asignar memoria compartida clave %lu:%s\n",(unsigned long) cl,strerror(errno));
  917.  
  918.         }
  919.     }
  920.  
  921.     else if(numtrozos>1 && strcmp(trozos[1],"-mmap")==0){
  922.  
  923.     if(numtrozos==2 || numtrozos==3){
  924.             printf("******Lista de bloques asignados mmap para el proceso %d\n", getpid());
  925.             for(i=0;i<nmmap;i++){
  926.                 printf("%p \t %d  %s  %d  %d:%02d  %s (descriptor %d)\n",histMmapElemento(i)->dir,histMmapElemento(i)->Bytes, nombreMes(histMmapElemento(i)->month), histMmapElemento(i)->dia, histMmapElemento(i)->hora, histMmapElemento(i)->min, histMmapElemento(i)->nombre, histMmapElemento(i)->filedescriptor);
  927.             }
  928.     }else{
  929.  
  930.      char *perm;
  931.      void *p;
  932.      int protection=0;
  933.  
  934.      if ((perm=trozos[3])!=NULL && strlen(perm)<4) {
  935.             if (strchr(perm,'r')!=NULL) protection|=PROT_READ;
  936.             if (strchr(perm,'w')!=NULL) protection|=PROT_WRITE;
  937.             if (strchr(perm,'x')!=NULL) protection|=PROT_EXEC;
  938.      }
  939.      if ((p=MapearFichero(trozos[2],protection))==NULL)
  940.              perror ("Imposible mapear fichero");
  941.      else
  942.              printf ("fichero %s mapeado en %p\n", trozos[2], p);
  943.  
  944.         }
  945.     }
  946. }
  947.  
  948. void do_DeallocateDelkey (char *key)
  949. {
  950.    key_t clave;
  951.    int id;
  952.  
  953.  
  954.    if (key==NULL || (clave=(key_t) strtoul(key,NULL,10))==IPC_PRIVATE){
  955.         printf ("      delkey necesita clave_valida\n");
  956.         return;
  957.    }
  958.    if ((id=shmget(clave,0,0666))==-1){
  959.         perror ("shmget: imposible obtener memoria compartida");
  960.         return;
  961.    }
  962.    if (shmctl(id,IPC_RMID,NULL)==-1)
  963.         perror ("shmctl: imposible eliminar memoria compartida\n");
  964. }
  965.  
  966. void cmdDeallocate(){
  967.     int i;
  968.  
  969.         if(numtrozos==1){
  970.             printf("******Lista de bloques asignados para el proceso %d\n", getpid());
  971.             for(i=0;i<nbloq;i++){
  972.                 printf("%p \t %d  %s  %d  %d:%02d  %s\n",histBloqElemento(i)->dir,histBloqElemento(i)->Bytes, nombreMes(histBloqElemento(i)->month), histBloqElemento(i)->dia, histBloqElemento(i)->hora, histBloqElemento(i)->min, histBloqElemento(i)->tipo);
  973.             }
  974.             for(i=0;i<nshared;i++){
  975.                 printf("%p \t %d  %s  %d  %d:%02d  %s (key %d)\n",histSharedElemento(i)->dir,histSharedElemento(i)->Bytes, nombreMes(histSharedElemento(i)->month), histSharedElemento(i)->dia, histSharedElemento(i)->hora, histSharedElemento(i)->min, histSharedElemento(i)->tipo, histSharedElemento(i)->key);
  976.             }
  977.             for(i=0;i<nmmap;i++){
  978.                 printf("%p \t %d  %s  %d  %d:%02d  %s (descriptor %d)\n",histMmapElemento(i)->dir,histMmapElemento(i)->Bytes, nombreMes(histMmapElemento(i)->month), histMmapElemento(i)->dia, histMmapElemento(i)->hora, histMmapElemento(i)->min, histMmapElemento(i)->nombre, histMmapElemento(i)->filedescriptor);
  979.             }
  980.             //////////IMPRIMIR RESTO DE LISTAS
  981.         }
  982.         else if(numtrozos>1 && strcmp(trozos[1],"-malloc")==0){
  983.             if(numtrozos==2){
  984.                 printf("******Lista de bloques asignados malloc para el proceso %d\n", getpid());
  985.             for(i=0;i<nbloq;i++){
  986.                 printf("%p \t %d  %s  %d  %d:%02d  %s\n",histBloqElemento(i)->dir,histBloqElemento(i)->Bytes, nombreMes(histBloqElemento(i)->month), histBloqElemento(i)->dia, histBloqElemento(i)->hora, histBloqElemento(i)->min, histBloqElemento(i)->tipo);
  987.              }
  988.             }
  989.             else if(strcmp(trozos[2],"0")==0){
  990.                 printf("No se asignan bloques de 0 bytes\n");
  991.             }else{
  992.                 if(nbloq ==0){
  993.                     printf("No hay bloque de ese tamaño asignado con malloc\n");
  994.                 }else{
  995.                 for(i=0;i<nbloq && histBloqElemento(i)->Bytes != atoi(trozos[2]) ;i++);
  996.                 if(i>=nbloq){
  997.                     printf("No hay bloque de ese tamaño asignado con malloc\n");
  998.                 }else{
  999.                     free(histBloqElemento(i)->dir);
  1000.                     for(;i<nbloq-1;i++){
  1001.                         HistBloq[i] =HistBloq[i+1];
  1002.                         }
  1003.                         nbloq--;
  1004.                     }
  1005.                 }
  1006.         }
  1007.  
  1008.         }else if(numtrozos>1 && strcmp(trozos[1],"-delkey")==0){
  1009.  
  1010.  
  1011.         if(numtrozos==2){
  1012.             printf("del_key necesita una clave válida\n");
  1013.         }else{
  1014.  
  1015.         do_DeallocateDelkey (trozos[2]);
  1016.     }
  1017. }
  1018.  
  1019.         else if(numtrozos>1 && strcmp(trozos[1],"-shared")==0){
  1020.  
  1021.             if(numtrozos==2){
  1022.             printf("******Lista de bloques asignados shared para el proceso %d\n", getpid());
  1023.             for(i=0;i<nshared;i++){
  1024.                 printf("%p \t %d  %s  %d  %d:%02d  %s (key %d)\n",histSharedElemento(i)->dir,histSharedElemento(i)->Bytes, nombreMes(histSharedElemento(i)->month), histSharedElemento(i)->dia, histSharedElemento(i)->hora, histSharedElemento(i)->min, histSharedElemento(i)->tipo, histSharedElemento(i)->key);
  1025.             }
  1026.         }else{
  1027.             if(nshared ==0){
  1028.                     printf("No hay bloque de esa clave mapeado en el proceso\n");
  1029.                 }else{
  1030.                 //NO HACER DEALLOCATE DELKEY
  1031.                 for(i=0;i<nshared && histSharedElemento(i)->key != atoi(trozos[2]) ;i++);
  1032.                 if(i>=nshared){
  1033.                     printf("No hay bloque de esa clave mapeado en el proceso\n");
  1034.                 }else{
  1035.                     for(;i<nshared-1;i++){
  1036.                         HistShared[i] =HistShared[i+1];
  1037.                         }
  1038.                         nshared--;
  1039.                     }
  1040.                 }
  1041.  
  1042.  
  1043.         }
  1044.     }
  1045.  
  1046.     else if(numtrozos>1 && strcmp(trozos[1],"-mmap")==0){
  1047.  
  1048.     if(numtrozos==2){
  1049.             printf("******Lista de bloques asignados mmap para el proceso %d\n", getpid());
  1050.             for(i=0;i<nmmap;i++){
  1051.                 printf("%p \t %d  %s  %d  %d:%02d  %s (descriptor %d)\n",histMmapElemento(i)->dir,histMmapElemento(i)->Bytes, nombreMes(histMmapElemento(i)->month), histMmapElemento(i)->dia, histMmapElemento(i)->hora, histMmapElemento(i)->min, histMmapElemento(i)->nombre, histMmapElemento(i)->filedescriptor);
  1052.             }
  1053.     }else{
  1054.         if(nmmap ==0){
  1055.                     printf("Fichero %s no mapeado\n",trozos[2]);
  1056.                 }else{
  1057.                 for(i=0;i<nmmap && strcmp(histMmapElemento(i)->nombre,trozos[2]) != 0 ;i++);
  1058.                 if(i>=nmmap){
  1059.                     printf("Fichero %s no mapeado\n",trozos[2]);
  1060.                 }else{
  1061.                     munmap(histMmapElemento(i)->dir,histMmapElemento(i)->Bytes);
  1062.                     for(;i<nmmap-1;i++){
  1063.                         HistMmap[i]=HistMmap[i+1];
  1064.                         }
  1065.                         nmmap--;
  1066.                     }
  1067.                 }
  1068.  
  1069.  
  1070.         }
  1071.     }
  1072.     else{
  1073.         int flagNoEsta=0;
  1074.         EntraEnBloque=0;
  1075.         EntraEnShared=0;
  1076.         EntraEnMmap=0;
  1077.  
  1078.         if(nbloq ==0 && nshared ==0 && nmmap ==0){
  1079.             printf("Direccion %s no asignada con malloc, shared o mmap\n",trozos[1]);
  1080.         }else{
  1081.  
  1082.         if(nbloq!=0){
  1083.         EntraEnBloque=1;
  1084.  
  1085.         char comp[20];
  1086.         sprintf(comp,"%p",histBloqElemento(0)->dir);
  1087.  
  1088.         for(i=0;i<nbloq && strcmp(comp,trozos[1])!=0 ;i++){
  1089.             if(i!=nbloq-1){
  1090.             sprintf(comp,"%p",histBloqElemento(i+1)->dir);
  1091.             }
  1092.         }
  1093.  
  1094.  
  1095.         if(i<nbloq){
  1096.  
  1097.                     free(histBloqElemento(i)->dir);
  1098.                     for(;i<nbloq-1;i++){
  1099.                         HistBloq[i] =HistBloq[i+1];
  1100.                         }
  1101.                         nbloq--;
  1102.                     }else{flagNoEsta++;}
  1103.  
  1104.           }if(nshared!=0){
  1105.             EntraEnShared=1;
  1106.  
  1107.             char comp[20];
  1108.             sprintf(comp,"%p",histSharedElemento(0)->dir);
  1109.  
  1110.             for(i=0;i<nshared && strcmp(comp,trozos[1])!=0 ;i++){
  1111.                 if(i!=nshared-1){
  1112.                 sprintf(comp,"%p",histSharedElemento(i+1)->dir);
  1113.                 }
  1114.             }
  1115.  
  1116.             if(i<nshared){
  1117.             //NO HACER DEALLOCATE DELKEY
  1118.                     for(;i<nshared-1;i++){
  1119.                         HistShared[i] =HistShared[i+1];
  1120.                         }
  1121.                         nshared--;
  1122.                     }else{flagNoEsta++;}
  1123.  
  1124.  
  1125.          }if(nmmap!=0){
  1126.              EntraEnMmap=1;
  1127.  
  1128.             char comp[20];
  1129.             sprintf(comp,"%p",histMmapElemento(0)->dir);
  1130.  
  1131.             for(i=0;i<nmmap && strcmp(comp,trozos[1])!=0 ;i++){
  1132.                 if(i!=nmmap-1){
  1133.                 sprintf(comp,"%p",histMmapElemento(i+1)->dir);
  1134.                 }
  1135.             }
  1136.  
  1137.             if(i<nmmap){
  1138.                     munmap(histMmapElemento(i)->dir,histMmapElemento(i)->Bytes);
  1139.                     for(;i<nmmap-1;i++){
  1140.                         HistMmap[i]=HistMmap[i+1];
  1141.                         }
  1142.                         nmmap--;
  1143.                     }else{flagNoEsta++;}
  1144.  
  1145.            }if((flagNoEsta==3) || (flagNoEsta==1 && !EntraEnBloque && !EntraEnMmap) || (flagNoEsta==1 && !EntraEnBloque && !EntraEnShared) || (flagNoEsta==1 && !EntraEnShared && !EntraEnMmap) || (flagNoEsta==2 && !EntraEnBloque) || (flagNoEsta==2 && !EntraEnShared) || (flagNoEsta==2 && !EntraEnMmap)){
  1146.  
  1147.                printf("Direccion %s no asignada con malloc, shared o mmap\n",trozos[1]);
  1148.                }
  1149.           }
  1150.         }
  1151. }
  1152.  
  1153. void LlenarMemoria (void *p, size_t cont, unsigned char byte)
  1154. {
  1155.   unsigned char *arr=(unsigned char *) p;
  1156.   size_t i;
  1157.  
  1158.   for (i=0; i<cont;i++)
  1159.         arr[i]=byte;
  1160. }
  1161.  
  1162. void cmdMemfill(){
  1163.     char A='A';
  1164.     int Bytes=128;
  1165.     int *p,i;
  1166.  
  1167.     if(numtrozos==1){
  1168.         return;
  1169.     }if(numtrozos>2){
  1170.         Bytes=atoi(trozos[2]);
  1171.     }
  1172.     if(numtrozos>3){
  1173.         A=trozos[3][0];
  1174.         }
  1175.     if(nbloq!=0 || nshared!=0){
  1176.     if(nbloq!=0){
  1177.     char comp[20];
  1178.         sprintf(comp,"%p",histBloqElemento(0)->dir);
  1179.  
  1180.         for(i=0;i<nbloq && strcmp(comp,trozos[1])!=0 ;i++){
  1181.             if(i!=nbloq-1){
  1182.             sprintf(comp,"%p",histBloqElemento(i+1)->dir);
  1183.             }
  1184.         }
  1185.  
  1186.     }
  1187.         if(i<nbloq && nbloq!=0){
  1188.             p=histBloqElemento(i)->dir;
  1189.             if(histBloqElemento(i)->Bytes<Bytes){
  1190.                 printf("Violacion de segmento generado\n");
  1191.                 exit(0);
  1192.             }
  1193.  
  1194.  
  1195.         }else if(nshared!=0){
  1196.             char comp2[20];
  1197.             sprintf(comp2,"%p",histSharedElemento(0)->dir);
  1198.  
  1199.             for(i=0;i<nshared && strcmp(comp2,trozos[1])!=0 ;i++){
  1200.                 if(i!=nshared-1){
  1201.                 sprintf(comp2,"%p",histSharedElemento(i+1)->dir);
  1202.                 }
  1203.             }
  1204.  
  1205.             if(i<nshared){
  1206.                 p=histSharedElemento(i)->dir;
  1207.                 if(histSharedElemento(i)->Bytes<Bytes){
  1208.                 printf("Violacion de segmento generado\n");
  1209.                 exit(0);
  1210.                 }
  1211.             }else{
  1212.                 printf("Violacion de segmento generado\n");
  1213.                 exit(0);
  1214.                 }
  1215.  
  1216.         }else{
  1217.                 printf("Violacion de segmento generado\n");
  1218.                 exit(0);
  1219.                 }
  1220.  
  1221.         }else{
  1222.                 printf("Violacion de segmento generado\n");
  1223.                 exit(0);
  1224.                 }
  1225.  
  1226.  
  1227.     printf("Llenando %d bytes de memoria con el byte %c(%02x) a partir de la direccion %p\n",Bytes,A,A,p);
  1228.     LlenarMemoria(p,Bytes,(unsigned char)A);
  1229. }
  1230.  
  1231.  
  1232. void cmdMemdump(){
  1233.     int i, numbytes;
  1234.     char *p,*q,*r;
  1235.  
  1236.     if(numtrozos > 2){
  1237.         numbytes = atoi(trozos[2]);
  1238.     }
  1239.     else{
  1240.         numbytes = 25;
  1241.     }
  1242.  
  1243.     if(nbloq!=0 || nshared!=0){
  1244.     if(nbloq!=0){
  1245.     char comp[20];
  1246.         sprintf(comp,"%p",histBloqElemento(0)->dir);
  1247.  
  1248.         for(i=0;i<nbloq && strcmp(comp,trozos[1])!=0 ;i++){
  1249.             if(i!=nbloq-1){
  1250.             sprintf(comp,"%p",histBloqElemento(i+1)->dir);
  1251.             }
  1252.         }
  1253.  
  1254.     }
  1255.         if(i<nbloq && nbloq!=0){
  1256.             p=(char *)histBloqElemento(i)->dir;
  1257.             if(histBloqElemento(i)->Bytes<numbytes){
  1258.                 printf("Violacion de segmento generado\n");
  1259.                 exit(0);
  1260.             }
  1261.  
  1262.  
  1263.         }else if(nshared!=0){
  1264.             char comp2[20];
  1265.             sprintf(comp2,"%p",histSharedElemento(0)->dir);
  1266.  
  1267.             for(i=0;i<nshared && strcmp(comp2,trozos[1])!=0 ;i++){
  1268.                 if(i!=nshared-1){
  1269.                 sprintf(comp2,"%p",histSharedElemento(i+1)->dir);
  1270.                 }
  1271.             }
  1272.  
  1273.             if(i<nshared){
  1274.                 p=(char *)histSharedElemento(i)->dir;
  1275.                 if(histSharedElemento(i)->Bytes<numbytes){
  1276.                 printf("Violacion de segmento generado\n");
  1277.                 exit(0);
  1278.                 }
  1279.             }else{
  1280.                 printf("Violacion de segmento generado\n");
  1281.                 exit(0);
  1282.                 }
  1283.  
  1284.         }else{
  1285.                 printf("Violacion de segmento generado\n");
  1286.                 exit(0);
  1287.                 }
  1288.  
  1289.         }else{
  1290.                 printf("Violacion de segmento generado\n");
  1291.                 exit(0);
  1292.                 }
  1293.  
  1294.     printf("Volcando %d bytes desde la direccion %p\n", numbytes, p);
  1295.     q=p;
  1296.     r=p;
  1297.     int mod = numbytes % 25;
  1298.  
  1299.     for(int j=0;j<numbytes/25;j++){
  1300.         for(i=0;i<numbytes&&i<25;i++,r++){
  1301.             printf("%2c ",*r);
  1302.             }
  1303.             printf("\n");
  1304.         for(i=0;i<numbytes&&i<25;i++,q++){
  1305.             char buf[10];
  1306.             sprintf(buf,"%x",*q);
  1307.             printf("%.2s ",buf);
  1308.             }
  1309.             printf("\n");
  1310.  
  1311.         }if(mod!=0){
  1312.             for(i=0;i<mod;i++,r++){
  1313.             printf("%2c ",*r);
  1314.             }
  1315.  
  1316.             printf("\n");
  1317.             for(i=0;i<mod;i++,q++){
  1318.             char buf[10];
  1319.             sprintf(buf,"%x",*q);
  1320.             printf("%.2s ",buf);
  1321.             }
  1322.  
  1323.  
  1324.             printf("\n");
  1325.          }
  1326.  
  1327. }
  1328.  
  1329. ssize_t LeerFichero (char *f, void *p, size_t cont)
  1330. {
  1331.    struct stat s;
  1332.    ssize_t  n;
  1333.    int df,aux;
  1334.  
  1335.    if (stat (f,&s)==-1 || (df=open(f,O_RDONLY))==-1)
  1336.     return -1;
  1337.    if (cont==-1)   /* si pasamos -1 como bytes a leer lo leemos entero*/
  1338.     cont=s.st_size;
  1339.    if ((n=read(df,p,cont))==-1){
  1340.     aux=errno;
  1341.     close(df);
  1342.     errno=aux;
  1343.     return -1;
  1344.    }
  1345.    close (df);
  1346.    return n;
  1347. }
  1348.  
  1349. ssize_t EscribirFichero (char *f, void *p, size_t cont,int overwrite)
  1350. {
  1351.    ssize_t  n;
  1352.    int df,aux, flags=O_CREAT | O_EXCL | O_WRONLY;
  1353.  
  1354.    if (overwrite)
  1355.     flags=O_CREAT | O_WRONLY | O_TRUNC;
  1356.  
  1357.    if ((df=open(f,flags,0777))==-1)
  1358.     return -1;
  1359.  
  1360.    if ((n=write(df,p,cont))==-1){
  1361.     aux=errno;
  1362.     close(df);
  1363.     errno=aux;
  1364.     return -1;
  1365.    }
  1366.    close (df);
  1367.    return n;
  1368. }
  1369.  
  1370.  
  1371. void cmdIo(){
  1372.  
  1373.     if( (strcmp(trozos[1], "read") == 0)){
  1374.         ssize_t cont = -1;
  1375.         char *file;
  1376.         void *addr;
  1377.  
  1378.         file = trozos[2];
  1379.         addr = (void *) strtol(trozos[3], NULL, 16);
  1380.  
  1381.         if(numtrozos == 5){
  1382.             cont = atoi(trozos[4]);
  1383.         }
  1384.  
  1385.         if((cont = LeerFichero(file, addr, cont)) == -1){
  1386.             printf("Imposible leer fichero");
  1387.         }
  1388.         printf("leidos %ld bytes de %s en %p\n", cont, file, addr);
  1389.     }
  1390.     else if((strcmp(trozos[1], "write") == 0)){
  1391.         int fd=0, numbytes;
  1392.         char *file;
  1393.         void *addr;
  1394.         struct stat filestat;
  1395.  
  1396.         //Sobreescritura con -o
  1397.         if (numtrozos == 6 && strcmp(trozos[2], "-o") == 0) {
  1398.             file = trozos[3];
  1399.             if ((fd = open(file, O_WRONLY)) == -1) {
  1400.                 return;
  1401.             }
  1402.             addr = (void *) strtol(trozos[4], NULL, 16);
  1403.             numbytes = atoi(trozos[5]);
  1404.             if (write(fd, addr, numbytes) == -1) {
  1405.                 close(fd);
  1406.             } else {
  1407.                 printf("escritos %d bytes en %s desde %p\n", numbytes, file, addr);
  1408.                 close(fd);
  1409.             }
  1410.         } else if (numtrozos == 5) { //Sobreescritura sin -o
  1411.             file = trozos[2];
  1412.             if (stat(file, &filestat) == 0) {
  1413.                 printf("Imposible escribir fichero: File exists\n");
  1414.                 return;
  1415.         }
  1416.  
  1417.         addr = (void *) strtol(trozos[3], NULL, 16);
  1418.         numbytes = (int) atoi(trozos[4]);
  1419.  
  1420.         if (write(fd, addr, numbytes) == -1) {
  1421.             close(fd);
  1422.             return;
  1423.         } else {
  1424.             printf("escritos %d bytes en %s desde %p\n", numbytes, file, addr);
  1425.             close(fd);
  1426.             }
  1427.         }
  1428.     }
  1429.     else{
  1430.         printf("uso: e-s [read|write] ......");
  1431.     }
  1432. }
  1433.  
  1434.  
  1435. void Recursiva (int n)
  1436. {
  1437.   char automatico[TAMANO];
  1438.   static char estatico[TAMANO];
  1439.  
  1440.   printf ("parametro:%3d(%p) array %p, arr estatico %p\n",n,&n,automatico, estatico);
  1441.  
  1442.   if (n>0)
  1443.     Recursiva(n-1);
  1444. }
  1445.  
  1446. void cmdRecurse(){
  1447.     if(numtrozos>1){
  1448.         Recursiva(atoi(trozos[1]));
  1449.         }else return;
  1450. }
  1451.  
  1452. void Do_pmap (void) /*sin argumentos*/
  1453.  { pid_t pid;       /*hace el pmap (o equivalente) del proceso actual*/
  1454.    char elpid[32];
  1455.    char *argv[4]={"pmap",elpid,NULL};
  1456.  
  1457.    sprintf (elpid,"%d", (int) getpid());
  1458.    if ((pid=fork())==-1){
  1459.       perror ("Imposible crear proceso");
  1460.       return;
  1461.       }
  1462.    if (pid==0){
  1463.       if (execvp(argv[0],argv)==-1)
  1464.          perror("cannot execute pmap (linux, solaris)");
  1465.  
  1466.       argv[0]="procstat"; argv[1]="vm"; argv[2]=elpid; argv[3]=NULL;
  1467.       if (execvp(argv[0],argv)==-1)/*No hay pmap, probamos procstat FreeBSD */
  1468.          perror("cannot execute procstat (FreeBSD)");
  1469.  
  1470.       argv[0]="procmap",argv[1]=elpid;argv[2]=NULL;
  1471.             if (execvp(argv[0],argv)==-1)  /*probamos procmap OpenBSD*/
  1472.          perror("cannot execute procmap (OpenBSD)");
  1473.  
  1474.       argv[0]="vmmap"; argv[1]="-interleave"; argv[2]=elpid;argv[3]=NULL;
  1475.       if (execvp(argv[0],argv)==-1) /*probamos vmmap Mac-OS*/
  1476.          perror("cannot execute vmmap (Mac-OS)");
  1477.       exit(1);
  1478.   }
  1479.   waitpid (pid,NULL,0);
  1480. }
  1481.  
  1482.  
  1483. void cmdMemory(){
  1484.     int i,j,k;
  1485.     if(numtrozos==1 || (numtrozos>1 && strcmp(trozos[1],"-all")==0)){
  1486.  
  1487.     printf("Variables locales %18p %18p %18p\n",&i,&j,&k);
  1488.     printf("Variables globales %18p %18p %18p\n",linea,trozos,&numtrozos);
  1489.     printf("Variables estaticas %18p %18p %18p\n",&varMem,&varMem2,&varMem3);
  1490.     printf("Funciones programa %18p %18p %18p\n",&cmdRecurse,&cmdMemory,&cmdAllocate);
  1491.     printf("Funciones libreria %18p %18p %18p\n",&malloc,&printf,&scanf);
  1492.     printf("******Lista de bloques asignados para el proceso %d\n", getpid());
  1493.             for(i=0;i<nbloq;i++){
  1494.                 printf("%p \t %d  %s  %d  %d:%02d  %s\n",histBloqElemento(i)->dir,histBloqElemento(i)->Bytes, nombreMes(histBloqElemento(i)->month), histBloqElemento(i)->dia, histBloqElemento(i)->hora, histBloqElemento(i)->min, histBloqElemento(i)->tipo);
  1495.             }
  1496.             for(i=0;i<nshared;i++){
  1497.                 printf("%p \t %d  %s  %d  %d:%02d  %s (key %d)\n",histSharedElemento(i)->dir,histSharedElemento(i)->Bytes, nombreMes(histSharedElemento(i)->month), histSharedElemento(i)->dia, histSharedElemento(i)->hora, histSharedElemento(i)->min, histSharedElemento(i)->tipo, histSharedElemento(i)->key);
  1498.             }
  1499.             for(i=0;i<nmmap;i++){
  1500.                 printf("%p \t %d  %s  %d  %d:%02d  %s (descriptor %d)\n",histMmapElemento(i)->dir,histMmapElemento(i)->Bytes, nombreMes(histMmapElemento(i)->month), histMmapElemento(i)->dia, histMmapElemento(i)->hora, histMmapElemento(i)->min, histMmapElemento(i)->nombre, histMmapElemento(i)->filedescriptor);
  1501.             }
  1502.  
  1503.     }else{
  1504.     if(strcmp("-blocks",trozos[1])==0){
  1505.         printf("******Lista de bloques asignados para el proceso %d\n", getpid());
  1506.             for(i=0;i<nbloq;i++){
  1507.                 printf("%p \t %d  %s  %d  %d:%02d  %s\n",histBloqElemento(i)->dir,histBloqElemento(i)->Bytes, nombreMes(histBloqElemento(i)->month), histBloqElemento(i)->dia, histBloqElemento(i)->hora, histBloqElemento(i)->min, histBloqElemento(i)->tipo);
  1508.             }
  1509.             for(i=0;i<nshared;i++){
  1510.                 printf("%p \t %d  %s  %d  %d:%02d  %s (key %d)\n",histSharedElemento(i)->dir,histSharedElemento(i)->Bytes, nombreMes(histSharedElemento(i)->month), histSharedElemento(i)->dia, histSharedElemento(i)->hora, histSharedElemento(i)->min, histSharedElemento(i)->tipo, histSharedElemento(i)->key);
  1511.             }
  1512.             for(i=0;i<nmmap;i++){
  1513.                 printf("%p \t %d  %s  %d  %d:%02d  %s (descriptor %d)\n",histMmapElemento(i)->dir,histMmapElemento(i)->Bytes, nombreMes(histMmapElemento(i)->month), histMmapElemento(i)->dia, histMmapElemento(i)->hora, histMmapElemento(i)->min, histMmapElemento(i)->nombre, histMmapElemento(i)->filedescriptor);
  1514.             }
  1515.         }else if(strcmp("-pmap",trozos[1])==0){
  1516.             Do_pmap();
  1517.         }else if(strcmp("-funcs",trozos[1])==0){
  1518.             printf("Funciones programa %18p %18p %18p\n",&cmdRecurse,&cmdMemory,&cmdAllocate);
  1519.             printf("Funciones libreria %18p %18p %18p\n",&malloc,&printf,&scanf);
  1520.         }else if(strcmp("-vars",trozos[1])==0){
  1521.             printf("Variables locales %18p %18p %18p\n",&i,&j,&k);
  1522.             printf("Variables globales %18p %18p %18p\n",linea,trozos,&numtrozos);
  1523.             printf("Variables estaticas %18p %18p %18p\n",&varMem,&varMem2,&varMem3);
  1524.         }
  1525.     }
  1526. }
  1527.  
  1528. //P3
  1529.  
  1530. void MostrarEntorno(char **entorno, char *nombre_entorno){
  1531.     int i = 0;
  1532.     while(entorno[i] != NULL){
  1533.         printf("%p->%s[%d]=(%p) %s\n", &entorno[i], nombre_entorno, i, entorno[i], entorno[i]);
  1534.         i++;
  1535.     }
  1536. }
  1537.  
  1538. int BuscarVariable(char *var, char *e[]){
  1539.     int pos=0;
  1540.     char aux[MaxHist];
  1541.     strcpy(aux, var);
  1542.     strcat(aux, "=");
  1543.     while(e[pos]!=NULL)
  1544.         if(!strncmp(e[pos], aux, strlen(aux)))
  1545.             return pos;
  1546.         else
  1547.             pos++;
  1548.     errno=ENOENT;
  1549.     return(-1);
  1550. }
  1551.  
  1552. int CambiarVariable(char *var, char *valor, char *e[]){
  1553.    
  1554.     int pos;
  1555.     char *aux;
  1556.    
  1557.     if((pos=BuscarVariable(var, e)) == -1)
  1558.         return(-1);
  1559.     if(((aux)=(char *)malloc(strlen(var)+strlen(valor)+2)) == NULL)
  1560.         return -1;
  1561.     strcpy(aux, var);
  1562.     strcat(aux, "=");
  1563.     strcat(aux, valor);
  1564.     e[pos]=aux;
  1565.     return(pos);
  1566. }
  1567.  
  1568. void cmdPriority(){
  1569.     int w, i, j, z, m;
  1570.    
  1571.     if(numtrozos == 1){
  1572.         z = getpid();
  1573.         m = getpriority(0, z);
  1574.         printf("Prioridad del proceso %d es %d\n", z, m);
  1575.     }
  1576.    
  1577.     if(numtrozos == 2){
  1578.         i = atoi(trozos[1]);
  1579.         w = getpriority(0, i);
  1580.         printf("Prioridad del proceso %d es %d\n", i, w);
  1581.     }
  1582.    
  1583.     if(numtrozos == 3){
  1584.         i = atoi(trozos[1]);
  1585.         j = atoi(trozos[2]);
  1586.         setpriority(0, i, j);
  1587.     }
  1588. }
  1589.  
  1590. void cmdEntorno(){
  1591.    
  1592.     if(numtrozos == 1)
  1593.         MostrarEntorno(entorno, "agr3");
  1594.        
  1595.     if(numtrozos == 2 && (strcmp(trozos[1], "-addr") == 0)){
  1596.         printf("entorno: %p (almacenado en %p)\n", entorno, &entorno);
  1597.         printf("main arg3: %p (almacenado en %p)\n", entorno, &entorno);
  1598.     }
  1599.    
  1600.     if(numtrozos == 2 && (strcmp(trozos[1], "-environ") == 0))
  1601.         MostrarEntorno(environ, "environ");
  1602. }
  1603.  
  1604.  
  1605. void cmdCambiarVar(){
  1606.     char aux[1000];
  1607.    
  1608.     if(numtrozos == 4 && (strcmp(trozos[1], "-a") == 0))
  1609.         CambiarVariable(trozos[2], trozos[3], entorno);
  1610.        
  1611.     if(numtrozos == 4 && (strcmp(trozos[1], "-e") == 0))
  1612.         CambiarVariable(trozos[2], trozos[3], environ);
  1613.        
  1614.     if(numtrozos == 4 && (strcmp(trozos[1], "-p") == 0)){
  1615.         strcpy(aux, trozos[2]);
  1616.         strcat(aux, "=");
  1617.         strcat(aux, trozos[3]);
  1618.         putenv(aux);
  1619.     }
  1620. }
  1621.  
  1622.  
  1623. void cmdMostrarVar(){
  1624.  
  1625.     if(numtrozos == 1)
  1626.         MostrarEntorno(entorno, "arg3");
  1627.     else{
  1628.         int i = BuscarVariable(trozos[1], entorno);
  1629.         int w = BuscarVariable(trozos[1], environ);
  1630.         printf("main arg3: %s %p (almacenado en %p)\n", entorno[i], entorno[i], &entorno[i]);
  1631.         printf("environ:    %s %p (almacenado en %p)\n", entorno[w], entorno[w], &entorno[w]);
  1632.         printf("getenv:         %s %p\n", getenv(trozos[1]), getenv(trozos[1]));
  1633.     }
  1634. }
  1635.  
  1636. void cmdFork ()
  1637. {
  1638.     pid_t pid;
  1639.  
  1640.     if ((pid=fork())==0){
  1641.         HistProcesosBorrar();
  1642.         printf ("ejecutando proceso %d\n", getpid());
  1643.     }
  1644.     else if (pid!=-1)
  1645.         waitpid (pid,NULL,0);
  1646. }
  1647.  
  1648. int ValorSenal(char * sen)  /*devuelve el numero de senial a partir del nombre*/
  1649. {
  1650.   int i;
  1651.   for (i=0; sigstrnum[i].nombre!=NULL; i++)
  1652.     if (!strcmp(sen, sigstrnum[i].nombre))
  1653.         return sigstrnum[i].senal;
  1654.   return -1;
  1655. }
  1656.  
  1657.  
  1658. char *NombreSenal(int sen)  /*devuelve el nombre senal a partir de la senal*/
  1659. {           /* para sitios donde no hay sig2str*/
  1660.  int i;
  1661.   for (i=0; sigstrnum[i].nombre!=NULL; i++)
  1662.     if (sen==sigstrnum[i].senal)
  1663.         return sigstrnum[i].nombre;
  1664.  return ("SIGUNKNOWN");
  1665. }
  1666.  
  1667. void cmdListJobs(){
  1668.     int i;
  1669.     int status;
  1670.     pid_t pid;
  1671.    
  1672.     for(i=0;i<nprocesos;i++){
  1673.         printf("--- El pid de histprocesoelemento es %d\n",HistProcesosElemento(i)->PID);
  1674.         pid=waitpid(HistProcesosElemento(i)->PID,&status,WNOHANG| WUNTRACED| WCONTINUED);
  1675.         printf("----waitpid es %d y senal es %d\n",pid,HistProcesosElemento(i)->senal);
  1676.        
  1677.         if(/*strcmp("FINISHED",HistProcesosElemento(i)->status)!=0 &&*/ pid != -1){
  1678.            
  1679.         if(WIFEXITED(status)){
  1680.             strcpy(HistProcesosElemento(i)->status,"FINISHED");
  1681.             HistProcesos[i]->prioridad=-1;
  1682.             printf("Terminado con WIFEXITED(status)=%d\n",WIFEXITED(status));
  1683.             status=WIFEXITED(status);
  1684.         }else if(WIFSIGNALED(status) && (pid!=0 || HistProcesosElemento(i)->senal !=0)){
  1685.             printf("Entra\n");
  1686.             //if(WTERMSIG(status)<=31){
  1687.                 strcpy(HistProcesosElemento(i)->status,"SIGNALED");
  1688.                 HistProcesos[i]->prioridad=-1;
  1689.                 HistProcesosElemento(i)->senal=WTERMSIG(status);
  1690.                 printf("----senal es %d\n",HistProcesosElemento(i)->senal);
  1691.                 printf("Terminado con WIFSIGNALED(status)=%d\n",WIFSIGNALED(status));
  1692.                 status=WIFSIGNALED(status);
  1693.             //}
  1694.         }else if(WIFSTOPPED(status)){
  1695.             strcpy(HistProcesosElemento(i)->status,"STOPPED");
  1696.             HistProcesosElemento(i)->senal=WSTOPSIG(status);
  1697.             printf("----senal es %d\n",HistProcesosElemento(i)->senal);
  1698.             printf("Terminado con WIFSTOPPED(status)=%d\n",WIFSTOPPED(status));
  1699.             status=WIFSTOPPED(status);
  1700.         }else if(HistProcesosElemento(i)->senal==0 && pid==0){
  1701.             strcpy(HistProcesosElemento(i)->status,"ACTIVE");
  1702.         }
  1703.     }
  1704.        
  1705.        
  1706.         printf("Status es %d\n",status);
  1707.         if(HistProcesosElemento(i)->senal!=0){
  1708.             printf("%d \t %s p=%d  %s  %d  %d:%02d  %s  (%s)  %s\n",HistProcesosElemento(i)->PID,HistProcesosElemento(i)->usuario, HistProcesos[i]->prioridad,nombreMes(HistProcesosElemento(i)->month), HistProcesosElemento(i)->dia, HistProcesosElemento(i)->hora, HistProcesosElemento(i)->min, HistProcesosElemento(i)->status, NombreSenal(HistProcesosElemento(i)->senal),HistProcesosElemento(i)->nombre);
  1709.         }else printf("%d \t %s p=%d  %s  %d  %d:%02d  %s  (%03d)  %s\n",HistProcesosElemento(i)->PID,HistProcesosElemento(i)->usuario, HistProcesos[i]->prioridad,nombreMes(HistProcesosElemento(i)->month), HistProcesosElemento(i)->dia, HistProcesosElemento(i)->hora, HistProcesosElemento(i)->min, HistProcesosElemento(i)->status, HistProcesosElemento(i)->senal,HistProcesosElemento(i)->nombre);
  1710.         }
  1711.     }
  1712.    
  1713. void cmdDelJobs(){
  1714.     int flagTERM;
  1715.     int flagSIG;
  1716.     int i,j;
  1717.    
  1718.     if(numtrozos==1){
  1719.         printf("Uso del comando: deljobs [-sig][-term]\n");
  1720.        
  1721.     }else{
  1722.        
  1723.         for(int i = 1; i < numtrozos && trozos[i][0] == '-' ; i++){
  1724.             if(strcmp(trozos[i],"-term")==0) flagTERM = 1;
  1725.             if(strcmp(trozos[i], "-sig") == 0) flagSIG = 1;
  1726.         }
  1727.         printf("FlagTERM=%d, FlagSIG=%d\n",flagTERM, flagSIG);
  1728.         if(flagTERM==1){
  1729.             printf("Entra en TERM\n");
  1730.             for(i=0;i<nprocesos;){
  1731.                 if(strcmp(HistProcesosElemento(i)->status,"FINISHED")==0){
  1732.                    
  1733.                    
  1734.                         for(j=i;j<nprocesos-1;j++){
  1735.                             HistProcesos[j]=HistProcesos[j+1];
  1736.                         }
  1737.                         nprocesos--;
  1738.                      
  1739.                     }else{
  1740.                         i++;
  1741.                     }
  1742.                
  1743.                
  1744.                 }
  1745.         }
  1746.        
  1747.         if(flagSIG==1){
  1748.             printf("Entra en SIG\n");
  1749.             for(i=0;i<nprocesos;){
  1750.                 if(strcmp(HistProcesosElemento(i)->status,"SIGNALED")==0){
  1751.                    
  1752.                    
  1753.                         for(j=i;j<nprocesos-1;j++){
  1754.                             HistProcesos[j]=HistProcesos[j+1];
  1755.                         }
  1756.                         nprocesos--;
  1757.                      
  1758.                     }else{
  1759.                         i++;
  1760.                     }
  1761.                
  1762.                
  1763.                 }
  1764.            
  1765.         }
  1766.        
  1767.         if(flagTERM==0 && flagSIG==0){
  1768.             printf("Uso del comando: deljobs [-sig][-term]\n");
  1769.         }
  1770.        
  1771.         }
  1772.    
  1773.     }
  1774.    
  1775. void cmdJob(){
  1776.     int i;
  1777.     int flagFG=0;
  1778.     int pidbuscado;
  1779.     int pid;
  1780.     int status;
  1781.    
  1782.     for(i = 1; i < numtrozos && trozos[i][0] == '-' ; i++){
  1783.             if(strcmp(trozos[i],"-fg")==0) flagFG = 1;
  1784.         }
  1785.    
  1786.     if(numtrozos==1){
  1787.         cmdListJobs();
  1788.        
  1789.     }else if(numtrozos==2 && flagFG==0){
  1790.        
  1791.         pidbuscado=atoi(trozos[1]);
  1792.         for(i=0;i<nprocesos && HistProcesosElemento(i)->PID != pidbuscado;i++);
  1793.         if(i>=nprocesos){
  1794.             printf("No existe ese proceso\n");
  1795.         }else{
  1796.            
  1797.         pid=waitpid(HistProcesosElemento(i)->PID,&status,WNOHANG| WUNTRACED| WCONTINUED);
  1798.        
  1799.         if(strcmp("FINISHED",HistProcesosElemento(i)->status)!=0 /*&& pid != -1*/){
  1800.            
  1801.         if(WIFEXITED(status)){
  1802.             strcpy(HistProcesosElemento(i)->status,"FINISHED");
  1803.             HistProcesos[i]->prioridad=-1;
  1804.             status=WIFEXITED(status);
  1805.         }else if(WIFSIGNALED(status) && (pid!=0 || HistProcesosElemento(i)->senal !=0)){
  1806.             printf("Entra\n");
  1807.             if(WTERMSIG(status)<=31){
  1808.                 strcpy(HistProcesosElemento(i)->status,"SIGNALED");
  1809.                 HistProcesos[i]->prioridad=-1;
  1810.                 HistProcesosElemento(i)->senal=WTERMSIG(status);
  1811.                 status=WIFSIGNALED(status);
  1812.             }
  1813.         }else if(WIFSTOPPED(status)){
  1814.             strcpy(HistProcesosElemento(i)->status,"STOPPED");
  1815.             HistProcesosElemento(i)->senal=WSTOPSIG(status);
  1816.             status=WIFSTOPPED(status);
  1817.         }else if(HistProcesosElemento(i)->senal==0 && pid==0){
  1818.             strcpy(HistProcesosElemento(i)->status,"ACTIVE");
  1819.         }
  1820.     }
  1821.        
  1822.        
  1823.         if(HistProcesosElemento(i)->senal!=0){
  1824.             printf("%d \t %s p=%d  %s  %d  %d:%02d  %s  (%s)  %s\n",HistProcesosElemento(i)->PID,HistProcesosElemento(i)->usuario, HistProcesos[i]->prioridad,nombreMes(HistProcesosElemento(i)->month), HistProcesosElemento(i)->dia, HistProcesosElemento(i)->hora, HistProcesosElemento(i)->min, HistProcesosElemento(i)->status, NombreSenal(HistProcesosElemento(i)->senal),HistProcesosElemento(i)->nombre);
  1825.         }else printf("%d \t %s p=%d  %s  %d  %d:%02d  %s  (%03d)  %s\n",HistProcesosElemento(i)->PID,HistProcesosElemento(i)->usuario, HistProcesos[i]->prioridad,nombreMes(HistProcesosElemento(i)->month), HistProcesosElemento(i)->dia, HistProcesosElemento(i)->hora, HistProcesosElemento(i)->min, HistProcesosElemento(i)->status, HistProcesosElemento(i)->senal,HistProcesosElemento(i)->nombre);
  1826.            
  1827.     }
  1828.        
  1829.        
  1830.        
  1831.            
  1832.     }else if(numtrozos==2 && flagFG==1){
  1833.         cmdListJobs();
  1834.     }else if(numtrozos>=3){
  1835.        
  1836.         if(flagFG==1){
  1837.             pidbuscado=atoi(trozos[2]);
  1838.             if(waitpid(pidbuscado,&status,0)==-1){
  1839.                 printf("No existe ese proceso\n");
  1840.             }
  1841.        
  1842.         }else{
  1843.             pidbuscado=atoi(trozos[1]);
  1844.         for(i=0;i<nprocesos && HistProcesosElemento(i)->PID != pidbuscado;i++);
  1845.         if(i>=nprocesos){
  1846.             printf("No existe ese proceso\n");
  1847.         }else{
  1848.            
  1849.         pid=waitpid(HistProcesosElemento(i)->PID,&status,WNOHANG| WUNTRACED| WCONTINUED);
  1850.        
  1851.         if(strcmp("FINISHED",HistProcesosElemento(i)->status)!=0 && pid != -1){
  1852.            
  1853.         if(WIFEXITED(status)){
  1854.             strcpy(HistProcesosElemento(i)->status,"FINISHED");
  1855.             HistProcesos[i]->prioridad=-1;
  1856.             status=WIFEXITED(status);
  1857.         }else if(WIFSIGNALED(status) && (pid!=0 || HistProcesosElemento(i)->senal !=0)){
  1858.             printf("Entra\n");
  1859.             if(WTERMSIG(status)<=31){
  1860.                 strcpy(HistProcesosElemento(i)->status,"SIGNALED");
  1861.                 HistProcesos[i]->prioridad=-1;
  1862.                 HistProcesosElemento(i)->senal=WTERMSIG(status);
  1863.                 status=WIFSIGNALED(status);
  1864.             }
  1865.         }else if(WIFSTOPPED(status)){
  1866.             strcpy(HistProcesosElemento(i)->status,"STOPPED");
  1867.             HistProcesosElemento(i)->senal=WSTOPSIG(status);
  1868.             status=WIFSTOPPED(status);
  1869.         }else if(HistProcesosElemento(i)->senal==0 && pid==0){
  1870.             strcpy(HistProcesosElemento(i)->status,"ACTIVE");
  1871.         }
  1872.     }
  1873.        
  1874.        
  1875.         if(HistProcesosElemento(i)->senal!=0){
  1876.             printf("%d \t %s p=%d  %s  %d  %d:%02d  %s  (%s)  %s\n",HistProcesosElemento(i)->PID,HistProcesosElemento(i)->usuario, HistProcesos[i]->prioridad,nombreMes(HistProcesosElemento(i)->month), HistProcesosElemento(i)->dia, HistProcesosElemento(i)->hora, HistProcesosElemento(i)->min, HistProcesosElemento(i)->status, NombreSenal(HistProcesosElemento(i)->senal),HistProcesosElemento(i)->nombre);
  1877.         }else printf("%d \t %s p=%d  %s  %d  %d:%02d  %s  (%03d)  %s\n",HistProcesosElemento(i)->PID,HistProcesosElemento(i)->usuario, HistProcesos[i]->prioridad,nombreMes(HistProcesosElemento(i)->month), HistProcesosElemento(i)->dia, HistProcesosElemento(i)->hora, HistProcesosElemento(i)->min, HistProcesosElemento(i)->status, HistProcesosElemento(i)->senal,HistProcesosElemento(i)->nombre);
  1878.            
  1879.         }
  1880.            
  1881.            
  1882.            
  1883.         }
  1884.     }
  1885.    
  1886.    
  1887.    
  1888.    
  1889.    
  1890. }
  1891.  
  1892. const char * Ejecutable(const char* file){
  1893.     char destino[20] = "/usr/bin/";
  1894.     char *destinos[] = {destino};
  1895.     strcat(destino,file);
  1896.     return destinos[0];
  1897. }
  1898.  
  1899. void OurExecvpe(const char *file, char *const argv[], char *const envp[])
  1900. {
  1901.     if( (execve(Ejecutable(file),argv, envp)==-1) ){
  1902.        perror("Imposible ejecutar: ");
  1903.        };
  1904. }
  1905.  
  1906. void cmdExecute(){
  1907.     int i,j;
  1908.     char* argv[TAMANO];
  1909.     char* envp[TAMANO];
  1910.     char x[TAMANO];
  1911.     char y[TAMANO];
  1912.     char entorno[TAMANO];
  1913.     bool flagEntorno=true;
  1914.     int var,cont=1;
  1915.  
  1916.     strcpy(x,getenv("XAUTHORITY"));
  1917.     strcpy(y,"XAUTHORITY=");
  1918.     strcat(y,x);
  1919.  
  1920.     if(numtrozos==2){
  1921.         envp[0]= (char *)"DISPLAY=:0.0";
  1922.         envp[1]=(char *)y;
  1923.         envp[2]=NULL;
  1924.  
  1925.         argv[0]= trozos[1];
  1926.         argv[1]= NULL;
  1927.     }else{
  1928.         if(!isupper(trozos[1][0])){
  1929.  
  1930.         envp[0]= (char *)"DISPLAY=:0.0";
  1931.         envp[1]=(char *)y;
  1932.         envp[2]=NULL;
  1933.  
  1934.         flagEntorno=false;
  1935.         argv[0]=trozos[1];
  1936.         for(i=2;i<numtrozos && i<20;i++){
  1937.             if(trozos[i][0]!='@'){
  1938.             argv[i-1]=trozos[i];
  1939.               }
  1940.             }
  1941.             argv[i-1]=NULL;
  1942.         }else{
  1943.  
  1944.             for(i=1;i<numtrozos;i++){
  1945.                 for(j=0;j<strlen(trozos[i])-1 && isupper(trozos[i][j]);j++);
  1946.  
  1947.                 if(j+1==strlen(trozos[i])){
  1948.                     strcpy(entorno,trozos[i]);
  1949.                     strcat(entorno,"=");
  1950.  
  1951.                     strcat(entorno,getenv(trozos[i]));
  1952.  
  1953.                     envp[i-1]=malloc(100);
  1954.                     strcpy(envp[i-1],entorno);
  1955.  
  1956.                 }else break;
  1957.             }
  1958.             envp[i-1]=NULL;
  1959.  
  1960.  
  1961.  
  1962.         argv[0]=malloc(100);
  1963.         strcpy(argv[0],trozos[i]);
  1964.  
  1965.  
  1966.         var=i;
  1967.         for(i=i+1;i<numtrozos && i<20;i++){
  1968.             if(trozos[i][0]!='@'){
  1969.             argv[cont]=malloc(100);
  1970.             strcpy(argv[cont],trozos[i]);
  1971.  
  1972.             cont++;
  1973.               }
  1974.             }
  1975.             if(var+1==numtrozos){
  1976.             argv[var-1]=NULL;
  1977.             } else argv[i-2]=NULL;
  1978.  
  1979.  
  1980.  
  1981.  
  1982.             }
  1983.         }
  1984.  
  1985.         for(i = 1; i < numtrozos && trozos[i][0] != '@' ; i++);
  1986.             if(i<numtrozos){
  1987.             if(trozos[i][0] == '@'){
  1988.                 char *prioridad;
  1989.                 int prioridadint;
  1990.                 prioridad = trozos[i] + 1;
  1991.                 prioridadint= atoi(prioridad);
  1992.                 setpriority(PRIO_PROCESS,getpid(),prioridadint); //getpid() o 0
  1993.                 }
  1994.             }
  1995.  
  1996.  
  1997.  
  1998.  
  1999.     if(flagEntorno==false){
  2000.     OurExecvpe(trozos[1],argv,envp);
  2001.     }else {
  2002.         OurExecvpe(argv[0],argv,envp);
  2003.         }
  2004.     for(i=0;i<TAMANO;i++){
  2005.         free(envp[i]);      //Liberar
  2006.         }
  2007.  
  2008. }
  2009.  
  2010.  
  2011. //Comando ayuda
  2012. void cmdAyuda() {
  2013.     if (numtrozos == 1) {
  2014.         printf("'ayuda cmd' donde cmd es uno de los siguientes comandos:\n"
  2015.                "fin salir bye fecha pid autores hist comando carpeta infosis ayuda\n");
  2016.     } else if (numtrozos > 1 && strcmp(trozos[1], "fin") == 0) {
  2017.         printf("fin \tTermina la ejecucion del shell\n");
  2018.     } else if (numtrozos > 1 && strcmp(trozos[1], "salir") == 0) {
  2019.         printf("salir \tTermina la ejecucion del shell\n");
  2020.     } else if (numtrozos > 1 && strcmp(trozos[1], "bye") == 0) {
  2021.         printf("bye \tTermina la ejecucion del shell\n");
  2022.     } else if (numtrozos > 1 && strcmp(trozos[1], "fecha") == 0) {
  2023.         printf("fecha [-d|.h\tMuestra la fecha y o la hora actual\n");
  2024.     } else if (numtrozos > 1 && strcmp(trozos[1], "pid") == 0) {
  2025.         printf("pid [-p]\tMuestra el pid del shell o de su proceso padre\n");
  2026.     }else if (numtrozos > 1 && strcmp(trozos[1], "autores") == 0) {
  2027.         printf("autores [-n|-l]\tMuestra los nombres y logins de los autores\n");
  2028.     }else if (numtrozos > 1 && strcmp(trozos[1], "hist") == 0) {
  2029.         printf("hist [-c|-N]\tMuestra el historico de comandos, con -c lo borra\n");
  2030.     }else if (numtrozos > 1 && strcmp(trozos[1], "comando") == 0) {
  2031.         printf("comando [-N]\tRepite el comando N (del historico)\n");
  2032.     }else if (numtrozos > 1 && strcmp(trozos[1], "carpeta") == 0) {
  2033.         printf("carpeta [dir]\tCambia (o muestra) el directorio actual del shell\n");
  2034.     }else if (numtrozos > 1 && strcmp(trozos[1], "carpeta") == 0) {
  2035.         printf("infosis \tMuestra informacion de la maquina donde corre el shell\n");
  2036.     }else if (numtrozos > 1 && strcmp(trozos[1], "ayuda") == 0) {
  2037.         printf("ayuda [cmd]\tMuestra ayuda sobre los comandos\n");
  2038.     }else if (numtrozos > 1 && strcmp(trozos[1], "create") == 0) {
  2039.         printf("create [-f] [name]  Crea un directorio o un fichero (-f)\n");
  2040.     }else if (numtrozos > 1 && strcmp(trozos[1], "stat") == 0) {
  2041.         printf("stat [-long][-link][-acc] name1 name2 ..    lista ficheros;\n-long: listado largo\n-acc: acesstime\n-link: si es enlace simbolico, el path contenido\n");
  2042.     }else if (numtrozos > 1 && strcmp(trozos[1], "list") == 0) {
  2043.         printf("list [-reca] [-recb] [-hid][-long][-link][-acc] n1 n2 ..    lista contenidos de directorios\n-hid: incluye los ficheros ocultos\n-reca: recursivo (antes)\n-recb: recursivo (despues)\nresto parametros como stat\n");
  2044.     }else if (numtrozos > 1 && strcmp(trozos[1], "delete") == 0) {
  2045.         printf("delete [name1 name2 ..] Borra ficheros o directorios vacios\n");
  2046.     }else if (numtrozos > 1 && strcmp(trozos[1], "deltree") == 0) {
  2047.         printf("deltree [name1 name2 ..]    Borra ficheros o directorios no vacios recursivamente\n");
  2048.     }
  2049. }
  2050.  
  2051. struct cm_entrada{
  2052.     char *cm_nombre;
  2053.     void (*cm_fun)();
  2054. };
  2055.  
  2056. struct cm_entrada cm_tabla[] = {
  2057.     {"autores", cmdAutores},
  2058.     {"ayuda", cmdAyuda},
  2059.     {"bye", cmdFin},
  2060.     {"carpeta", cmdCarpeta},
  2061.     {"comando", cmdComandoN},
  2062.     {"create", cmdCreate},
  2063.     {"delete", cmdDelete},
  2064.     {"fecha", cmdFecha},
  2065.     {"fin", cmdFin},
  2066.     {"hist", cmdHist},
  2067.     {"infosis", cmdInfosis},
  2068.     {"pid", cmdPid},
  2069.     {"salir", cmdFin},
  2070.     {"stat", cmdStat},
  2071.     {"list", cmdList},
  2072.     {"allocate",cmdAllocate},
  2073.     {"deallocate",cmdDeallocate},
  2074.     {"memdump",cmdMemdump},
  2075.     {"recurse",cmdRecurse},
  2076.     {"memory",cmdMemory},
  2077.     {"memfill",cmdMemfill},
  2078.     {"i-o",cmdIo},
  2079.     {"fork",cmdFork},
  2080.     {"listjobs",cmdListJobs},
  2081.     {"execute",cmdExecute},
  2082.     {"deljobs",cmdDelJobs},
  2083.     {"job",cmdJob},
  2084.     {"priority",cmdPriority},
  2085.     {"showenv",cmdEntorno},
  2086.     {"showvar",cmdMostrarVar},
  2087.     {"changevar",cmdCambiarVar},
  2088.     //Actualizar número en función de abajo (Actual 31)
  2089. };
  2090.  
  2091. void comprobarSiEsta(char *linea){
  2092.     int i,j;
  2093.     int pid;
  2094.     int status;
  2095.     time_t t = time(NULL);
  2096.     struct tm tm = *localtime(&t);
  2097.     uid_t uid = geteuid();
  2098.     struct passwd *pws = getpwuid(uid);
  2099.  
  2100.     char aux[TAMANO], aux2[TAMANO];
  2101.     char *prioridad;
  2102.     int prioridadint;
  2103.    
  2104.  
  2105.     pid=fork();
  2106.     pidglobal=pid;
  2107.    
  2108.  
  2109.     char *copialinea = strdup(linea);
  2110.     numtrozos = TrocearCadena(copialinea, trozos);
  2111.  
  2112.     for(i=0;i<31 && strcmp(cm_tabla[i].cm_nombre, trozos[0]) != 0;i++); //CAMBIAR
  2113.  
  2114.     if(pid==0){
  2115.         if(i<31){ //CAMBIAR
  2116.             if(strcmp(trozos[0],"execute")!=0 && strcmp(trozos[0],"listjobs")!=0 && strcmp(trozos[0],"deljobs")!=0 && strcmp(trozos[0],"job")!=0 && strcmp(trozos[0],"showenv")!=0 && strcmp(trozos[0],"priority")!=0 && strcmp(trozos[0],"showvar")!=0 && strcmp(trozos[0],"changevar")!=0){ ///////////////////////////////////////
  2117.             ejecutarComando2(linea);
  2118.         }
  2119.  
  2120.         }else{
  2121.             if(strcmp(trozos[numtrozos-1],"&")!=0){
  2122.             //Programar *****
  2123.             trozos[numtrozos]=malloc(1000); //Hacer free
  2124.  
  2125.             for(i=1;i<numtrozos+1;i++){
  2126.                 if(i==1){
  2127.                     strcpy(aux,trozos[1]);
  2128.  
  2129.  
  2130.                     trozos[1]=malloc(TAMANO);
  2131.                     strcpy(trozos[1],trozos[0]);//AQUÍ
  2132.  
  2133.                     }else{
  2134.                         if(i%2==0){
  2135.                             strcpy(aux2,trozos[i]);
  2136.  
  2137.                             trozos[i]=malloc(TAMANO);
  2138.                             strcpy(trozos[i],aux);
  2139.  
  2140.                             }else{
  2141.                                 strcpy(aux,trozos[i]);
  2142.  
  2143.                                 trozos[i]=malloc(TAMANO);
  2144.                                 strcpy(trozos[i],aux2);
  2145.  
  2146.                                 }
  2147.  
  2148.                         }
  2149.             }numtrozos++; //Aumentar trozos
  2150.  
  2151.             cmdExecute();
  2152.         }else{
  2153.  
  2154.             numtrozos--;
  2155.             //Con &
  2156.             //Programar *****
  2157.             trozos[numtrozos]=malloc(1000); //Hacer free
  2158.  
  2159.             for(i=1;i<numtrozos+1;i++){
  2160.                 if(i==1){
  2161.                     strcpy(aux,trozos[1]);
  2162.  
  2163.  
  2164.                     trozos[1]=malloc(TAMANO);
  2165.                     strcpy(trozos[1],trozos[0]);//AQUÍ
  2166.  
  2167.                     }else{
  2168.                         if(i%2==0){
  2169.                             strcpy(aux2,trozos[i]);
  2170.  
  2171.                             trozos[i]=malloc(TAMANO);
  2172.                             strcpy(trozos[i],aux);
  2173.  
  2174.                             }else{
  2175.                                 strcpy(aux,trozos[i]);
  2176.  
  2177.                                 trozos[i]=malloc(TAMANO);
  2178.                                 strcpy(trozos[i],aux2);
  2179.  
  2180.                                 }
  2181.  
  2182.                         }
  2183.             }numtrozos++; //Aumentar trozos
  2184.  
  2185.             cmdExecute();
  2186.  
  2187.  
  2188.  
  2189.             }
  2190.         exit(0);
  2191.             }
  2192.     }else{
  2193.  
  2194.         if(strcmp(trozos[0],"execute")==0){
  2195.             ejecutarComando(linea);
  2196.             waitpid(-1,&status,0);
  2197.         }
  2198.  
  2199.         if(strcmp(trozos[0],"listjobs")==0){////////////////////////
  2200.             ejecutarComando(linea);
  2201.             waitpid(pid,&status,WNOHANG);
  2202.         }
  2203.        
  2204.         if(strcmp(trozos[0],"deljobs")==0){////////////////////////
  2205.             ejecutarComando(linea);
  2206.             waitpid(pid,&status,WNOHANG);
  2207.         }
  2208.        
  2209.         if(strcmp(trozos[0],"job")==0){////////////////////////
  2210.             ejecutarComando(linea);
  2211.             waitpid(pid,&status,WNOHANG);
  2212.         }
  2213.        
  2214.         if(strcmp(trozos[0],"showenv")==0){////////////////////////
  2215.             ejecutarComando(linea);
  2216.             waitpid(pid,&status,WNOHANG);
  2217.         }
  2218.        
  2219.         if(strcmp(trozos[0],"priority")==0){////////////////////////
  2220.             ejecutarComando(linea);
  2221.             waitpid(pid,&status,WNOHANG);
  2222.         }
  2223.        
  2224.         if(strcmp(trozos[0],"showvar")==0){////////////////////////
  2225.             ejecutarComando(linea);
  2226.             waitpid(pid,&status,WNOHANG);
  2227.         }
  2228.        
  2229.         if(strcmp(trozos[0],"changevar")==0){////////////////////////
  2230.             ejecutarComando(linea);
  2231.             waitpid(pid,&status,WNOHANG);
  2232.         }
  2233.        
  2234.         /*if( (strcmp(trozos[0],"salir")==0 || strcmp(trozos[0],"fin")==0 || strcmp(trozos[0],"bye")==0)){////////////////////////
  2235.             ejecutarComando(linea);
  2236.             waitpid(pid,&status,WNOHANG);
  2237.         }*/
  2238.  
  2239.         if(strcmp(trozos[numtrozos-1],"&")==0){
  2240.             //
  2241.             for(i=0;i<numtrozos && isupper(trozos[i][0]);i++);
  2242.             for(j=0;j<numtrozos && trozos[j][0]!='@';j++);
  2243.             if(j==numtrozos){
  2244.                 histProcesoInsert(pid,tm.tm_mon + 1,tm.tm_mday,tm.tm_hour,tm.tm_min,"ACTIVE",0,pws->pw_name, trozos[i],0);
  2245.             }else{
  2246.                 prioridad = trozos[j] + 1;
  2247.                 prioridadint= atoi(prioridad);
  2248.                 histProcesoInsert(pid,tm.tm_mon + 1,tm.tm_mday,tm.tm_hour,tm.tm_min,"ACTIVE",0,pws->pw_name, trozos[i],prioridadint);
  2249.             }
  2250.             //
  2251.             //waitpid(pid,&status,WNOHANG);
  2252.         }else{
  2253.             waitpid(-1,&status,0);
  2254.             //waitpid(pid,&status,WNOHANG);
  2255.         }
  2256.     }
  2257.  
  2258.  
  2259.     free(copialinea);
  2260.     if(pid==0){
  2261.         exit(0);
  2262.     }
  2263.        
  2264. }
  2265.  
  2266. void ejecutarComando(char *linea){
  2267.     int i;
  2268.  
  2269.  
  2270.     if(numtrozos == 0) {return;}
  2271.     for( i=0; ; i++){
  2272.         if(cm_tabla[i].cm_nombre == NULL){
  2273.             printf("%s: comando no reconocido\n", trozos[0]);
  2274.             break;
  2275.         }
  2276.         if(strcmp(cm_tabla[i].cm_nombre, trozos[0]) == 0){
  2277.             cm_tabla[i].cm_fun();
  2278.             break;
  2279.         }
  2280.     }
  2281. }
  2282.  
  2283.  
  2284. void ejecutarComando2(char *linea){
  2285.     int i;
  2286.  
  2287.  
  2288.     if(numtrozos == 0) {return;}
  2289.     for( i=0; ; i++){
  2290.         if(cm_tabla[i].cm_nombre == NULL){
  2291.             printf("%s: comando no reconocido\n", trozos[0]);
  2292.             break;
  2293.         }
  2294.         if(strcmp(cm_tabla[i].cm_nombre, trozos[0]) == 0){
  2295.             cm_tabla[i].cm_fun();
  2296.             break;
  2297.         }
  2298.     }
  2299.     exit(0);
  2300. }
  2301.  
  2302. int main(int argc, char *argv[], char *envp[]){
  2303. pidglobal=getpid();
  2304.     while(1){
  2305.         entorno=envp;
  2306.         usleep(15000);
  2307.         printf("%d @>",pidglobal);       //Prompt
  2308.         if( fgets(linea, 4096, stdin) == NULL ){
  2309.             exit(0);
  2310.         }
  2311.         if(linea[0]!=10){
  2312.         comprobarSiEsta(linea);
  2313.         histInsert(linea);
  2314.         }
  2315.     }
  2316.     for(int i=0; i < nhist; i++){
  2317.         free(Hist[i]);
  2318.     }
  2319.     for(int i=0; i < nbloq; i++){
  2320.         free(histBloqElemento(i)->dir);
  2321.         free(HistBloq[i]);
  2322.     }
  2323.     for(int i=0; i < nshared; i++){
  2324.         free(histSharedElemento(i)->dir);
  2325.         free(HistShared[i]);
  2326.     }
  2327.     for(int i=0; i < nmmap; i++){
  2328.         free(histMmapElemento(i)->dir);
  2329.         free(HistMmap[i]);
  2330.     }
  2331.     HistProcesosBorrar();
  2332.  
  2333.     for(int i=0;i<MaxTrozos;i++){
  2334.                 free (trozos[i]);
  2335.             }
  2336. }
  2337.  
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!