server now runs (hopefully)
This commit is contained in:
parent
17d2a0e93e
commit
924603e43e
|
@ -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
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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-----
|
|
@ -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-----
|
|
@ -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-----
|
|
@ -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-----
|
|
@ -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<rustls::ServerCertVerified, rustls::TLSError> {
|
||||
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<rustls::ClientConfig> {
|
||||
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<rustls::ServerCertVerified, rustls::TLSError> {
|
||||
// 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<rustls::ClientConfig> {
|
||||
// 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();
|
||||
// }
|
||||
//}
|
||||
|
|
|
@ -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<rustls::Certificate> {
|
||||
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<Vec<Certificate>> {
|
||||
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<rustls::Certificate> {
|
|||
/// filename - Path to .key file.
|
||||
///
|
||||
/// Returns: rustls::PrivateKey
|
||||
fn load_private_key(filename: &str) -> rustls::PrivateKey {
|
||||
fn load_private_keys(path: &Path) -> io::Result<Vec<PrivateKey>> {
|
||||
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<u8> {
|
||||
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<u8> {
|
|||
/// 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<rustls::ServerConfig> {
|
||||
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<Arc<ServerConfig>> {
|
||||
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))
|
||||
}
|
||||
|
|
|
@ -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<TcpStream>,
|
||||
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(())
|
||||
}
|
||||
|
|
|
@ -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<TcpStream>,
|
||||
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(())
|
||||
}
|
||||
|
|
|
@ -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<TcpStream>,
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
|
|
@ -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<()>
|
||||
};
|
||||
|
|
|
@ -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::<i64>()
|
||||
.unwrap();
|
||||
let end_epoch = data["end_epoch"]
|
||||
.as_str()
|
||||
.unwrap()
|
||||
.to_string()
|
||||
.parse::<i64>()
|
||||
.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::<i64>()
|
||||
// .unwrap();
|
||||
// let end_epoch = data["end_epoch"]
|
||||
// .as_str()
|
||||
// .unwrap()
|
||||
// .to_string()
|
||||
// .parse::<i64>()
|
||||
// .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());
|
||||
// }
|
||||
// }
|
||||
//}
|
||||
|
|
|
@ -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());
|
||||
// }
|
||||
// }
|
||||
//}
|
||||
|
|
|
@ -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<TcpStream>,
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
//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::<i64>().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;
|
||||
// //}
|
||||
//
|
||||
// //* */
|
||||
//}
|
||||
|
||||
//* 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::<i64>().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;
|
||||
//}
|
||||
|
||||
//* */
|
||||
}
|
||||
|
|
|
@ -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<TcpStream>,
|
||||
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(())
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
|
@ -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<TcpStream>,
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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<TcpStream>,
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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<TcpStream>, 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,30 +36,18 @@ 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,
|
||||
|
@ -75,31 +56,27 @@ pub fn handle_data(connection: &mut TlsConnection, buf: &[u8]) -> Result<(), Str
|
|||
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();
|
||||
socket
|
||||
.write_all(bincode::serialize(&server_response).unwrap().as_slice())
|
||||
.await
|
||||
}
|
||||
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,
|
||||
|
@ -108,35 +85,32 @@ pub fn handle_data(connection: &mut TlsConnection, buf: &[u8]) -> Result<(), Str
|
|||
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();
|
||||
socket
|
||||
.write_all(bincode::serialize(&server_response).unwrap().as_slice())
|
||||
.await
|
||||
}
|
||||
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)
|
||||
_ => Ok(()),
|
||||
}
|
||||
_ 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(())
|
||||
}
|
||||
|
|
|
@ -1,5 +1,3 @@
|
|||
pub mod cmd;
|
||||
pub mod handle_data;
|
||||
pub mod jwt_wrapper;
|
||||
pub mod tls_connection;
|
||||
pub mod tls_server;
|
||||
|
|
|
@ -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<usize> {
|
||||
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()
|
||||
}
|
||||
}
|
|
@ -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<mio::Token, TlsConnection>,
|
||||
pub next_id: usize,
|
||||
pub tls_config: Arc<rustls::ServerConfig>,
|
||||
}
|
||||
|
||||
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<rustls::ServerConfig>) -> 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
Loading…
Reference in New Issue