Dodany przez: rust, 16:44 19-09-2016

Nowy Pobierz
  1. extern crate nix;
  2. extern crate unix_socket;
  3. extern crate libc;
  4.  
  5. use std::io::prelude::*;
  6. use nix::sys::signal::*;
  7. use nix::unistd::*;
  8. use std::thread;
  9. use std::time::Duration;
  10. use unix_socket::*;
  11. use std::str::*;
  12. use std::io::ErrorKind;
  13.  
  14.  
  15. fn stworz_pare_gniazd() -> (UnixStream,UnixStream)
  16. {
  17.     UnixStream::pair().unwrap()
  18. }
  19.  
  20. fn kod_dla_rodzica(krotka_z_gniazdami : (unix_socket::UnixStream,unix_socket::UnixStream), &child_no : &libc::pid_t)
  21. {
  22.     let (gniazdo_dziecka,mut gniazdo_rodzica)  = krotka_z_gniazdami;
  23.     drop(gniazdo_dziecka);
  24.     println!("Ro: Rodzic");
  25.     std::io::stdout().flush().unwrap();
  26.     for iteracja in 1..6 {
  27.         println!("Ro: iteracja={}",iteracja);
  28.         std::io::stdout().flush().unwrap();
  29.         match (gniazdo_rodzica).write_all(b"Czesc\0") {
  30.             Ok(_) => {},
  31.             Err(i) => {
  32.                 thread::sleep(Duration::from_millis(300));
  33.                 kill(child_no, SIGKILL).expect("kill failed");
  34.                 println!("Ro: Błąd: {}",i);
  35.                 panic!("Panika");
  36.             },
  37.         }
  38.         gniazdo_rodzica.flush().unwrap();
  39.         thread::sleep(Duration::from_millis(650));
  40.        
  41.     }
  42.     println!("Ro: Porzucanie gniazd w rodzicu zaraz po ostatniej iteracji");
  43.     std::io::stdout().flush().unwrap();
  44.     drop(gniazdo_rodzica);
  45.     thread::sleep(Duration::from_millis(4000));
  46.     kill(child_no, SIGKILL).expect("kill failed");
  47. }
  48.  
  49. fn kod_dla_dziecka(krotka_z_gniazdami : (UnixStream,UnixStream))
  50. {
  51.     let (mut gniazdo_dziecka,gniazdo_rodzica)  = krotka_z_gniazdami;
  52.     drop(gniazdo_rodzica);
  53.     println!("Dz: Dziecko");
  54.     gniazdo_dziecka.set_nonblocking(true).unwrap();
  55.     std::io::stdout().flush().unwrap();
  56.     thread::sleep(Duration::from_millis(50));
  57.     let mut odpowiedz = String::new();
  58.     let mut liczba_iteracji_od_nulla = 0;
  59.     for iteracja in 1.. {
  60.         let mut bufor_na_1_bajt = [0; 1];
  61.         let mut wart_bool = false;
  62.         match gniazdo_dziecka.read(&mut bufor_na_1_bajt){
  63.             Ok(wielkosc) if wielkosc > 0 => {wart_bool = true;},
  64.             Ok(_)                         => {},
  65.             Err(blad) => {
  66.                 let numer_bledu = blad.raw_os_error().unwrap();
  67.                 if numer_bledu == 11 {
  68.                     true;
  69.                 } else {
  70.                     break;
  71.                 }
  72.             },
  73.         }
  74.  
  75.         println!("Dz: {}",iteracja);
  76.  
  77.         if wart_bool {
  78.             let kawalek = &[(bufor_na_1_bajt[0])];
  79.             let st = String::from_utf8_lossy(kawalek);
  80.  
  81.             if liczba_iteracji_od_nulla == 0 {
  82.                 print!("Dz: ");
  83.             }
  84.  
  85.             if bufor_na_1_bajt[0] == ('\0' as u8) {
  86.                 println!("\nDz: Ilość read_exact() od ostatniego wyświetlenia {}",
  87.                     liczba_iteracji_od_nulla);
  88.                 liczba_iteracji_od_nulla = 0;
  89.             }else {
  90.                 print!("{}",st);
  91.                 liczba_iteracji_od_nulla += 1;
  92.             }
  93.         }
  94.  
  95.         std::io::stdout().flush().unwrap();
  96.     }  // until killed
  97. }
  98.  
  99. fn main()
  100. {
  101.     let gniazda = stworz_pare_gniazd();
  102.  
  103.     match fork().expect("fork failed") {
  104.         Fork::Parent( child ) => {
  105.             kod_dla_rodzica(gniazda,&child);
  106.         }
  107.         Fork::Child => {
  108.             kod_dla_dziecka(gniazda);
  109.         }
  110.     }
  111. }

Źródło:

Ostatnie wpisy

Linki

Funkcje