diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 9e34e14..b0dddb3 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -16,12 +16,12 @@ jobs: - name: Check Code Format run: cargo fmt --all -- --check - name: Build Minimal - run: cargo build + run: cargo build --no-default-features - name: Build Client - run: cargo build --features "client" + run: cargo build --no-default-features --features "client" - name: Build Server - run: cargo build --features "server" + run: cargo build --no-default-features --features "server" - name: Build Hybrid - run: cargo build --features "server,client" + run: cargo build --no-default-features --features "server,client" - name: Run benches run: cargo bench diff --git a/Cargo.toml b/Cargo.toml index 831aa42..1dad11d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -29,6 +29,8 @@ chrono = "0.4" tokio = { version = "*", features = [ "full" ] } tokio-io = "*" tokio-rustls = { version = "*" } +tokio-util = { version = "*" } +#rustls-pemfile = { version = "*" } futures = "*" bytes = "*" postgres = "0.17.3" diff --git a/certs/certificate.crt b/certs/certificate.crt new file mode 100644 index 0000000..10cc3a6 --- /dev/null +++ b/certs/certificate.crt @@ -0,0 +1,31 @@ +-----BEGIN CERTIFICATE----- +MIIFazCCA1OgAwIBAgIUE/QczssNBXwqW/RVRiG4BjGSaRUwDQYJKoZIhvcNAQEL +BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM +GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMTA1MjMxNTQ0MTBaFw0yMjA1 +MjMxNTQ0MTBaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw +HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQCqRBit5zb9lhOOR4GK9pAu9l+0Z1Br7G693S+UU/sZ +TmQVlpq89z3qV3teKveNmak0ambJe9ULkGVb00vubJa5Pzf7n6bbxtRrMnawVTPV +nXUQh6mPdiz6z69pqIH/BekNdQ8RG2ZNeYvtfhcyOI8KCwwP4IzcnwEJl8O9sYD5 +sskP4wVL7rNQNOmiiLBO5NUDHGY3sTkgmU3UA+SXJrxm22J9g8Uw1eSH8dd/ilZ2 +lRuirfQ7AZQqvs0nJ970oz52CM49v4wGLotqOcsn3kS8mKynT9/KZGzNZfdknyiQ +ZkCCQmPc85uU7ZNctimPCjiwqd5BINL2tekpKMlafolR+AdegON9G19y2YE+nkYf +bIAjIlGxEpkIuHNvd/FixsgJCSPMRPwBMFbBlombKLZ38Jmbi1ktO264Ah27nOKt +7Q4lCWscD0ED/Q1Lpn2l3S9zvsMDukJoV65sjJy2dj1rrTg4jqOd+3ejgp7cLWS5 +RbmGOOOzQsNOR6BfqXeQfgwKd8TKYtuUEF02sUXif6yebWhWwaSCI4Fia7B90wc7 +OR3KZmC0ZEOlGvyUPHq6iDiDWmxTRl/D7CkRHCkWngaKiTgBT+3v4rmdg7ZoPyQq +ECjFRgLM/1bWdyoVZqtB4AiFviBja7nb7MC9v/9eG2GSPXTpNUIL5uXUruhIamIZ +MQIDAQABo1MwUTAdBgNVHQ4EFgQUCgavSrC/1bXWujQJNGiVGpPS2ZswHwYDVR0j +BBgwFoAUCgavSrC/1bXWujQJNGiVGpPS2ZswDwYDVR0TAQH/BAUwAwEB/zANBgkq +hkiG9w0BAQsFAAOCAgEASj0HFJ9bw8vfqN8vVsKxQOkeG9WrYLvJhhUQqNjojSt/ +016+3NlPbh6Xy/AeCcoEAdA9umi9pcJChsVdASpZSGZBYcVilSR1uHjhgmQgSX7t +2JFHkRUOeMOSyDuY3q7N1+WJaSAJdyRCfjC1Sug+vfDKvo3lplV4r3t3JvdeBjcs +3qd9ybH1vEGQf9qAa3qSrH2YV92wFYazva2vv52AEzeIwErPR8yvB8poqFK8xgwV +MTh/N9Rluzkp2SfhtoatOcc+MJ1Txuh/PXTVFQJySvh7zduUOdE3zFGrqKmJjDYx +xON1JSgYeIoBjpwzMl+CXAAI6gMlm9AzRTSkpgM7qf07fr1Wd1uDm/HmFJk8QSvv +DPFfLJcSajsyEE+AhNs6EpQo+Y2CPadAYSt7VFmJfYlOmKmib3+gbH/f28rzXP7n +C1TwqQWX3esWcLcMrbU5lyiorDMAs5d9Q3CiMZUSeCz00v64lSAnQgP4SVmZDPzI +vbJyFwn+SyR7wjn/976m/GZsjD0FLd2DI+jFWABml8nBqiGy/JO64scmAzxNqYe8 +/6an4yzclrlvdM1F3PjYcjwsK4/suxFKn/2O9aI2JwFeLJB03L66L4yXX2ugaeWk +ZuOlf8Jex9dh/eeqaSGg7hjLS6yVi7a5oY+tUGa3rg9n02gJB6OXKg8hOtMQtPE= +-----END CERTIFICATE----- diff --git a/certs/private.key b/certs/private.key new file mode 100644 index 0000000..f111fc9 --- /dev/null +++ b/certs/private.key @@ -0,0 +1,52 @@ +-----BEGIN PRIVATE KEY----- +MIIJQgIBADANBgkqhkiG9w0BAQEFAASCCSwwggkoAgEAAoICAQCqRBit5zb9lhOO +R4GK9pAu9l+0Z1Br7G693S+UU/sZTmQVlpq89z3qV3teKveNmak0ambJe9ULkGVb +00vubJa5Pzf7n6bbxtRrMnawVTPVnXUQh6mPdiz6z69pqIH/BekNdQ8RG2ZNeYvt +fhcyOI8KCwwP4IzcnwEJl8O9sYD5sskP4wVL7rNQNOmiiLBO5NUDHGY3sTkgmU3U +A+SXJrxm22J9g8Uw1eSH8dd/ilZ2lRuirfQ7AZQqvs0nJ970oz52CM49v4wGLotq +Ocsn3kS8mKynT9/KZGzNZfdknyiQZkCCQmPc85uU7ZNctimPCjiwqd5BINL2tekp +KMlafolR+AdegON9G19y2YE+nkYfbIAjIlGxEpkIuHNvd/FixsgJCSPMRPwBMFbB +lombKLZ38Jmbi1ktO264Ah27nOKt7Q4lCWscD0ED/Q1Lpn2l3S9zvsMDukJoV65s +jJy2dj1rrTg4jqOd+3ejgp7cLWS5RbmGOOOzQsNOR6BfqXeQfgwKd8TKYtuUEF02 +sUXif6yebWhWwaSCI4Fia7B90wc7OR3KZmC0ZEOlGvyUPHq6iDiDWmxTRl/D7CkR +HCkWngaKiTgBT+3v4rmdg7ZoPyQqECjFRgLM/1bWdyoVZqtB4AiFviBja7nb7MC9 +v/9eG2GSPXTpNUIL5uXUruhIamIZMQIDAQABAoICAAaEDJ27F3Ok5qKvQdnbjbD+ +ZLM2sPEwXxyM9mEqxZU2VsYsuUc5/viU2HfGFSsqEjubRsu3HXQP1pEpCOLa7Pmx +3aaXeX83oLFpgPlGiXFHUU+MoYSH9Tiz8faNKExmIYEOVcFF1yhn2l8AUErvtymf +Oprw8PMQcq23TRpZTKJBoUgmW/GH9PzAyaAaswSR5UT1NUQ0WAdTVpMigwD1zofx +JVfATy+LP++j5adP1/c5xZD4LzyC1vS70IYLFJEwHhfORnY+elFSPquWApxH+UFu +Zk0Q1XOdXDyQBmOnY5oDD7zsZX3zJKUSYm1N21FKBtlb5tF/PBOM6ptUoEACT6bv +ZdA1gIexXlvO/tguEgd2W0OCgqsEERInRFzm3drZhULOEMXxmPKYjHp854BOuwNJ +1hTCQksITOBEKwMfU7ES8cfCbft+PDH8t4w+AQJh6vPTqfukI2QCA34JZnjVQiLc +zj0gVC6SVdFtkMHEBp5fyeIV/epJmiI37rh/SyYnTPiBLLboSjtLi4XYGkr/8Ziw +4ccCh3p5D2dalla3tfI4pvT4quZ3CQKo7uir+YR9CrzURTYtOFzxSTx2hnLBGOPg +HrAcc8enuFK2vkRmD8+s650Wj960aMIMM98twkq6DL25t1VWpdjD87QEEz9/P4rX +OPpLk0tiWGjFnC5hHYOxAoIBAQDYFilCb5sz98QORQscxjK6/TVNKheZfLiGzwsG +8iyDs5CZ7FgqFaMw6xQmhIWhgKCkV0Qby13c1uJeml7oUU8R/Hsx8Hr4akWqUJID +dj7UY3R2dsGQTofbtl52SWnNQquKdlR0Qnz8ETqJLMDnUwP2bUvOB3YBbV9q97H3 +vFL1yk3zLROfN6SSqOoTU8NDDHhyRjHjnRmouHSjLYinj11dp/wwiE1A3RgHJ2YP +gNtBYLreHVJaCEPuVwAh6vVTmHXi43iOjq+TXDCDEcaGQJKkFejqf2eNG9AkUOYt +53qmqJzsF0wJKpoXu6xaswmELjFZBrtVYp9J41MmKYLsD+0vAoIBAQDJt0U8vnpp +cPQQyFR792XqzXTL8y6hHU/ASbvlFESdtbaQVNmHNfb0fb2gz+Ha+tc2Ek5rKNRp +oFnRuVRM+3xkX18aQuezp8RavxO2F0lWpQf/b9nVIF2v341iN066pC4TITwIR+1L +tg0r2eGf2sB/CrW8HFAWA3nhDeQzMlB41L3un98VLswySmjT05d0gDyXqoZrC2OG +bw/gbZfepCxkhsnB5zCjP/+cCulJvc5Gg3vT4iXUZstbgXQ3mQyDoJwZnZhbt9cF +d07iVEkWxmzijSTPx3O1Ptta0X1yl6II14/4TpkFJMCgtdy/myy7OoO5K3jxrObv +GQ1faQfptoefAoIBAH8om2MTFjwAo4jaLG3kXFoZQ1KDYJvb/yKlmBGgVX2zH3bU +1BT/4qaYz6TS+2hMrzvGdrf8duHMOi39nbgMkQE+mKiMoXCp6REOlL4gyVxmolRM +Eh//dodezDvDe9VkVFoIxC4eKjqTUOUERwhZm81aB+/YCCNS34Gs/TeRxSgKwtBF +SHS7Y8dCS2zQL+m23vIwSI9vFXhqA4k69F3WSdUhU5CjxQJUmR0snCynYV8Zsx2e +F6YPkxogbF2JTJDC+SxpO7p4UO3gpFOdFDxQp3qTwhqsmp05LsUQLkP5If4M3zs3 +gnEqdr9cm1JMZV85Z6TCB195x87NTVL5vqd3v9UCggEBAL+W8g1DAfO6VCbIj+36 +ynOdV40LWkOvGnuRzQRFHvMIj/FAliflqr0H3R+rs2KRE+4IrzD64927bvRS6e4A +g2K2bxb7ayVpeIeUqz0tmvvP3evRKf5TMokEdT5PN9jwbc6/p0xaPNnHfXUkCjgR +xvojiv+ziKGQBagr0I6MAIDz176ZXIK7Izm1ESH4/AascmC/l9J+S7Z5MIRCs5fF +KWEF4QXp93lnJPnqJzBiNlUlN2zFhJbcV9R+/Yp9NLSkzP9Lf1XGJFXNv0AbPByE +tRDtbIRpdc41eJUnGtbHjSCG1fjLdm27PbanZZcb5P2kE07CKqqpReLdUaVIljp2 +oxMCggEAYZd8RoqzWtmvizcWQ+KwY5exPwlIp9dlyucupGLy5WaQi0MRv5m87rtp +ymRhcXDeKAoZ40P9CeFwukBWpxqngFVpJcJ76QV04jUzcQYt7PuuqkaB+uaPlNlI +iB58y23LN1SIRFXOsCIj08dcIpBebjtiFySAYtMJWnEejZOQjXwDps9ow3NI8PeS +KCePZGixdSFTvECFsiy/zTniTzbmx3SosU/Z0cNRggEr+z/1bHNF8S22E6CY3ZS4 +xhRPRjoJCdOHRQWR6er1sgSIoOe4zkiPQeRsAjxQIf0iayhtfSANJsp2XHYGT6Qh +DcoDHp2AECmWwvf8XPk4wppAdeivHg== +-----END PRIVATE KEY----- diff --git a/certs/test_tls.crt b/certs/test_tls.crt deleted file mode 100644 index 1167adc..0000000 --- a/certs/test_tls.crt +++ /dev/null @@ -1,35 +0,0 @@ ------BEGIN CERTIFICATE----- -MIIGBTCCA+2gAwIBAgIUO6aWQ4Gkyu+ZQWSsY5V1xyy4HCowDQYJKoZIhvcNAQEL -BQAwgZExCzAJBgNVBAYTAkFVMRAwDgYDVQQIDAdBIHN0YXRlMQ0wCwYDVQQHDARj -aXR5MSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEDAOBgNVBAsM -B3NlY3Rpb24xDTALBgNVBAMMBG5hbWUxHTAbBgkqhkiG9w0BCQEWDnRlc3RAZW1h -aWwuY29tMB4XDTIwMDgwNTA4MzgzOVoXDTIxMDgwNTA4MzgzOVowgZExCzAJBgNV -BAYTAkFVMRAwDgYDVQQIDAdBIHN0YXRlMQ0wCwYDVQQHDARjaXR5MSEwHwYDVQQK -DBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEDAOBgNVBAsMB3NlY3Rpb24xDTAL -BgNVBAMMBG5hbWUxHTAbBgkqhkiG9w0BCQEWDnRlc3RAZW1haWwuY29tMIICIjAN -BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAmELJvn4lQCnexOCqb9tljI/d5qUU -tjx15vuNUA4TOzMc14qpLJ2rA6Tbd0oZyQPmx6nRxuEMxu8vLY4677zkOvXTxss2 -f2duhEJAGJ9dzkdsQ8P1FCpp3IOC2DyY/S88ZTd1UMv9VT8Vb45xxoYsWfztBNH/ -nZLyTCviaiI0q6ax+rogHxGml4GZS3pqubHIznlNj/+IzbedVyN1GbG3IrERSraj -NGbPV/T1y6mmR3DoyuaKbrTC/Hv2hP3xoA/GqGjoPA0eiU8G3/Kzg79DkH52AjcJ -nurSDFmBu/u1iWnrzlibvEMwyjiVJOtg5erykueyp2/8g0e0JO4T6O1r0KE8aHOE -ZM8Q75U4widjE7cOBNSEQhIhN+msq5XJhPX4bdN+DdvikSuIMDCyhyuHwMc7c8HS -pEU6gA9VLD3UiZP0U3TB6ZLXusJLsjc8skOXyIHBUos7NjTpSTbUj7xTc4Pt1ity -n1BUjy6c/1oDoYULcEe79fMYO5yn/RRDfHeMGkerbxmuXIV3t/U9Ur8W68JCzFau -Xru5b3885KQJSdcQsWj5/BUJqXWwYE7Ncp9nZhnIv76/XV0PLEFFaLpLipiqU5sL -kSiusUOgSK48abS/2k3QRXREr9miVD/aSElv5V9cI3xHlBGls3J36YfeQ3DuVzO1 -HmBLAYGeY4dH2McCAwEAAaNTMFEwHQYDVR0OBBYEFOYMEyr+SUNVms3K0TlcGAph -T+iSMB8GA1UdIwQYMBaAFOYMEyr+SUNVms3K0TlcGAphT+iSMA8GA1UdEwEB/wQF -MAMBAf8wDQYJKoZIhvcNAQELBQADggIBAHu+bJeTKpK1bkQcPFQfU/tgd4pYfgkX -Ylnx4Q7gvtlsduNLBh/Vnp6ZhDP7lQW5/en9tvBFbeQx8zC+Oi4LkSOLGDzWYeDj -R8jspnW5Tw0XNDB96B60R+ylh82vz+t0I0iW/tIFc6oEObL9UFL3OE0/BAq9MyDQ -ODZD7r4+dAMao7M7kIySkPY3HMRCJ93P9b5ssEdSwMhidv2rZGqwqiQvZMSTr951 -AjQLMa8Ra+w3r8DYsnUJ40Q0GrHApOpJqTSlRpkGeFCvQdMvAjXuXQOP7uxYCpIB -Y1h+enlHbtsHZBfyF4alxR9RLNwbbh1YDv+aM1sol777Aw7I07BHmZE9TgTGA/ag -3iNToh6fFzStL9SH8e73ge/5GJ2/q1zWwm/frr92AevbE0iUNlZ5I77msZJrgtDg -BmoI2dTYcQSfWL/M0uGrHMSdiiV6ZHxBoI2xkfWzgQ+vfPtR4iKf1RKJjPwokMO2 -fha5g96E/MPdCZz7tIQNs3EUuh8E8V1wN3Hm8Pwsz1Y2KhlpnQOR8BgZsyNKsSmF -2fwLuoN9h8DHisLzsf/S/U49S9oBqpARp+zbxExgD5lwxqc6I7ZH92V48oH364Ks -rtBtnLo1rRj3cdMs4x8acdgqXm0eSNeRAs1O87jNAJF0uNsuiJvYxz7e/fdjtGJi -fbo1osrgCluU ------END CERTIFICATE----- diff --git a/certs/test_tls.key b/certs/test_tls.key deleted file mode 100644 index faccdad..0000000 --- a/certs/test_tls.key +++ /dev/null @@ -1,52 +0,0 @@ ------BEGIN PRIVATE KEY----- -MIIJQwIBADANBgkqhkiG9w0BAQEFAASCCS0wggkpAgEAAoICAQCYQsm+fiVAKd7E -4Kpv22WMj93mpRS2PHXm+41QDhM7MxzXiqksnasDpNt3ShnJA+bHqdHG4QzG7y8t -jjrvvOQ69dPGyzZ/Z26EQkAYn13OR2xDw/UUKmncg4LYPJj9LzxlN3VQy/1VPxVv -jnHGhixZ/O0E0f+dkvJMK+JqIjSrprH6uiAfEaaXgZlLemq5scjOeU2P/4jNt51X -I3UZsbcisRFKtqM0Zs9X9PXLqaZHcOjK5oputML8e/aE/fGgD8aoaOg8DR6JTwbf -8rODv0OQfnYCNwme6tIMWYG7+7WJaevOWJu8QzDKOJUk62Dl6vKS57Knb/yDR7Qk -7hPo7WvQoTxoc4RkzxDvlTjCJ2MTtw4E1IRCEiE36ayrlcmE9fht034N2+KRK4gw -MLKHK4fAxztzwdKkRTqAD1UsPdSJk/RTdMHpkte6wkuyNzyyQ5fIgcFSizs2NOlJ -NtSPvFNzg+3WK3KfUFSPLpz/WgOhhQtwR7v18xg7nKf9FEN8d4waR6tvGa5chXe3 -9T1SvxbrwkLMVq5eu7lvfzzkpAlJ1xCxaPn8FQmpdbBgTs1yn2dmGci/vr9dXQ8s -QUVoukuKmKpTmwuRKK6xQ6BIrjxptL/aTdBFdESv2aJUP9pISW/lX1wjfEeUEaWz -cnfph95DcO5XM7UeYEsBgZ5jh0fYxwIDAQABAoICAEeOA5+JStpHkxB1AMQGmEeh -iMgOxpgJ++KsTzHTG4iTsbc9y9lS036n6Be8dDe6pKcqkJJlSwrmdwZytBHcdGmd -A4SGFbt0EUUImXS42G3LtP53xeJPOGbQSxpyB/fcTgbHNFPfOdPpDJrbl26TuZ4k -tgKw6e7Ukxfm+8WjA5uzgCrzc4sGUYMb/b2x7xwLh/I4oZHNpi3/X2sHF84WbZlZ -G2ZARJyowEJ2tVicBq/GSTCpfV8fhg7/9s9zRC1TnKmie5lVFQe0Yue1+FUu+oKa -W70YvmW3tzTkj4qXdS354D6d97pW3UP7qWOrVmNWsd8GEjiL8WCEvw0n8aVihmrQ -+gj6cJ1DlgzdN5sB81+b9ms/S/vR1OarOO18aDKkn/DSsDBifTdqwf2gCo11rbXV -spPJMzDz9KOBV5Z0aolMj3cxgj7XPY6yJGJNzoh20JGdHFS7saoTedy0wXyFIHqX -l5uz7oYgfvTlWqUKUaXFhQQIPTWCxZ+uPaoaHW78Fll4p2v0mh9GfHce/BTUAyvP -ltR3gx8qZGead5NFpWrSCdufa9Fw1noijGWHstpMN3v+qqAU1nxsC4Pjwv1rcXn2 -TVzuSp/OX2MZ9rNcBePVNfPPXJcvyu5GxCqKopcJoMbnBuYaTzwN913/erBClryq -og3UtyeiX0GIV4KcBe7BAoIBAQDFvXhv5CAUq+CrL0UjTTA2PSP/hSLnfcd7lCP0 -gxkpRUeclhVI6j4osjkWY2/IdC8jlPao74BsSzObu044PtrWHzXPIjqLF5XcP8kw -CyIvYiDvFf63ybvnFf9xRolRoPrYLMr5pXmXt5GbCZxt9ImPAL6jesNAyghcp5PC -PY623Pg2f9BkHAfWB1Pu6JeMsfsDmj9FC+gazPmTX713iybXiehiN8mqTunz+2dC -Fc05ENx4b43pbn5hx8rImNbzLcg9dDCJvcvg6tfNWJQby3UwzWyc1ID+goNHmO9A -owLLkG/80K5P+EBjMsDLclO400qb1Qnazq3GJPoUZnSATybhAoIBAQDFHw0aIUGC -fGT9mXl6j5zXJungtuowCySwwtYAKsIrrxsfADdj5xgngTi99iyWwj+uEfMv4vsX -t+dnO2lwMaaJbXN8GhUsAQcejxG67KeIS0ucsaVVMqysXbbJRMT8/vXZMaKTY+Jc -YhBVf14xYh75md8BlE+2ta4o+YBWilh/ss1ko9SrmLtmQR+2m/ufP2nTuVDYjS/9 -Q8k90Xw2K6DaoeSz8WBzjrYnzwWZldMjz5l62+Ca3qu+Awx2co8MQYfPBxB+RNng -nK34kDl5Z05gCoZRKw7S6v5ZpQqsK4eFI5qXROecQsXWEZC0oY+uOA3PCI7Y8Auq -aFv2bHL1YPynAoIBAQC/l0w5RZSb0sk1s/BOOvzKoMTfUBU4rJL6ttd7kwZvCXRQ -UM7Avk2Jyt0rRx9I3uHJnQy9NIl+5AJWEs7ACo6oRscxMd39ZNXL+HWrui3eMTrt -zKbnVmxcg+Dj1U85qztA922XI3DDwpYu3MoXc4dQ6ozMAydqABbIB4pP+qrrnQBW -ddLpHIuvIZx+cBhetxgaLnq9IMM8LHxpAaunR0lUL4fcmmcoP5vIzT8INe2JLEAh -5RxgH7IOdbGSWRxztFk+yfQ5kY8YFxMPIJMotyKOLYveDLwLXVNrrM+sFgWgTQtk -rqEmVMe2Fbfdp6FdBERW5rzMp9KRmMRBvd+FbquhAoIBAQCFO5+XcbLdh0abQgih -lj/kDCE4CWnwXxfFgWszYbMr44bpRTQrCh+BVA4OFz28CD8SYH+GdlxQg7ScScPS -WTy+1oOf9eEphOhS91B8j0gNDxdkKY4eL8oWFqFdGGYsugdhbfL8vB5bYsy3fQcl -SbS18BKS9rOKQvIcL8dWtttqNGgvBazQ7sJ7MrlEq9k+oZXdzPuf4o31GMQETHsw -Af0OyS3TkeonMOZdscePL30uTzrll4gQJUDfhR//Tx7woboxbAzxy4eYEU5lGtY+ -AF0w/OwcIIY8eSjBXpQAGsvWaWIrrB7/twIQ1n6AGFMM5kYvERG7/0NjQnYl8Nci -kxMxAoIBAEKVPdxnaIQjA2PVUCxkXqpNTE7l/uQR0apNrLzYj0MAePMQ1LgfIO87 -8/Zfvp708WZzb01/E8pVw8RLqKH1dgiYbZq7fgdLbnGilphqBbxYiBPGr/oRu201 -CTO7k96zU6/doQvNnrnT9IxGXNU5KNs8uEF1eUGq90Bcoo07Vyl15tphdGglFCBd -GToN27UCvR01vQ60McoFkZNz4EwKJQ19XPktIKxRtPE8R2mMbHs8+T9kCDmNHNVg -ZyMjP8OgqSeD0q3mseUOKIGR8pQdSG8L2F+oZ6jO+1lOABnyRXz+1Py/JT/IN2J/ -np5e3973f8T6CU4d+8/NHUaC/7nxpkY= ------END PRIVATE KEY----- diff --git a/src/libtrader/common/misc/gen_tls_client_config.rs b/src/libtrader/common/misc/gen_tls_client_config.rs index 8d726ba..58c1ec1 100644 --- a/src/libtrader/common/misc/gen_tls_client_config.rs +++ b/src/libtrader/common/misc/gen_tls_client_config.rs @@ -1,70 +1,70 @@ -use ct_logs; -use rustls; -use std::sync::Arc; -use webpki_roots; - -/// A "always accept" Certficate verifier. -/// -/// WARN: only to be used in development environments. -/// using this in production envs will be a HUGE security vuln. -#[cfg(feature = "tls_no_verify")] -mod danger { - use super::rustls; - use webpki; - - pub struct NoCertificateVerification {} - - impl rustls::ServerCertVerifier for NoCertificateVerification { - fn verify_server_cert( - &self, - _roots: &rustls::RootCertStore, - _presented_certs: &[rustls::Certificate], - _dns_name: webpki::DNSNameRef<'_>, - _ocsp: &[u8], - ) -> Result { - warn!("IF THIS IS NOT A DEV BUILD DO NOT PROCEED"); - Ok(rustls::ServerCertVerified::assertion()) - } - } -} - -/// Generates a TlsClient Config. -/// -/// Uses defualt settings for: -/// - TLS Protocol Version. -/// - TLs Protocol CypherSuite. -/// -/// Assumed Settings: -/// - Certificate Authentication. -/// - No persistent session storage. -/// -/// Returns; the client configuration in an Arc. -pub fn gen_tls_client_config() -> Arc { - let mut config = rustls::ClientConfig::new(); - config.key_log = Arc::new(rustls::KeyLogFile::new()); - - config - .root_store - .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS); - config.ct_logs = Some(&ct_logs::LOGS); - - let persist = Arc::new(rustls::NoClientSessionStorage {}); - config.set_persistence(persist); - - #[cfg(feature = "tls_no_verify")] - config - .dangerous() - .set_certificate_verifier(Arc::new(danger::NoCertificateVerification {})); - - Arc::new(config) -} - -#[cfg(test)] -mod test { - use super::*; - - #[test] - fn test_gen_tls_client_config() { - let _ = gen_tls_client_config(); - } -} +//use ct_logs; +//use rustls; +//use std::sync::Arc; +//use webpki_roots; +// +///// A "always accept" Certficate verifier. +///// +///// WARN: only to be used in development environments. +///// using this in production envs will be a HUGE security vuln. +//#[cfg(feature = "tls_no_verify")] +//mod danger { +// use super::rustls; +// use webpki; +// +// pub struct NoCertificateVerification {} +// +// impl rustls::ServerCertVerifier for NoCertificateVerification { +// fn verify_server_cert( +// &self, +// _roots: &rustls::RootCertStore, +// _presented_certs: &[rustls::Certificate], +// _dns_name: webpki::DNSNameRef<'_>, +// _ocsp: &[u8], +// ) -> Result { +// warn!("IF THIS IS NOT A DEV BUILD DO NOT PROCEED"); +// Ok(rustls::ServerCertVerified::assertion()) +// } +// } +//} +// +///// Generates a TlsClient Config. +///// +///// Uses defualt settings for: +///// - TLS Protocol Version. +///// - TLs Protocol CypherSuite. +///// +///// Assumed Settings: +///// - Certificate Authentication. +///// - No persistent session storage. +///// +///// Returns; the client configuration in an Arc. +//pub fn gen_tls_client_config() -> Arc { +// let mut config = rustls::ClientConfig::new(); +// config.key_log = Arc::new(rustls::KeyLogFile::new()); +// +// config +// .root_store +// .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS); +// config.ct_logs = Some(&ct_logs::LOGS); +// +// let persist = Arc::new(rustls::NoClientSessionStorage {}); +// config.set_persistence(persist); +// +// #[cfg(feature = "tls_no_verify")] +// config +// .dangerous() +// .set_certificate_verifier(Arc::new(danger::NoCertificateVerification {})); +// +// Arc::new(config) +//} +// +//#[cfg(test)] +//mod test { +// use super::*; +// +// #[test] +// fn test_gen_tls_client_config() { +// let _ = gen_tls_client_config(); +// } +//} diff --git a/src/libtrader/common/misc/gen_tls_server_config.rs b/src/libtrader/common/misc/gen_tls_server_config.rs index 2fa9687..fb6373b 100644 --- a/src/libtrader/common/misc/gen_tls_server_config.rs +++ b/src/libtrader/common/misc/gen_tls_server_config.rs @@ -1,19 +1,21 @@ -use rustls; -use rustls::NoClientAuth; -use std::fs; -use std::io::{BufReader, Read}; +use std::fs::File; +use std::io::{self, BufReader}; +use std::path::Path; use std::sync::Arc; +//use tokio_rustls::rustls::internal::pemfile::{certs, rsa_private_keys}; +use tokio_rustls::rustls::internal::pemfile::{certs, pkcs8_private_keys, rsa_private_keys}; +use tokio_rustls::rustls::{Certificate, NoClientAuth, PrivateKey, ServerConfig}; + /// Loads a TLS public certificate /// /// Arguments: /// filename - Path to .crt file. /// /// Returns: vector of rustls' Certificate -fn load_certs(filename: &str) -> Vec { - let certfile = fs::File::open(filename).expect("cannot open certificate file"); - let mut reader = BufReader::new(certfile); - rustls::internal::pemfile::certs(&mut reader).unwrap() +fn load_certs(path: &Path) -> io::Result> { + certs(&mut BufReader::new(File::open(path)?)) + .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid cert")) } /// Load a TLS private key. @@ -22,46 +24,30 @@ fn load_certs(filename: &str) -> Vec { /// filename - Path to .key file. /// /// Returns: rustls::PrivateKey -fn load_private_key(filename: &str) -> rustls::PrivateKey { +fn load_private_keys(path: &Path) -> io::Result> { let rsa_keys = { - let keyfile = fs::File::open(filename).expect("cannot open private key file"); + let keyfile = File::open(path).expect("cannot open private key file"); let mut reader = BufReader::new(keyfile); - rustls::internal::pemfile::rsa_private_keys(&mut reader) - .expect("file contains invalid rsa private key") + rsa_private_keys(&mut reader).expect("file contains invalid rsa private key") }; let pkcs8_keys = { - let keyfile = fs::File::open(filename).expect("cannot open private key file"); + let keyfile = File::open(path).expect("cannot open private key file"); let mut reader = BufReader::new(keyfile); - rustls::internal::pemfile::pkcs8_private_keys(&mut reader) + pkcs8_private_keys(&mut reader) .expect("file contains invalid pkcs8 private key (encrypted keys not supported)") }; // prefer to load pkcs8 keys if !pkcs8_keys.is_empty() { - pkcs8_keys[0].clone() + Ok(pkcs8_keys.clone()) } else { assert!(!rsa_keys.is_empty()); - rsa_keys[0].clone() + Ok(rsa_keys.clone()) } -} - -/// Loads OCSP stapling key. -/// -/// Argument: -/// filename - path to OCSP stapling key. -/// -/// Returns: u8 vec -fn load_ocsp(filename: &Option<&str>) -> Vec { - let mut ret = Vec::new(); - - if let &Some(ref name) = filename { - fs::File::open(name) - .expect("cannot open ocsp file") - .read_to_end(&mut ret) - .unwrap(); - } - ret + //rsa_private_keys(&mut BufReader::new(File::open(path)?)) + // .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid key")) + // TODO: use this kind of chekcing elsewhere too } /// Generates a TlsServer Config. @@ -87,34 +73,22 @@ fn load_ocsp(filename: &Option<&str>) -> Vec { /// let config = gen_tls_server_config("tests.crt", "priv.key", None); /// ``` pub fn gen_tls_server_config( - certs_file: &str, - priv_key_file: &str, - ocsp_key_file: Option<&str>, -) -> Arc { - let mut config = rustls::ServerConfig::new(NoClientAuth::new()); - config.key_log = Arc::new(rustls::KeyLogFile::new()); + certs_file: &Path, + priv_key_file: &Path, +) -> io::Result> { + let mut config = ServerConfig::new(NoClientAuth::new()); + //config.key_log = Arc::new(rustls::KeyLogFile::new()); /* load TLS certificate */ - let certs = load_certs(certs_file); - let privkey = load_private_key(priv_key_file); - let ocsp = load_ocsp(&ocsp_key_file); + let certs = load_certs(certs_file)?; + let mut privkeys = load_private_keys(priv_key_file)?; config - .set_single_cert_with_ocsp_and_sct(certs, privkey, ocsp, vec![]) - .expect("bad certs/priv key"); + .set_single_cert(certs, privkeys.remove(0)) + .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?; /* enable session resumption */ - config.set_persistence(rustls::ServerSessionMemoryCache::new(512)); - config.ticketer = rustls::Ticketer::new(); + //config.set_persistence(rustls::ServerSessionMemoryCache::new(512)); + //config.ticketer = rustls::Ticketer::new(); - Arc::new(config) -} - -#[cfg(test)] -mod test { - use super::*; - - #[test] - fn test_gen_tls_server_config() { - let _ = gen_tls_server_config("certs/test_tls.crt", "certs/test_tls.key", None); - } + Ok(Arc::new(config)) } diff --git a/src/libtrader/server/account/authorization.rs b/src/libtrader/server/account/authorization.rs index 444e262..b85b2c1 100644 --- a/src/libtrader/server/account/authorization.rs +++ b/src/libtrader/server/account/authorization.rs @@ -1,5 +1,3 @@ -use std::io::Write; - use data_encoding::HEXUPPER; use ring::pbkdf2; use std::num::NonZeroU32; @@ -12,11 +10,17 @@ use crate::common::misc::return_flags::ReturnFlags; use crate::server::db::cmd::get_user_hash::get_user_hash; use crate::server::db::cmd::get_user_id::get_user_id; use crate::server::db::cmd::get_user_salt::get_user_salt; -use crate::server::network::tls_connection::TlsConnection; use crate::server::network::jwt_wrapper::create_jwt_token; -pub fn acc_auth(tls_connection: &mut TlsConnection, message: &Message) -> Result<(), ReturnFlags> { +use tokio::io::AsyncWriteExt; +use tokio::net::TcpStream; +use tokio_rustls::server::TlsStream; + +pub async fn acc_auth( + tls_connection: &mut TlsStream, + message: &Message, +) -> Result<(), ReturnFlags> { /* * Parse account data. * */ @@ -106,7 +110,10 @@ pub fn acc_auth(tls_connection: &mut TlsConnection, message: &Message) -> Result 0, jwt_token.as_bytes().to_vec(), ); - let _ = tls_connection.write(bincode::serialize(&message).unwrap().as_slice()); + tls_connection + .write_all(bincode::serialize(&message).unwrap().as_slice()) + .await + .expect("could not write to client"); Ok(()) } diff --git a/src/libtrader/server/account/retrieval_portfolio.rs b/src/libtrader/server/account/retrieval_portfolio.rs index 32f2309..6e574bf 100644 --- a/src/libtrader/server/account/retrieval_portfolio.rs +++ b/src/libtrader/server/account/retrieval_portfolio.rs @@ -1,5 +1,3 @@ -use std::io::Write; - use crate::common::account::portfolio::Portfolio; use crate::common::account::position::Position; use crate::common::message::message::Message; @@ -10,10 +8,13 @@ use crate::common::misc::return_flags::ReturnFlags; use crate::server::db::config::{DB_PORTFOLIO_PASS, DB_PORTFOLIO_USER}; use crate::server::db::initializer::db_connect; use crate::server::network::jwt_wrapper::verify_jwt_token; -use crate::server::network::tls_connection::TlsConnection; -pub fn acc_retrieve_portfolio( - tls_connection: &mut TlsConnection, +use tokio::io::AsyncWriteExt; +use tokio::net::TcpStream; +use tokio_rustls::server::TlsStream; + +pub async fn acc_retrieve_portfolio( + tls_connection: &mut TlsStream, message: &Message, ) -> Result<(), ReturnFlags> { /* verify JWT token */ @@ -21,7 +22,7 @@ pub fn acc_retrieve_portfolio( Ok(token) => token, Err(_) => { warn!("ACC_RETRIEVE_PORTFOLIO_UNAUTH_TOKEN"); - tls_connection.closing = true; + tls_connection.shutdown().await.unwrap(); return Err(ReturnFlags::ServerAccUnauthorized); } }; @@ -63,7 +64,10 @@ pub fn acc_retrieve_portfolio( 0, bincode::serialize(&portfolio).unwrap(), ); - let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); + let _ = tls_connection + .write_all(&bincode::serialize(&message).unwrap()) + .await + .expect("could not write to client"); Ok(()) } diff --git a/src/libtrader/server/account/retrieval_transaction.rs b/src/libtrader/server/account/retrieval_transaction.rs index 875dea8..0be2cd8 100644 --- a/src/libtrader/server/account/retrieval_transaction.rs +++ b/src/libtrader/server/account/retrieval_transaction.rs @@ -1,5 +1,3 @@ -use std::io::Write; - use crate::common::account::transaction::Transaction; use crate::common::message::message::Message; use crate::common::message::message_builder::message_builder; @@ -9,10 +7,13 @@ use crate::common::misc::return_flags::ReturnFlags; use crate::server::db::config::{DB_ACC_PASS, DB_ACC_USER}; use crate::server::db::initializer::db_connect; use crate::server::network::jwt_wrapper::verify_jwt_token; -use crate::server::network::tls_connection::TlsConnection; -pub fn acc_retrieve_transaction( - tls_connection: &mut TlsConnection, +use tokio::io::AsyncWriteExt; +use tokio::net::TcpStream; +use tokio_rustls::server::TlsStream; + +pub async fn acc_retrieve_transaction( + tls_connection: &mut TlsStream, message: &Message, ) -> Result<(), ReturnFlags> { /* verify JWT token */ @@ -20,7 +21,7 @@ pub fn acc_retrieve_transaction( Ok(token) => token, Err(_) => { warn!("ACC_RETRIEVE_TRANSACTION_UNAUTH_TOKEN"); - tls_connection.closing = true; + tls_connection.shutdown().await.unwrap(); return Err(ReturnFlags::ServerAccUnauthorized); } }; diff --git a/src/libtrader/server/initializer.rs b/src/libtrader/server/initializer.rs index b941ea9..d617e1d 100644 --- a/src/libtrader/server/initializer.rs +++ b/src/libtrader/server/initializer.rs @@ -1,6 +1,6 @@ use argh::FromArgs; use std::path::PathBuf; -use tokio::io::{copy, sink, split, AsyncWriteExt}; +use tokio::io::AsyncReadExt; use tokio::net::TcpListener; use tokio_rustls::TlsAcceptor; @@ -9,8 +9,7 @@ use std::net::ToSocketAddrs; use crate::common::misc::gen_tls_server_config::gen_tls_server_config; use crate::common::misc::path_exists::path_exists; use crate::common::misc::return_flags::ReturnFlags; - -//use crate::server::network::tls_server::TlsServer; +use crate::server::network::handle_data::handle_data; /// Server Options #[derive(FromArgs)] @@ -54,7 +53,8 @@ fn libtrader_init_log() -> Result<(), ReturnFlags> { gen_log(); #[cfg(debug_assertions)] - { use simplelog::*; + { + use simplelog::*; use std::fs::File; if !path_exists("log") { @@ -94,15 +94,18 @@ pub async fn libtrader_init_server() -> std::io::Result<()> { // Initialize log. //#[cfg(not(test))] // wot dis match libtrader_init_log() { - Ok(()) => {} - Err(err) => {}, // TODO: handle this case + Ok(_) => {} + Err(_) => {} // TODO: handle this case }; // Initialize arguments let options: Options = argh::from_env(); - let addr = options.addr.to_socket_addrs()?.next(). - ok_or_else(|| std::io::Error::from(std::io::ErrorKind::AddrNotAvailable))?; + let addr = options + .addr + .to_socket_addrs()? + .next() + .ok_or_else(|| std::io::Error::from(std::io::ErrorKind::AddrNotAvailable))?; let config = gen_tls_server_config(&options.cert, &options.key)?; let acceptor = TlsAcceptor::from(config); @@ -110,13 +113,24 @@ pub async fn libtrader_init_server() -> std::io::Result<()> { let listener = TcpListener::bind(&addr).await?; loop { - let (stream, peer_addr) = listener.accept().await?; + let (socket, _) = listener.accept().await?; // socket, peer_addr let acceptor = acceptor.clone(); + // function to run in the thread let fut = async move { - let mut _stream = acceptor.accept(stream).await?; + let mut socket = acceptor.accept(socket).await?; - // handle_data here? + let mut buf = Vec::with_capacity(4096); + loop { + socket.read_buf(&mut buf).await?; + match handle_data(&mut socket, buf.as_slice()).await { + Ok(()) => {} + Err(err) => { + warn!("{}", format!("Failed running handle_data: {:#?}", err)); + break; + } + }; + } Ok(()) as std::io::Result<()> }; diff --git a/src/libtrader/server/network/cmd/get_asset_data.rs b/src/libtrader/server/network/cmd/get_asset_data.rs index eca4c7d..fac0b8e 100644 --- a/src/libtrader/server/network/cmd/get_asset_data.rs +++ b/src/libtrader/server/network/cmd/get_asset_data.rs @@ -1,82 +1,82 @@ -use std::io::Write; - -use crate::common::message::message::Message; -use crate::common::message::message_builder::message_builder; -use crate::common::message::message_type::MessageType; -use crate::common::misc::assert_msg::assert_msg; - -use crate::server::db::cmd::get_stock::get_stock_from_db_between_epochs; -use crate::server::network::tls_connection::TlsConnection; - -pub fn get_asset_data(tls_connection: &mut TlsConnection, message: &Message) { - /* assert recieved message */ - if !assert_msg( - message, - MessageType::DataTransfer, - true, - 3, - false, - 0, - false, - 0, - false, - 0, - ) { - tls_connection.closing = true; - warn!("GET_ASSET_DATA_MSG_ASSERT_FAILED"); - return; - } - - /* - * Parse arguments - * */ - /* get json data */ - let stringified_data = std::str::from_utf8(&message.data).unwrap(); - let data = json::parse(&stringified_data).unwrap(); - /* get symbol, start_epoch, and end_epoch */ - let symbol = data["symbol"].as_str().unwrap(); - let start_epoch = data["start_epoch"] - .as_str() - .unwrap() - .to_string() - .parse::() - .unwrap(); - let end_epoch = data["end_epoch"] - .as_str() - .unwrap() - .to_string() - .parse::() - .unwrap(); - - /* call get_stock_from_db_between_epochs() */ - match get_stock_from_db_between_epochs(symbol, start_epoch, end_epoch) { - Ok(vals) => { - /* send the data */ - let mut counter = 0; - for val in &vals { - let message = message_builder( - MessageType::DataTransfer, - 1, - counter, - vals.len(), - 0, - bincode::serialize(&val).unwrap(), - ); - let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); - counter = counter + 1; - } - } - Err(err) => { - /* handle error */ - let message = message_builder( - MessageType::ServerReturn, - 0, - 0, - 0, - 0, - bincode::serialize(&err).unwrap(), - ); - let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); - } - } -} +//use std::io::Write; +// +//use crate::common::message::message::Message; +//use crate::common::message::message_builder::message_builder; +//use crate::common::message::message_type::MessageType; +//use crate::common::misc::assert_msg::assert_msg; +// +//use crate::server::db::cmd::get_stock::get_stock_from_db_between_epochs; +//use crate::server::network::tls_connection::TlsConnection; +// +//pub fn get_asset_data(tls_connection: &mut TlsConnection, message: &Message) { +// /* assert recieved message */ +// if !assert_msg( +// message, +// MessageType::DataTransfer, +// true, +// 3, +// false, +// 0, +// false, +// 0, +// false, +// 0, +// ) { +// tls_connection.closing = true; +// warn!("GET_ASSET_DATA_MSG_ASSERT_FAILED"); +// return; +// } +// +// /* +// * Parse arguments +// * */ +// /* get json data */ +// let stringified_data = std::str::from_utf8(&message.data).unwrap(); +// let data = json::parse(&stringified_data).unwrap(); +// /* get symbol, start_epoch, and end_epoch */ +// let symbol = data["symbol"].as_str().unwrap(); +// let start_epoch = data["start_epoch"] +// .as_str() +// .unwrap() +// .to_string() +// .parse::() +// .unwrap(); +// let end_epoch = data["end_epoch"] +// .as_str() +// .unwrap() +// .to_string() +// .parse::() +// .unwrap(); +// +// /* call get_stock_from_db_between_epochs() */ +// match get_stock_from_db_between_epochs(symbol, start_epoch, end_epoch) { +// Ok(vals) => { +// /* send the data */ +// let mut counter = 0; +// for val in &vals { +// let message = message_builder( +// MessageType::DataTransfer, +// 1, +// counter, +// vals.len(), +// 0, +// bincode::serialize(&val).unwrap(), +// ); +// let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); +// counter = counter + 1; +// } +// } +// Err(err) => { +// /* handle error */ +// let message = message_builder( +// MessageType::ServerReturn, +// 0, +// 0, +// 0, +// 0, +// bincode::serialize(&err).unwrap(), +// ); +// let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); +// } +// } +//} diff --git a/src/libtrader/server/network/cmd/get_asset_info.rs b/src/libtrader/server/network/cmd/get_asset_info.rs index 4c73696..32e981f 100644 --- a/src/libtrader/server/network/cmd/get_asset_info.rs +++ b/src/libtrader/server/network/cmd/get_asset_info.rs @@ -1,56 +1,56 @@ -use std::io::Write; - -use crate::common::message::inst::DataTransferInst; -use crate::common::message::message::Message; -use crate::common::message::message_builder::message_builder; -use crate::common::message::message_type::MessageType; -use crate::common::misc::assert_msg::assert_msg; - -use crate::server::db::cmd::get_company::get_company_from_db; -use crate::server::network::tls_connection::TlsConnection; - -pub fn get_asset_info(tls_connection: &mut TlsConnection, message: &Message) { - /* assert recieved message */ - if !assert_msg( - message, - MessageType::DataTransfer, - true, - 1, - false, - 0, - false, - 0, - false, - 0, - ) { - tls_connection.closing = true; - warn!("GET_ASSET_INFO_INVALID_MESSAGE"); - return; - } - - /* call get_company_from_db() */ - match get_company_from_db(bincode::deserialize(&message.data).unwrap()) { - Ok(company) => { - let message = message_builder( - MessageType::ServerReturn, - DataTransferInst::GetAssetInfo as i64, - 0, - 0, - 1, - bincode::serialize(&company).unwrap(), - ); - let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); - } - Err(err) => { - let message = message_builder( - MessageType::ServerReturn, - 0, - 0, - 0, - 0, - bincode::serialize(&err).unwrap(), - ); - let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); - } - } -} +//use std::io::Write; +// +//use crate::common::message::inst::DataTransferInst; +//use crate::common::message::message::Message; +//use crate::common::message::message_builder::message_builder; +//use crate::common::message::message_type::MessageType; +//use crate::common::misc::assert_msg::assert_msg; +// +//use crate::server::db::cmd::get_company::get_company_from_db; +//use crate::server::network::tls_connection::TlsConnection; +// +//pub fn get_asset_info(tls_connection: &mut TlsConnection, message: &Message) { +// /* assert recieved message */ +// if !assert_msg( +// message, +// MessageType::DataTransfer, +// true, +// 1, +// false, +// 0, +// false, +// 0, +// false, +// 0, +// ) { +// tls_connection.closing = true; +// warn!("GET_ASSET_INFO_INVALID_MESSAGE"); +// return; +// } +// +// /* call get_company_from_db() */ +// match get_company_from_db(bincode::deserialize(&message.data).unwrap()) { +// Ok(company) => { +// let message = message_builder( +// MessageType::ServerReturn, +// DataTransferInst::GetAssetInfo as i64, +// 0, +// 0, +// 1, +// bincode::serialize(&company).unwrap(), +// ); +// let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); +// } +// Err(err) => { +// let message = message_builder( +// MessageType::ServerReturn, +// 0, +// 0, +// 0, +// 0, +// bincode::serialize(&err).unwrap(), +// ); +// let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); +// } +// } +//} diff --git a/src/libtrader/server/network/cmd/login_normal.rs b/src/libtrader/server/network/cmd/login_normal.rs index a9a42b5..68b6865 100644 --- a/src/libtrader/server/network/cmd/login_normal.rs +++ b/src/libtrader/server/network/cmd/login_normal.rs @@ -1,5 +1,3 @@ -use std::io::Write; - use crate::common::message::inst::CommandInst; use crate::common::message::message::Message; use crate::common::message::message_builder::message_builder; @@ -7,9 +5,15 @@ use crate::common::message::message_type::MessageType; use crate::common::misc::assert_msg::assert_msg; use crate::server::account::authorization::acc_auth; -use crate::server::network::tls_connection::TlsConnection; -pub fn login_normal(tls_connection: &mut TlsConnection, message: &Message) { +use tokio::io::AsyncWriteExt; +use tokio::net::TcpStream; +use tokio_rustls::server::TlsStream; + +pub async fn login_normal( + tls_connection: &mut TlsStream, + message: &Message, +) -> std::io::Result<()> { /* assert recieved message */ if !assert_msg( message, @@ -25,16 +29,15 @@ pub fn login_normal(tls_connection: &mut TlsConnection, message: &Message) { ) && message.instruction == CommandInst::LoginMethod1 as i64 && message.data.len() != 0 { - tls_connection.closing = true; warn!("LOGIN_INVALID_MESSAGE"); - return; + return tls_connection.shutdown().await; } /* call acc_auth() server version */ - match acc_auth(tls_connection, message) { - Ok(_) => {} + match acc_auth(tls_connection, message).await { + Ok(_) => Ok(()), Err(err) => { - let message = message_builder( + let server_response = message_builder( MessageType::ServerReturn, 0, 0, @@ -42,7 +45,9 @@ pub fn login_normal(tls_connection: &mut TlsConnection, message: &Message) { 0, bincode::serialize(&err).unwrap(), ); - let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); + tls_connection + .write_all(&bincode::serialize(&server_response).unwrap()) + .await } } } diff --git a/src/libtrader/server/network/cmd/purchase_asset.rs b/src/libtrader/server/network/cmd/purchase_asset.rs index cab7233..d60a677 100644 --- a/src/libtrader/server/network/cmd/purchase_asset.rs +++ b/src/libtrader/server/network/cmd/purchase_asset.rs @@ -1,35 +1,35 @@ -use crate::common::message::message::Message; - -use crate::server::network::tls_connection::TlsConnection; - -pub fn purchase_asset(_tls_connection: &mut TlsConnection, _message: &Message) { - /* assert recieved message */ - //if message.msgtype != MessageType::Command || message.argument_count != 4 - // || message.data_message_number != 0 || message.data_message_max != 0 - // || message.data.len() == 0 { - // warn!("PURCHASE_ASSET_INVALID_MESSAGE"); - // tls_connection.closing = true; - // return; - // } - - //* parse request data */ - //let stringified_data = std::str::from_utf8(&message.data).unwrap(); - //let data = json::parse(&stringified_data).unwrap(); - //* get symbol, shares amount, price, buy or sell */ - //let symbol = data["symbol"].as_str().unwrap(); - //let shares_amount = data["shares_amount"].as_str().unwrap().to_string().parse::().unwrap(); - //let is_buy = data["is_buy"].as_bool().unwrap(); - - //* connect to the data base */ - //let mut client = db_connect(DB_USER, DB_PASS).unwrap(); - - //* check if the symbol exists */ - //let company = get_company_from_db(symbol); - //if !company.is_ok() { - // let msg = message_builder(MessageType::ServerReturn, 0, 1, 0, 0, - // bincode::serialize("COULDNOT FIND COMPANY")).unwrap(); - // return; - //} - - //* */ -} +//use crate::common::message::message::Message; +// +//use crate::server::network::tls_connection::TlsConnection; +// +//pub fn purchase_asset(_tls_connection: &mut TlsConnection, _message: &Message) { +// /* assert recieved message */ +// //if message.msgtype != MessageType::Command || message.argument_count != 4 +// // || message.data_message_number != 0 || message.data_message_max != 0 +// // || message.data.len() == 0 { +// // warn!("PURCHASE_ASSET_INVALID_MESSAGE"); +// // tls_connection.closing = true; +// // return; +// // } +// +// //* parse request data */ +// //let stringified_data = std::str::from_utf8(&message.data).unwrap(); +// //let data = json::parse(&stringified_data).unwrap(); +// //* get symbol, shares amount, price, buy or sell */ +// //let symbol = data["symbol"].as_str().unwrap(); +// //let shares_amount = data["shares_amount"].as_str().unwrap().to_string().parse::().unwrap(); +// //let is_buy = data["is_buy"].as_bool().unwrap(); +// +// //* connect to the data base */ +// //let mut client = db_connect(DB_USER, DB_PASS).unwrap(); +// +// //* check if the symbol exists */ +// //let company = get_company_from_db(symbol); +// //if !company.is_ok() { +// // let msg = message_builder(MessageType::ServerReturn, 0, 1, 0, 0, +// // bincode::serialize("COULDNOT FIND COMPANY")).unwrap(); +// // return; +// //} +// +// //* */ +//} diff --git a/src/libtrader/server/network/cmd/register.rs b/src/libtrader/server/network/cmd/register.rs index 9723cfc..587917f 100644 --- a/src/libtrader/server/network/cmd/register.rs +++ b/src/libtrader/server/network/cmd/register.rs @@ -1,5 +1,3 @@ -use std::io::Write; - use crate::common::message::inst::CommandInst; use crate::common::message::message::Message; use crate::common::message::message_builder::message_builder; @@ -7,9 +5,15 @@ use crate::common::message::message_type::MessageType; use crate::common::misc::assert_msg::assert_msg; use crate::server::account::creation::acc_create; -use crate::server::network::tls_connection::TlsConnection; -pub fn register(tls_connection: &mut TlsConnection, message: &Message) { +use tokio::io::AsyncWriteExt; +use tokio::net::TcpStream; +use tokio_rustls::server::TlsStream; + +pub async fn register( + tls_connection: &mut TlsStream, + message: &Message, +) -> std::io::Result<()> { /* assert recieved message */ if !assert_msg( message, @@ -26,18 +30,21 @@ pub fn register(tls_connection: &mut TlsConnection, message: &Message) { && message.data.len() != 0 { warn!("REGISTER_INVALID_MESSAGE"); - tls_connection.closing = true; - return; + return tls_connection.shutdown().await; } /* call acc_create() server version */ match acc_create(message) { Ok(_) => { - let message = message_builder(MessageType::ServerReturn, 1, 0, 0, 0, Vec::new()); - let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); + let server_response = + message_builder(MessageType::ServerReturn, 1, 0, 0, 0, Vec::new()); + tls_connection + .write_all(&bincode::serialize(&server_response).unwrap()) + .await } Err(err) => { warn!("REGISTER_FAILED: {}", err); + Ok(()) } - }; + } } diff --git a/src/libtrader/server/network/cmd/retrieve_portfolio.rs b/src/libtrader/server/network/cmd/retrieve_portfolio.rs index 48c6d65..3438dfb 100644 --- a/src/libtrader/server/network/cmd/retrieve_portfolio.rs +++ b/src/libtrader/server/network/cmd/retrieve_portfolio.rs @@ -4,9 +4,15 @@ use crate::common::message::message_type::MessageType; use crate::common::misc::assert_msg::assert_msg; use crate::server::account::retrieval_portfolio::acc_retrieve_portfolio; -use crate::server::network::tls_connection::TlsConnection; -pub fn retrieve_portfolio(tls_connection: &mut TlsConnection, message: &Message) { +use tokio::io::AsyncWriteExt; +use tokio::net::TcpStream; +use tokio_rustls::server::TlsStream; + +pub async fn retrieve_portfolio( + tls_connection: &mut TlsStream, + message: &Message, +) -> std::io::Result<()> { /* assert recieved message */ if !assert_msg( message, @@ -22,14 +28,16 @@ pub fn retrieve_portfolio(tls_connection: &mut TlsConnection, message: &Message) ) && message.instruction == DataTransferInst::GetUserPortfolio as i64 && message.data.len() != 0 { - tls_connection.closing = true; warn!("RETRIEVE_PORTFOLIO_INVALID_MESSAGE"); - return; + return tls_connection.shutdown().await; } /* call acc_retrieve_portfolio() server version */ - match acc_retrieve_portfolio(tls_connection, message) { - Ok(_) => {} - Err(err) => warn!("RETRIEVE_PORTFOLIO_FAILED: {}", err), - }; + match acc_retrieve_portfolio(tls_connection, message).await { + Ok(_) => Ok(()), + Err(err) => { + warn!("RETRIEVE_PORTFOLIO_FAILED: {}", err); + Ok(()) // TODO: return error + } + } } diff --git a/src/libtrader/server/network/cmd/retrieve_transactions.rs b/src/libtrader/server/network/cmd/retrieve_transactions.rs index ea09637..200d416 100644 --- a/src/libtrader/server/network/cmd/retrieve_transactions.rs +++ b/src/libtrader/server/network/cmd/retrieve_transactions.rs @@ -4,9 +4,15 @@ use crate::common::message::message_type::MessageType; use crate::common::misc::assert_msg::assert_msg; use crate::server::account::retrieval_transaction::acc_retrieve_transaction; -use crate::server::network::tls_connection::TlsConnection; -pub fn retrieve_transactions(tls_connection: &mut TlsConnection, message: &Message) { +use tokio::io::AsyncWriteExt; +use tokio::net::TcpStream; +use tokio_rustls::server::TlsStream; + +pub async fn retrieve_transactions( + tls_connection: &mut TlsStream, + message: &Message, +) -> std::io::Result<()> { /* assert recieved message */ if !assert_msg( message, @@ -22,14 +28,16 @@ pub fn retrieve_transactions(tls_connection: &mut TlsConnection, message: &Messa ) && message.instruction == DataTransferInst::GetUserTransactionHist as i64 && message.data.len() != 0 { - tls_connection.closing = true; warn!("RETRIEVE_TRANSACTION_INVALID_MESSAGE"); - return; + return tls_connection.shutdown().await; } /* call acc_retrieve_transaction() server version */ - match acc_retrieve_transaction(tls_connection, message) { - Ok(_) => {} - Err(err) => warn!("RETRIEVE_TRANSACTION_FAILED: {}", err), - }; + match acc_retrieve_transaction(tls_connection, message).await { + Ok(_) => Ok(()), + Err(err) => { + warn!("RETRIEVE_TRANSACTION_FAILED: {}", err); + Ok(()) // TODO: return error + } + } } diff --git a/src/libtrader/server/network/handle_data.rs b/src/libtrader/server/network/handle_data.rs index cf5b114..61ac5ad 100644 --- a/src/libtrader/server/network/handle_data.rs +++ b/src/libtrader/server/network/handle_data.rs @@ -1,30 +1,23 @@ use data_encoding::HEXUPPER; -use std::io::Write; use crate::common::message::inst::{CommandInst, DataTransferInst}; use crate::common::message::message::Message; use crate::common::message::message_builder::message_builder; use crate::common::message::message_type::MessageType; -use crate::server::network::cmd::get_asset_data::get_asset_data; -use crate::server::network::cmd::get_asset_info::get_asset_info; use crate::server::network::cmd::login_normal::login_normal; -use crate::server::network::cmd::purchase_asset::purchase_asset; use crate::server::network::cmd::register::register; use crate::server::network::cmd::retrieve_portfolio::retrieve_portfolio; use crate::server::network::cmd::retrieve_transactions::retrieve_transactions; -use crate::server::network::tls_connection::TlsConnection; -pub fn handle_data(connection: &mut TlsConnection, buf: &[u8]) -> Result<(), String> { +//use tokio::net::TcpStream; +use tokio::io::AsyncWriteExt; +use tokio::net::TcpStream; +use tokio_rustls::server::TlsStream; + +pub async fn handle_data(socket: &mut TlsStream, buf: &[u8]) -> std::io::Result<()> { /* decode incoming message */ - let client_msg: Message = match bincode::deserialize(&buf) { - Ok(msg) => msg, - Err(err) => { - warn!("HANDLE_DATA_RCVD_INV_MSG: {}", err); - connection.closing = true; /* disconnect any unrecognized message senders */ - return Ok(()); - } - }; + let client_msg: Message = bincode::deserialize(&buf).expect("HANDLE_DATA_RCVD_INV_MSG"); /* handle individual client instructions */ match client_msg.instruction { @@ -43,100 +36,81 @@ pub fn handle_data(connection: &mut TlsConnection, buf: &[u8]) -> Result<(), Str 1, salt.to_vec(), ); - connection - .tls_session - .write(bincode::serialize(&server_response).unwrap().as_slice()) - .unwrap(); - connection.do_tls_write_and_handle_error(); + socket + .write_all(bincode::serialize(&server_response).unwrap().as_slice()) + .await } _ if client_msg.instruction == CommandInst::GetEmailSalt as i64 => { use crate::server::db::cmd::get_user_salt::get_user_salt; - let salt = match get_user_salt( + match get_user_salt( String::from_utf8(client_msg.data).unwrap().as_str(), true, false, ) { - Ok(salt) => salt, - Err(_) => { - let msg = message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new()); - connection - .tls_session - .write(&bincode::serialize(&msg).unwrap()) - .unwrap(); - connection.do_tls_write_and_handle_error(); - return Ok(()); + Ok(salt) => { + let server_response: Message = message_builder( + MessageType::DataTransfer, + CommandInst::GetEmailSalt as i64, + 1, + 0, + 1, + HEXUPPER.decode(salt.as_bytes()).unwrap(), + ); + socket + .write_all(bincode::serialize(&server_response).unwrap().as_slice()) + .await } - }; - let server_response: Message = message_builder( - MessageType::DataTransfer, - CommandInst::GetEmailSalt as i64, - 1, - 0, - 1, - HEXUPPER.decode(salt.as_bytes()).unwrap(), - ); - connection - .tls_session - .write(bincode::serialize(&server_response).unwrap().as_slice()) - .unwrap(); - connection.do_tls_write_and_handle_error(); + Err(_) => { + let server_response = + message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new()); + socket + .write_all(bincode::serialize(&server_response).unwrap().as_slice()) + .await + } + } } _ if client_msg.instruction == CommandInst::GetPasswordSalt as i64 => { use crate::server::db::cmd::get_user_salt::get_user_salt; - let salt = match get_user_salt( + match get_user_salt( String::from_utf8(client_msg.data).unwrap().as_str(), false, false, ) { - Ok(salt) => salt, - Err(_) => { - let message = - message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new()); - connection - .tls_session - .write(&bincode::serialize(&message).unwrap()) - .unwrap(); - connection.do_tls_write_and_handle_error(); - return Ok(()); + Ok(salt) => { + let server_response: Message = message_builder( + MessageType::DataTransfer, + CommandInst::GetPasswordSalt as i64, + 1, + 0, + 1, + HEXUPPER.decode(salt.as_bytes()).unwrap(), + ); + socket + .write_all(bincode::serialize(&server_response).unwrap().as_slice()) + .await } - }; - let server_response: Message = message_builder( - MessageType::DataTransfer, - CommandInst::GetPasswordSalt as i64, - 1, - 0, - 1, - HEXUPPER.decode(salt.as_bytes()).unwrap(), - ); - connection - .tls_session - .write(bincode::serialize(&server_response).unwrap().as_slice()) - .unwrap(); - connection.do_tls_write_and_handle_error(); + Err(_) => { + let server_response = + message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new()); + + socket + .write_all(bincode::serialize(&server_response).unwrap().as_slice()) + .await + } + } } _ if client_msg.instruction == CommandInst::Register as i64 => { - register(connection, &client_msg) + register(socket, &client_msg).await } _ if client_msg.instruction == CommandInst::LoginMethod1 as i64 => { - login_normal(connection, &client_msg) + login_normal(socket, &client_msg).await } _ if client_msg.instruction == DataTransferInst::GetUserPortfolio as i64 => { - retrieve_portfolio(connection, &client_msg) + retrieve_portfolio(socket, &client_msg).await } _ if client_msg.instruction == DataTransferInst::GetUserTransactionHist as i64 => { - retrieve_transactions(connection, &client_msg) + retrieve_transactions(socket, &client_msg).await } - _ if client_msg.instruction == DataTransferInst::GetAssetInfo as i64 => { - get_asset_info(connection, &client_msg) - } - _ if client_msg.instruction == DataTransferInst::GetAssetValue as i64 => { - get_asset_data(connection, &client_msg) - } - _ if client_msg.instruction == CommandInst::PurchaseAsset as i64 => { - purchase_asset(connection, &client_msg) - } - _ => {} - }; - - Ok(()) + _ => Ok(()), + } } diff --git a/src/libtrader/server/network/mod.rs b/src/libtrader/server/network/mod.rs index 1d5e578..c8e2647 100644 --- a/src/libtrader/server/network/mod.rs +++ b/src/libtrader/server/network/mod.rs @@ -1,5 +1,3 @@ pub mod cmd; pub mod handle_data; pub mod jwt_wrapper; -pub mod tls_connection; -pub mod tls_server; diff --git a/src/libtrader/server/network/tls_connection.rs b/src/libtrader/server/network/tls_connection.rs deleted file mode 100644 index 2a718a9..0000000 --- a/src/libtrader/server/network/tls_connection.rs +++ /dev/null @@ -1,222 +0,0 @@ -use std::io; -use std::io::Read; -use std::net; - -use mio; -use mio::net::TcpStream; -use rustls; -use rustls::Session; - -use crate::server::network::handle_data::handle_data; - -/// The TlsConnection struct that represents a tls connection. -/// -/// Members: -/// socket - The TcpStream for which TLS is used on. -/// token - The ```mio::Token``` representing the TlsConnection. -/// closing - Used for starting a closing TlsConnection state. -/// closed - Used for determining whether the TlsConnection is closed. -/// tls_session - The ServerSession that is the TLS connecton. -#[derive(Debug)] -pub struct TlsConnection { - pub socket: TcpStream, - pub token: mio::Token, - pub closing: bool, - pub closed: bool, - pub tls_session: rustls::ServerSession, -} - -impl TlsConnection { - /// Returns a new TlsConnection struct. - /// - /// Arguments: - /// socket - The ```TcpStream``` to be used for the TlsConnection - /// token - The ```mio::Token``` to be used to identify the TlsConnection - /// tls_session - The ```rustls::ServerSession``` to be used in the Tls Connection - /// - /// Returns: a new TlsConnection - pub fn new( - socket: TcpStream, - token: mio::Token, - tls_session: rustls::ServerSession, - ) -> TlsConnection { - TlsConnection { - socket, - token, - closing: false, - closed: false, - tls_session, - } - } - - /// TlsConnection event reciever. - /// - /// Determines if the mio::event::Event is readable/writable or is closing. Calls the - /// appropriate TlsConnection function to handle the event. The event is not sent to the - /// receiving function. - /// - /// Arguments: - /// registry - The mio::Registry containing the mio::Tokens. - /// event - The event to be 'dispatched'. - /// - /// Returns: nothing - pub fn ready(&mut self, registry: &mio::Registry, ev: &mio::event::Event) { - if ev.is_readable() { - self.do_tls_read(); - self.try_plain_read(); - } - - if ev.is_writable() { - self.do_tls_write_and_handle_error(); - } - - if self.closing { - let _ = self.socket.shutdown(net::Shutdown::Both); - self.closed = true; - self.deregister(registry); - } else { - self.reregister(registry); - } - } - - /// Private TlsConnection function that reads incoming TLS packets. - /// - /// Reads the ```self.tls_session``` received TLS packets and then handles any errors - /// generated. If reading TLS packets succeeds, issue new packets to be ready for reading. - fn do_tls_read(&mut self) { - // read some tls data. - let rc = self.tls_session.read_tls(&mut self.socket); - if rc.is_err() { - let err = rc.unwrap_err(); - - if let io::ErrorKind::WouldBlock = err.kind() { - /* make this simpler */ - return; - } - - error!("tls read error: {:?}", err); - self.closing = true; - return; - } - - if rc.unwrap() == 0 { - self.closing = true; - return; - } - - // process newly-recieved tls messages. - let processed = self.tls_session.process_new_packets(); - if processed.is_err() { - error!("tls cannot process packet: {:?}", processed); - - // last gasp write to send any alerts - self.do_tls_write_and_handle_error(); - - self.closing = true; - return; - } - } - - /// Private TlsConnection function that reads decrypted TLS packets. - /// - /// Reads from ``self.tls_sessions``` and fills a buffer. The buffer is sent to - /// ```self.incoming_plaintext()```. - fn try_plain_read(&mut self) { - // read and process all available plaintext. - let mut buf = Vec::new(); - - let rc = self.tls_session.read_to_end(&mut buf); - if rc.is_err() { - error!("tls plaintext read failed: {:?}", rc); - self.closing = true; - return; - } - - if !buf.is_empty() { - debug!("plaintext read {:?}", buf.len()); - self.incoming_plaintext(&buf); - } - } - - /// Private TlsConnection function that dispatches decrypted TLS packets. - /// - /// Dispatches decrypted TLS data to ```handle_data()```. - fn incoming_plaintext(&mut self, buf: &[u8]) { - match handle_data(self, buf) { - Ok(()) => {} - Err(err) => error!("Error processing TLS connection: {}", err), - } - } - - /// Private TlsConnection function that flushes TLS packets and handles any errors. - pub fn do_tls_write_and_handle_error(&mut self) { - let rc = self.tls_session.write_tls(&mut self.socket); - if rc.is_err() { - error!("write failed: {:?}", rc); - self.closing = true; - return; - } - } - - /// Registers the TlsConnection to a mio::Registry - /// - /// Arguments: - /// registry - The registry to register - pub fn register(&mut self, registry: &mio::Registry) { - let event_set = self.event_set(); - registry - .register(&mut self.socket, self.token, event_set) - .unwrap(); - } - - /// Reregisters the TlsConnection to a mio::Registry - /// - /// Arguments: - /// registry - The registry to reregister - fn reregister(&mut self, registry: &mio::Registry) { - let event_set = self.event_set(); - registry - .reregister(&mut self.socket, self.token, event_set) - .unwrap(); - } - - /// Unregisters the TlsConnection from a mio::Registry - /// - /// Arguments: - /// registry - The registry to unregister - fn deregister(&mut self, registry: &mio::Registry) { - registry.deregister(&mut self.socket).unwrap(); - } - - /// Private TlsConnection function to return the ```self.tls_session```'s ```mio::Interest``` - /// - /// Returns: the interests of ```self.tls_session``` - fn event_set(&self) -> mio::Interest { - let rd = self.tls_session.wants_read(); - let wr = self.tls_session.wants_write(); - - if rd && wr { - mio::Interest::READABLE | mio::Interest::WRITABLE - } else if wr { - mio::Interest::WRITABLE - } else { - mio::Interest::READABLE - } - } -} - -impl io::Write for TlsConnection { - fn write(&mut self, bytes: &[u8]) -> io::Result { - let res = self.tls_session.write(bytes); - if res.is_err() { - warn!("TLS_CONNECTION_WRITE_FAILED"); - } else { - self.do_tls_write_and_handle_error(); - } - res - } - - fn flush(&mut self) -> io::Result<()> { - self.tls_session.flush() - } -} diff --git a/src/libtrader/server/network/tls_server.rs b/src/libtrader/server/network/tls_server.rs deleted file mode 100644 index ae967cc..0000000 --- a/src/libtrader/server/network/tls_server.rs +++ /dev/null @@ -1,94 +0,0 @@ -use std::collections::HashMap; -use std::io; -use std::sync::Arc; - -use mio; -use mio::net::TcpListener; -use rustls; - -use crate::server::network::tls_connection::TlsConnection; - -/// The TlsServer struct that represents a working TLS Server -/// -/// Members: -/// server - The TcpListener for which TLS is accepted. -/// connections - The map of all connections. -/// next_id - The next unused ID for registering in the mio::Poll -/// tls_config - The TLS server configuration. -pub struct TlsServer { - pub server: TcpListener, - pub connections: HashMap, - pub next_id: usize, - pub tls_config: Arc, -} - -impl TlsServer { - /// Returns a new TlsServer struct - /// - /// Arguments: - /// server - The ```TcpListener``` to be used for the TLS Server. - /// cfg - The TLS server configuration to be used. - /// - /// Returns: a new TlsServer - pub fn new(server: TcpListener, cfg: Arc) -> TlsServer { - TlsServer { - server, - connections: HashMap::new(), - next_id: 1, - tls_config: cfg, - } - } - - /// Accepts any new TLS connections. - /// - /// Arguments: - /// registry - The registry to register connections. - /// - /// Returns: nothing on success, io::Error on failure. - pub fn accept(&mut self, registry: &mio::Registry) -> Result<(), io::Error> { - loop { - match self.server.accept() { - Ok((socket, addr)) => { - debug!("Accepting new connection from {:?}", addr); - - let tls_session = rustls::ServerSession::new(&self.tls_config); - - let token = mio::Token(self.next_id); - self.next_id += 1; - - let mut connection = TlsConnection::new(socket, token, tls_session); - connection.register(registry); - self.connections.insert(token, connection); - } - Err(err) if err.kind() == io::ErrorKind::WouldBlock => return Ok(()), - Err(err) => { - error!("tls server error accepting connections; err={:?}", err); - return Err(err); - } - } - } - } - - /// TLS Server Dispatcher - /// - /// Checks if the token issuing the event is in the list of active connections and then - /// dispatches the event to TlsConnection. - /// - /// Arguments: - /// registry - The registry to check the registered connections from. - /// event - The event to be dispatched. - pub fn conn_event(&mut self, registry: &mio::Registry, event: &mio::event::Event) { - let token = event.token(); - - if self.connections.contains_key(&token) { - self.connections - .get_mut(&token) - .unwrap() - .ready(registry, event); - - if self.connections[&token].closed { - self.connections.remove(&token); - } - } - } -}