client.rs 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139
  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, 4>::new();
  36. ip_addrs.push(IpCidr::new(IpAddress::v4(192, 168, 69, 2), 24)).unwrap();
  37. let default_v4_gw = Ipv4Address::new(192, 168, 69, 100);
  38. let mut routes_storage = [None; 1];
  39. let mut routes = Routes::new(&mut routes_storage[..]);
  40. routes.add_default_ipv4_route(default_v4_gw).unwrap();
  41. let medium = device.capabilities().medium;
  42. let mut builder = InterfaceBuilder::new().ip_addrs(ip_addrs).routes(routes);
  43. #[cfg(feature = "proto-ipv4-fragmentation")]
  44. let mut ipv4_out_packet_cache = [0u8; 1280];
  45. #[cfg(feature = "proto-ipv4-fragmentation")]
  46. {
  47. let ipv4_frag_cache = ReassemblyBuffer::new(vec![], BTreeMap::new());
  48. builder = builder
  49. .ipv4_reassembly_buffer(ipv4_frag_cache)
  50. .ipv4_fragmentation_buffer(&mut ipv4_out_packet_cache[..]);
  51. }
  52. #[cfg(feature = "proto-sixlowpan-fragmentation")]
  53. let mut sixlowpan_out_packet_cache = [0u8; 1280];
  54. #[cfg(feature = "proto-sixlowpan-fragmentation")]
  55. {
  56. let sixlowpan_frag_cache = ReassemblyBuffer::new(vec![], BTreeMap::new());
  57. builder = builder
  58. .sixlowpan_reassembly_buffer(sixlowpan_frag_cache)
  59. .sixlowpan_fragmentation_buffer(&mut sixlowpan_out_packet_cache[..]);
  60. }
  61. if medium == Medium::Ethernet {
  62. builder = builder
  63. .hardware_addr(ethernet_addr.into())
  64. .neighbor_cache(neighbor_cache);
  65. }
  66. let mut iface = builder.finalize(&mut device);
  67. let mut sockets = SocketSet::new(vec![]);
  68. let tcp_handle = sockets.add(tcp_socket);
  69. let socket = sockets.get_mut::<tcp::Socket>(tcp_handle);
  70. socket
  71. .connect(iface.context(), (address, port), 49500)
  72. .unwrap();
  73. let mut tcp_active = false;
  74. loop {
  75. let timestamp = Instant::now();
  76. match iface.poll(timestamp, &mut device, &mut sockets) {
  77. Ok(_) => {}
  78. Err(e) => {
  79. debug!("poll error: {}", e);
  80. }
  81. }
  82. let socket = sockets.get_mut::<tcp::Socket>(tcp_handle);
  83. if socket.is_active() && !tcp_active {
  84. debug!("connected");
  85. } else if !socket.is_active() && tcp_active {
  86. debug!("disconnected");
  87. break;
  88. }
  89. tcp_active = socket.is_active();
  90. if socket.may_recv() {
  91. let data = socket
  92. .recv(|data| {
  93. let mut data = data.to_owned();
  94. if !data.is_empty() {
  95. debug!(
  96. "recv data: {:?}",
  97. str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
  98. );
  99. data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
  100. data.reverse();
  101. data.extend(b"\n");
  102. }
  103. (data.len(), data)
  104. })
  105. .unwrap();
  106. if socket.can_send() && !data.is_empty() {
  107. debug!(
  108. "send data: {:?}",
  109. str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
  110. );
  111. socket.send_slice(&data[..]).unwrap();
  112. }
  113. } else if socket.may_send() {
  114. debug!("close");
  115. socket.close();
  116. }
  117. phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
  118. }
  119. }