client.rs 3.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112
  1. mod utils;
  2. use log::debug;
  3. use std::collections::BTreeMap;
  4. use std::os::unix::io::AsRawFd;
  5. use std::str::{self, FromStr};
  6. use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes, SocketSet};
  7. use smoltcp::phy::{wait as phy_wait, Device, Medium};
  8. use smoltcp::socket::tcp;
  9. use smoltcp::time::Instant;
  10. use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, Ipv4Address};
  11. fn main() {
  12. utils::setup_logging("");
  13. let (mut opts, mut free) = utils::create_options();
  14. utils::add_tuntap_options(&mut opts, &mut free);
  15. utils::add_middleware_options(&mut opts, &mut free);
  16. free.push("ADDRESS");
  17. free.push("PORT");
  18. let mut matches = utils::parse_options(&opts, free);
  19. let device = utils::parse_tuntap_options(&mut matches);
  20. let fd = device.as_raw_fd();
  21. let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
  22. let address = IpAddress::from_str(&matches.free[0]).expect("invalid address format");
  23. let port = u16::from_str(&matches.free[1]).expect("invalid port format");
  24. let neighbor_cache = NeighborCache::new(BTreeMap::new());
  25. let tcp_rx_buffer = tcp::SocketBuffer::new(vec![0; 64]);
  26. let tcp_tx_buffer = tcp::SocketBuffer::new(vec![0; 128]);
  27. let tcp_socket = tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer);
  28. let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]);
  29. let ip_addrs = [IpCidr::new(IpAddress::v4(192, 168, 69, 2), 24)];
  30. let default_v4_gw = Ipv4Address::new(192, 168, 69, 100);
  31. let mut routes_storage = [None; 1];
  32. let mut routes = Routes::new(&mut routes_storage[..]);
  33. routes.add_default_ipv4_route(default_v4_gw).unwrap();
  34. let medium = device.capabilities().medium;
  35. let mut builder = InterfaceBuilder::new(device)
  36. .ip_addrs(ip_addrs)
  37. .routes(routes);
  38. if medium == Medium::Ethernet {
  39. builder = builder
  40. .hardware_addr(ethernet_addr.into())
  41. .neighbor_cache(neighbor_cache);
  42. }
  43. let mut iface = builder.finalize();
  44. let mut sockets = SocketSet::new(vec![]);
  45. let tcp_handle = sockets.add(tcp_socket);
  46. let socket = sockets.get::<tcp::Socket>(tcp_handle);
  47. socket
  48. .connect(iface.context(), (address, port), 49500)
  49. .unwrap();
  50. let mut tcp_active = false;
  51. loop {
  52. let timestamp = Instant::now();
  53. match iface.poll(timestamp, &mut sockets) {
  54. Ok(_) => {}
  55. Err(e) => {
  56. debug!("poll error: {}", e);
  57. }
  58. }
  59. let socket = sockets.get::<tcp::Socket>(tcp_handle);
  60. if socket.is_active() && !tcp_active {
  61. debug!("connected");
  62. } else if !socket.is_active() && tcp_active {
  63. debug!("disconnected");
  64. break;
  65. }
  66. tcp_active = socket.is_active();
  67. if socket.may_recv() {
  68. let data = socket
  69. .recv(|data| {
  70. let mut data = data.to_owned();
  71. if !data.is_empty() {
  72. debug!(
  73. "recv data: {:?}",
  74. str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
  75. );
  76. data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
  77. data.reverse();
  78. data.extend(b"\n");
  79. }
  80. (data.len(), data)
  81. })
  82. .unwrap();
  83. if socket.can_send() && !data.is_empty() {
  84. debug!(
  85. "send data: {:?}",
  86. str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
  87. );
  88. socket.send_slice(&data[..]).unwrap();
  89. }
  90. } else if socket.may_send() {
  91. debug!("close");
  92. socket.close();
  93. }
  94. phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
  95. }
  96. }