client.rs 4.8 KB

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