mirror of
https://github.com/cesanta/mongoose.git
synced 2026-10-23 11:44:53 +00:00
ws_ssl -> websocket_ssl_proxy
This commit is contained in:
Sergey Lyubka committed
1 parent
6083b9c5c5
commit
2987cbdb5c
13 files changed
+4
-4
No files matched your search
@@ -0,0 +1,17 @@
|
||||
# Copyright (c) 2014 Cesanta Software
|
||||
# All rights reserved
|
||||
|
||||
CFLAGS = -W -Wall -I../.. -I. -g -O0 $(CFLAGS_EXTRA)
|
||||
|
||||
SOURCES = ws_ssl.c ../../mongoose.c net_skeleton.c ssl_wrapper.c
|
||||
PROG = ws_ssl
|
||||
|
||||
all: $(PROG)
|
||||
|
||||
$(PROG): $(SOURCES)
|
||||
$(CC) -o $(PROG) $(SOURCES) \
|
||||
-DNS_ENABLE_SSL -DNOEMBED_NET_SKELETON \
|
||||
-DSSL_WRAPPER_USE_AS_LIBRARY -lssl $(CFLAGS)
|
||||
|
||||
clean:
|
||||
rm -rf $(PROG) *.exe *.dSYM *.obj *.exp .*o *.lib
|
||||
@@ -0,0 +1,49 @@
|
||||
-----BEGIN RSA PRIVATE KEY-----
|
||||
MIIEowIBAAKCAQEAwizPnrCx+/kPSdEeSJFLDXrBH+cSQsSLrCm99G1hCjzqSlIk
|
||||
1BhkZMEHxBaiVLky4+M/nwhjwwRHI10h6U2Or3tbPLv7z94cPf+uCx1aF7TE3Fm3
|
||||
6YnDk+CjrYVFN5GRPGOPPdFxGoc+vFvQJyAAimvchnS1ZoEQFvermwzOnKspA6gc
|
||||
Px+7wnOeju9TyJuDr5ngtDXFnkcpkBNPxz3En4MJY4xJiaueafh9pIES2vSl7uP0
|
||||
J/qot9v2rdiL7nt1H1vwseeEkZhQ+NLB5e2z4psyktJcwDX7wQ6j7JnKfHeP+ixO
|
||||
TUORgV4foBMVOqo//Guo92Q5HoLNK77V0y4+ZQIDAQABAoIBAGEsx+LlDs3JQQty
|
||||
KjOq8uKWElyC6bKcZkIMydGvg6b6AU6ceW3jnyqFJ/vMUAUSghNmQQq3yiVo2Kks
|
||||
DLKTa9sKYwisE0NeJsgoUtOhJttCTlrwU4f+t/AjtgY68f7zTLnqIV+Ql4ftM0pU
|
||||
sIFEFMExZbWsZrQb1w+Hd0wrRqNEbSOfSjHeigvuw1T3GH2tSBUTGTpcoewCzy7U
|
||||
PKS5pkYyiKySQQNqZTac3NHPjxdK6xxzwURZp1irKdiPdt04KHLVLX8KXelt/J0k
|
||||
AeYkVbpFIeQ9rNBerMEp6uRBt+nE5mvP+xx1XPqKRxuxbMyTnBXeOM2zS/a/dBiz
|
||||
fwokwcECgYEA9RSsv9AQ/AR8tt+aPEQvjhJ5pn/YbCb1DA9IDXpaq3tzacGd8JHj
|
||||
3kUtb79nosu85LvSkAYmtzgfJs6xZyUkscra6q+xlsJ12QRxLzqfxcp9Y0wsdqM4
|
||||
AcOwuiPKrjkWxOQpyWPWRwbmAefLfRMekHt4Y/QY0CwhslpnsOsj3O0CgYEAytOE
|
||||
8I4GBfSQfSjXwfrso++Oi75VSsl5ZeiMGihfEhYFTE8/3rEZf7nf9iFSkN3TT+7f
|
||||
pFqQzddzPBZXlpVM6k1jcEjdpJizbeR8DmICpABFrZvKz1o8pQ2Yw+FYI86ih0x4
|
||||
806snMNgg/RgcVijXKFrC5joJOI+DVgwWoQyMFkCgYBxt4MkiV2oIkjf7ca6GgVa
|
||||
zbXGjOGV5Umkq96J6nDxyplVw/IN8xOhScX4aP6kahaep4vfKguCzjaeIh/stS5e
|
||||
lLqZVKZ5Roe6B7ag7HnAI+GkVm73KWrOXse8xui/iFvJRfkhqgJ9+HR3A9/GjD2N
|
||||
Ws0Uy+lLhn6oLAya6bA9TQKBgAVfZP4aRP6TY+Bs3Io+41XUWqpI+GlqvNR+PHfU
|
||||
6e/ItYs37jEv78T6X3xdlZpQxfAwG6x22a8aLetBjEBo5Aiw1Bl9VKGvidE3ZDHd
|
||||
VsSRXUckAVNMyJ52pb1KktMf/h4nYGzRgLEGW+Ai8QsPlgQ2ImfEPSH8/DfORjmf
|
||||
ltTBAoGBAMxIZ52DrJvuxogSOfA1MoCD6a90trkXCquvi+A/fXojZ8BHmMQshvhK
|
||||
rAO7SDIV1i1Nh3jQ/oFWE8KOprqrOLO6jNTyF65vh+zk7ztGsEME9FkDhHasUiXf
|
||||
t5PE9KeTChHRvIa4FGCl9We9GftE5Ii77LWMOIq22pyxYbvHQFEf
|
||||
-----END RSA PRIVATE KEY-----
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIDlDCCAnygAwIBAgIJAIOoO+AapJ5WMA0GCSqGSIb3DQEBBQUAMDoxDDAKBgNV
|
||||
BAMTA3dzMTEMMAoGA1UEChMDd3MxMQswCQYDVQQGEwJJRTEPMA0GA1UEBxMGRHVi
|
||||
bGluMB4XDTE0MDgwMzA5MTU0NVoXDTI0MDczMTA5MTU0NVowOjEMMAoGA1UEAxMD
|
||||
d3MxMQwwCgYDVQQKEwN3czExCzAJBgNVBAYTAklFMQ8wDQYDVQQHEwZEdWJsaW4w
|
||||
ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCLM+esLH7+Q9J0R5IkUsN
|
||||
esEf5xJCxIusKb30bWEKPOpKUiTUGGRkwQfEFqJUuTLj4z+fCGPDBEcjXSHpTY6v
|
||||
e1s8u/vP3hw9/64LHVoXtMTcWbfpicOT4KOthUU3kZE8Y4890XEahz68W9AnIACK
|
||||
a9yGdLVmgRAW96ubDM6cqykDqBw/H7vCc56O71PIm4OvmeC0NcWeRymQE0/HPcSf
|
||||
gwljjEmJq55p+H2kgRLa9KXu4/Qn+qi32/at2Ivue3UfW/Cx54SRmFD40sHl7bPi
|
||||
mzKS0lzANfvBDqPsmcp8d4/6LE5NQ5GBXh+gExU6qj/8a6j3ZDkegs0rvtXTLj5l
|
||||
AgMBAAGjgZwwgZkwHQYDVR0OBBYEFL54xAgtJTW6US4Mbr4QG0yKzvaxMGoGA1Ud
|
||||
IwRjMGGAFL54xAgtJTW6US4Mbr4QG0yKzvaxoT6kPDA6MQwwCgYDVQQDEwN3czEx
|
||||
DDAKBgNVBAoTA3dzMTELMAkGA1UEBhMCSUUxDzANBgNVBAcTBkR1YmxpboIJAIOo
|
||||
O+AapJ5WMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAJz/RzMa9Wa2
|
||||
eEXed7ijH1gcWtgVsVT1xZo0ksFl+QJ5Be1AJpOIe8nKdzYjxPWUkofIoaGHdMLL
|
||||
Uc/udRzsXncup+0mD+Yos6Cqyo9yHq7L1HbXfKYZtBXIjWHdF2+RP8j9tHfITXYI
|
||||
Pb2zsQ+A6PYpp5OLGZTDAnI2qffqsmwXFNhPfFhOANrGlOjsvy1P7JDzvymj/90m
|
||||
NomlO3vjxLHOf6MvedTgCB0dRcAoUWPgbxPWifjBmGBjQjA4ukMQ58wbBQgvIoCW
|
||||
obrXmLCNZIkpWTw4gMRYquY880IYK/OuFNJH/dawxx/WzuVr7IdLmbFY15zf5TUb
|
||||
ZpIpwqRCysg=
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,45 @@
|
||||
-----BEGIN RSA PRIVATE KEY-----
|
||||
MIIEpQIBAAKCAQEAwOp1RS9RnE8L5TszDPIOmpf/1pqb+ki99l/sGhqB/KZBKCuq
|
||||
uoCc2VPK3PCByBE15/xJ7t691FnJfForI9DO5p2R0FPD6o357hqRsh0dJNBm0VgG
|
||||
iNtLQ8lyYoE72HJbkgCAUZW4N0OBibOmvp/s3Fmr7rEjW5LmZxOtX+iULKIUZ0w6
|
||||
gJlM8G5QA1SuqndN0PbPx+RZKSXZCoJj+Nboqw03nyJUexzs+lynR9ITMziUaaVM
|
||||
4rzG+P6joQAnUkDNydxo/d4tj4xaioZdKxWLYEbj2BUtOlJJydotWo2wcG85ONrT
|
||||
Gw0ltR1vku1hidMm2QL30uGIL5SeqyE8TqWk4QIDAQABAoIBAQCxHtKauc45MA4g
|
||||
4hCGAzvLTmETnRI2YlEfAoTYlpvf5pkOE8GFyI25r4gjACJ4GO0gWG9dBF7Pt7wZ
|
||||
EwRmttEvxV3aIv5OvRnKNdSs7rQSV9D+xc4CGy1oSG1f6X2TxbMzQoiN32OqQa2O
|
||||
S0Z94IFs8lu8JCDtc9tcqiFVXEmnC3RvJZOShWpsCsbmh5ue1Xed0MQQ47vt7Zt7
|
||||
I0cutvwSFJMsZkZUJp5+KjVNYo9TEJxVD3m2NJNJxBfBoRVHXNii3hUEHcTIdIAz
|
||||
omtRwBU8AKgJirGIRo1h2ZFyubI8ScGOJWIiWMQvQqTHKiOaz3yUar1NSG+kFn0U
|
||||
cj7s3FhdAoGBAOQbx8Jwhtp4iOkP6aW1nVTgiaTj4LMlyJZioFwgPFRIcA3oRHt9
|
||||
5SRetmgFZNvcuNw1udfeaObKmlzxwUruprwOpihgAQWJFTtOjQNrt2gsYuX4l3W6
|
||||
T46dO2W1pV+mW4A5gt0aqhLv7pCS4lpreNAqyHSPqcQWcCeiTzmp/LfDAoGBANiB
|
||||
FQOTyMElR9OzKwmcGfIvnhUfJQwi5qNE3R+xXiP5x36a9HQBey5ri2lnBle0Ksr/
|
||||
G+RKoflmk1eFXVHN0w35yw0dVco//WE4vOknldNEnIT85k02ld8lDTa2Q/EJZtPH
|
||||
un6zeU0Q2/4SZ/GXPssEZPlpPM7WtQzztlH3+sqLAoGBAKnhppvAgi4ippQsLa4j
|
||||
29BiiSAsNiQ1d3XIbfUubL+4UvuIh7gQwp6biu1dVwgHEgWuXYHPOgDn0p51zaao
|
||||
pbRYlJZtKVWeChnpHkv15NnIdL8grGwZHTbxElNlPIxHsM2GB1fzi8YeumUhf0In
|
||||
2AnwUum8NIq8yzo5PxeK6ZNRAoGBAIEA2Q6ankJH/nZsCbbeJq+iI+Wd+ysyGI8s
|
||||
Vz2tJ9Tz3iTYG9SLlWRhfF4/nw3fMqhmPa5Xsg+zSRQbSTGXHKz1LEISOq4aVtX5
|
||||
QscCaUnLVh//uRJE9iRSJX92NyGGYpjKJ5ubQSnkY9EOEpVnc2jwo2HhjPQKBzNC
|
||||
fF53Dh5lAoGALwTN5uxrBZLPu4DtZkOosKkv4l+kzFoOjLJR4vA7ONBx2CSe9G7F
|
||||
tSsH7lZS3b0mxBWjO90WhaSvtMWWrfqq8vrqmoTE795fYxNoLfCLK13W31aTDUsI
|
||||
pQRJIL30MPvASbcFHN2MD2dXz2nQzY8C9lvtvap/krYiDKDU2L7+iP8=
|
||||
-----END RSA PRIVATE KEY-----
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIC7DCCAdQCBRQHBXNHMA0GCSqGSIb3DQEBBQUAMDoxDDAKBgNVBAMTA3dzMTEM
|
||||
MAoGA1UEChMDd3MxMQswCQYDVQQGEwJJRTEPMA0GA1UEBxMGRHVibGluMB4XDTE0
|
||||
MDgwMzA5MTU0NVoXDTI0MDczMTA5MTU0NVowOjEMMAoGA1UEAxMDd3MxMQwwCgYD
|
||||
VQQKEwN3czExCzAJBgNVBAYTAklFMQ8wDQYDVQQHEwZHYWx3YXkwggEiMA0GCSqG
|
||||
SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDA6nVFL1GcTwvlOzMM8g6al//Wmpv6SL32
|
||||
X+waGoH8pkEoK6q6gJzZU8rc8IHIETXn/Enu3r3UWcl8Wisj0M7mnZHQU8Pqjfnu
|
||||
GpGyHR0k0GbRWAaI20tDyXJigTvYcluSAIBRlbg3Q4GJs6a+n+zcWavusSNbkuZn
|
||||
E61f6JQsohRnTDqAmUzwblADVK6qd03Q9s/H5FkpJdkKgmP41uirDTefIlR7HOz6
|
||||
XKdH0hMzOJRppUzivMb4/qOhACdSQM3J3Gj93i2PjFqKhl0rFYtgRuPYFS06UknJ
|
||||
2i1ajbBwbzk42tMbDSW1HW+S7WGJ0ybZAvfS4YgvlJ6rITxOpaThAgMBAAEwDQYJ
|
||||
KoZIhvcNAQEFBQADggEBABPLmq6zKOMY0WRjtBoSymq6f+vXeEwtWCfVejdG6RlG
|
||||
/PTdCKNvp3OL7FDnmQQ+r5rMs4+Os4fX/g315QFKXu01rqxmFb2XVNhhaECdUWtK
|
||||
QP6ZoVZviUiDjhK6a+05aerPCJpkGy/lz0W6gmj4qhuAQbobxb6UbzqTRYY+ZwGk
|
||||
+SI3TAVCdmXFlxN/M9b0DbmkseRG8GGFmyRYyRb84vbV6zemFI++5ROUT9zXT7ey
|
||||
nYfFJvAAk5jJhY5UP2aMlVWYYa4jUZrrPLoiBLUuRrp67EKGebCH9mgCIf8ztNJF
|
||||
fpuvcz++LUeRyTlAGDefe+FyHGIwFzIfZn39D7CaRvM=
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,45 @@
|
||||
-----BEGIN RSA PRIVATE KEY-----
|
||||
MIIEpAIBAAKCAQEAyal0BZKRYd+Wpxv4MB8LjjgXv/MxSN5oSAKThlCZ/AWG0FEP
|
||||
d4nrBACT2xUxwo+xbYl3joiwL/eCPAp6QNKRGhvXVOnSIFVSjKZWbdX+toqK9pDS
|
||||
QMDTL4ZJvK6pLZXknyHjEr0PxZh22F7iS1+C8HxBPj0Xgg/u5/+jPhFPPZ1d5elv
|
||||
4cm/z+xy6RjFlA80aIeK7dcWssOsOIPjUNFfmoYgR63ScZIlUZj6j8VX9oX7fJID
|
||||
jumGajDxgD2nBWFbHcGKin6bz/wZ+OIhXOCDdY7oKuMW4JiBwbfBtedkQuQYS11s
|
||||
PRFFYDLoZH59Ivcu0c4F2tomE86qM8THsI910wIDAQABAoIBAG55FAQRfO8/C0rU
|
||||
eavy9eOdOvV+hltC66G3N5X3BcQYSvhHz89OkJ6KqnT0MWRCT5KQIhzFKK++SWwW
|
||||
2U41jCPfaKEtzlzEIQrH/MUC3Byn3OSiBWxPteFtEWv5ytgcKzg52iljxQYcNc7m
|
||||
e9WKpzKS/zLXSM+JZvlVA9p2pRA88kUZ/EE5H+FW3kHj5eGNqX+cxUVpL0VKTiLv
|
||||
aXWjYotpmDJW/Rn9wRQethm6Gdx3bvo+LEVlJRELNq8NM5H/tZIVRzudJOgzsw5v
|
||||
3OQGhfKB6Eg/vqSFoZxX6ApXDxmtaSO83B0kK550bDVv4sBnOExGjKCzybt04tet
|
||||
KtLPPoECgYEA5WUD+mFL99sCX6pzIyUVlxp9eUhVy5nvhoF6u3mvhay2XsZUY0wy
|
||||
+/qVqYSZTvuvJ6JSXc4iVIX8u/gj7914805AwujepIF/8E0AaXLBMndzDE4ze5S5
|
||||
2RHI7Cy4/3AWOcQ9wFFmUdSs7/6oAkcQtvzP40hGg3J2jAEhIdCqmbMCgYEA4Q0G
|
||||
BYP9XeTdh0C+BcP9B5VUEC0jerYS8VqVqriB+9JfT3InI7K08sOG2DiQQBhAHuzL
|
||||
RhCECU2a9j0+u5F5JNeY5m3IhU73Lw+lOlUkMaAO6x7JJEzhXhonE7Kv8fWygr/0
|
||||
OB7yzqz+YsWdQ2VOPZ88ntlAYE65vzcaVswZY2ECgYEAr7Gt2VA6Ei0A5Wq0Yr+d
|
||||
iKz2WzUG2TkelqOG8B4kTDrbNz2qFp+fERV9GWgAz9i+75lIgqZF7vzsdL96LtYv
|
||||
NBLEUURwegjhh5hCb4E/7bpFOLCQh9+CdHpFrHYYfzRHIZlnPmxZ9OTyS6J85bmu
|
||||
WKjLRKXvs++wUkzvJmoesDcCgYEAkTOB6xUZ5/a+J4HSGI43NylVr4owFgBbgHVd
|
||||
k2SwGPXGoM+aCSJINUmKOv9jsrbyyAEntfD5/7aegLlLPGHDs82WzTWP5tLoEOkb
|
||||
ReOhEpOejHy0ckNYNQrSo5bqhkZsAogu3fa52jcrejbeHJnEPWX8CtFJA9pHZeP7
|
||||
jnzo9IECgYBefHg0dymSj2xxN0XmC+S5cvQu2K/NYUpatoWvHnPiQ87wIM0AWz0O
|
||||
D0ghEI+Ze57NbtSrrcTE7hY/LHrAqXGAB9XNIM5g9Pp/lM+XjzKVr1FMf4xpuHf1
|
||||
VJJRHrOU14CvMvKbgbPrL6B0d5yrYmeex7GxNw0ZVvtjCa502Eck+w==
|
||||
-----END RSA PRIVATE KEY-----
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIC7DCCAdQCBRQHBXNGMA0GCSqGSIb3DQEBBQUAMDoxDDAKBgNVBAMTA3dzMTEM
|
||||
MAoGA1UEChMDd3MxMQswCQYDVQQGEwJJRTEPMA0GA1UEBxMGRHVibGluMB4XDTE0
|
||||
MDgwMzA5MTU0NVoXDTI0MDczMTA5MTU0NVowOjEMMAoGA1UEAxMDd3MxMQwwCgYD
|
||||
VQQKEwN3czExCzAJBgNVBAYTAklFMQ8wDQYDVQQHEwZHYWx3YXkwggEiMA0GCSqG
|
||||
SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDJqXQFkpFh35anG/gwHwuOOBe/8zFI3mhI
|
||||
ApOGUJn8BYbQUQ93iesEAJPbFTHCj7FtiXeOiLAv94I8CnpA0pEaG9dU6dIgVVKM
|
||||
plZt1f62ior2kNJAwNMvhkm8rqktleSfIeMSvQ/FmHbYXuJLX4LwfEE+PReCD+7n
|
||||
/6M+EU89nV3l6W/hyb/P7HLpGMWUDzRoh4rt1xayw6w4g+NQ0V+ahiBHrdJxkiVR
|
||||
mPqPxVf2hft8kgOO6YZqMPGAPacFYVsdwYqKfpvP/Bn44iFc4IN1jugq4xbgmIHB
|
||||
t8G152RC5BhLXWw9EUVgMuhkfn0i9y7RzgXa2iYTzqozxMewj3XTAgMBAAEwDQYJ
|
||||
KoZIhvcNAQEFBQADggEBAE20gAykuuaCoP49GnZ/Z6ZItFry4Fl6iCWBDdEsWI9R
|
||||
wRNYumeaeejdFPXfSJdTT7UlrVK1WWGLQLq+ixHRDX+V9T67ou85F92H/OxbUoPr
|
||||
iz/TZAEBTC1GvTJl49lsfPl1dTWH8T4Ej2hxCUvIJrkCkI2Ov4Wwef6A26USrwBt
|
||||
S/CPInjCe6qkE5E8xfTDl8k5IIgMadTPhi5sbV2piBJoN4floJPqR0hdDKbgUymn
|
||||
5WNSiRkuI6UIDZwQEp+A8TmFBHbSwfTGt2Sz5iI27P8J6pFvR5eRA1k57dRUWNXC
|
||||
WAU1nqteP3QAjj9L3o8IO0T62scaiJX8x01gTmVVe2I=
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,49 @@
|
||||
-----BEGIN RSA PRIVATE KEY-----
|
||||
MIIEowIBAAKCAQEAwXIMpHuTNsro2pxe6y1mu27md2Olhvfx26rO3maO0/stIC2z
|
||||
G/xQatFDLIWzfKFYOT0iSEj252ENFDCw6aDRKpiaUFtXcMAWkNkkKntEyoEgE45k
|
||||
rTrvpay0v0B+ojwjA1Jz/9v35cgvDwTs3vNFno5HhI0m2YF4ocTmeHJ6u0xRL/qy
|
||||
atfKsfuVq5s5CXOYCXp3Ux6kJ1c22J0EdZMvS75SVjAZgRkqQpqt9L3e2ZBCEgUr
|
||||
w0KwlERvpeJF+sJJOshXjfrDzvwL8IpPnGZLJNINFbSJMk5MFGcMyq/28pSZLB9E
|
||||
Dh8vk5D5gUnxM60ONUy2nYPcYr5p1PLDiC8hfQIDAQABAoIBAB0Twpi6xn8W8vdh
|
||||
R9c75NRJsDTD8q6d+GnXe+7sJY3xlG/gzqpnO8NCn0FC+57BNdystsl8xjgzW17s
|
||||
jrsfZDFt7MwlXrhg90NgkFIeY1G5JRQrdDChykHx+t1AmYhTV8P5EdykuNd+RqyQ
|
||||
RfahRJa3tkJTYUKSdoqCaU4zjwU2CSxltuJx24V+WoZE12EwewJ8HPg2XTnbsGE7
|
||||
Fnx5s29O4ItM70CC0536AY/OgfuPix5z573VQiilqqfOQkVkKa1fHd6tGpWU+3kH
|
||||
X9FnhEBf9cN9tVgmaB0sCSVVrfgqSXg1EwKHqe/+FCumuesA68Q35+/K3b+QrNiR
|
||||
ka2yliECgYEA+V/4pbgG/lPYvTwWhKxGXXdJmrSPgZC0mwE+fRuYkeptbIkS0pwt
|
||||
/UDTXk9nttj1f1ZJ3NgQbT/1w8jpXfsCJ8VeGzL9+ADhRKWVFRlu/nyFCMXawLEV
|
||||
rot7SEr8BW/m8moHgY5lYipM3dXJPk0F+KLrN60U/aNmFUtPGW802BkCgYEAxpWy
|
||||
FGL2sEQ0QaRDTcqqF5faVqw+5rVGvN+EX5o26E0QWWnoo3L2c2/5X93iBl+Fqtnm
|
||||
9jSIQUC3rYOawKnZ/HcIE2ergFit/p6JaV9NiLDRtDUmSzlffEGVCj0neYFsnWp5
|
||||
zcmkUyZ6fr19EmKQWfdteNBlXue32TjVlFbfUQUCgYAfMbgi0sBdNBPaqBeRBRPQ
|
||||
QUm9xnRlGrrc4Oz2LWuKZS7G8uad3deK5H8MPxaUMtOS2DJpI8X6RJPzp8A5d1qv
|
||||
quq4sEpAqauEMMpTV1khEGZ70HQqwnwZ12zWgDrCW1siW80QkcVw4CW5YjLITk4+
|
||||
6fJOhqInkDcG1uLQJa8QkQKBgQCfs8l4DbJ4RRGFbLXXvNGXkb68j18yqLxPrq3F
|
||||
OL9JiJhKYBsAP7clVPrG9ykLmQxlP0I35D1jxMkymLD+mlo9Z/itqmTJHggnyZWW
|
||||
kVdIQ3MSKuA2BNjek9tpVY8Gb2hLHFMChVRKrpo6jOclvvB5+bsnOukbLtyyq7tP
|
||||
xaFohQKBgByCmlltjOBWZLFLeA1x8j3inm9zM/FAJuANbHUOZ1RwrRcNFbDv/FXm
|
||||
rLPnPCaH5AwAWhVRJcNHo37Ee0s/xqe+Q4dG4xL943k+6KlopAw1SXhuXF6PnBfF
|
||||
y+ArVlh9d2oWN5cBEzRddnWnKJuMi70kMzYf6dIW9s/dHbq/gFDy
|
||||
-----END RSA PRIVATE KEY-----
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIDlDCCAnygAwIBAgIJAJDtcXU2wiJIMA0GCSqGSIb3DQEBBQUAMDoxDDAKBgNV
|
||||
BAMTA3dzMjEMMAoGA1UEChMDd3MyMQswCQYDVQQGEwJJRTEPMA0GA1UEBxMGRHVi
|
||||
bGluMB4XDTE0MDgwMzA5MTU0OFoXDTI0MDczMTA5MTU0OFowOjEMMAoGA1UEAxMD
|
||||
d3MyMQwwCgYDVQQKEwN3czIxCzAJBgNVBAYTAklFMQ8wDQYDVQQHEwZEdWJsaW4w
|
||||
ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDBcgyke5M2yujanF7rLWa7
|
||||
buZ3Y6WG9/Hbqs7eZo7T+y0gLbMb/FBq0UMshbN8oVg5PSJISPbnYQ0UMLDpoNEq
|
||||
mJpQW1dwwBaQ2SQqe0TKgSATjmStOu+lrLS/QH6iPCMDUnP/2/flyC8PBOze80We
|
||||
jkeEjSbZgXihxOZ4cnq7TFEv+rJq18qx+5WrmzkJc5gJendTHqQnVzbYnQR1ky9L
|
||||
vlJWMBmBGSpCmq30vd7ZkEISBSvDQrCURG+l4kX6wkk6yFeN+sPO/Avwik+cZksk
|
||||
0g0VtIkyTkwUZwzKr/bylJksH0QOHy+TkPmBSfEzrQ41TLadg9xivmnU8sOILyF9
|
||||
AgMBAAGjgZwwgZkwHQYDVR0OBBYEFLK4flD5QD/mRufsPx63xlEKM8pwMGoGA1Ud
|
||||
IwRjMGGAFLK4flD5QD/mRufsPx63xlEKM8pwoT6kPDA6MQwwCgYDVQQDEwN3czIx
|
||||
DDAKBgNVBAoTA3dzMjELMAkGA1UEBhMCSUUxDzANBgNVBAcTBkR1YmxpboIJAJDt
|
||||
cXU2wiJIMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAEYD+CReikYr
|
||||
Rzvk+/Vdi/7IcaH9CFknIdtineSIw1y98nxnbnNJqxwfNaRblbYvg6OFdUI3POuI
|
||||
+rdYLCFl8z3tWqRHLkGqHSJA9xcng3jLJxz0+ctiVcekJvXaB3O6eSZjhGbmmI/s
|
||||
CQhdy2zpEIVOeUq50DrSJp9CknyGu/IkaGx5GOZtkiHMrpig50CRjX1lS6qrMNYp
|
||||
vB8gfuqpjsL4Ar3vg+lgMSwNWXBNHrIRPHB5VEzBEdmLFZlvueR0ooEMCklpwX/a
|
||||
lFImVc6JcY1pBEkHTiTLGMpGAHG3I1aVUaWb3L+V+2ym/KNRNL5C2+1eiqql5u8m
|
||||
HUaOcNC90ew=
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,45 @@
|
||||
-----BEGIN RSA PRIVATE KEY-----
|
||||
MIIEpAIBAAKCAQEA0ucemqFwBFziVOgTgx4mZII4WnGDpA/rWAGHvUZOqy2dQ3Pz
|
||||
woGKxBaVPAl5kxEosROVGa7dTuq5yFZ4XIGvwCKxF30vCmdGCytqq6MMp904jG32
|
||||
KikkmjCApIMGxMO4eoBHZZxiyVvKTbg9M2CRXErwnYWhFH/qGdPnuo0CEaHJA4VK
|
||||
A9incT9dpeEhU30R6ajAe/je9rCj2OMLMFSMfd51L/VYfO60zDwUNY7YVIghQZgJ
|
||||
e44EVGsp1pXaqaD6o3PvGY3ohw2aZjJzlJ7MJHbKV9lft98R3pklbpBzMH849cEy
|
||||
Q/51L/rlfTUgCpTy7wEZpWHQNtHfu/1rhJjpNQIDAQABAoIBAQCUNIHXG/dBuZv7
|
||||
GpMLotZL7w520Co30lAJqhmfMpb5x7YpvoPffXTsUwpQBECAzqAPv7kZMT6nxF8F
|
||||
n245Y5EDrd1QqlGyN9yK4Nm2/39XPygL1wITopHsIIVmFgVdpEQxIZAKoZjx8yT4
|
||||
9K1dO1Eq0CbCKzOE2lbCC51eBNUdWZIMxwC6O/j/KoIkZ/HwlG2hpUuXg8x/XawA
|
||||
ZJDCoTcWHCjYP10FxKVN3vAyWM2IM44o9IbsAGEOswR4gUwRsgq6Ehc1U59XUHi+
|
||||
x30oda55I1/8xD+SfP/zk2dDPHkv/hq5+258GU/THsw2+AAexocvSIS/g9EppTEg
|
||||
biFaDKzJAoGBAPqey10JeyiOlHbBjoSSa7lJYUjocQANFQ4ayOAgfNX72iyabrKF
|
||||
p9sVAeO/nM00+DPrm2wWws03ScsPeh+9BDJMPRBUHfSNp7+F+oyj7PWHBEFHbyO9
|
||||
5HnYZP+1vhdG2dYPIY2gRSFXpiGn3j0M1D0w9c7Ilm8ee3krdR4E/mw3AoGBANdu
|
||||
EfS1dK3+m7sEgc2+3U32z83GpuCHeUIKGPYMLI0fIb1CPpboHU9YjOFJZH9iIIdl
|
||||
00JC963O3+pqLe0XbMOmBVt9QjZfhfB+AY+JHtbPgoQVLtq9X/WvW7h3xn6S971r
|
||||
Crkhqay3Cs4BzsgYDYraQCTw3oq4twR9Nuy4etfzAoGAXOsG5wWe3diO/sCggFJx
|
||||
Eg88vHVBgA1ZoxMXKtGgtw1bRHI1XIblRvqw6qmeDw72fvl5dEe0DbXT7C9ezemc
|
||||
ZrGRaj5lpMfoS7/2trIIJrfaQgGkGRJMZUhvmcbeJW8lUJHnlMS5HLWMaKn+YZAi
|
||||
GFXQrMv9ylD44mHUWD7tvV0CgYBNctPfvvCQsQ05ofgsiKa1Jbs1hmpuJCYy2MB6
|
||||
jIvjvEJ78PnhdNc8tGAJikIoDZYWN0RI+RxkDxCvDLcwGpDOkbwxVQnd1F+pwxM6
|
||||
kBhXL8kDRT5QA28hO4bk/aKN1LZeEcKMJg8C+ddXkozNoOAVgDs5TKMlCh057u41
|
||||
EmmPgwKBgQDOlYi7fPYOCy0yjHMxSrp2SZOS06AMWGbbCoGkjRtvuP+FmKSNB+LZ
|
||||
pOSEPJgzjsRutKjneww4LpV6dViAyTcP5JoeQpokHf7UVo7yq2QH/iwF3zJwsC/S
|
||||
OuVLkqpZzWuye/QCH5NOTfw27ye8jG8VcQW2QPbcbkLXLM7zg2yX7g==
|
||||
-----END RSA PRIVATE KEY-----
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIC7DCCAdQCBRQHBXNJMA0GCSqGSIb3DQEBBQUAMDoxDDAKBgNVBAMTA3dzMjEM
|
||||
MAoGA1UEChMDd3MyMQswCQYDVQQGEwJJRTEPMA0GA1UEBxMGRHVibGluMB4XDTE0
|
||||
MDgwMzA5MTU0OFoXDTI0MDczMTA5MTU0OFowOjEMMAoGA1UEAxMDd3MyMQwwCgYD
|
||||
VQQKEwN3czIxCzAJBgNVBAYTAklFMQ8wDQYDVQQHEwZHYWx3YXkwggEiMA0GCSqG
|
||||
SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDS5x6aoXAEXOJU6BODHiZkgjhacYOkD+tY
|
||||
AYe9Rk6rLZ1Dc/PCgYrEFpU8CXmTESixE5UZrt1O6rnIVnhcga/AIrEXfS8KZ0YL
|
||||
K2qrowyn3TiMbfYqKSSaMICkgwbEw7h6gEdlnGLJW8pNuD0zYJFcSvCdhaEUf+oZ
|
||||
0+e6jQIRockDhUoD2KdxP12l4SFTfRHpqMB7+N72sKPY4wswVIx93nUv9Vh87rTM
|
||||
PBQ1jthUiCFBmAl7jgRUaynWldqpoPqjc+8ZjeiHDZpmMnOUnswkdspX2V+33xHe
|
||||
mSVukHMwfzj1wTJD/nUv+uV9NSAKlPLvARmlYdA20d+7/WuEmOk1AgMBAAEwDQYJ
|
||||
KoZIhvcNAQEFBQADggEBACCCAJypO9DFU6GeOH+FwE0JCLTypHoIwERWxNL7xfjg
|
||||
rwVqIxwAEo+fJjL+QY7JbAb/eqKaXIBYkAF2lFc4iEmecXX/A3Aqw95AYi78o7HD
|
||||
MwRPqJha9mxLcCWwjX8XK8pT152BvYFPNhi+6jd++rDRxKDfmNvgdUQ2/YW6a5Wv
|
||||
zEmLDPUWRIuMQIEmOa2/JhlllDviMExTw51nbqYgCghycRvDACyQAuu8re7P6gcg
|
||||
bXObNlfxcU/8Ph6MFI+2S9ODtQ4BHyuKd4kRNsYn8vV42a0h3bCYSGPk3kSIgxd7
|
||||
XijwHT/o8E9ddH2BvDv+6Nhno9C6/MbezEOIs4nlhRk=
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,45 @@
|
||||
-----BEGIN RSA PRIVATE KEY-----
|
||||
MIIEpQIBAAKCAQEA29iFnMf4pjty6knOt4wT0joPUlU2dGCFWxQ5Eg77Yx3Lou2a
|
||||
FOzNGp7zLYH8gauOK+mgY+B9cBv8PvVtUQQKB0SKTTV8ZNKVyP3O5F2gRSJ+tHtT
|
||||
FqaPfG0WPOn/f02YbOpAe6Rk+NnlJoeuBxG4uapUSq7r0mTGJQe+52y1LcMs23ID
|
||||
ENBfDoUMVt5vCnF+cYK5ndeFVLyPO3JjohDH1zv3a9ECG28rtjKHLpNYFDsPJaD7
|
||||
UPuyyk3hIvfPCZoJOUlEVfpLT/lM+9oCPnq9PwIp5NqYofkuc3eKooCo7N4r4IlP
|
||||
Ajktaao6b0ScNwNQB3leOIdEUFSIYy8N1JszVwIDAQABAoIBAFlIvjrGG/2m9yyf
|
||||
fQyeHw6p9b8CTHNHH+G1fNgQrZe7ahBpXsJQyZueIjTBLcOb4MmEwFbPvSHiu7b2
|
||||
Bcd5VHlPJLvmlPZ9b8eJDJVCUOzC7aJu03fHfU6THwzuG42f/d9942JTiY5nL+FO
|
||||
CSdl0xfUTRdnou53buFrG+TxCUPj13HP1HY6DAVzEIq1H4TZwIZo7KRRTIYpTB3P
|
||||
6yvr9xsISLlnmfQ4tp2pApl5o+bHJEhr1VO6SAT/pSyShi79KmMMqYtyTmOMz7w6
|
||||
VJkre5ybnXBDN6tfMHWqdobJ4gRWK9rqf+LIZig5XQnyzkue8k+I7aPgO4xNFh56
|
||||
dkejQcECgYEA9MDCWViqpfvof+epiKzccqnIRnz1EfHdRQjiKsKGRe39+K+pyaqJ
|
||||
FOOPFy3aOw6M4cFWwcdMYzKTItvzyLVhDqMzT5eup/NVqo5tPoy93XPf2qRYiTl4
|
||||
2j5wvm0RVkYEONd3pk2lbfbUmn7XQXj0+AG60SvsqErF/UhIBGec/xsCgYEA5fLC
|
||||
EdiiC98kr4sVaE8G854WI+aAkStqO5YXyrnsMzRsqk8KVVYE1yCC9rYyymDBYmlx
|
||||
uEW+vbWqLc8PO3v4ty3o5ff303lPMWIrvKiUldjqMjS6ncWxsQjU0bygGVgOgHO7
|
||||
c8rjiDH5M0JgWSREYUVFT5mW/5+Y1LVT8mYNlHUCgYEAhMSX6N23XGkFW3Twu2qB
|
||||
/1Vohgw86OoaDNvfzDBPpFmQ3rlz0ijHSeSTd5BxBH5FICXACUgygNErjcphOSxj
|
||||
JQyUxgVTQlo2y1mNm1O/nwS/lxx1xqK9ky4x/Kqvr+w1WBxSFI2kQr2V4OUTobma
|
||||
sXpGvDcmnrhJJLd0EaefO6cCgYEA3Xw/S9tC8nZjqqYn34nHI16Q6tF54tpTf8Np
|
||||
dT4x8Xw8cqqhRGMPVHsfSi1irKYXfwgbnienuqlBmtAHVv9pKF+TJfb7gXkmO2XY
|
||||
xOYIAHGn2uYJHjCun9vmyYKLHv4/MaDH3Jd/I88mviXgEdyp9Js5UJua4utB1Rg3
|
||||
HJMJ34UCgYEAr0PpHEBMbZXZBybNU96+jRTgkrNeJpzlnMy7et2IsRAtLjZ0mpbn
|
||||
NaX8i8eO+ubweqFdhOvbh7Hd0zr7BzrYcUG1e3njhtxJE1MgWL5plnLVUbIyDAm3
|
||||
iBpIHIBASNCN3sqeq+VqXvavRmeZh5O0vyLP46/kxZx0rzR/NCi9xxU=
|
||||
-----END RSA PRIVATE KEY-----
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIC7DCCAdQCBRQHBXNIMA0GCSqGSIb3DQEBBQUAMDoxDDAKBgNVBAMTA3dzMjEM
|
||||
MAoGA1UEChMDd3MyMQswCQYDVQQGEwJJRTEPMA0GA1UEBxMGRHVibGluMB4XDTE0
|
||||
MDgwMzA5MTU0OFoXDTI0MDczMTA5MTU0OFowOjEMMAoGA1UEAxMDd3MyMQwwCgYD
|
||||
VQQKEwN3czIxCzAJBgNVBAYTAklFMQ8wDQYDVQQHEwZHYWx3YXkwggEiMA0GCSqG
|
||||
SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDb2IWcx/imO3LqSc63jBPSOg9SVTZ0YIVb
|
||||
FDkSDvtjHcui7ZoU7M0anvMtgfyBq44r6aBj4H1wG/w+9W1RBAoHRIpNNXxk0pXI
|
||||
/c7kXaBFIn60e1MWpo98bRY86f9/TZhs6kB7pGT42eUmh64HEbi5qlRKruvSZMYl
|
||||
B77nbLUtwyzbcgMQ0F8OhQxW3m8KcX5xgrmd14VUvI87cmOiEMfXO/dr0QIbbyu2
|
||||
Mocuk1gUOw8loPtQ+7LKTeEi988Jmgk5SURV+ktP+Uz72gI+er0/Aink2pih+S5z
|
||||
d4qigKjs3ivgiU8COS1pqjpvRJw3A1AHeV44h0RQVIhjLw3UmzNXAgMBAAEwDQYJ
|
||||
KoZIhvcNAQEFBQADggEBALi/RmqeXGazT/WRj9+ZqdcnbcHwK5wwr2/YkpFPJ0Hf
|
||||
ZDm+2vgjDdTT6cJS6fau0M5nliYdz89aQQo1j9RSRZnzlc/2YCFXyRLCOJYaINbj
|
||||
1MEUAvNDGL7xTpepK9hVkXASRkbyNXERXRKFI1N+vpKu6UorT6/osEV/qM+MFJ3s
|
||||
24xE8/J3J4MirVQVt6eY6Jb+tkliOPMIugr6YQlLsqJygEWATP8Qsr81XSfcZhVq
|
||||
rXzVt7QV8dO0nStMjKK5omrtEAhVnASk7w1tFHkpBF1rqXGoo9ML40RnFZ+E5zqi
|
||||
iZtzp+NzzLnEnWMNs+fJpPJ96P0kbq2bQzuSBcUynq0=
|
||||
-----END CERTIFICATE-----
|
||||
@@ -0,0 +1,934 @@
|
||||
// Copyright (c) 2014 Cesanta Software Limited
|
||||
// All rights reserved
|
||||
//
|
||||
// This software is dual-licensed: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License version 2 as
|
||||
// published by the Free Software Foundation. For the terms of this
|
||||
// license, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
// You are free to use this software under the terms of the GNU General
|
||||
// Public License, but WITHOUT ANY WARRANTY; without even the implied
|
||||
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// Alternatively, you can license this software under a commercial
|
||||
// license, as set out in <http://cesanta.com/>.
|
||||
//
|
||||
// $Date: 2014-09-09 17:09:33 UTC $
|
||||
|
||||
#include "net_skeleton.h"
|
||||
|
||||
#ifndef NS_MALLOC
|
||||
#define NS_MALLOC malloc
|
||||
#endif
|
||||
|
||||
#ifndef NS_REALLOC
|
||||
#define NS_REALLOC realloc
|
||||
#endif
|
||||
|
||||
#ifndef NS_FREE
|
||||
#define NS_FREE free
|
||||
#endif
|
||||
|
||||
#define NS_UDP_RECEIVE_BUFFER_SIZE 2000
|
||||
#define NS_VPRINTF_BUFFER_SIZE 500
|
||||
|
||||
struct ctl_msg {
|
||||
ns_callback_t callback;
|
||||
char message[1024 * 8];
|
||||
};
|
||||
|
||||
void iobuf_init(struct iobuf *iobuf, size_t size) {
|
||||
iobuf->len = iobuf->size = 0;
|
||||
iobuf->buf = NULL;
|
||||
|
||||
if (size > 0 && (iobuf->buf = (char *) NS_MALLOC(size)) != NULL) {
|
||||
iobuf->size = size;
|
||||
}
|
||||
}
|
||||
|
||||
void iobuf_free(struct iobuf *iobuf) {
|
||||
if (iobuf != NULL) {
|
||||
if (iobuf->buf != NULL) NS_FREE(iobuf->buf);
|
||||
iobuf_init(iobuf, 0);
|
||||
}
|
||||
}
|
||||
|
||||
size_t iobuf_append(struct iobuf *io, const void *buf, size_t len) {
|
||||
char *p = NULL;
|
||||
|
||||
assert(io != NULL);
|
||||
assert(io->len <= io->size);
|
||||
|
||||
if (len <= 0) {
|
||||
} else if (io->len + len <= io->size) {
|
||||
memcpy(io->buf + io->len, buf, len);
|
||||
io->len += len;
|
||||
} else if ((p = (char *) NS_REALLOC(io->buf, io->len + len)) != NULL) {
|
||||
io->buf = p;
|
||||
memcpy(io->buf + io->len, buf, len);
|
||||
io->len += len;
|
||||
io->size = io->len;
|
||||
} else {
|
||||
len = 0;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
void iobuf_remove(struct iobuf *io, size_t n) {
|
||||
if (n > 0 && n <= io->len) {
|
||||
memmove(io->buf, io->buf + n, io->len - n);
|
||||
io->len -= n;
|
||||
}
|
||||
}
|
||||
|
||||
static size_t ns_out(struct ns_connection *nc, const void *buf, size_t len) {
|
||||
if (nc->flags & NSF_UDP) {
|
||||
long n = send(nc->sock, buf, len, 0);
|
||||
DBG(("%p %d send %ld (%d)", nc, nc->sock, n, errno));
|
||||
return n < 0 ? 0 : n;
|
||||
} else {
|
||||
return iobuf_append(&nc->send_iobuf, buf, len);
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef NS_DISABLE_THREADS
|
||||
void *ns_start_thread(void *(*f)(void *), void *p) {
|
||||
#ifdef _WIN32
|
||||
return (void *) _beginthread((void (__cdecl *)(void *)) f, 0, p);
|
||||
#else
|
||||
pthread_t thread_id = (pthread_t) 0;
|
||||
pthread_attr_t attr;
|
||||
|
||||
(void) pthread_attr_init(&attr);
|
||||
(void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
||||
|
||||
#if defined(NS_STACK_SIZE) && NS_STACK_SIZE > 1
|
||||
(void) pthread_attr_setstacksize(&attr, NS_STACK_SIZE);
|
||||
#endif
|
||||
|
||||
pthread_create(&thread_id, &attr, f, p);
|
||||
pthread_attr_destroy(&attr);
|
||||
|
||||
return (void *) thread_id;
|
||||
#endif
|
||||
}
|
||||
#endif // NS_DISABLE_THREADS
|
||||
|
||||
static void ns_add_conn(struct ns_mgr *mgr, struct ns_connection *c) {
|
||||
c->next = mgr->active_connections;
|
||||
mgr->active_connections = c;
|
||||
c->prev = NULL;
|
||||
if (c->next != NULL) c->next->prev = c;
|
||||
}
|
||||
|
||||
static void ns_remove_conn(struct ns_connection *conn) {
|
||||
if (conn->prev == NULL) conn->mgr->active_connections = conn->next;
|
||||
if (conn->prev) conn->prev->next = conn->next;
|
||||
if (conn->next) conn->next->prev = conn->prev;
|
||||
}
|
||||
|
||||
// Print message to buffer. If buffer is large enough to hold the message,
|
||||
// return buffer. If buffer is to small, allocate large enough buffer on heap,
|
||||
// and return allocated buffer.
|
||||
int ns_avprintf(char **buf, size_t size, const char *fmt, va_list ap) {
|
||||
va_list ap_copy;
|
||||
int len;
|
||||
|
||||
va_copy(ap_copy, ap);
|
||||
len = vsnprintf(*buf, size, fmt, ap_copy);
|
||||
va_end(ap_copy);
|
||||
|
||||
if (len < 0) {
|
||||
// eCos and Windows are not standard-compliant and return -1 when
|
||||
// the buffer is too small. Keep allocating larger buffers until we
|
||||
// succeed or out of memory.
|
||||
*buf = NULL;
|
||||
while (len < 0) {
|
||||
if (*buf) free(*buf);
|
||||
size *= 2;
|
||||
if ((*buf = (char *) NS_MALLOC(size)) == NULL) break;
|
||||
va_copy(ap_copy, ap);
|
||||
len = vsnprintf(*buf, size, fmt, ap_copy);
|
||||
va_end(ap_copy);
|
||||
}
|
||||
} else if (len > (int) size) {
|
||||
// Standard-compliant code path. Allocate a buffer that is large enough.
|
||||
if ((*buf = (char *) NS_MALLOC(len + 1)) == NULL) {
|
||||
len = -1;
|
||||
} else {
|
||||
va_copy(ap_copy, ap);
|
||||
len = vsnprintf(*buf, len + 1, fmt, ap_copy);
|
||||
va_end(ap_copy);
|
||||
}
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int ns_vprintf(struct ns_connection *nc, const char *fmt, va_list ap) {
|
||||
char mem[NS_VPRINTF_BUFFER_SIZE], *buf = mem;
|
||||
int len;
|
||||
|
||||
if ((len = ns_avprintf(&buf, sizeof(mem), fmt, ap)) > 0) {
|
||||
ns_out(nc, buf, len);
|
||||
}
|
||||
if (buf != mem && buf != NULL) {
|
||||
free(buf);
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int ns_printf(struct ns_connection *conn, const char *fmt, ...) {
|
||||
int len;
|
||||
va_list ap;
|
||||
va_start(ap, fmt);
|
||||
len = ns_vprintf(conn, fmt, ap);
|
||||
va_end(ap);
|
||||
return len;
|
||||
}
|
||||
|
||||
static void hexdump(struct ns_connection *nc, const char *path,
|
||||
int num_bytes, enum ns_event ev) {
|
||||
const struct iobuf *io = ev == NS_SEND ? &nc->send_iobuf : &nc->recv_iobuf;
|
||||
FILE *fp;
|
||||
char *buf, src[60], dst[60];
|
||||
int buf_size = num_bytes * 5 + 100;
|
||||
|
||||
if ((fp = fopen(path, "a")) != NULL) {
|
||||
ns_sock_to_str(nc->sock, src, sizeof(src), 3);
|
||||
ns_sock_to_str(nc->sock, dst, sizeof(dst), 7);
|
||||
fprintf(fp, "%lu %p %s %s %s %d\n", (unsigned long) time(NULL),
|
||||
nc->connection_data, src,
|
||||
ev == NS_RECV ? "<-" : ev == NS_SEND ? "->" :
|
||||
ev == NS_ACCEPT ? "<A" : ev == NS_CONNECT ? "C>" : "XX",
|
||||
dst, num_bytes);
|
||||
if (num_bytes > 0 && (buf = (char *) NS_MALLOC(buf_size)) != NULL) {
|
||||
ns_hexdump(io->buf + (ev == NS_SEND ? 0 : io->len) -
|
||||
(ev == NS_SEND ? 0 : num_bytes), num_bytes, buf, buf_size);
|
||||
fprintf(fp, "%s", buf);
|
||||
free(buf);
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
}
|
||||
|
||||
static void ns_call(struct ns_connection *conn, enum ns_event ev, void *p) {
|
||||
if (conn->mgr->hexdump_file != NULL && ev != NS_POLL) {
|
||||
int len = (ev == NS_RECV || ev == NS_SEND) ? * (int *) p : 0;
|
||||
hexdump(conn, conn->mgr->hexdump_file, len, ev);
|
||||
}
|
||||
if (conn->mgr->callback) conn->mgr->callback(conn, ev, p);
|
||||
}
|
||||
|
||||
static void ns_destroy_conn(struct ns_connection *conn) {
|
||||
closesocket(conn->sock);
|
||||
iobuf_free(&conn->recv_iobuf);
|
||||
iobuf_free(&conn->send_iobuf);
|
||||
#ifdef NS_ENABLE_SSL
|
||||
if (conn->ssl != NULL) {
|
||||
SSL_free(conn->ssl);
|
||||
}
|
||||
if (conn->ssl_ctx != NULL) {
|
||||
SSL_CTX_free(conn->ssl_ctx);
|
||||
}
|
||||
#endif
|
||||
NS_FREE(conn);
|
||||
}
|
||||
|
||||
static void ns_close_conn(struct ns_connection *conn) {
|
||||
DBG(("%p %d", conn, conn->flags));
|
||||
ns_call(conn, NS_CLOSE, NULL);
|
||||
ns_remove_conn(conn);
|
||||
ns_destroy_conn(conn);
|
||||
}
|
||||
|
||||
void ns_set_close_on_exec(sock_t sock) {
|
||||
#ifdef _WIN32
|
||||
(void) SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0);
|
||||
#else
|
||||
fcntl(sock, F_SETFD, FD_CLOEXEC);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void ns_set_non_blocking_mode(sock_t sock) {
|
||||
#ifdef _WIN32
|
||||
unsigned long on = 1;
|
||||
ioctlsocket(sock, FIONBIO, &on);
|
||||
#else
|
||||
int flags = fcntl(sock, F_GETFL, 0);
|
||||
fcntl(sock, F_SETFL, flags | O_NONBLOCK);
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifndef NS_DISABLE_SOCKETPAIR
|
||||
int ns_socketpair2(sock_t sp[2], int sock_type) {
|
||||
union socket_address sa;
|
||||
sock_t sock;
|
||||
socklen_t len = sizeof(sa.sin);
|
||||
int ret = 0;
|
||||
|
||||
sp[0] = sp[1] = INVALID_SOCKET;
|
||||
|
||||
(void) memset(&sa, 0, sizeof(sa));
|
||||
sa.sin.sin_family = AF_INET;
|
||||
sa.sin.sin_port = htons(0);
|
||||
sa.sin.sin_addr.s_addr = htonl(0x7f000001);
|
||||
|
||||
if ((sock = socket(AF_INET, sock_type, 0)) != INVALID_SOCKET &&
|
||||
!bind(sock, &sa.sa, len) &&
|
||||
(sock_type == SOCK_DGRAM || !listen(sock, 1)) &&
|
||||
!getsockname(sock, &sa.sa, &len) &&
|
||||
(sp[0] = socket(AF_INET, sock_type, 0)) != INVALID_SOCKET &&
|
||||
!connect(sp[0], &sa.sa, len) &&
|
||||
(sock_type == SOCK_STREAM ||
|
||||
(!getsockname(sp[0], &sa.sa, &len) && !connect(sock, &sa.sa, len))) &&
|
||||
(sp[1] = (sock_type == SOCK_DGRAM ? sock :
|
||||
accept(sock, &sa.sa, &len))) != INVALID_SOCKET) {
|
||||
ns_set_close_on_exec(sp[0]);
|
||||
ns_set_close_on_exec(sp[1]);
|
||||
ret = 1;
|
||||
} else {
|
||||
if (sp[0] != INVALID_SOCKET) closesocket(sp[0]);
|
||||
if (sp[1] != INVALID_SOCKET) closesocket(sp[1]);
|
||||
sp[0] = sp[1] = INVALID_SOCKET;
|
||||
}
|
||||
if (sock_type != SOCK_DGRAM) closesocket(sock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ns_socketpair(sock_t sp[2]) {
|
||||
return ns_socketpair2(sp, SOCK_STREAM);
|
||||
}
|
||||
#endif // NS_DISABLE_SOCKETPAIR
|
||||
|
||||
// TODO(lsm): use non-blocking resolver
|
||||
static int ns_resolve2(const char *host, struct in_addr *ina) {
|
||||
struct hostent *he;
|
||||
if ((he = gethostbyname(host)) == NULL) {
|
||||
DBG(("gethostbyname(%s) failed: %s", host, strerror(errno)));
|
||||
} else {
|
||||
memcpy(ina, he->h_addr_list[0], sizeof(*ina));
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Resolve FDQN "host", store IP address in the "ip".
|
||||
// Return > 0 (IP address length) on success.
|
||||
int ns_resolve(const char *host, char *buf, size_t n) {
|
||||
struct in_addr ad;
|
||||
return ns_resolve2(host, &ad) ? snprintf(buf, n, "%s", inet_ntoa(ad)) : 0;
|
||||
}
|
||||
|
||||
// Address format: [PROTO://][IP_ADDRESS:]PORT[:CERT][:CA_CERT]
|
||||
static int ns_parse_address(const char *str, union socket_address *sa,
|
||||
int *proto, int *use_ssl, char *cert, char *ca) {
|
||||
unsigned int a, b, c, d, port;
|
||||
int n = 0, len = 0;
|
||||
char host[200];
|
||||
#ifdef NS_ENABLE_IPV6
|
||||
char buf[100];
|
||||
#endif
|
||||
|
||||
// MacOS needs that. If we do not zero it, subsequent bind() will fail.
|
||||
// Also, all-zeroes in the socket address means binding to all addresses
|
||||
// for both IPv4 and IPv6 (INADDR_ANY and IN6ADDR_ANY_INIT).
|
||||
memset(sa, 0, sizeof(*sa));
|
||||
sa->sin.sin_family = AF_INET;
|
||||
|
||||
*proto = SOCK_STREAM;
|
||||
*use_ssl = 0;
|
||||
cert[0] = ca[0] = '\0';
|
||||
|
||||
if (memcmp(str, "ssl://", 6) == 0) {
|
||||
str += 6;
|
||||
*use_ssl = 1;
|
||||
} else if (memcmp(str, "udp://", 6) == 0) {
|
||||
str += 6;
|
||||
*proto = SOCK_DGRAM;
|
||||
} else if (memcmp(str, "tcp://", 6) == 0) {
|
||||
str += 6;
|
||||
}
|
||||
|
||||
if (sscanf(str, "%u.%u.%u.%u:%u%n", &a, &b, &c, &d, &port, &len) == 5) {
|
||||
// Bind to a specific IPv4 address, e.g. 192.168.1.5:8080
|
||||
sa->sin.sin_addr.s_addr = htonl((a << 24) | (b << 16) | (c << 8) | d);
|
||||
sa->sin.sin_port = htons((uint16_t) port);
|
||||
#ifdef NS_ENABLE_IPV6
|
||||
} else if (sscanf(str, "[%99[^]]]:%u%n", buf, &port, &len) == 2 &&
|
||||
inet_pton(AF_INET6, buf, &sa->sin6.sin6_addr)) {
|
||||
// IPv6 address, e.g. [3ffe:2a00:100:7031::1]:8080
|
||||
sa->sin6.sin6_family = AF_INET6;
|
||||
sa->sin6.sin6_port = htons((uint16_t) port);
|
||||
#endif
|
||||
} else if (sscanf(str, "%199[^ :]:%u%n", host, &port, &len) == 2) {
|
||||
sa->sin.sin_port = htons((uint16_t) port);
|
||||
ns_resolve2(host, &sa->sin.sin_addr);
|
||||
} else if (sscanf(str, "%u%n", &port, &len) == 1) {
|
||||
// If only port is specified, bind to IPv4, INADDR_ANY
|
||||
sa->sin.sin_port = htons((uint16_t) port);
|
||||
}
|
||||
|
||||
if (*use_ssl && (sscanf(str + len, ":%99[^:]:%99[^:]%n", cert, ca, &n) == 2 ||
|
||||
sscanf(str + len, ":%99[^:]%n", cert, &n) == 1)) {
|
||||
len += n;
|
||||
}
|
||||
|
||||
return port < 0xffff && str[len] == '\0' ? len : 0;
|
||||
}
|
||||
|
||||
// 'sa' must be an initialized address to bind to
|
||||
static sock_t ns_open_listening_socket(union socket_address *sa, int proto) {
|
||||
socklen_t sa_len = (sa->sa.sa_family == AF_INET) ?
|
||||
sizeof(sa->sin) : sizeof(sa->sin6);
|
||||
sock_t sock = INVALID_SOCKET;
|
||||
#ifndef _WIN32
|
||||
int on = 1;
|
||||
#endif
|
||||
|
||||
if ((sock = socket(sa->sa.sa_family, proto, 0)) != INVALID_SOCKET &&
|
||||
#ifndef _WIN32
|
||||
// SO_RESUSEADDR is not enabled on Windows because the semantics of
|
||||
// SO_REUSEADDR on UNIX and Windows is different. On Windows,
|
||||
// SO_REUSEADDR allows to bind a socket to a port without error even if
|
||||
// the port is already open by another program. This is not the behavior
|
||||
// SO_REUSEADDR was designed for, and leads to hard-to-track failure
|
||||
// scenarios. Therefore, SO_REUSEADDR was disabled on Windows.
|
||||
!setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *) &on, sizeof(on)) &&
|
||||
#endif
|
||||
!bind(sock, &sa->sa, sa_len) &&
|
||||
(proto == SOCK_DGRAM || listen(sock, SOMAXCONN) == 0)) {
|
||||
ns_set_non_blocking_mode(sock);
|
||||
// In case port was set to 0, get the real port number
|
||||
(void) getsockname(sock, &sa->sa, &sa_len);
|
||||
} else if (sock != INVALID_SOCKET) {
|
||||
closesocket(sock);
|
||||
sock = INVALID_SOCKET;
|
||||
}
|
||||
|
||||
return sock;
|
||||
}
|
||||
|
||||
#ifdef NS_ENABLE_SSL
|
||||
// Certificate generation script is at
|
||||
// https://github.com/cesanta/net_skeleton/blob/master/scripts/gen_certs.sh
|
||||
|
||||
static int ns_use_ca_cert(SSL_CTX *ctx, const char *cert) {
|
||||
if (ctx == NULL) {
|
||||
return -1;
|
||||
} else if (cert == NULL || cert[0] == '\0') {
|
||||
return 0;
|
||||
}
|
||||
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0);
|
||||
return SSL_CTX_load_verify_locations(ctx, cert, NULL) == 1 ? 0 : -2;
|
||||
}
|
||||
|
||||
static int ns_use_cert(SSL_CTX *ctx, const char *pem_file) {
|
||||
if (ctx == NULL) {
|
||||
return -1;
|
||||
} else if (pem_file == NULL || pem_file[0] == '\0') {
|
||||
return 0;
|
||||
} else if (SSL_CTX_use_certificate_file(ctx, pem_file, 1) == 0 ||
|
||||
SSL_CTX_use_PrivateKey_file(ctx, pem_file, 1) == 0) {
|
||||
return -2;
|
||||
} else {
|
||||
SSL_CTX_set_mode(ctx, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
|
||||
SSL_CTX_use_certificate_chain_file(ctx, pem_file);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
#endif // NS_ENABLE_SSL
|
||||
|
||||
struct ns_connection *ns_bind(struct ns_mgr *srv, const char *str, void *data) {
|
||||
union socket_address sa;
|
||||
struct ns_connection *nc = NULL;
|
||||
int use_ssl, proto;
|
||||
char cert[100], ca_cert[100];
|
||||
sock_t sock;
|
||||
|
||||
ns_parse_address(str, &sa, &proto, &use_ssl, cert, ca_cert);
|
||||
if (use_ssl && cert[0] == '\0') return NULL;
|
||||
|
||||
if ((sock = ns_open_listening_socket(&sa, proto)) == INVALID_SOCKET) {
|
||||
} else if ((nc = ns_add_sock(srv, sock, NULL)) == NULL) {
|
||||
closesocket(sock);
|
||||
} else {
|
||||
nc->sa = sa;
|
||||
nc->flags |= NSF_LISTENING;
|
||||
nc->connection_data = data;
|
||||
|
||||
if (proto == SOCK_DGRAM) {
|
||||
nc->flags |= NSF_UDP;
|
||||
}
|
||||
|
||||
#ifdef NS_ENABLE_SSL
|
||||
if (use_ssl) {
|
||||
nc->ssl_ctx = SSL_CTX_new(SSLv23_server_method());
|
||||
if (ns_use_cert(nc->ssl_ctx, cert) != 0 ||
|
||||
ns_use_ca_cert(nc->ssl_ctx, ca_cert) != 0) {
|
||||
ns_close_conn(nc);
|
||||
nc = NULL;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
DBG(("%p sock %d/%d ssl %p %p", nc, sock, proto, nc->ssl_ctx, nc->ssl));
|
||||
}
|
||||
|
||||
return nc;
|
||||
}
|
||||
|
||||
static struct ns_connection *accept_conn(struct ns_connection *ls) {
|
||||
struct ns_connection *c = NULL;
|
||||
union socket_address sa;
|
||||
socklen_t len = sizeof(sa);
|
||||
sock_t sock = INVALID_SOCKET;
|
||||
|
||||
// NOTE(lsm): on Windows, sock is always > FD_SETSIZE
|
||||
if ((sock = accept(ls->sock, &sa.sa, &len)) == INVALID_SOCKET) {
|
||||
} else if ((c = ns_add_sock(ls->mgr, sock, NULL)) == NULL) {
|
||||
closesocket(sock);
|
||||
#ifdef NS_ENABLE_SSL
|
||||
} else if (ls->ssl_ctx != NULL &&
|
||||
((c->ssl = SSL_new(ls->ssl_ctx)) == NULL ||
|
||||
SSL_set_fd(c->ssl, sock) != 1)) {
|
||||
DBG(("SSL error"));
|
||||
ns_close_conn(c);
|
||||
c = NULL;
|
||||
#endif
|
||||
} else {
|
||||
c->listener = ls;
|
||||
ns_call(c, NS_ACCEPT, &sa);
|
||||
DBG(("%p %d %p %p", c, c->sock, c->ssl_ctx, c->ssl));
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
static int ns_is_error(int n) {
|
||||
return n == 0 ||
|
||||
(n < 0 && errno != EINTR && errno != EINPROGRESS &&
|
||||
errno != EAGAIN && errno != EWOULDBLOCK
|
||||
#ifdef _WIN32
|
||||
&& WSAGetLastError() != WSAEINTR && WSAGetLastError() != WSAEWOULDBLOCK
|
||||
#endif
|
||||
);
|
||||
}
|
||||
|
||||
void ns_sock_to_str(sock_t sock, char *buf, size_t len, int flags) {
|
||||
union socket_address sa;
|
||||
socklen_t slen = sizeof(sa);
|
||||
|
||||
if (buf != NULL && len > 0) {
|
||||
buf[0] = '\0';
|
||||
memset(&sa, 0, sizeof(sa));
|
||||
if (flags & 4) {
|
||||
getpeername(sock, &sa.sa, &slen);
|
||||
} else {
|
||||
getsockname(sock, &sa.sa, &slen);
|
||||
}
|
||||
if (flags & 1) {
|
||||
#if defined(NS_ENABLE_IPV6)
|
||||
inet_ntop(sa.sa.sa_family, sa.sa.sa_family == AF_INET ?
|
||||
(void *) &sa.sin.sin_addr :
|
||||
(void *) &sa.sin6.sin6_addr, buf, len);
|
||||
#elif defined(_WIN32)
|
||||
// Only Windoze Vista (and newer) have inet_ntop()
|
||||
strncpy(buf, inet_ntoa(sa.sin.sin_addr), len);
|
||||
#else
|
||||
inet_ntop(sa.sa.sa_family, (void *) &sa.sin.sin_addr, buf,(socklen_t)len);
|
||||
#endif
|
||||
}
|
||||
if (flags & 2) {
|
||||
snprintf(buf + strlen(buf), len - (strlen(buf) + 1), "%s%d",
|
||||
flags & 1 ? ":" : "", (int) ntohs(sa.sin.sin_port));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int ns_hexdump(const void *buf, int len, char *dst, int dst_len) {
|
||||
const unsigned char *p = (const unsigned char *) buf;
|
||||
char ascii[17] = "";
|
||||
int i, idx, n = 0;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
idx = i % 16;
|
||||
if (idx == 0) {
|
||||
if (i > 0) n += snprintf(dst + n, dst_len - n, " %s\n", ascii);
|
||||
n += snprintf(dst + n, dst_len - n, "%04x ", i);
|
||||
}
|
||||
n += snprintf(dst + n, dst_len - n, " %02x", p[i]);
|
||||
ascii[idx] = p[i] < 0x20 || p[i] > 0x7e ? '.' : p[i];
|
||||
ascii[idx + 1] = '\0';
|
||||
}
|
||||
|
||||
while (i++ % 16) n += snprintf(dst + n, dst_len - n, "%s", " ");
|
||||
n += snprintf(dst + n, dst_len - n, " %s\n\n", ascii);
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
#ifdef NS_ENABLE_SSL
|
||||
static int ns_ssl_err(struct ns_connection *conn, int res) {
|
||||
int ssl_err = SSL_get_error(conn->ssl, res);
|
||||
if (ssl_err == SSL_ERROR_WANT_READ) conn->flags |= NSF_WANT_READ;
|
||||
if (ssl_err == SSL_ERROR_WANT_WRITE) conn->flags |= NSF_WANT_WRITE;
|
||||
return ssl_err;
|
||||
}
|
||||
#endif
|
||||
|
||||
static void ns_read_from_socket(struct ns_connection *conn) {
|
||||
char buf[2048];
|
||||
int n = 0;
|
||||
|
||||
if (conn->flags & NSF_CONNECTING) {
|
||||
int ok = 1, ret;
|
||||
socklen_t len = sizeof(ok);
|
||||
|
||||
ret = getsockopt(conn->sock, SOL_SOCKET, SO_ERROR, (char *) &ok, &len);
|
||||
(void) ret;
|
||||
#ifdef NS_ENABLE_SSL
|
||||
if (ret == 0 && ok == 0 && conn->ssl != NULL) {
|
||||
int res = SSL_connect(conn->ssl);
|
||||
int ssl_err = ns_ssl_err(conn, res);
|
||||
if (res == 1) {
|
||||
conn->flags |= NSF_SSL_HANDSHAKE_DONE;
|
||||
} else if (ssl_err == SSL_ERROR_WANT_READ ||
|
||||
ssl_err == SSL_ERROR_WANT_WRITE) {
|
||||
return; // Call us again
|
||||
} else {
|
||||
ok = 1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
conn->flags &= ~NSF_CONNECTING;
|
||||
DBG(("%p ok=%d", conn, ok));
|
||||
if (ok != 0) {
|
||||
conn->flags |= NSF_CLOSE_IMMEDIATELY;
|
||||
}
|
||||
ns_call(conn, NS_CONNECT, &ok);
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef NS_ENABLE_SSL
|
||||
if (conn->ssl != NULL) {
|
||||
if (conn->flags & NSF_SSL_HANDSHAKE_DONE) {
|
||||
// SSL library may have more bytes ready to read then we ask to read.
|
||||
// Therefore, read in a loop until we read everything. Without the loop,
|
||||
// we skip to the next select() cycle which can just timeout.
|
||||
while ((n = SSL_read(conn->ssl, buf, sizeof(buf))) > 0) {
|
||||
DBG(("%p %d <- %d bytes (SSL)", conn, conn->flags, n));
|
||||
iobuf_append(&conn->recv_iobuf, buf, n);
|
||||
ns_call(conn, NS_RECV, &n);
|
||||
}
|
||||
ns_ssl_err(conn, n);
|
||||
} else {
|
||||
int res = SSL_accept(conn->ssl);
|
||||
int ssl_err = ns_ssl_err(conn, res);
|
||||
if (res == 1) {
|
||||
conn->flags |= NSF_SSL_HANDSHAKE_DONE;
|
||||
} else if (ssl_err == SSL_ERROR_WANT_READ ||
|
||||
ssl_err == SSL_ERROR_WANT_WRITE) {
|
||||
return; // Call us again
|
||||
} else {
|
||||
conn->flags |= NSF_CLOSE_IMMEDIATELY;
|
||||
}
|
||||
return;
|
||||
}
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
while ((n = (int) recv(conn->sock, buf, sizeof(buf), 0)) > 0) {
|
||||
DBG(("%p %d <- %d bytes (PLAIN)", conn, conn->flags, n));
|
||||
iobuf_append(&conn->recv_iobuf, buf, n);
|
||||
ns_call(conn, NS_RECV, &n);
|
||||
}
|
||||
}
|
||||
|
||||
if (ns_is_error(n)) {
|
||||
conn->flags |= NSF_CLOSE_IMMEDIATELY;
|
||||
}
|
||||
}
|
||||
|
||||
static void ns_write_to_socket(struct ns_connection *conn) {
|
||||
struct iobuf *io = &conn->send_iobuf;
|
||||
int n = 0;
|
||||
|
||||
#ifdef NS_ENABLE_SSL
|
||||
if (conn->ssl != NULL) {
|
||||
n = SSL_write(conn->ssl, io->buf, io->len);
|
||||
if (n <= 0) {
|
||||
int ssl_err = ns_ssl_err(conn, n);
|
||||
if (ssl_err == SSL_ERROR_WANT_READ || ssl_err == SSL_ERROR_WANT_WRITE) {
|
||||
return; // Call us again
|
||||
} else {
|
||||
conn->flags |= NSF_CLOSE_IMMEDIATELY;
|
||||
}
|
||||
}
|
||||
} else
|
||||
#endif
|
||||
{ n = (int) send(conn->sock, io->buf, io->len, 0); }
|
||||
|
||||
DBG(("%p %d -> %d bytes", conn, conn->flags, n));
|
||||
|
||||
ns_call(conn, NS_SEND, &n);
|
||||
if (ns_is_error(n)) {
|
||||
conn->flags |= NSF_CLOSE_IMMEDIATELY;
|
||||
} else if (n > 0) {
|
||||
iobuf_remove(io, n);
|
||||
}
|
||||
}
|
||||
|
||||
int ns_send(struct ns_connection *conn, const void *buf, int len) {
|
||||
return (int) ns_out(conn, buf, len);
|
||||
}
|
||||
|
||||
static void ns_handle_udp(struct ns_connection *ls) {
|
||||
struct ns_connection nc;
|
||||
char buf[NS_UDP_RECEIVE_BUFFER_SIZE];
|
||||
int n;
|
||||
socklen_t s_len = sizeof(nc.sa);
|
||||
|
||||
memset(&nc, 0, sizeof(nc));
|
||||
n = recvfrom(ls->sock, buf, sizeof(buf), 0, &nc.sa.sa, &s_len);
|
||||
if (n <= 0) {
|
||||
DBG(("%p recvfrom: %s", ls, strerror(errno)));
|
||||
} else {
|
||||
nc.recv_iobuf.buf = buf;
|
||||
nc.recv_iobuf.len = nc.recv_iobuf.size = n;
|
||||
nc.sock = ls->sock;
|
||||
nc.mgr = ls->mgr;
|
||||
DBG(("%p %d bytes received", ls, n));
|
||||
ns_call(&nc, NS_RECV, &n);
|
||||
}
|
||||
}
|
||||
|
||||
static void ns_add_to_set(sock_t sock, fd_set *set, sock_t *max_fd) {
|
||||
if (sock != INVALID_SOCKET) {
|
||||
FD_SET(sock, set);
|
||||
if (*max_fd == INVALID_SOCKET || sock > *max_fd) {
|
||||
*max_fd = sock;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int ns_mgr_poll(struct ns_mgr *mgr, int milli) {
|
||||
struct ns_connection *conn, *tmp_conn;
|
||||
struct timeval tv;
|
||||
fd_set read_set, write_set;
|
||||
int num_active_connections = 0;
|
||||
sock_t max_fd = INVALID_SOCKET;
|
||||
time_t current_time = time(NULL);
|
||||
|
||||
FD_ZERO(&read_set);
|
||||
FD_ZERO(&write_set);
|
||||
ns_add_to_set(mgr->ctl[1], &read_set, &max_fd);
|
||||
|
||||
for (conn = mgr->active_connections; conn != NULL; conn = tmp_conn) {
|
||||
tmp_conn = conn->next;
|
||||
ns_call(conn, NS_POLL, ¤t_time);
|
||||
if (!(conn->flags & NSF_WANT_WRITE)) {
|
||||
//DBG(("%p read_set", conn));
|
||||
ns_add_to_set(conn->sock, &read_set, &max_fd);
|
||||
}
|
||||
if (((conn->flags & NSF_CONNECTING) && !(conn->flags & NSF_WANT_READ)) ||
|
||||
(conn->send_iobuf.len > 0 && !(conn->flags & NSF_CONNECTING) &&
|
||||
!(conn->flags & NSF_BUFFER_BUT_DONT_SEND))) {
|
||||
//DBG(("%p write_set", conn));
|
||||
ns_add_to_set(conn->sock, &write_set, &max_fd);
|
||||
}
|
||||
if (conn->flags & NSF_CLOSE_IMMEDIATELY) {
|
||||
ns_close_conn(conn);
|
||||
}
|
||||
}
|
||||
|
||||
tv.tv_sec = milli / 1000;
|
||||
tv.tv_usec = (milli % 1000) * 1000;
|
||||
|
||||
if (select((int) max_fd + 1, &read_set, &write_set, NULL, &tv) > 0) {
|
||||
// select() might have been waiting for a long time, reset current_time
|
||||
// now to prevent last_io_time being set to the past.
|
||||
current_time = time(NULL);
|
||||
|
||||
// Read wakeup messages
|
||||
if (mgr->ctl[1] != INVALID_SOCKET &&
|
||||
FD_ISSET(mgr->ctl[1], &read_set)) {
|
||||
struct ctl_msg ctl_msg;
|
||||
int len = (int) recv(mgr->ctl[1], (char *) &ctl_msg, sizeof(ctl_msg), 0);
|
||||
send(mgr->ctl[1], ctl_msg.message, 1, 0);
|
||||
if (len >= (int) sizeof(ctl_msg.callback) && ctl_msg.callback != NULL) {
|
||||
struct ns_connection *c;
|
||||
for (c = ns_next(mgr, NULL); c != NULL; c = ns_next(mgr, c)) {
|
||||
ctl_msg.callback(c, NS_POLL, ctl_msg.message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (conn = mgr->active_connections; conn != NULL; conn = tmp_conn) {
|
||||
tmp_conn = conn->next;
|
||||
if (FD_ISSET(conn->sock, &read_set)) {
|
||||
if (conn->flags & NSF_LISTENING) {
|
||||
if (conn->flags & NSF_UDP) {
|
||||
ns_handle_udp(conn);
|
||||
} else {
|
||||
// We're not looping here, and accepting just one connection at
|
||||
// a time. The reason is that eCos does not respect non-blocking
|
||||
// flag on a listening socket and hangs in a loop.
|
||||
accept_conn(conn);
|
||||
}
|
||||
} else {
|
||||
conn->last_io_time = current_time;
|
||||
ns_read_from_socket(conn);
|
||||
}
|
||||
}
|
||||
|
||||
if (FD_ISSET(conn->sock, &write_set)) {
|
||||
if (conn->flags & NSF_CONNECTING) {
|
||||
ns_read_from_socket(conn);
|
||||
} else if (!(conn->flags & NSF_BUFFER_BUT_DONT_SEND)) {
|
||||
conn->last_io_time = current_time;
|
||||
ns_write_to_socket(conn);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (conn = mgr->active_connections; conn != NULL; conn = tmp_conn) {
|
||||
tmp_conn = conn->next;
|
||||
num_active_connections++;
|
||||
if ((conn->flags & NSF_CLOSE_IMMEDIATELY) ||
|
||||
(conn->send_iobuf.len == 0 &&
|
||||
(conn->flags & NSF_FINISHED_SENDING_DATA))) {
|
||||
ns_close_conn(conn);
|
||||
}
|
||||
}
|
||||
//DBG(("%d active connections", num_active_connections));
|
||||
|
||||
return num_active_connections;
|
||||
}
|
||||
|
||||
struct ns_connection *ns_connect(struct ns_mgr *mgr,
|
||||
const char *address, void *param) {
|
||||
sock_t sock = INVALID_SOCKET;
|
||||
struct ns_connection *nc = NULL;
|
||||
union socket_address sa;
|
||||
char cert[100], ca_cert[100];
|
||||
int connect_ret_val, use_ssl, proto;
|
||||
|
||||
ns_parse_address(address, &sa, &proto, &use_ssl, cert, ca_cert);
|
||||
if ((sock = socket(AF_INET, proto, 0)) == INVALID_SOCKET) {
|
||||
return NULL;
|
||||
}
|
||||
ns_set_non_blocking_mode(sock);
|
||||
connect_ret_val = connect(sock, &sa.sa, sizeof(sa.sin));
|
||||
|
||||
if (connect_ret_val != 0 && ns_is_error(connect_ret_val)) {
|
||||
closesocket(sock);
|
||||
return NULL;
|
||||
} else if ((nc = ns_add_sock(mgr, sock, param)) == NULL) {
|
||||
closesocket(sock);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
nc->sa = sa; // Essential, cause UDP conns will use sendto()
|
||||
if (proto == SOCK_DGRAM) {
|
||||
nc->flags = NSF_UDP;
|
||||
} else {
|
||||
nc->flags = NSF_CONNECTING;
|
||||
}
|
||||
|
||||
#ifdef NS_ENABLE_SSL
|
||||
if (use_ssl) {
|
||||
if ((nc->ssl_ctx = SSL_CTX_new(SSLv23_client_method())) == NULL ||
|
||||
ns_use_cert(nc->ssl_ctx, cert) != 0 ||
|
||||
ns_use_ca_cert(nc->ssl_ctx, ca_cert) != 0 ||
|
||||
(nc->ssl = SSL_new(nc->ssl_ctx)) == NULL) {
|
||||
ns_close_conn(nc);
|
||||
return NULL;
|
||||
} else {
|
||||
SSL_set_fd(nc->ssl, sock);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return nc;
|
||||
}
|
||||
|
||||
struct ns_connection *ns_add_sock(struct ns_mgr *s, sock_t sock, void *p) {
|
||||
struct ns_connection *conn;
|
||||
if ((conn = (struct ns_connection *) NS_MALLOC(sizeof(*conn))) != NULL) {
|
||||
memset(conn, 0, sizeof(*conn));
|
||||
ns_set_non_blocking_mode(sock);
|
||||
ns_set_close_on_exec(sock);
|
||||
conn->sock = sock;
|
||||
conn->connection_data = p;
|
||||
conn->mgr = s;
|
||||
conn->last_io_time = time(NULL);
|
||||
ns_add_conn(s, conn);
|
||||
DBG(("%p %d", conn, sock));
|
||||
}
|
||||
return conn;
|
||||
}
|
||||
|
||||
struct ns_connection *ns_next(struct ns_mgr *s, struct ns_connection *conn) {
|
||||
return conn == NULL ? s->active_connections : conn->next;
|
||||
}
|
||||
|
||||
void ns_broadcast(struct ns_mgr *mgr, ns_callback_t cb,void *data, size_t len) {
|
||||
struct ctl_msg ctl_msg;
|
||||
if (mgr->ctl[0] != INVALID_SOCKET && data != NULL &&
|
||||
len < sizeof(ctl_msg.message)) {
|
||||
ctl_msg.callback = cb;
|
||||
memcpy(ctl_msg.message, data, len);
|
||||
send(mgr->ctl[0], (char *) &ctl_msg,
|
||||
offsetof(struct ctl_msg, message) + len, 0);
|
||||
recv(mgr->ctl[0], (char *) &len, 1, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void ns_mgr_init(struct ns_mgr *s, void *user_data, ns_callback_t cb) {
|
||||
memset(s, 0, sizeof(*s));
|
||||
s->ctl[0] = s->ctl[1] = INVALID_SOCKET;
|
||||
s->user_data = user_data;
|
||||
s->callback = cb;
|
||||
|
||||
#ifdef _WIN32
|
||||
{ WSADATA data; WSAStartup(MAKEWORD(2, 2), &data); }
|
||||
#else
|
||||
// Ignore SIGPIPE signal, so if client cancels the request, it
|
||||
// won't kill the whole process.
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
#endif
|
||||
|
||||
#ifndef NS_DISABLE_SOCKETPAIR
|
||||
do {
|
||||
ns_socketpair2(s->ctl, SOCK_DGRAM);
|
||||
} while (s->ctl[0] == INVALID_SOCKET);
|
||||
#endif
|
||||
|
||||
#ifdef NS_ENABLE_SSL
|
||||
{static int init_done; if (!init_done) { SSL_library_init(); init_done++; }}
|
||||
#endif
|
||||
}
|
||||
|
||||
void ns_mgr_free(struct ns_mgr *s) {
|
||||
struct ns_connection *conn, *tmp_conn;
|
||||
|
||||
DBG(("%p", s));
|
||||
if (s == NULL) return;
|
||||
// Do one last poll, see https://github.com/cesanta/mongoose/issues/286
|
||||
ns_mgr_poll(s, 0);
|
||||
|
||||
if (s->ctl[0] != INVALID_SOCKET) closesocket(s->ctl[0]);
|
||||
if (s->ctl[1] != INVALID_SOCKET) closesocket(s->ctl[1]);
|
||||
s->ctl[0] = s->ctl[1] = INVALID_SOCKET;
|
||||
|
||||
for (conn = s->active_connections; conn != NULL; conn = tmp_conn) {
|
||||
tmp_conn = conn->next;
|
||||
ns_close_conn(conn);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,239 @@
|
||||
// Copyright (c) 2014 Cesanta Software Limited
|
||||
// All rights reserved
|
||||
//
|
||||
// This software is dual-licensed: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License version 2 as
|
||||
// published by the Free Software Foundation. For the terms of this
|
||||
// license, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
// You are free to use this software under the terms of the GNU General
|
||||
// Public License, but WITHOUT ANY WARRANTY; without even the implied
|
||||
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// Alternatively, you can license this software under a commercial
|
||||
// license, as set out in <http://cesanta.com/>.
|
||||
//
|
||||
// $Date: 2014-09-09 17:09:33 UTC $
|
||||
|
||||
#ifndef NS_SKELETON_HEADER_INCLUDED
|
||||
#define NS_SKELETON_HEADER_INCLUDED
|
||||
|
||||
#define NS_SKELETON_VERSION "2.0.0"
|
||||
|
||||
#undef UNICODE // Use ANSI WinAPI functions
|
||||
#undef _UNICODE // Use multibyte encoding on Windows
|
||||
#define _MBCS // Use multibyte encoding on Windows
|
||||
#define _INTEGRAL_MAX_BITS 64 // Enable _stati64() on Windows
|
||||
#define _CRT_SECURE_NO_WARNINGS // Disable deprecation warning in VS2005+
|
||||
#undef WIN32_LEAN_AND_MEAN // Let windows.h always include winsock2.h
|
||||
#define _XOPEN_SOURCE 600 // For flockfile() on Linux
|
||||
#define __STDC_FORMAT_MACROS // <inttypes.h> wants this for C++
|
||||
#define __STDC_LIMIT_MACROS // C++ wants that for INT64_MAX
|
||||
#ifndef _LARGEFILE_SOURCE
|
||||
#define _LARGEFILE_SOURCE // Enable fseeko() and ftello() functions
|
||||
#endif
|
||||
#define _FILE_OFFSET_BITS 64 // Enable 64-bit file offsets
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning (disable : 4127) // FD_SET() emits warning, disable it
|
||||
#pragma warning (disable : 4204) // missing c99 support
|
||||
#endif
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdarg.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <signal.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
#ifdef _MSC_VER
|
||||
#pragma comment(lib, "ws2_32.lib") // Linking with winsock library
|
||||
#endif
|
||||
#include <windows.h>
|
||||
#include <process.h>
|
||||
#ifndef EINPROGRESS
|
||||
#define EINPROGRESS WSAEINPROGRESS
|
||||
#endif
|
||||
#ifndef EWOULDBLOCK
|
||||
#define EWOULDBLOCK WSAEWOULDBLOCK
|
||||
#endif
|
||||
#ifndef __func__
|
||||
#define STRX(x) #x
|
||||
#define STR(x) STRX(x)
|
||||
#define __func__ __FILE__ ":" STR(__LINE__)
|
||||
#endif
|
||||
#ifndef va_copy
|
||||
#define va_copy(x,y) x = y
|
||||
#endif // MINGW #defines va_copy
|
||||
#define snprintf _snprintf
|
||||
#define vsnprintf _vsnprintf
|
||||
#define sleep(x) Sleep((x) * 1000)
|
||||
#define to64(x) _atoi64(x)
|
||||
typedef int socklen_t;
|
||||
typedef unsigned char uint8_t;
|
||||
typedef unsigned int uint32_t;
|
||||
typedef unsigned short uint16_t;
|
||||
typedef unsigned __int64 uint64_t;
|
||||
typedef __int64 int64_t;
|
||||
typedef SOCKET sock_t;
|
||||
#ifndef S_ISDIR
|
||||
#define S_ISDIR(x) ((x) & _S_IFDIR)
|
||||
#endif
|
||||
#else
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <netdb.h>
|
||||
#include <pthread.h>
|
||||
#include <stdarg.h>
|
||||
#include <unistd.h>
|
||||
#include <arpa/inet.h> // For inet_pton() when NS_ENABLE_IPV6 is defined
|
||||
#include <netinet/in.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/select.h>
|
||||
#define closesocket(x) close(x)
|
||||
#define __cdecl
|
||||
#define INVALID_SOCKET (-1)
|
||||
#define to64(x) strtoll(x, NULL, 10)
|
||||
typedef int sock_t;
|
||||
#endif
|
||||
|
||||
#ifdef NS_ENABLE_DEBUG
|
||||
#define DBG(x) do { printf("%-20s ", __func__); printf x; putchar('\n'); \
|
||||
fflush(stdout); } while(0)
|
||||
#else
|
||||
#define DBG(x)
|
||||
#endif
|
||||
|
||||
#ifndef ARRAY_SIZE
|
||||
#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
|
||||
#endif
|
||||
|
||||
#ifdef NS_ENABLE_SSL
|
||||
#ifdef __APPLE__
|
||||
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
||||
#endif
|
||||
#include <openssl/ssl.h>
|
||||
#else
|
||||
typedef void *SSL;
|
||||
typedef void *SSL_CTX;
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif // __cplusplus
|
||||
|
||||
union socket_address {
|
||||
struct sockaddr sa;
|
||||
struct sockaddr_in sin;
|
||||
#ifdef NS_ENABLE_IPV6
|
||||
struct sockaddr_in6 sin6;
|
||||
#else
|
||||
struct sockaddr sin6;
|
||||
#endif
|
||||
};
|
||||
|
||||
// IO buffers interface
|
||||
struct iobuf {
|
||||
char *buf;
|
||||
size_t len;
|
||||
size_t size;
|
||||
};
|
||||
|
||||
void iobuf_init(struct iobuf *, size_t initial_size);
|
||||
void iobuf_free(struct iobuf *);
|
||||
size_t iobuf_append(struct iobuf *, const void *data, size_t data_size);
|
||||
void iobuf_remove(struct iobuf *, size_t data_size);
|
||||
|
||||
// Net skeleton interface
|
||||
// Events. Meaning of event parameter (evp) is given in the comment.
|
||||
enum ns_event {
|
||||
NS_POLL, // Sent to each connection on each call to ns_mgr_poll()
|
||||
NS_ACCEPT, // New connection accept()-ed. union socket_address *remote_addr
|
||||
NS_CONNECT, // connect() succeeded or failed. int *success_status
|
||||
NS_RECV, // Data has benn received. int *num_bytes
|
||||
NS_SEND, // Data has been written to a socket. int *num_bytes
|
||||
NS_CLOSE // Connection is closed. NULL
|
||||
};
|
||||
|
||||
// Callback function (event handler) prototype, must be defined by user.
|
||||
// Net skeleton will call event handler, passing events defined above.
|
||||
struct ns_connection;
|
||||
typedef void (*ns_callback_t)(struct ns_connection *, enum ns_event, void *evp);
|
||||
|
||||
struct ns_mgr {
|
||||
struct ns_connection *active_connections;
|
||||
ns_callback_t callback; // Event handler function
|
||||
const char *hexdump_file; // Debug hexdump file path
|
||||
sock_t ctl[2]; // Socketpair for mg_wakeup()
|
||||
void *user_data; // User data
|
||||
};
|
||||
|
||||
struct ns_connection {
|
||||
struct ns_connection *next, *prev; // ns_mgr::active_connections linkage
|
||||
struct ns_connection *listener; // Set only for accept()-ed connections
|
||||
struct ns_mgr *mgr;
|
||||
sock_t sock;
|
||||
union socket_address sa;
|
||||
struct iobuf recv_iobuf;
|
||||
struct iobuf send_iobuf;
|
||||
SSL *ssl;
|
||||
SSL_CTX *ssl_ctx;
|
||||
void *connection_data;
|
||||
time_t last_io_time;
|
||||
|
||||
unsigned int flags;
|
||||
#define NSF_FINISHED_SENDING_DATA (1 << 0)
|
||||
#define NSF_BUFFER_BUT_DONT_SEND (1 << 1)
|
||||
#define NSF_SSL_HANDSHAKE_DONE (1 << 2)
|
||||
#define NSF_CONNECTING (1 << 3)
|
||||
#define NSF_CLOSE_IMMEDIATELY (1 << 4)
|
||||
#define NSF_WANT_READ (1 << 5)
|
||||
#define NSF_WANT_WRITE (1 << 6)
|
||||
#define NSF_LISTENING (1 << 7)
|
||||
#define NSF_UDP (1 << 8)
|
||||
|
||||
#define NSF_USER_1 (1 << 20)
|
||||
#define NSF_USER_2 (1 << 21)
|
||||
#define NSF_USER_3 (1 << 22)
|
||||
#define NSF_USER_4 (1 << 23)
|
||||
#define NSF_USER_5 (1 << 24)
|
||||
#define NSF_USER_6 (1 << 25)
|
||||
};
|
||||
|
||||
void ns_mgr_init(struct ns_mgr *, void *data, ns_callback_t);
|
||||
void ns_mgr_free(struct ns_mgr *);
|
||||
int ns_mgr_poll(struct ns_mgr *, int milli);
|
||||
void ns_broadcast(struct ns_mgr *, ns_callback_t, void *, size_t);
|
||||
|
||||
struct ns_connection *ns_next(struct ns_mgr *, struct ns_connection *);
|
||||
struct ns_connection *ns_add_sock(struct ns_mgr *, sock_t sock, void *p);
|
||||
struct ns_connection *ns_bind(struct ns_mgr *, const char *addr, void *p);
|
||||
struct ns_connection *ns_connect(struct ns_mgr *, const char *addr, void *p);
|
||||
|
||||
int ns_send(struct ns_connection *, const void *buf, int len);
|
||||
int ns_printf(struct ns_connection *, const char *fmt, ...);
|
||||
int ns_vprintf(struct ns_connection *, const char *fmt, va_list ap);
|
||||
|
||||
// Utility functions
|
||||
void *ns_start_thread(void *(*f)(void *), void *p);
|
||||
int ns_socketpair(sock_t [2]);
|
||||
int ns_socketpair2(sock_t [2], int sock_type); // SOCK_STREAM or SOCK_DGRAM
|
||||
void ns_set_close_on_exec(sock_t);
|
||||
void ns_sock_to_str(sock_t sock, char *buf, size_t len, int flags);
|
||||
int ns_hexdump(const void *buf, int len, char *dst, int dst_len);
|
||||
int ns_avprintf(char **buf, size_t size, const char *fmt, va_list ap);
|
||||
int ns_resolve(const char *domain_name, char *ip_addr_buf, size_t buf_len);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // NS_SKELETON_HEADER_INCLUDED
|
||||
@@ -0,0 +1,123 @@
|
||||
// Copyright (c) 2014 Cesanta Software Limited
|
||||
// All rights reserved
|
||||
//
|
||||
// This software is dual-licensed: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License version 2 as
|
||||
// published by the Free Software Foundation. For the terms of this
|
||||
// license, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
// You are free to use this software under the terms of the GNU General
|
||||
// Public License, but WITHOUT ANY WARRANTY; without even the implied
|
||||
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// Alternatively, you can license this software under a commercial
|
||||
// license, as set out in <http://cesanta.com/products.html>.
|
||||
//
|
||||
// $Date: 2014-09-09 17:09:33 UTC $
|
||||
|
||||
#include "net_skeleton.h"
|
||||
#include "ssl_wrapper.h"
|
||||
|
||||
static void ev_handler(struct ns_connection *nc, enum ns_event ev, void *p) {
|
||||
const char *target_addr = (const char *) nc->mgr->user_data;
|
||||
struct ns_connection *pc = (struct ns_connection *) nc->connection_data;
|
||||
struct iobuf *io = &nc->recv_iobuf;
|
||||
|
||||
(void) p;
|
||||
switch (ev) {
|
||||
case NS_ACCEPT:
|
||||
// Create a connection to the target, and interlink both connections
|
||||
nc->connection_data = ns_connect(nc->mgr, target_addr, nc);
|
||||
if (nc->connection_data == NULL) {
|
||||
nc->flags |= NSF_CLOSE_IMMEDIATELY;
|
||||
}
|
||||
break;
|
||||
|
||||
case NS_CLOSE:
|
||||
// If either connection closes, unlink them and shedule closing
|
||||
if (pc != NULL) {
|
||||
pc->flags |= NSF_FINISHED_SENDING_DATA;
|
||||
pc->connection_data = NULL;
|
||||
}
|
||||
nc->connection_data = NULL;
|
||||
break;
|
||||
|
||||
case NS_RECV:
|
||||
// Forward arrived data to the other connection, and discard from buffer
|
||||
if (pc != NULL) {
|
||||
ns_send(pc, io->buf, io->len);
|
||||
iobuf_remove(io, io->len);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void *ssl_wrapper_init(const char *local_addr, const char *target_addr,
|
||||
const char **err_msg) {
|
||||
struct ns_mgr *mgr = (struct ns_mgr *) calloc(1, sizeof(mgr[0]));
|
||||
*err_msg = NULL;
|
||||
|
||||
if (mgr == NULL) {
|
||||
*err_msg = "malloc failed";
|
||||
} else {
|
||||
ns_mgr_init(mgr, (void *) target_addr, ev_handler);
|
||||
if (ns_bind(mgr, local_addr, NULL) == NULL) {
|
||||
*err_msg = "ns_bind() failed: bad listening_port";
|
||||
ns_mgr_free(mgr);
|
||||
free(mgr);
|
||||
mgr = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return mgr;
|
||||
}
|
||||
|
||||
void ssl_wrapper_serve(void *param, volatile int *quit) {
|
||||
struct ns_mgr *mgr = (struct ns_mgr *) param;
|
||||
|
||||
while (*quit == 0) {
|
||||
ns_mgr_poll(mgr, 1000);
|
||||
}
|
||||
ns_mgr_free(mgr);
|
||||
free(mgr);
|
||||
}
|
||||
|
||||
#ifndef SSL_WRAPPER_USE_AS_LIBRARY
|
||||
static int s_received_signal = 0;
|
||||
|
||||
static void signal_handler(int sig_num) {
|
||||
signal(sig_num, signal_handler);
|
||||
s_received_signal = sig_num;
|
||||
}
|
||||
|
||||
static void show_usage_and_exit(const char *prog) {
|
||||
fprintf(stderr, "Usage: %s <listening_address> <target_address>\n", prog);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
void *wrapper;
|
||||
const char *err_msg;
|
||||
|
||||
if (argc != 3) {
|
||||
show_usage_and_exit(argv[0]);
|
||||
}
|
||||
|
||||
// Setup signal handlers
|
||||
signal(SIGTERM, signal_handler);
|
||||
signal(SIGINT, signal_handler);
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
|
||||
if ((wrapper = ssl_wrapper_init(argv[1], argv[2], &err_msg)) == NULL) {
|
||||
fprintf(stderr, "Error: %s\n", err_msg);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
ssl_wrapper_serve(wrapper, &s_received_signal);
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
#endif // SSL_WRAPPER_USE_AS_LIBRARY
|
||||
@@ -0,0 +1,34 @@
|
||||
// Copyright (c) 2014 Cesanta Software Limited
|
||||
// All rights reserved
|
||||
//
|
||||
// This software is dual-licensed: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License version 2 as
|
||||
// published by the Free Software Foundation. For the terms of this
|
||||
// license, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
// You are free to use this software under the terms of the GNU General
|
||||
// Public License, but WITHOUT ANY WARRANTY; without even the implied
|
||||
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
// See the GNU General Public License for more details.
|
||||
//
|
||||
// Alternatively, you can license this software under a commercial
|
||||
// license, as set out in <http://cesanta.com/products.html>.
|
||||
//
|
||||
// $Date: 2014-09-09 17:09:33 UTC $
|
||||
|
||||
#ifndef SSL_WRAPPER_HEADER_INCLUDED
|
||||
#define SSL_WRAPPER_HEADER_INCLUDED
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif // __cplusplus
|
||||
|
||||
void *ssl_wrapper_init(const char *listen_addr, const char *target_addr,
|
||||
const char **err_msg);
|
||||
void ssl_wrapper_serve(void *, volatile int *stop_marker);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // SSL_WRAPPER_HEADER_INCLUDED
|
||||
@@ -0,0 +1,182 @@
|
||||
// Copyright (c) 2014 Cesanta Software
|
||||
// All rights reserved
|
||||
//
|
||||
// This example demostrates proxying of WebSocket traffic, regardless of the
|
||||
// protocol (ws:// or wss://).
|
||||
// To use this example:
|
||||
// 1. configure your browser to use a proxy on port 2014
|
||||
// 2. import certs/ws1_ca.pem and certs/ws2_ca.pem into the trusted
|
||||
// certificates list on your browser
|
||||
// 3. make && ./ws_ssl
|
||||
// 4. Point your browser to http://ws_ssl.com
|
||||
// A page with 4 sections should appear, showing websocket echoes
|
||||
|
||||
#include "net_skeleton.h"
|
||||
#include "mongoose.h"
|
||||
#include "ssl_wrapper.h"
|
||||
|
||||
#define S1_PEM "certs/ws1_server.pem"
|
||||
#define C1_PEM "certs/ws1_client.pem"
|
||||
#define CA1_PEM "certs/ws1_ca.pem"
|
||||
#define S2_PEM "certs/ws2_server.pem"
|
||||
#define C2_PEM "certs/ws2_client.pem"
|
||||
#define CA2_PEM "certs/ws2_ca.pem"
|
||||
|
||||
struct config {
|
||||
const char *uri;
|
||||
const char *wrapper_server_addr;
|
||||
const char *wrapper_client_addr;
|
||||
const char *target_addr;
|
||||
};
|
||||
|
||||
static struct config s_wrappers[] = {
|
||||
{
|
||||
"ws1:80",
|
||||
"tcp://127.0.0.1:7001",
|
||||
"tcp://127.0.0.1:7001",
|
||||
"tcp://127.0.0.1:9001"
|
||||
},
|
||||
{
|
||||
"ws1:443",
|
||||
"ssl://127.0.0.1:7002:" S1_PEM,
|
||||
"tcp://127.0.0.1:7002",
|
||||
"tcp://127.0.0.1:9001"
|
||||
},
|
||||
{
|
||||
"ws2:80",
|
||||
"tcp://127.0.0.1:7003",
|
||||
"tcp://127.0.0.1:7003",
|
||||
"ssl://127.0.0.1:9002:" C2_PEM ":" CA2_PEM
|
||||
},
|
||||
{
|
||||
"ws2:443",
|
||||
"ssl://127.0.0.1:7004:" S2_PEM,
|
||||
"tcp://127.0.0.1:7004",
|
||||
"ssl://127.0.0.1:9002:" C2_PEM ":" CA2_PEM
|
||||
},
|
||||
};
|
||||
|
||||
static int s_received_signal = 0;
|
||||
|
||||
static void signal_handler(int sig_num) {
|
||||
signal(sig_num, signal_handler);
|
||||
s_received_signal = sig_num;
|
||||
}
|
||||
|
||||
static int ev_handler(struct mg_connection *conn, enum mg_event ev) {
|
||||
int i;
|
||||
|
||||
switch (ev) {
|
||||
case MG_AUTH:
|
||||
return MG_TRUE;
|
||||
|
||||
case MG_REQUEST:
|
||||
printf("==> [%s] [%s]\n", conn->request_method, conn->uri);
|
||||
|
||||
if (strcmp(conn->request_method, "CONNECT") == 0) {
|
||||
// Iterate over configured wrappers, see if we can use one of them
|
||||
for (i = 0; i < (int) ARRAY_SIZE(s_wrappers); i++) {
|
||||
if (strcmp(conn->uri, s_wrappers[i].uri) == 0) {
|
||||
mg_forward(conn, s_wrappers[i].wrapper_client_addr);
|
||||
return MG_MORE;
|
||||
}
|
||||
}
|
||||
|
||||
// No suitable wrappers found. Disallow that CONNECT request.
|
||||
mg_send_status(conn, 405);
|
||||
return MG_TRUE;
|
||||
}
|
||||
|
||||
// Not a CONNECT request, serve HTML file.
|
||||
mg_send_file(conn, "ws_ssl.html");
|
||||
return MG_MORE;
|
||||
|
||||
default:
|
||||
return MG_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
static int ws_handler(struct mg_connection *conn, enum mg_event ev) {
|
||||
switch (ev) {
|
||||
case MG_AUTH:
|
||||
return MG_TRUE;
|
||||
case MG_REQUEST:
|
||||
if (conn->is_websocket) {
|
||||
// Simple websocket echo server
|
||||
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT,
|
||||
conn->content, conn->content_len);
|
||||
} else {
|
||||
mg_printf_data(conn, "%s", "websocket connection expected");
|
||||
}
|
||||
return MG_TRUE;
|
||||
default:
|
||||
return MG_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
static void *serve_thread_func(void *param) {
|
||||
struct mg_server *server = (struct mg_server *) param;
|
||||
printf("Listening on port %s\n", mg_get_option(server, "listening_port"));
|
||||
while (s_received_signal == 0) {
|
||||
mg_poll_server(server, 1000);
|
||||
}
|
||||
mg_destroy_server(&server);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void *wrapper_thread_func(void *param) {
|
||||
struct config *c = (struct config *) param;
|
||||
const char *err_msg;
|
||||
void *wrapper;
|
||||
|
||||
wrapper = ssl_wrapper_init(c->wrapper_server_addr, c->target_addr, &err_msg);
|
||||
if (wrapper == NULL) {
|
||||
fprintf(stderr, "Error: %s\n", err_msg);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
//((struct ns_mgr *) wrapper)->hexdump_file = "/dev/stderr";
|
||||
ssl_wrapper_serve(wrapper, &s_received_signal);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
struct mg_server *proxy_server = mg_create_server(NULL, ev_handler);
|
||||
struct mg_server *ws1_server = mg_create_server(NULL, ws_handler);
|
||||
struct mg_server *ws2_server = mg_create_server(NULL, ws_handler);
|
||||
size_t i;
|
||||
|
||||
((struct ns_mgr *) proxy_server)->hexdump_file = "/dev/stderr";
|
||||
|
||||
// Configure proxy server to listen on port 2014
|
||||
mg_set_option(proxy_server, "listening_port", "2014");
|
||||
//mg_set_option(proxy_server, "enable_proxy", "yes");
|
||||
|
||||
// Configure two websocket echo servers:
|
||||
// ws1 is WS, listening on 9001
|
||||
// ws2 is WSS, listening on 9002
|
||||
// Note that HTML page thinks that ws1 is WSS, and ws2 is WS,
|
||||
// where in reality it is vice versa and proxy server makes the decision.
|
||||
mg_set_option(ws1_server, "listening_port", "tcp://127.0.0.1:9001");
|
||||
mg_set_option(ws2_server, "listening_port",
|
||||
"ssl://127.0.0.1:9002:" S2_PEM ":" CA2_PEM);
|
||||
|
||||
// Setup signal handlers
|
||||
signal(SIGTERM, signal_handler);
|
||||
signal(SIGINT, signal_handler);
|
||||
|
||||
// Start SSL wrappers, each in it's own thread
|
||||
for (i = 0; i < ARRAY_SIZE(s_wrappers); i++) {
|
||||
ns_start_thread(wrapper_thread_func, &s_wrappers[i]);
|
||||
}
|
||||
|
||||
// Start websocket servers in separate threads
|
||||
mg_start_thread(serve_thread_func, ws1_server);
|
||||
mg_start_thread(serve_thread_func, ws2_server);
|
||||
|
||||
// Finally, start proxy server in this thread: this call blocks
|
||||
serve_thread_func(proxy_server);
|
||||
|
||||
printf("Existing on signal %d\n", s_received_signal);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>Websocket Proxy SSL Test</title>
|
||||
<meta charset="utf-8">
|
||||
<script>
|
||||
window.onload = function() {
|
||||
var protocols = ['ws://', 'wss://'];
|
||||
var websocketServers = ['ws1', 'ws2'];
|
||||
//protocols = ['wss://'];
|
||||
//websocketServers = ['ws1']
|
||||
|
||||
var createWebsocketConnection = function(proto, server) {
|
||||
var conn = new WebSocket(proto + server);
|
||||
|
||||
var div = document.createElement('div');
|
||||
var h2 = document.createElement('h2');
|
||||
h2.innerHTML = 'Connection to ' + proto + server;
|
||||
document.body.appendChild(h2);
|
||||
document.body.appendChild(div);
|
||||
|
||||
conn.onmessage = function(ev) {
|
||||
var el = document.createElement('div');
|
||||
el.innerHTML = 'websocket message: ' + ev.data;
|
||||
div.appendChild(el);
|
||||
// Keep only last 5 messages in the list
|
||||
while (div.childNodes.length > 5) div.removeChild(div.firstChild);
|
||||
};
|
||||
|
||||
// Send some string to the websocket connection periodically.
|
||||
// websocket server much echo it back.
|
||||
window.setInterval(function() { conn.send(Math.random()); }, 1000);
|
||||
};
|
||||
|
||||
for (var i = 0; i < protocols.length; i++) {
|
||||
for (var j = 0; j < websocketServers.length; j++) {
|
||||
createWebsocketConnection(protocols[i], websocketServers[j]);
|
||||
}
|
||||
}
|
||||
};
|
||||
</script>
|
||||
<style>
|
||||
body > div {
|
||||
border: 1px solid #ccc; background: #f0f0f0; padding: 0 1em;
|
||||
margin: 0 2em; min-height: 4em; max-width: 40em;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
</body>
|
||||
</html>
|
||||
Reference in new issue
Block a user