Sto lavorando su un incarico che usa i segnali per trasferire un messaggio binario tra due processi, con l'obiettivo di conoscere i segnali (è uno strano uso).Perché il mio gestore di segnale non viene chiamato?
Nel mio programma, i due processi comunicano un codice, quindi uno trasferisce un messaggio all'altro. SIGUSR1 rappresenta 0, SIGUSR2 rappresenta 1. L'idea è che il processo che invia il messaggio utilizzi la funzione kill con qualsiasi SIGUSR per ricevere il messaggio, e il processo di ricezione avrà un gestore di segnali per interpretare i codici.
Quindi ecco il problema. Ho avviato il mittente. dorme mentre attende il codice da inviare. Il ricevitore invia due SIGINT per indicare la 'password', utilizzando pidof(8) per trovare il pid del mittente.
Una volta che il gestore del segnale del mittente ha letto questi segnali, riconosce che è la password corretta, quindi procede all'invio del messaggio.
Il ricevitore ha subito alcune funzioni e sta dormendo ogni secondo in attesa che ogni bit venga passato tramite un'interruzione. Il problema è che questo non succede mai.
ho creato in modo tale che il mittente invia un bit (0 in questo caso) in questo modo:
kill(SIGUSR1,washingtonPID);
dove washingtonPID è il PID del ricevitore, e ho verificato questo è il corretto PID.
gestore del ricevitore è collegato in questo modo:
//IN MAIN
signal(SIGINT,bitReceiver);
signal(SIGUSR1,bitReceiver);
signal(SIGUSR2,bitReceiver);
//OUTSIDE MAIN
void bitReceiver(int signum)
{
if(signum == SIGUSR1)
{
fprintf(stderr,"SIGUSR1 - 0");
bit = 0;
}
else if (signum == SIGUSR2)
{
fprintf(stderr,"SIGUSR2 - 1");
bit = 1;
}
else //sigint
raise(SIGINT);
return;
}
cui bit è una variabile globale. è inizialmente impostato su -1.
Qui è la funzione che legge i bit:
int receiveBit()
{
while(bit == -1)
{
sleep(1);
}
fprintf(stderr,"%d",bit);
int bit2 = bit;
bit = -1;
return bit2;
}
Quindi la corsa di base attraverso questo: Dopo che il codice è stato inviato dal ricevitore al mittente, il mittente inizia a inviare segnali uccidere di USR1 e USR2 al ricevitore, che alla fine dovrebbe formare un messaggio binario.
Il ricevitore sta semplicemente aspettando a questo punto, dormendo ogni secondo. Quando viene interrotto, il gestore imposterà bit a 0 o 1, tirandolo fuori dal sonno, stampando il bit e restituendolo.
se lascio i due programmi eseguiti normalmente, il ricevitore si trova proprio di sonno, e il gestore non è mai chiamato (anche se posso vedere le chiamate effettuate dal l'altro processo.
se mi fermo il mittente e inviando manualmente i segnali di Kill, posso inviare uno, forse due segnali, entrambi gestiti correttamente, dopodiché, e ricevo un messaggio stampato sul terminale come "segnale utente 2". Che non è qualcosa che ho nel mio programma e il programma si interrompe immediatamente
Qualsiasi intuizione sul perché il mio gestore non viene invocato, e sul motivo per cui non posso inviare manualmente più di uno o due segnali, sarebbe molto apprezzato
Grazie per il vostro tempo.
MODIFICA: Sembra che le persone siano perplesse su questo. Ci sono suggerimenti per il debug che potrei provare?
Tutto quello che posso dire è che questo è un design ridicolmente inefficiente, e l'uso di 'pidof' per trovare un processo non è sicuro o robusto. (Immagina che qualcuno faccia un processo con lo stesso nome per rubare la password.) Dovresti usare socket di dominio UNIX per questo tipo di comunicazione. –
Se noterai nel primo paragrafo, ho menzionato che questo è un compito e non un problema del mondo reale. È inefficiente e usare pidof non è sicuro. Ma non sono preoccupato per quello. – Blackbinary
'bit' dichiarato' volatile'? –