client.rs 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141
  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. #[cfg(any(
  7. feature = "proto-sixlowpan-fragmentation",
  8. feature = "proto-ipv4-fragmentation"
  9. ))]
  10. use smoltcp::iface::ReassemblyBuffer;
  11. use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes, SocketSet};
  12. use smoltcp::phy::{wait as phy_wait, Device, Medium};
  13. use smoltcp::socket::tcp;
  14. use smoltcp::time::Instant;
  15. use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, Ipv4Address};
  16. fn main() {
  17. utils::setup_logging("");
  18. let (mut opts, mut free) = utils::create_options();
  19. utils::add_tuntap_options(&mut opts, &mut free);
  20. utils::add_middleware_options(&mut opts, &mut free);
  21. free.push("ADDRESS");
  22. free.push("PORT");
  23. let mut matches = utils::parse_options(&opts, free);
  24. let device = utils::parse_tuntap_options(&mut matches);
  25. let fd = device.as_raw_fd();
  26. let mut device =
  27. utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
  28. let address = IpAddress::from_str(&matches.free[0]).expect("invalid address format");
  29. let port = u16::from_str(&matches.free[1]).expect("invalid port format");
  30. let neighbor_cache = NeighborCache::new(BTreeMap::new());
  31. let tcp_rx_buffer = tcp::SocketBuffer::new(vec![0; 1500]);
  32. let tcp_tx_buffer = tcp::SocketBuffer::new(vec![0; 1500]);
  33. let tcp_socket = tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer);
  34. let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]);
  35. let mut ip_addrs = heapless::Vec::<IpCidr, 5>::new();
  36. ip_addrs
  37. .push(IpCidr::new(IpAddress::v4(192, 168, 69, 2), 24))
  38. .unwrap();
  39. let default_v4_gw = Ipv4Address::new(192, 168, 69, 100);
  40. let mut routes_storage = [None; 1];
  41. let mut routes = Routes::new(&mut routes_storage[..]);
  42. routes.add_default_ipv4_route(default_v4_gw).unwrap();
  43. let medium = device.capabilities().medium;
  44. let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs).routes(routes);
  45. #[cfg(feature = "proto-ipv4-fragmentation")]
  46. let mut ipv4_out_packet_cache = [0u8; 1280];
  47. #[cfg(feature = "proto-ipv4-fragmentation")]
  48. {
  49. let ipv4_frag_cache = ReassemblyBuffer::new(vec![], BTreeMap::new());
  50. builder = builder
  51. .ipv4_reassembly_buffer(ipv4_frag_cache)
  52. .ipv4_fragmentation_buffer(&mut ipv4_out_packet_cache[..]);
  53. }
  54. #[cfg(feature = "proto-sixlowpan-fragmentation")]
  55. let mut sixlowpan_out_packet_cache = [0u8; 1280];
  56. #[cfg(feature = "proto-sixlowpan-fragmentation")]
  57. {
  58. let sixlowpan_frag_cache = ReassemblyBuffer::new(vec![], BTreeMap::new());
  59. builder = builder
  60. .sixlowpan_reassembly_buffer(sixlowpan_frag_cache)
  61. .sixlowpan_fragmentation_buffer(&mut sixlowpan_out_packet_cache[..]);
  62. }
  63. if medium == Medium::Ethernet {
  64. builder = builder
  65. .hardware_addr(ethernet_addr.into())
  66. .neighbor_cache(neighbor_cache);
  67. }
  68. let mut iface = builder.finalize(&mut device);
  69. let mut sockets = SocketSet::new(vec![]);
  70. let tcp_handle = sockets.add(tcp_socket);
  71. let socket = sockets.get_mut::<tcp::Socket>(tcp_handle);
  72. socket
  73. .connect(iface.context(), (address, port), 49500)
  74. .unwrap();
  75. let mut tcp_active = false;
  76. loop {
  77. let timestamp = Instant::now();
  78. match iface.poll(timestamp, &mut device, &mut sockets) {
  79. Ok(_) => {}
  80. Err(e) => {
  81. debug!("poll error: {}", e);
  82. }
  83. }
  84. let socket = sockets.get_mut::<tcp::Socket>(tcp_handle);
  85. if socket.is_active() && !tcp_active {
  86. debug!("connected");
  87. } else if !socket.is_active() && tcp_active {
  88. debug!("disconnected");
  89. break;
  90. }
  91. tcp_active = socket.is_active();
  92. if socket.may_recv() {
  93. let data = socket
  94. .recv(|data| {
  95. let mut data = data.to_owned();
  96. if !data.is_empty() {
  97. debug!(
  98. "recv data: {:?}",
  99. str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
  100. );
  101. data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
  102. data.reverse();
  103. data.extend(b"\n");
  104. }
  105. (data.len(), data)
  106. })
  107. .unwrap();
  108. if socket.can_send() && !data.is_empty() {
  109. debug!(
  110. "send data: {:?}",
  111. str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
  112. );
  113. socket.send_slice(&data[..]).unwrap();
  114. }
  115. } else if socket.may_send() {
  116. debug!("close");
  117. socket.close();
  118. }
  119. phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
  120. }
  121. }