Ledger Nano X - The secure hardware wallet
SHARE
TWEET

Untitled

a guest Apr 2nd, 2020 139 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <time.h>
  5. #include <mqueue.h>
  6. #include <sys/wait.h>
  7. #include <errno.h> //Control de errores
  8. #include <string.h> //Para la funcion strerror()
  9.  
  10. #define MAX_SIZE    5
  11. #define QUEUE_NAME  "/una_cola"
  12.  
  13. int main()
  14. {
  15.     // Descriptor de la cola
  16.     mqd_t mq;
  17.     // Buffer para la lectura/escritura
  18.     char buffer[MAX_SIZE];
  19.     // Atributos de la cola
  20.     struct mq_attr attr;
  21.     // Almacena el nombre de la cola
  22.     char queue_name[100];
  23.     // Resultado de las operaciones
  24.     int resultado;
  25.     // Para realizar el fork
  26.     pid_t rf, flag;
  27.     int status;
  28.     int parada = 0;
  29.     int tamano = 0;
  30.     // Numero aleatorio a generar
  31.     //int numeroAleatorio;
  32.     // Inicializar los atributos de la cola.
  33.     attr.mq_maxmsg = 10;        // Maximo número de mensajes
  34.     attr.mq_msgsize = MAX_SIZE; // Maximo tamaño de un mensaje. Tener en cuenta que debe incluir el '/0'
  35.     // Nombre para la cola. Al concatenar el login, sera unica en un sistema compartido.
  36.     sprintf(queue_name, "%s-%s", QUEUE_NAME, getenv("USER"));
  37.  
  38.     // Realizar el fork
  39.     rf = fork();
  40.     switch (rf)
  41.     {
  42.         // Error
  43.         case -1:
  44.             printf ("No he podido crear el proceso hijo \n");
  45.             exit(1);
  46.  
  47.         case 0: // Hijo. El hijo solo se encargará de escribir.
  48.  
  49.             /* Apertura de la cola
  50.                O_CREAT: si no existe, se crea
  51.                O_RDWR: lectura/escritura
  52.                O_RDONLY: solo lectura
  53.                O_WRONLY: solo escritura
  54.                0644: permisos rw-r--r--
  55.                      permisos de lectura y escritura para el propietario, y de sólo lectura para el grupo y para otros
  56.                attr: estructura con atributos para la cola  */
  57.             mq = mq_open(queue_name, O_CREAT | O_RDWR, 0644, &attr);
  58.             printf ("[HIJO]: El nombre de la cola es: %s\n", queue_name);
  59.             printf ("[HIJO]: El descriptor de la cola es: %d\n", (int) mq);
  60.  
  61.             if(mq==-1)
  62.             {
  63.                 perror("[HIJO]: Error en la apertura de la cola");
  64.                 exit(-1);
  65.             }
  66.             printf ("[HIJO]: Mi PID es %d y mi PPID es %d\n", getpid(), getppid());
  67.  
  68.             /* Rellenamos el buffer que vamos a enviar
  69.                Semilla de los números aleatorios, establecida a la hora actual*/
  70.             /*
  71.             srand(time(NULL));
  72.             // Número aleatorio entre 0 y 4999
  73.             numeroAleatorio = rand()%5000;
  74.             sprintf(buffer,"%d",numeroAleatorio); // La funcion sprintf escribe en una cadena el valor indicado y añade el '/0'.
  75.             printf("[HIJO]: Generado el mensaje \"%s\"\n", buffer);
  76.  
  77.             // Mandamos el mensaje
  78.             printf("[HIJO]: Enviando mensaje...\n");
  79.             resultado = mq_send(mq, buffer, MAX_SIZE, 0);
  80.             if(resultado == -1)
  81.             {
  82.                 perror("[HIJO]: Error al enviar mensaje");
  83.                 exit(-1);
  84.             }
  85.  
  86.             printf("[HIJO]: Mensaje enviado!\n");
  87.             // Cerrar la cola
  88.             if(mq_close(mq) == -1)
  89.             {
  90.                 perror("[HIJO]: Error cerrando la cola");
  91.                 exit(-1);
  92.             }
  93.             printf("[HIJO]: Cola cerrada.\n");
  94.             break; //Saldría del switch()
  95.             */
  96.             do
  97.             {
  98.                 printf("[HIJO]: Introduzca un cadena: ");
  99.                 fflush(stdin);
  100.                 fgets(buffer, MAX_SIZE, stdin);
  101.  
  102.                 printf("[HIJO]: Enviando mensaje...\n");
  103.                 resultado = mq_send(mq, buffer, MAX_SIZE, 0);
  104.                 if(resultado == -1)
  105.                 {
  106.                     perror("[HIJO]: Error al enviar mensaje");
  107.                     exit(-1);
  108.                 }
  109.                 printf("[HIJO]: Mensaje enviado!\n");
  110.  
  111.                 if (strncmp(buffer, "exit", 4))
  112.                     parada = 1;
  113.  
  114.                 if (parada == 0)
  115.                 {
  116.                     printf ("[PADRE]: Recibiendo mensaje (espera bloqueante)...\n");
  117.                     resultado = mq_receive(mq, buffer, MAX_SIZE, NULL);
  118.                     if(resultado <= 0)
  119.                     {
  120.                         perror("[HIJO]: Error al recibir el mensaje");
  121.                         exit(-1);
  122.                     }
  123.                     // Imprimimos el mensaje recibido
  124.                     printf("[HIJO]: El mensaje recibido es \"%s\"\n", buffer);
  125.                 }
  126.  
  127.             } while (parada == 0);
  128.            
  129.             // Cerrar la cola
  130.             if(mq_close(mq) == -1)
  131.             {
  132.                 perror("[HIJO]: Error cerrando la cola");
  133.                 exit(-1);
  134.             }
  135.             printf("[HIJO]: Cola cerrada.\n");
  136.             break; //Saldría del switch()
  137.  
  138.         default: // Padre. El padre solo se encargará de leer
  139.  
  140.             /* Apertura de la cola */
  141.             mq = mq_open(queue_name, O_CREAT | O_RDWR, 0644, &attr);
  142.             printf ("[PADRE]: El nombre de la cola es: %s\n", queue_name);
  143.             printf ("[PADRE]: El descriptor de la cola es:%d\n", (int) mq);
  144.  
  145.             if(mq==-1)
  146.             {
  147.                 perror("[PADRE]: Error en la apertura de la cola");
  148.                 exit(-1);
  149.             }
  150.  
  151.             printf ("[PADRE]: Mi PID es %d y el PID de mi hijo es %d \n", getpid(), rf);
  152.             printf ("[PADRE]: Recibiendo mensaje (espera bloqueante)...\n");
  153.  
  154.             do
  155.             {
  156.                 // Recibimos un mensaje a través de la cola
  157.                 resultado = mq_receive(mq, buffer, MAX_SIZE, NULL);
  158.                 if(resultado <= 0)
  159.                 {
  160.                     perror("[PADRE]: Error al recibir el mensaje");
  161.                     exit(-1);
  162.                 }
  163.  
  164.                 // Imprimimos el mensaje recibido
  165.                 printf("[PADRE]: El mensaje recibido es \"%s\"\n", buffer);
  166.  
  167.                 if (strncmp(buffer, "exit", 4))
  168.                     parada = 1;
  169.  
  170.                 buffer[strlen(buffer)-1] = '\0';
  171.                 tamano = strlen(buffer);
  172.                 sprintf(buffer, "%d", tamano);
  173.  
  174.                 if (parada == 0)
  175.                 {
  176.                     printf("[PADRE]: Enviando mensaje...\n");
  177.                     resultado = mq_send(mq, buffer, MAX_SIZE, 0);
  178.                     if(resultado == -1)
  179.                     {
  180.                         perror("[PADRE]: Error al enviar mensaje");
  181.                         exit(-1);
  182.                     }
  183.                     printf("[PADRE]: Mensaje enviado!\n");
  184.  
  185.                 }
  186.             } while (parada == 0);
  187.  
  188.             // Cerrar la cola
  189.             if(mq_close(mq) == -1)
  190.             {
  191.                 perror("[PADRE]: Error cerrando la cola");
  192.                 exit(-1);
  193.             }
  194.  
  195.             printf("[PADRE]: Cola cerrada.\n");
  196.  
  197.             // Eliminar la cola
  198.             if(mq_unlink(queue_name) == -1)
  199.             {
  200.                 perror("[PADRE]: Error eliminando la cola");
  201.                 exit(-1);
  202.             }
  203.  
  204.         /*Espera del padre a los hijos*/
  205.         while ( (flag=wait(&status)) > 0 )
  206.         {
  207.             if (WIFEXITED(status)) {
  208.                 printf("Proceso Padre, Hijo con PID %ld finalizado, status = %d\n", (long int)flag, WEXITSTATUS(status));
  209.             }
  210.             else if (WIFSIGNALED(status)) {  //Para seniales como las de finalizar o matar
  211.                 printf("Proceso Padre, Hijo con PID %ld finalizado al recibir la señal %d\n", (long int)flag, WTERMSIG(status));
  212.             }
  213.         }
  214.         if (flag==(pid_t)-1 && errno==ECHILD)
  215.         {
  216.             printf("Proceso Padre %d, no hay mas hijos que esperar. Valor de errno = %d, definido como: %s\n", getpid(), errno, strerror(errno));
  217.         }
  218.         else
  219.         {
  220.             printf("Error en la invocacion de wait o waitpid. Valor de errno = %d, definido como: %s\n", errno, strerror(errno));
  221.             exit(EXIT_FAILURE);
  222.         }
  223.     }
  224.     exit(0);
  225. }
RAW Paste Data
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
Top