SYMBOL INDEX (166 symbols across 19 files)

FILE: build.rs
  function main (line 1) | fn main() {

FILE: src/common.rs
  function get_expired_time (line 15) | pub(crate) fn get_expired_time() -> Instant {
  function test_if_valid_server (line 22) | pub(crate) fn test_if_valid_server(host: &str, name: &str) -> ResultType...
  function get_servers (line 39) | pub(crate) fn get_servers(s: &str, tag: &str) -> Vec<String> {
  function arg_name (line 51) | fn arg_name(name: &str) -> String {
  function init_args (line 56) | pub fn init_args(args: &str, name: &str, about: &str) {
  function get_arg (line 88) | pub fn get_arg(name: &str) -> String {
  function get_arg_or (line 94) | pub fn get_arg_or(name: &str, default: String) -> String {
  function now (line 100) | pub fn now() -> u64 {
  function gen_sk (line 107) | pub fn gen_sk(wait: u64) -> (String, Option<sign::SecretKey>) {
  function listen_signal (line 158) | pub async fn listen_signal() -> Result<()> {
  function listen_signal (line 187) | pub async fn listen_signal() -> Result<()> {
  function check_software_update (line 193) | pub fn check_software_update() {
  function check_software_update_ (line 202) | async fn check_software_update_() -> hbb_common::ResultType<()> {

FILE: src/database.rs
  type Pool (line 10) | type Pool = deadpool::managed::Pool<DbPool>;
  type DbPool (line 12) | pub struct DbPool {
    type Type (line 18) | type Type = SqliteConnection;
    type Error (line 19) | type Error = SqlxError;
    method create (line 20) | async fn create(&self) -> Result<SqliteConnection, SqlxError> {
    method recycle (line 25) | async fn recycle(
  type Database (line 34) | pub struct Database {
    method new (line 50) | pub async fn new(url: &str) -> ResultType<Database> {
    method create_tables (line 71) | async fn create_tables(&self) -> ResultType<()> {
    method get_peer (line 96) | pub async fn get_peer(&self, id: &str) -> ResultType<Option<Peer>> {
    method insert_peer (line 106) | pub async fn insert_peer(
    method update_pk (line 127) | pub async fn update_pk(
  type Peer (line 39) | pub struct Peer {
  function test_insert (line 151) | fn test_insert() {
  function insert (line 156) | async fn insert() {

FILE: src/hbbr.rs
  function main (line 9) | fn main() -> ResultType<()> {

FILE: src/main.rs
  constant RMEM (line 8) | const RMEM: usize = 0;
  function main (line 10) | fn main() -> ResultType<()> {

FILE: src/peer.rs
  type IpBlockMap (line 13) | type IpBlockMap = HashMap<String, ((u32, Instant), (HashSet<String>, Ins...
  type UserStatusMap (line 14) | type UserStatusMap = HashMap<Vec<u8>, Arc<(Option<Vec<u8>>, bool)>>;
  type IpChangesMap (line 15) | type IpChangesMap = HashMap<String, (Instant, HashMap<String, i32>)>;
  constant IP_CHANGE_DUR (line 21) | pub const IP_CHANGE_DUR: u64 = 180;
  constant IP_CHANGE_DUR_X2 (line 22) | pub const IP_CHANGE_DUR_X2: u64 = IP_CHANGE_DUR * 2;
  constant DAY_SECONDS (line 23) | pub const DAY_SECONDS: u64 = 3600 * 24;
  constant IP_BLOCK_DUR (line 24) | pub const IP_BLOCK_DUR: u64 = 60;
  type PeerInfo (line 27) | pub(crate) struct PeerInfo {
  type Peer (line 32) | pub(crate) struct Peer {
  method default (line 45) | fn default() -> Self {
  type LockPeer (line 60) | pub(crate) type LockPeer = Arc<RwLock<Peer>>;
  type PeerMap (line 63) | pub(crate) struct PeerMap {
    method new (line 69) | pub(crate) async fn new() -> ResultType<Self> {
    method update_pk (line 93) | pub(crate) async fn update_pk(
    method get (line 136) | pub(crate) async fn get(&self, id: &str) -> Option<LockPeer> {
    method get_or (line 158) | pub(crate) async fn get_or(&self, id: &str) -> LockPeer {
    method get_in_memory (line 172) | pub(crate) async fn get_in_memory(&self, id: &str) -> Option<LockPeer> {
    method is_in_memory (line 177) | pub(crate) async fn is_in_memory(&self, id: &str) -> bool {

FILE: src/relay_server.rs
  type Usage (line 31) | type Usage = (usize, usize, usize, usize);
  constant BLACKLIST_FILE (line 45) | const BLACKLIST_FILE: &str = "blacklist.txt";
  constant BLOCKLIST_FILE (line 46) | const BLOCKLIST_FILE: &str = "blocklist.txt";
  function start (line 49) | pub async fn start(port: &str, key: &str) -> ResultType<()> {
  function check_params (line 98) | fn check_params() {
  function check_cmd (line 152) | async fn check_cmd(cmd: &str, limiter: Limiter) -> String {
  function io_loop (line 326) | async fn io_loop(listener: TcpListener, listener2: TcpListener, key: &st...
  function handle_connection (line 359) | async fn handle_connection(
  function make_pair (line 393) | async fn make_pair(
  function make_pair_ (line 425) | async fn make_pair_(stream: impl StreamTrait, addr: SocketAddr, key: &st...
  function relay (line 464) | async fn relay(
  function get_server_sk (line 568) | fn get_server_sk(key: &str) -> String {
  type StreamTrait (line 590) | trait StreamTrait: Send + Sync + 'static {
    method recv (line 591) | async fn recv(&mut self) -> Option<Result<BytesMut, Error>>;
    method send_raw (line 592) | async fn send_raw(&mut self, bytes: Bytes) -> ResultType<()>;
    method is_ws (line 593) | fn is_ws(&self) -> bool;
    method set_raw (line 594) | fn set_raw(&mut self);
    method recv (line 599) | async fn recv(&mut self) -> Option<Result<BytesMut, Error>> {
    method send_raw (line 603) | async fn send_raw(&mut self, bytes: Bytes) -> ResultType<()> {
    method is_ws (line 607) | fn is_ws(&self) -> bool {
    method set_raw (line 611) | fn set_raw(&mut self) {
    method recv (line 618) | async fn recv(&mut self) -> Option<Result<BytesMut, Error>> {
    method send_raw (line 636) | async fn send_raw(&mut self, bytes: Bytes) -> ResultType<()> {
    method is_ws (line 642) | fn is_ws(&self) -> bool {
    method set_raw (line 646) | fn set_raw(&mut self) {}

FILE: src/rendezvous_server.rs
  type Data (line 44) | enum Data {
  constant REG_TIMEOUT (line 50) | const REG_TIMEOUT: i32 = 30_000;
  type TcpStreamSink (line 51) | type TcpStreamSink = SplitSink<Framed<TcpStream, BytesCodec>, Bytes>;
  type WsSink (line 52) | type WsSink = SplitSink<tokio_tungstenite::WebSocketStream<TcpStream>, t...
  type Sink (line 53) | enum Sink {
  type Sender (line 57) | type Sender = mpsc::UnboundedSender<Data>;
  type Receiver (line 58) | type Receiver = mpsc::UnboundedReceiver<Data>;
  type RelayServers (line 60) | type RelayServers = Vec<String>;
  constant CHECK_RELAY_TIMEOUT (line 61) | const CHECK_RELAY_TIMEOUT: u64 = 3_000;
  type PunchReqEntry (line 68) | struct PunchReqEntry { tm: Instant, from_ip: String, to_ip: String, to_i...
  constant PUNCH_REQ_DEDUPE_SEC (line 70) | const PUNCH_REQ_DEDUPE_SEC: u64 = 60;
  type Inner (line 73) | struct Inner {
  type RendezvousServer (line 83) | pub struct RendezvousServer {
    method start (line 102) | pub async fn start(port: i32, serial: i32, key: &str, rmem: usize) -> ...
    method io_loop (line 231) | async fn io_loop(
    method handle_udp (line 317) | async fn handle_udp(
    method handle_tcp (line 483) | async fn handle_tcp(
    method update_addr (line 572) | async fn update_addr(
    method handle_hole_sent (line 616) | async fn handle_hole_sent<'a>(
    method handle_local_addr (line 650) | async fn handle_local_addr<'a>(
    method handle_punch_hole_request (line 682) | async fn handle_punch_hole_request(
    method handle_online_request (line 793) | async fn handle_online_request(
    method send_to_tcp (line 822) | async fn send_to_tcp(&mut self, msg: RendezvousMessage, addr: SocketAd...
    method send_to_sink (line 830) | async fn send_to_sink(sink: &mut Option<Sink>, msg: RendezvousMessage) {
    method send_to_tcp_sync (line 846) | async fn send_to_tcp_sync(
    method handle_tcp_punch_hole_request (line 857) | async fn handle_tcp_punch_hole_request(
    method handle_udp_punch_hole_request (line 874) | async fn handle_udp_punch_hole_request(
    method check_ip_blocker (line 891) | async fn check_ip_blocker(&self, ip: &str, id: &str) -> bool {
    method parse_relay_servers (line 921) | fn parse_relay_servers(&mut self, relay_servers: &str) {
    method get_relay_server (line 927) | fn get_relay_server(&self, _pa: IpAddr, _pb: IpAddr) -> String {
    method check_cmd (line 937) | async fn check_cmd(&self, cmd: &str) -> String {
    method handle_listener2 (line 1102) | async fn handle_listener2(&self, stream: TcpStream, addr: SocketAddr) {
    method handle_listener (line 1142) | async fn handle_listener(&self, stream: TcpStream, addr: SocketAddr, k...
    method handle_listener_inner (line 1152) | async fn handle_listener_inner(
    method get_pk (line 1204) | async fn get_pk(&mut self, version: &str, id: String) -> Bytes {
    method get_server_sk (line 1229) | fn get_server_sk(key: &str) -> (String, Option<sign::SecretKey>) {
    method is_lan (line 1257) | fn is_lan(&self, addr: SocketAddr) -> bool {
  type LoopFailure (line 93) | enum LoopFailure {
  function check_relay_servers (line 1275) | async fn check_relay_servers(rs0: Arc<RelayServers>, tx: Sender) {
  function test_hbbs (line 1303) | async fn test_hbbs(addr: SocketAddr) -> ResultType<()> {
  function send_rk_res (line 1341) | async fn send_rk_res(
  function create_udp_listener (line 1354) | async fn create_udp_listener(port: i32, rmem: usize) -> ResultType<Frame...
  function create_tcp_listener (line 1367) | async fn create_tcp_listener(port: i32) -> ResultType<TcpListener> {

FILE: src/utils.rs
  function print_help (line 10) | fn print_help() {
  function error_then_help (line 22) | fn error_then_help(msg: &str) {
  function gen_keypair (line 27) | fn gen_keypair() {
  function validate_keypair (line 35) | fn validate_keypair(pk: &str, sk: &str) -> ResultType<()> {
  function doctor_tcp (line 75) | fn doctor_tcp(address: std::net::IpAddr, port: &str, desc: &str) {
  function doctor_ip (line 91) | fn doctor_ip(server_ip_address: std::net::IpAddr, server_address: Option...
  function doctor (line 122) | fn doctor(server_address_unclean: &str) {
  function main (line 142) | fn main() {

FILE: ui/build.rs
  function main (line 1) | fn main() {

FILE: ui/html/main.js
  class View (line 8) | class View {
    method constructor (line 9) | constructor() {
    method init (line 21) | async init() {
    method update (line 40) | async update() {
    method editorSave (line 64) | async editorSave(editor, e) {
    method editorScroll (line 80) | editorScroll(e) {
    method formChange (line 89) | formChange(e) {
    method appAction (line 96) | appAction(e) {
    method render (line 113) | render() {
    method renderForm (line 126) | renderForm() {
    method renderEditor (line 140) | renderEditor() {
    method renderScrollbar (line 153) | renderScrollbar() {

FILE: ui/src/adapter/service/windows.rs
  type WindowsDesktopService (line 11) | pub struct WindowsDesktopService {
  method start (line 17) | fn start(&mut self) {
  method stop (line 37) | fn stop(&mut self) {
  method restart (line 53) | fn restart(&mut self) {
  method pause (line 58) | fn pause(&mut self) {
  method check (line 72) | fn check(&mut self) -> DesktopServiceState {
  function call (line 82) | fn call(cmd: String) {
  function exec (line 95) | fn exec<I, S>(program: S, args: I) -> String
  function nssm (line 106) | fn nssm<I>(args: I) -> String
  function service_status (line 119) | fn service_status(name: &str) -> String {

FILE: ui/src/adapter/view/desktop.rs
  function run (line 18) | pub async fn run(sender: Sender<Event>, receiver: Receiver<Event>) {
  function root (line 219) | fn root() -> String {

FILE: ui/src/lib.rs
  function path (line 10) | pub fn path() -> PathBuf {

FILE: ui/src/main.rs
  function main (line 17) | async fn main() {

FILE: ui/src/usecase/presenter.rs
  function create (line 8) | pub async fn create(sender: Sender<Event>, receiver: Receiver<Event>) {

FILE: ui/src/usecase/service.rs
  function create (line 3) | pub fn create() -> Option<Box<dyn IDesktopService + Send>> {
  type DesktopServiceState (line 11) | pub enum DesktopServiceState {
  type IDesktopService (line 18) | pub trait IDesktopService {
    method start (line 19) | fn start(&mut self);
    method stop (line 20) | fn stop(&mut self);
    method restart (line 21) | fn restart(&mut self);
    method pause (line 22) | fn pause(&mut self);
    method check (line 23) | fn check(&mut self) -> DesktopServiceState;

FILE: ui/src/usecase/view.rs
  function create (line 5) | pub async fn create(sender: Sender<Event>, receiver: Receiver<Event>) {
  type Event (line 10) | pub enum Event {

FILE: ui/src/usecase/watcher.rs
  function create (line 9) | pub async fn create(sender: Sender<Event>) {
  function watch (line 27) | fn watch<P: AsRef<Path>>(path: P, sender: Sender<Event>) -> Result<()> {