Skip to content
项目
群组
代码片段
帮助
正在加载...
登录
切换导航
F
freeswitch
项目
项目
详情
活动
周期分析
仓库
仓库
文件
提交
分支
标签
贡献者
分枝图
比较
统计图
议题
0
议题
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
CI / CD
CI / CD
流水线
作业
日程
统计图
Wiki
Wiki
代码片段
代码片段
成员
成员
折叠边栏
关闭边栏
活动
分枝图
统计图
创建新议题
作业
提交
议题看板
打开侧边栏
张华
freeswitch
Commits
4def48b8
提交
4def48b8
authored
4月 24, 2014
作者:
Anthony Minessale
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
revert
上级
2e0cd74e
显示空白字符变更
内嵌
并排
正在显示
2 个修改的文件
包含
124 行增加
和
407 行删除
+124
-407
ws.c
src/mod/xml_int/mod_xml_rpc/ws.c
+103
-368
ws.h
src/mod/xml_int/mod_xml_rpc/ws.h
+21
-39
没有找到文件。
src/mod/xml_int/mod_xml_rpc/ws.c
浏览文件 @
4def48b8
#include "ws.h"
#include <pthread.h>
#ifndef _MSC_VER
#include <fcntl.h>
#endif
#ifndef _MSC_VER
#define ms_sleep(x) usleep( x * 1000);
#else
#define ms_sleep(x) Sleep( x );
#endif
#define SHA1_HASH_SIZE 20
struct
ws_globals_s
ws_
globals
;
struct
globals_s
globals
;
#ifndef WSS_STANDALONE
...
...
@@ -89,20 +82,20 @@ void init_ssl(void) {
OpenSSL_add_all_algorithms
();
/* load & register cryptos */
SSL_load_error_strings
();
/* load all error messages */
ws_
globals
.
ssl_method
=
TLSv1_server_method
();
/* create server instance */
ws_globals
.
ssl_ctx
=
SSL_CTX_new
(
ws_
globals
.
ssl_method
);
/* create context */
assert
(
ws_
globals
.
ssl_ctx
);
globals
.
ssl_method
=
TLSv1_server_method
();
/* create server instance */
globals
.
ssl_ctx
=
SSL_CTX_new
(
globals
.
ssl_method
);
/* create context */
assert
(
globals
.
ssl_ctx
);
/* set the local certificate from CertFile */
SSL_CTX_use_certificate_file
(
ws_globals
.
ssl_ctx
,
ws_
globals
.
cert
,
SSL_FILETYPE_PEM
);
SSL_CTX_use_certificate_file
(
globals
.
ssl_ctx
,
globals
.
cert
,
SSL_FILETYPE_PEM
);
/* set the private key from KeyFile */
SSL_CTX_use_PrivateKey_file
(
ws_globals
.
ssl_ctx
,
ws_
globals
.
key
,
SSL_FILETYPE_PEM
);
SSL_CTX_use_PrivateKey_file
(
globals
.
ssl_ctx
,
globals
.
key
,
SSL_FILETYPE_PEM
);
/* verify private key */
if
(
!
SSL_CTX_check_private_key
(
ws_
globals
.
ssl_ctx
)
)
{
if
(
!
SSL_CTX_check_private_key
(
globals
.
ssl_ctx
)
)
{
abort
();
}
SSL_CTX_set_cipher_list
(
ws_
globals
.
ssl_ctx
,
"HIGH:!DSS:!aNULL@STRENGTH"
);
SSL_CTX_set_cipher_list
(
globals
.
ssl_ctx
,
"HIGH:!DSS:!aNULL@STRENGTH"
);
thread_setup
();
}
...
...
@@ -147,7 +140,7 @@ static int cheezy_get_var(char *data, char *name, char *buf, size_t buflen)
}
if
(
v
&&
e
)
{
in
t
cplen
;
size_
t
cplen
;
size_t
len
=
e
-
v
;
if
(
len
>
buflen
-
1
)
{
...
...
@@ -224,55 +217,18 @@ static void sha1_digest(unsigned char *digest, char *in)
#endif
int
ws_handshake
(
wsh_t
*
wsh
)
int
ws_handshake
_kvp
(
wsh_t
*
wsh
,
char
*
key
,
char
*
version
,
char
*
proto
)
{
char
key
[
256
]
=
""
;
char
version
[
5
]
=
""
;
char
proto
[
256
]
=
""
;
char
proto_buf
[
384
]
=
""
;
char
uri
[
256
]
=
""
;
char
input
[
256
]
=
""
;
unsigned
char
output
[
SHA1_HASH_SIZE
]
=
""
;
char
b64
[
256
]
=
""
;
char
respond
[
512
]
=
""
;
ssize_t
bytes
;
char
*
p
,
*
e
=
0
;
if
(
wsh
->
sock
==
ws_sock_invalid
)
{
if
(
!
wsh
->
tsession
)
{
return
-
3
;
}
while
((
bytes
=
ws_raw_read
(
wsh
,
wsh
->
buffer
+
wsh
->
datalen
,
wsh
->
buflen
-
wsh
->
datalen
))
>
0
)
{
wsh
->
datalen
+=
bytes
;
if
(
strstr
(
wsh
->
buffer
,
"
\r\n\r\n
"
)
||
strstr
(
wsh
->
buffer
,
"
\n\n
"
))
{
break
;
}
}
if
(
bytes
>
sizeof
(
wsh
->
buffer
)
-
1
)
{
goto
err
;
}
*
(
wsh
->
buffer
+
bytes
)
=
'\0'
;
if
(
strncasecmp
(
wsh
->
buffer
,
"GET "
,
4
))
{
goto
err
;
}
p
=
wsh
->
buffer
+
4
;
e
=
strchr
(
p
,
' '
);
if
(
!
e
)
{
goto
err
;
}
strncpy
(
uri
,
p
,
e
-
p
);
cheezy_get_var
(
wsh
->
buffer
,
"Sec-WebSocket-Key"
,
key
,
sizeof
(
key
));
cheezy_get_var
(
wsh
->
buffer
,
"Sec-WebSocket-Version"
,
version
,
sizeof
(
version
));
cheezy_get_var
(
wsh
->
buffer
,
"Sec-WebSocket-Protocol"
,
proto
,
sizeof
(
proto
));
if
(
!*
key
)
{
if
(
!*
key
||
!*
version
||
!*
proto
)
{
goto
err
;
}
...
...
@@ -280,33 +236,25 @@ int ws_handshake(wsh_t *wsh)
sha1_digest
(
output
,
input
);
b64encode
((
unsigned
char
*
)
output
,
SHA1_HASH_SIZE
,
(
unsigned
char
*
)
b64
,
sizeof
(
b64
));
if
(
*
proto
)
{
snprintf
(
proto_buf
,
sizeof
(
proto_buf
),
"Sec-WebSocket-Protocol: %s
\r\n
"
,
proto
);
}
snprintf
(
respond
,
sizeof
(
respond
),
"HTTP/1.1 101 Switching Protocols
\r\n
"
"Upgrade: websocket
\r\n
"
"Connection: Upgrade
\r\n
"
"Sec-WebSocket-Accept: %s
\r\n
"
"
%s
\r\n
"
,
"
Sec-WebSocket-Protocol: %s
\r\n
\r\n
"
,
b64
,
proto
_buf
);
proto
);
ws_raw_write
(
wsh
,
respond
,
strlen
(
respond
));
if
(
ws_raw_write
(
wsh
,
respond
,
strlen
(
respond
)))
{
wsh
->
handshake
=
1
;
return
0
;
}
err:
snprintf
(
respond
,
sizeof
(
respond
),
"HTTP/1.1 400 Bad Request
\r\n
"
"Sec-WebSocket-Version: 13
\r\n\r\n
"
);
//printf("ERR:\n%s\n", respond);
ws_raw_write
(
wsh
,
respond
,
strlen
(
respond
));
ws_close
(
wsh
,
WS_NONE
);
...
...
@@ -315,238 +263,85 @@ int ws_handshake(wsh_t *wsh)
}
ssize_t
ws_raw_read
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
)
i
ssize_t
ws_raw_read
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
)
{
ssize_t
r
;
int
err
=
0
;
if
(
wsh
->
ssl
)
{
do
{
r
=
SSL_read
(
wsh
->
ssl
,
data
,
bytes
);
#ifndef _MSC_VER
if
(
wsh
->
x
++
)
usleep
(
10000
);
#else
if
(
wsh
->
x
++
)
Sleep
(
10
);
#endif
if
(
r
==
-
1
)
{
err
=
SSL_get_error
(
wsh
->
ssl
,
r
);
issize_t
r
;
TConn
*
conn
=
wsh
->
tsession
->
connP
;
if
(
wsh
->
handshake
&&
err
==
SSL_ERROR_WANT_READ
)
{
r
=
-
2
;
goto
end
;
}
}
if
(
!
wsh
->
handshake
)
{
r
=
wsh
->
tsession
->
connP
->
buffersize
;
memcpy
(
data
,
conn
->
buffer
.
b
,
r
);
printf
(
"%s
\n
"
,
conn
->
buffer
.
t
);
ConnReadInit
(
conn
);
return
r
;
}
else
{
const
char
*
readError
=
NULL
;
}
while
(
r
==
-
1
&&
err
==
SSL_ERROR_WANT_READ
&&
wsh
->
x
<
100
);
// printf(" pos=%d size=%d need=%d\n", conn->bufferpos, conn->buffersize, bytes
);
goto
end
;
}
r
=
conn
->
buffersize
-
conn
->
bufferpos
;
do
{
r
=
recv
(
wsh
->
sock
,
data
,
bytes
,
0
);
#ifndef _MSC_VER
if
(
wsh
->
x
++
)
usleep
(
10000
);
#else
if
(
wsh
->
x
++
)
Sleep
(
10
);
#endif
}
while
(
r
==
-
1
&&
xp_is_blocking
(
xp_errno
())
&&
wsh
->
x
<
100
);
if
(
r
<
0
)
{
printf
(
"286 Read Error %d!
\n
"
,
r
);
return
0
;
}
else
if
(
r
==
0
)
{
ConnRead
(
conn
,
2
,
NULL
,
NULL
,
&
readError
);
if
(
wsh
->
x
>=
100
)
{
r
=
-
1
;
if
(
readError
)
{
// printf("292 Read Error %s\n", readError);
free
((
void
*
)
readError
);
return
0
;
}
end:
r
=
conn
->
buffersize
-
conn
->
bufferpos
;
}
if
(
r
>
0
)
{
*
((
char
*
)
data
+
r
)
=
'\0'
;
if
(
r
<=
(
issize_t
)
bytes
)
{
memcpy
(
data
,
conn
->
buffer
.
b
+
conn
->
bufferpos
,
r
);
// ConnReadInit(conn);
conn
->
bufferpos
=
conn
->
buffersize
;
ConnReadInit
(
conn
);
return
r
;
}
else
{
memcpy
(
data
,
conn
->
buffer
.
b
+
conn
->
bufferpos
,
bytes
);
conn
->
bufferpos
+=
(
uint32_t
)
bytes
;
return
(
issize_t
)
bytes
;
}
if
(
r
>=
0
)
{
wsh
->
x
=
0
;
}
return
r
;
}
ssize_t
ws_raw_write
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
)
i
ssize_t
ws_raw_write
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
)
{
size_t
r
;
if
(
wsh
->
ssl
)
{
do
{
r
=
SSL_write
(
wsh
->
ssl
,
data
,
bytes
);
}
while
(
r
==
-
1
&&
SSL_get_error
(
wsh
->
ssl
,
r
)
==
SSL_ERROR_WANT_WRITE
);
return
r
;
}
do
{
r
=
send
(
wsh
->
sock
,
data
,
bytes
,
0
);
}
while
(
r
==
-
1
&&
xp_is_blocking
(
xp_errno
()));
//if (r<0) {
//printf("wRITE FAIL: %s\n", strerror(errno));
//}
return
r
;
}
#ifdef _MSC_VER
static
int
setup_socket
(
ws_socket_t
sock
)
{
unsigned
long
v
=
1
;
r
=
SSL_write
(
wsh
->
ssl
,
data
,
(
int
)
bytes
);
}
while
(
r
==
-
1
&&
SSL_get_error
(
wsh
->
ssl
,
(
int
)
r
)
==
SSL_ERROR_WANT_WRITE
);
if
(
ioctlsocket
(
sock
,
FIONBIO
,
&
v
)
==
SOCKET_ERROR
)
{
return
-
1
;
return
(
issize_t
)
r
;
}
if
(
ConnWrite
(
wsh
->
tsession
->
connP
,
data
,
(
uint32_t
)
bytes
))
{
return
(
issize_t
)
bytes
;
}
else
{
return
0
;
}
static
int
restore_socket
(
ws_socket_t
sock
)
{
unsigned
long
v
=
0
;
if
(
ioctlsocket
(
sock
,
FIONBIO
,
&
v
)
==
SOCKET_ERROR
)
{
return
-
1
;
}
return
0
;
}
#else
static
int
setup_socket
(
ws_socket_t
sock
)
{
int
flags
=
fcntl
(
sock
,
F_GETFL
,
0
);
return
fcntl
(
sock
,
F_SETFL
,
flags
|
O_NONBLOCK
);
}
static
int
restore_socket
(
ws_socket_t
sock
)
{
int
flags
=
fcntl
(
sock
,
F_GETFL
,
0
);
flags
&=
~
O_NONBLOCK
;
return
fcntl
(
sock
,
F_SETFL
,
flags
);
}
#endif
static
int
establish_logical_layer
(
wsh_t
*
wsh
)
wsh_t
*
ws_init
(
ws_tsession_t
*
tsession
)
{
wsh_t
*
wsh
=
(
wsh_t
*
)
malloc
(
sizeof
(
*
wsh
));
if
(
!
wsh
->
sanity
)
{
return
-
1
;
}
if
(
wsh
->
logical_established
)
{
return
0
;
}
if
(
wsh
->
secure
&&
!
wsh
->
secure_established
)
{
int
code
;
if
(
!
wsh
->
ssl
)
{
wsh
->
ssl
=
SSL_new
(
wsh
->
ssl_ctx
);
assert
(
wsh
->
ssl
);
SSL_set_fd
(
wsh
->
ssl
,
wsh
->
sock
);
}
do
{
code
=
SSL_accept
(
wsh
->
ssl
);
if
(
code
==
1
)
{
wsh
->
secure_established
=
1
;
break
;
}
if
(
code
==
0
)
{
return
-
1
;
}
if
(
code
<
0
)
{
if
(
code
==
-
1
&&
SSL_get_error
(
wsh
->
ssl
,
code
)
!=
SSL_ERROR_WANT_READ
)
{
return
-
1
;
}
}
if
(
wsh
->
block
)
{
ms_sleep
(
10
);
}
else
{
ms_sleep
(
1
);
}
wsh
->
sanity
--
;
if
(
!
wsh
->
block
)
{
return
-
2
;
}
}
while
(
wsh
->
sanity
>
0
);
if
(
!
wsh
->
sanity
)
{
return
-
1
;
}
}
while
(
!
wsh
->
down
&&
!
wsh
->
handshake
)
{
int
r
=
ws_handshake
(
wsh
);
if
(
r
<
0
)
{
wsh
->
down
=
1
;
return
-
1
;
}
if
(
!
wsh
->
handshake
&&
!
wsh
->
block
)
{
return
-
2
;
}
}
wsh
->
logical_established
=
1
;
return
0
;
}
if
(
!
wsh
)
return
NULL
;
int
ws_init
(
wsh_t
*
wsh
,
ws_socket_t
sock
,
SSL_CTX
*
ssl_ctx
,
int
close_sock
,
int
block
)
{
memset
(
wsh
,
0
,
sizeof
(
*
wsh
));
wsh
->
sock
=
sock
;
wsh
->
block
=
block
;
wsh
->
sanity
=
5000
;
wsh
->
ssl_ctx
=
ssl_ctx
;
if
(
!
ssl_ctx
)
{
ssl_ctx
=
ws_globals
.
ssl_ctx
;
}
if
(
close_sock
)
{
wsh
->
close_sock
=
1
;
}
wsh
->
tsession
=
tsession
;
wsh
->
buflen
=
sizeof
(
wsh
->
buffer
);
wsh
->
secure
=
ssl_ctx
?
1
:
0
;
setup_socket
(
sock
);
if
(
establish_logical_layer
(
wsh
)
==
-
1
)
{
return
-
1
;
}
if
(
wsh
->
down
)
{
return
-
1
;
}
return
0
;
return
wsh
;
}
void
ws_destroy
(
wsh_t
*
wsh
)
...
...
@@ -577,7 +372,7 @@ void ws_destroy(wsh_t *wsh)
}
}
ssize_t
ws_close
(
wsh_t
*
wsh
,
int16_t
reason
)
i
ssize_t
ws_close
(
wsh_t
*
wsh
,
int16_t
reason
)
{
if
(
wsh
->
down
)
{
...
...
@@ -586,45 +381,20 @@ ssize_t ws_close(wsh_t *wsh, int16_t reason)
wsh
->
down
=
1
;
if
(
reason
&&
wsh
->
sock
!=
ws_sock_invalid
)
{
uint16_t
*
u16
;
uint8_t
fr
[
4
]
=
{
WSOC_CLOSE
|
0x80
,
2
,
0
};
u16
=
(
uint16_t
*
)
&
fr
[
2
];
*
u16
=
htons
((
int16_t
)
reason
);
ws_raw_write
(
wsh
,
fr
,
4
);
}
restore_socket
(
wsh
->
sock
);
if
(
wsh
->
close_sock
&&
wsh
->
sock
!=
ws_sock_invalid
)
{
close
(
wsh
->
sock
);
}
wsh
->
sock
=
ws_sock_invalid
;
return
reason
*
-
1
;
}
ssize_t
ws_read_frame
(
wsh_t
*
wsh
,
ws_opcode_t
*
oc
,
uint8_t
**
data
)
i
ssize_t
ws_read_frame
(
wsh_t
*
wsh
,
ws_opcode_t
*
oc
,
uint8_t
**
data
)
{
ssize_t
need
=
2
;
i
ssize_t
need
=
2
;
char
*
maskp
;
int
ll
=
0
;
again:
need
=
2
;
maskp
=
NULL
;
*
data
=
NULL
;
ll
=
establish_logical_layer
(
wsh
);
if
(
ll
<
0
)
{
return
ll
;
}
if
(
wsh
->
down
)
{
return
-
1
;
}
...
...
@@ -633,15 +403,10 @@ ssize_t ws_read_frame(wsh_t *wsh, ws_opcode_t *oc, uint8_t **data)
return
ws_close
(
wsh
,
WS_PROTO_ERR
);
}
if
((
wsh
->
datalen
=
ws_raw_read
(
wsh
,
wsh
->
buffer
,
9
))
<
0
)
{
if
(
wsh
->
datalen
==
-
2
)
{
return
-
2
;
}
return
ws_close
(
wsh
,
WS_PROTO_ERR
);
}
if
((
wsh
->
datalen
=
ws_raw_read
(
wsh
,
wsh
->
buffer
,
14
))
<
need
)
{
while
(
!
wsh
->
down
&&
(
wsh
->
datalen
+=
ws_raw_read
(
wsh
,
wsh
->
buffer
+
wsh
->
datalen
,
14
-
wsh
->
datalen
))
<
need
)
;
if
(
wsh
->
datalen
<
need
)
{
if
((
wsh
->
datalen
+=
ws_raw_read
(
wsh
,
wsh
->
buffer
+
wsh
->
datalen
,
9
-
wsh
->
datalen
))
<
need
)
{
if
(
0
&&
(
wsh
->
datalen
+=
ws_raw_read
(
wsh
,
wsh
->
buffer
+
wsh
->
datalen
,
14
-
wsh
->
datalen
))
<
need
)
{
/* too small - protocol err */
return
ws_close
(
wsh
,
WS_PROTO_ERR
);
}
...
...
@@ -718,13 +483,7 @@ ssize_t ws_read_frame(wsh_t *wsh, ws_opcode_t *oc, uint8_t **data)
need
=
(
wsh
->
plen
-
(
wsh
->
datalen
-
need
));
if
(
need
<
0
)
{
/* invalid read - protocol err .. */
*
oc
=
WSOC_CLOSE
;
return
ws_close
(
wsh
,
WS_PROTO_ERR
);
}
if
((
need
+
wsh
->
datalen
)
>
(
ssize_t
)
wsh
->
buflen
)
{
if
((
need
+
wsh
->
datalen
)
>
(
issize_t
)
wsh
->
buflen
)
{
/* too big - Ain't nobody got time fo' dat */
*
oc
=
WSOC_CLOSE
;
return
ws_close
(
wsh
,
WS_DATA_TOO_BIG
);
...
...
@@ -733,7 +492,7 @@ ssize_t ws_read_frame(wsh_t *wsh, ws_opcode_t *oc, uint8_t **data)
wsh
->
rplen
=
wsh
->
plen
-
need
;
while
(
need
)
{
ssize_t
r
=
ws_raw_read
(
wsh
,
wsh
->
payload
+
wsh
->
rplen
,
need
);
i
ssize_t
r
=
ws_raw_read
(
wsh
,
wsh
->
payload
+
wsh
->
rplen
,
need
);
if
(
r
<
1
)
{
/* invalid read - protocol err .. */
...
...
@@ -747,7 +506,7 @@ ssize_t ws_read_frame(wsh_t *wsh, ws_opcode_t *oc, uint8_t **data)
}
if
(
mask
&&
maskp
)
{
ssize_t
i
;
i
ssize_t
i
;
for
(
i
=
0
;
i
<
wsh
->
datalen
;
i
++
)
{
wsh
->
payload
[
i
]
^=
maskp
[
i
%
4
];
...
...
@@ -780,7 +539,7 @@ ssize_t ws_read_frame(wsh_t *wsh, ws_opcode_t *oc, uint8_t **data)
}
}
ssize_t
ws_feed_buf
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
)
i
ssize_t
ws_feed_buf
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
)
{
if
(
bytes
+
wsh
->
wdatalen
>
wsh
->
buflen
)
{
...
...
@@ -789,14 +548,14 @@ ssize_t ws_feed_buf(wsh_t *wsh, void *data, size_t bytes)
memcpy
(
wsh
->
wbuffer
+
wsh
->
wdatalen
,
data
,
bytes
);
wsh
->
wdatalen
+=
bytes
;
wsh
->
wdatalen
+=
(
issize_t
)
bytes
;
return
bytes
;
return
(
issize_t
)
bytes
;
}
ssize_t
ws_send_buf
(
wsh_t
*
wsh
,
ws_opcode_t
oc
)
i
ssize_t
ws_send_buf
(
wsh_t
*
wsh
,
ws_opcode_t
oc
)
{
ssize_t
r
=
0
;
i
ssize_t
r
=
0
;
if
(
!
wsh
->
wdatalen
)
{
return
-
1
;
...
...
@@ -810,7 +569,7 @@ ssize_t ws_send_buf(wsh_t *wsh, ws_opcode_t oc)
}
ssize_t
ws_write_frame
(
wsh_t
*
wsh
,
ws_opcode_t
oc
,
void
*
data
,
size_t
bytes
)
i
ssize_t
ws_write_frame
(
wsh_t
*
wsh
,
ws_opcode_t
oc
,
void
*
data
,
size_t
bytes
)
{
uint8_t
hdr
[
14
]
=
{
0
};
size_t
hlen
=
2
;
...
...
@@ -844,39 +603,15 @@ ssize_t ws_write_frame(wsh_t *wsh, ws_opcode_t oc, void *data, size_t bytes)
*
u64
=
htonl
(
bytes
);
}
if
(
ws_raw_write
(
wsh
,
(
void
*
)
&
hdr
[
0
],
hlen
)
!=
(
ssize_t
)
hlen
)
{
if
(
ws_raw_write
(
wsh
,
(
void
*
)
&
hdr
[
0
],
hlen
)
!=
(
i
ssize_t
)
hlen
)
{
return
-
1
;
}
if
(
ws_raw_write
(
wsh
,
data
,
bytes
)
!=
(
ssize_t
)
bytes
)
{
if
(
ws_raw_write
(
wsh
,
data
,
bytes
)
!=
(
i
ssize_t
)
bytes
)
{
return
-
2
;
}
return
bytes
;
}
#ifdef _MSC_VER
int
xp_errno
(
void
)
{
return
WSAGetLastError
();
}
int
xp_is_blocking
(
int
errcode
)
{
return
errcode
==
WSAEWOULDBLOCK
||
errcode
==
WSAEINPROGRESS
;
}
#else
int
xp_errno
(
void
)
{
return
errno
;
return
(
issize_t
)
bytes
;
}
int
xp_is_blocking
(
int
errcode
)
{
return
errcode
==
EAGAIN
||
errcode
==
EWOULDBLOCK
||
errcode
==
EINPROGRESS
||
errcode
==
EINTR
||
errcode
==
ETIMEDOUT
;
}
#endif
src/mod/xml_int/mod_xml_rpc/ws.h
浏览文件 @
4def48b8
...
...
@@ -13,40 +13,30 @@
#include <sys/socket.h>
#else
#pragma warning(disable:4996)
#define snprintf _snprintf
#endif
#include <string.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
//#include "sha1.h"
#include <openssl/ssl.h>
#include <../lib/abyss/src/session.h>
#include <../lib/abyss/src/conn.h>
#ifdef _MSC_VER
#define strncasecmp _strnicmp
#define snprintf _snprintf
#ifdef _WIN64
#define WS_SSIZE_T __int64
#elif _MSC_VER >= 1400
#define WS_SSIZE_T __int32 __w64
#else
#define WS_SSIZE_T __int32
#endif
typedef
WS_SSIZE_T
ssize_t
;
#endif
typedef
TSession
ws_tsession_t
;
typedef
int
issize_t
;
struct
ws_
globals_s
{
struct
globals_s
{
const
SSL_METHOD
*
ssl_method
;
SSL_CTX
*
ssl_ctx
;
char
cert
[
512
];
char
key
[
512
];
};
extern
struct
ws_globals_s
ws_
globals
;
// extern struct globals_s
globals;
typedef
int
ws_socket_t
;
#define ws_sock_invalid -1
...
...
@@ -69,44 +59,36 @@ typedef enum {
}
ws_opcode_t
;
typedef
struct
wsh_s
{
ws_
socket_t
sock
;
ws_
tsession_t
*
tsession
;
char
buffer
[
65536
];
char
wbuffer
[
65536
];
size_t
buflen
;
ssize_t
datalen
;
ssize_t
wdatalen
;
i
ssize_t
datalen
;
i
ssize_t
wdatalen
;
char
*
payload
;
ssize_t
plen
;
ssize_t
rplen
;
i
ssize_t
plen
;
i
ssize_t
rplen
;
SSL
*
ssl
;
int
handshake
;
uint8_t
down
;
int
secure
;
uint8_t
close_sock
;
SSL_CTX
*
ssl_ctx
;
int
block
;
int
sanity
;
int
secure_established
;
int
logical_established
;
int
x
;
}
wsh_t
;
ssize_t
ws_send_buf
(
wsh_t
*
wsh
,
ws_opcode_t
oc
);
ssize_t
ws_feed_buf
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
);
i
ssize_t
ws_send_buf
(
wsh_t
*
wsh
,
ws_opcode_t
oc
);
i
ssize_t
ws_feed_buf
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
);
ssize_t
ws_raw_read
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
);
ssize_t
ws_raw_write
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
);
ssize_t
ws_read_frame
(
wsh_t
*
wsh
,
ws_opcode_t
*
oc
,
uint8_t
**
data
);
ssize_t
ws_write_frame
(
wsh_t
*
wsh
,
ws_opcode_t
oc
,
void
*
data
,
size_t
bytes
);
int
ws_init
(
wsh_t
*
wsh
,
ws_socket_t
sock
,
SSL_CTX
*
ssl_ctx
,
int
close_sock
,
int
block
);
ssize_t
ws_close
(
wsh_t
*
wsh
,
int16_t
reason
);
i
ssize_t
ws_raw_read
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
);
i
ssize_t
ws_raw_write
(
wsh_t
*
wsh
,
void
*
data
,
size_t
bytes
);
i
ssize_t
ws_read_frame
(
wsh_t
*
wsh
,
ws_opcode_t
*
oc
,
uint8_t
**
data
);
i
ssize_t
ws_write_frame
(
wsh_t
*
wsh
,
ws_opcode_t
oc
,
void
*
data
,
size_t
bytes
);
wsh_t
*
ws_init
(
ws_tsession_t
*
tsession
);
i
ssize_t
ws_close
(
wsh_t
*
wsh
,
int16_t
reason
);
void
ws_destroy
(
wsh_t
*
wsh
);
void
init_ssl
(
void
);
void
deinit_ssl
(
void
);
int
xp_errno
(
void
);
int
xp_is_blocking
(
int
errcode
);
int
ws_handshake_kvp
(
wsh_t
*
wsh
,
char
*
key
,
char
*
version
,
char
*
proto
);
#ifndef _MSC_VER
...
...
编写
预览
Markdown
格式
0%
重试
或
添加新文件
添加附件
取消
您添加了
0
人
到此讨论。请谨慎行事。
请先完成此评论的编辑!
取消
请
注册
或者
登录
后发表评论