GitLab/ocserv
1
0
Fork 0
mirror of https://gitlab.com/openconnect/ocserv.git synced 2026-02-10 08:46:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

Use 32-bit length variable for transferring between occtl and ocserv

Browse Source 
This allows to handle the transfer of long data between ocserv and occtl.
Reported by Liviu.

Resolves #29
This commit is contained in:
Nikos Mavrogiannopoulos
2016-01-28 13:12:21 +01:00
parent 353bd39686
commit ff5b2b7aad
13 changed files with 128 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
src/common/common.c
View File

@@ -30,6 +30,7 @@
#include <netinet/in.h>
#include <netinet/ip.h>
#include <poll.h>
#include <limits.h>
#include "common.h"
@@ -277,9 +278,11 @@ ssize_t recvmsg_timeout(int sockfd, struct msghdr * msg, int flags,
}
/* Sends message + socketfd */
static
int send_socket_msg(void *pool, int fd, uint8_t cmd,
int socketfd,
const void *msg, pack_size_func get_size, pack_func pack)
int socketfd, const void *msg,
pack_size_func get_size, pack_func pack,
unsigned use_32bit)
{
struct iovec iov[3];
struct msghdr hdr;
@@ -289,7 +292,9 @@ int send_socket_msg(void *pool, int fd, uint8_t cmd,
} control_un;
struct cmsghdr *cmptr;
void *packed = NULL;
uint16_t length;
uint16_t length16;
uint32_t length32;
size_t length;
int ret;
memset(&hdr, 0, sizeof(hdr));
@@ -299,8 +304,21 @@ int send_socket_msg(void *pool, int fd, uint8_t cmd,
length = get_size(msg);
iov[1].iov_base = &length;
iov[1].iov_len = 2;
if (use_32bit) {
if (length >= UINT32_MAX)
return -1;
length32 = length;
iov[1].iov_base = &length32;
iov[1].iov_len = 4;
} else {
if (length >= UINT16_MAX)
return -1;
length16 = length;
iov[1].iov_base = &length16;
iov[1].iov_len = 2;
}
hdr.msg_iov = iov;
hdr.msg_iovlen = 2;
@@ -349,16 +367,23 @@ int send_socket_msg(void *pool, int fd, uint8_t cmd,
cleanup:
talloc_free(packed);
return ret;
}
int send_msg(void *pool, int fd, uint8_t cmd,
const void *msg, pack_size_func get_size, pack_func pack)
int send_socket_msg16(void *pool, int fd, uint8_t cmd,
int socketfd, const void *msg,
pack_size_func get_size, pack_func pack)
{
return send_socket_msg(pool, fd, cmd, -1, msg, get_size, pack);
return send_socket_msg(pool, fd, cmd, socketfd, msg, get_size, pack, 0);
}
int recv_socket_msg(void *pool, int fd, uint8_t cmd,
int send_socket_msg32(void *pool, int fd, uint8_t cmd,
int socketfd, const void *msg,
pack_size_func get_size, pack_func pack)
{
return send_socket_msg(pool, fd, cmd, socketfd, msg, get_size, pack, 1);
}
int recv_socket_msg16(void *pool, int fd, uint8_t cmd,
int *socketfd, void **msg, unpack_func unpack,
unsigned timeout)
{
@@ -463,12 +488,6 @@ int recv_socket_msg(void *pool, int fd, uint8_t cmd,
return ret;
}
int recv_msg(void *pool, int fd, uint8_t cmd,
void **msg, unpack_func unpack, unsigned timeout)
{
return recv_socket_msg(pool, fd, cmd, NULL, msg, unpack, timeout);
}
void _talloc_free2(void *ctx, void *ptr)
{
talloc_free(ptr);

38
src/common/common.h
View File

@@ -54,19 +54,39 @@ typedef void* (*unpack_func)(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
int send_msg(void *pool, int fd, uint8_t cmd,
const void* msg, pack_size_func get_size, pack_func pack);
int send_socket_msg16(void *pool, int fd, uint8_t cmd,
int socketfd,
const void* msg, pack_size_func get_size, pack_func pack);
int send_socket_msg(void *pool, int fd, uint8_t cmd,
int socketfd,
const void* msg, pack_size_func get_size, pack_func pack);
int send_socket_msg32(void *pool, int fd, uint8_t cmd,
int socketfd,
const void* msg, pack_size_func get_size, pack_func pack);
inline static int send_msg16(void *pool, int fd, uint8_t cmd,
const void *msg, pack_size_func get_size, pack_func pack)
{
return send_socket_msg16(pool, fd, cmd, -1, msg, get_size, pack);
}
inline static
int send_msg32(void *pool, int fd, uint8_t cmd,
const void *msg, pack_size_func get_size, pack_func pack)
{
return send_socket_msg32(pool, fd, cmd, -1, msg, get_size, pack);
}
int recv_socket_msg16(void *pool, int fd, uint8_t cmd,
int *socketfd, void** msg, unpack_func, unsigned timeout);
/* the timeout is in seconds */
int recv_msg(void *pool, int fd, uint8_t cmd,
void** msg, unpack_func, unsigned timeout);
inline static int recv_msg16(void *pool, int fd, uint8_t cmd,
void **msg, unpack_func unpack, unsigned timeout)
{
return recv_socket_msg16(pool, fd, cmd, NULL, msg, unpack, timeout);
}
int recv_socket_msg(void *pool, int fd, uint8_t cmd,
int *socketfd, void** msg, unpack_func, unsigned timeout);
const char* cmd_request_to_str(unsigned cmd);
const char* discon_reason_to_str(unsigned reason);

20
src/main-ctl-unix.c
View File

@@ -183,7 +183,7 @@ static void method_status(method_ctx *ctx, int cfd, uint8_t * msg,
rep.stored_tls_sessions = ctx->s->tlsdb_entries;
rep.banned_ips = main_ban_db_elems(ctx->s);
ret = send_msg(ctx->pool, cfd, CTL_CMD_STATUS_REP, &rep,
ret = send_msg32(ctx->pool, cfd, CTL_CMD_STATUS_REP, &rep,
(pack_size_func) status_rep__get_packed_size,
(pack_func) status_rep__pack);
if (ret < 0) {
@@ -205,7 +205,7 @@ static void method_reload(method_ctx *ctx, int cfd, uint8_t * msg,
rep.status = 1;
ret = send_msg(ctx->pool, cfd, CTL_CMD_RELOAD_REP, &rep,
ret = send_msg32(ctx->pool, cfd, CTL_CMD_RELOAD_REP, &rep,
(pack_size_func) bool_msg__get_packed_size,
(pack_func) bool_msg__pack);
if (ret < 0) {
@@ -227,7 +227,7 @@ static void method_stop(method_ctx *ctx, int cfd, uint8_t * msg,
rep.status = 1;
ret = send_msg(ctx->pool, cfd, CTL_CMD_STOP_REP, &rep,
ret = send_msg32(ctx->pool, cfd, CTL_CMD_STOP_REP, &rep,
(pack_size_func) bool_msg__get_packed_size,
(pack_func) bool_msg__pack);
if (ret < 0) {
@@ -427,7 +427,7 @@ static void method_list_users(method_ctx *ctx, int cfd, uint8_t * msg,
}
}
ret = send_msg(ctx->pool, cfd, CTL_CMD_LIST_REP, &rep,
ret = send_msg32(ctx->pool, cfd, CTL_CMD_LIST_REP, &rep,
(pack_size_func) user_list_rep__get_packed_size,
(pack_func) user_list_rep__pack);
if (ret < 0) {
@@ -505,7 +505,7 @@ static void method_list_banned(method_ctx *ctx, int cfd, uint8_t * msg,
e = htable_next(db, &iter);
}
ret = send_msg(ctx->pool, cfd, CTL_CMD_LIST_BANNED_REP, &rep,
ret = send_msg32(ctx->pool, cfd, CTL_CMD_LIST_BANNED_REP, &rep,
(pack_size_func) ban_list_rep__get_packed_size,
(pack_func) ban_list_rep__pack);
if (ret < 0) {
@@ -561,7 +561,7 @@ static void single_info_common(method_ctx *ctx, int cfd, uint8_t * msg,
mslog(ctx->s, NULL, LOG_INFO, "could not find ID '%u'", id);
}
ret = send_msg(ctx->pool, cfd, CTL_CMD_LIST_REP, &rep,
ret = send_msg32(ctx->pool, cfd, CTL_CMD_LIST_REP, &rep,
(pack_size_func) user_list_rep__get_packed_size,
(pack_func) user_list_rep__pack);
if (ret < 0) {
@@ -633,7 +633,7 @@ static void method_unban_ip(method_ctx *ctx,
unban_req__free_unpacked(req, NULL);
ret = send_msg(ctx->pool, cfd, CTL_CMD_UNBAN_IP_REP, &rep,
ret = send_msg32(ctx->pool, cfd, CTL_CMD_UNBAN_IP_REP, &rep,
(pack_size_func) bool_msg__get_packed_size,
(pack_func) bool_msg__pack);
if (ret < 0) {
@@ -672,7 +672,7 @@ static void method_disconnect_user_name(method_ctx *ctx,
username_req__free_unpacked(req, NULL);
ret = send_msg(ctx->pool, cfd, CTL_CMD_DISCONNECT_NAME_REP, &rep,
ret = send_msg32(ctx->pool, cfd, CTL_CMD_DISCONNECT_NAME_REP, &rep,
(pack_size_func) bool_msg__get_packed_size,
(pack_func) bool_msg__pack);
if (ret < 0) {
@@ -712,7 +712,7 @@ static void method_disconnect_user_id(method_ctx *ctx, int cfd,
/* reply */
id_req__free_unpacked(req, NULL);
ret = send_msg(ctx->pool, cfd, CTL_CMD_DISCONNECT_ID_REP, &rep,
ret = send_msg32(ctx->pool, cfd, CTL_CMD_DISCONNECT_ID_REP, &rep,
(pack_size_func) bool_msg__get_packed_size,
(pack_func) bool_msg__pack);
if (ret < 0) {
@@ -887,7 +887,7 @@ void ctl_handler_notify (main_server_st* s, struct proc_st *proc, unsigned conne
}
rep.user = &list;
ret = send_msg(pool, s->top_fd, CTL_CMD_TOP_UPDATE_REP, &rep,
ret = send_msg32(pool, s->top_fd, CTL_CMD_TOP_UPDATE_REP, &rep,
(pack_size_func) top_update_rep__get_packed_size,
(pack_func) top_update_rep__pack);
if (ret < 0) {

10
src/main-sec-mod-cmd.c
View File

@@ -170,7 +170,7 @@ int handle_sec_mod_commands(main_server_st * s)
mslog(s, NULL, LOG_DEBUG, "sending msg %s to sec-mod", cmd_request_to_str(SM_CMD_AUTH_BAN_IP_REPLY));
ret = send_msg(NULL, s->sec_mod_fd, SM_CMD_AUTH_BAN_IP_REPLY,
ret = send_msg16(NULL, s->sec_mod_fd, SM_CMD_AUTH_BAN_IP_REPLY,
&reply, (pack_size_func)ban_ip_reply_msg__get_packed_size,
(pack_func)ban_ip_reply_msg__pack);
if (ret < 0) {
@@ -460,7 +460,7 @@ int session_open(main_server_st * s, struct proc_st *proc, const uint8_t *cookie
mslog(s, proc, LOG_DEBUG, "sending msg %s to sec-mod", cmd_request_to_str(SM_CMD_AUTH_SESSION_OPEN));
ret = send_msg(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_OPEN,
ret = send_msg16(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_OPEN,
&ireq, (pack_size_func)sec_auth_session_msg__get_packed_size,
(pack_func)sec_auth_session_msg__pack);
if (ret < 0) {
@@ -469,7 +469,7 @@ int session_open(main_server_st * s, struct proc_st *proc, const uint8_t *cookie
return -1;
}
ret = recv_msg(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_REPLY,
ret = recv_msg16(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_REPLY,
(void *)&msg, (unpack_func) sec_auth_session_reply_msg__unpack, MAIN_SEC_MOD_TIMEOUT);
if (ret < 0) {
e = errno;
@@ -512,7 +512,7 @@ int session_close(main_server_st * s, struct proc_st *proc)
mslog(s, proc, LOG_DEBUG, "sending msg %s to sec-mod", cmd_request_to_str(SM_CMD_AUTH_SESSION_CLOSE));
ret = send_msg(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_CLOSE,
ret = send_msg16(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_CLOSE,
&ireq, (pack_size_func)sec_auth_session_msg__get_packed_size,
(pack_func)sec_auth_session_msg__pack);
if (ret < 0) {
@@ -521,7 +521,7 @@ int session_close(main_server_st * s, struct proc_st *proc)
return -1;
}
ret = recv_msg(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_CLI_STATS,
ret = recv_msg16(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_CLI_STATS,
(void *)&msg, (unpack_func) cli_stats_msg__unpack, MAIN_SEC_MOD_TIMEOUT);
if (ret < 0) {
e = errno;

4
src/main.h
View File

@@ -315,7 +315,7 @@ int send_msg_to_worker(main_server_st* s, struct proc_st* proc, uint8_t cmd,
const void* msg, pack_size_func get_size, pack_func pack)
{
mslog(s, proc, LOG_DEBUG, "sending message '%s' to worker", cmd_request_to_str(cmd));
return send_msg(proc, proc->fd, cmd, msg, get_size, pack);
return send_msg16(proc, proc->fd, cmd, msg, get_size, pack);
}
inline static
@@ -323,7 +323,7 @@ int send_socket_msg_to_worker(main_server_st* s, struct proc_st* proc, uint8_t c
int socketfd, const void* msg, pack_size_func get_size, pack_func pack)
{
mslog(s, proc, LOG_DEBUG, "sending (socket) message %u to worker", (unsigned)cmd);
return send_socket_msg(proc, proc->fd, cmd, socketfd, msg, get_size, pack);
return send_socket_msg16(proc, proc->fd, cmd, socketfd, msg, get_size, pack);
}
void request_reload(int signo);

51
src/occtl/unix.c
View File

@@ -95,26 +95,27 @@ int send_cmd(struct unix_ctx *ctx, unsigned cmd, const void *data,
struct iovec iov[2];
unsigned iov_len = 1;
int e, ret;
uint16_t length = 0;
uint16_t rlength = 0;
uint32_t length32 = 0;
void *packed = NULL;
if (get_size)
length = get_size(data);
rlength = get_size(data);
header[0] = cmd;
memcpy(&header[1], &length, 2);
memcpy(&header[1], &rlength, 2);
iov[0].iov_base = header;
iov[0].iov_len = 3;
if (data != NULL) {
packed = talloc_size(ctx, length);
packed = talloc_size(ctx, rlength);
if (packed == NULL) {
fprintf(stderr, "memory error\n");
return -1;
}
iov[1].iov_base = packed;
iov[1].iov_len = length;
iov[1].iov_len = rlength;
ret = pack(data, packed);
if (ret == 0) {
@@ -134,7 +135,7 @@ int send_cmd(struct unix_ctx *ctx, unsigned cmd, const void *data,
}
if (rep != NULL) {
ret = force_read_timeout(ctx->fd, header, 3, DEFAULT_TIMEOUT);
ret = force_read_timeout(ctx->fd, header, 1+sizeof(length32), DEFAULT_TIMEOUT);
if (ret == -1) {
/*e = errno;
fprintf(stderr, "read: %s\n", strerror(e));*/
@@ -142,7 +143,7 @@ int send_cmd(struct unix_ctx *ctx, unsigned cmd, const void *data,
goto fail;
}
if (ret != 3) {
if (ret != 1+sizeof(length32)) {
fprintf(stderr, "short read %d\n", ret);
ret = -1;
goto fail;
@@ -156,17 +157,17 @@ int send_cmd(struct unix_ctx *ctx, unsigned cmd, const void *data,
goto fail;
}
memcpy(&length, &header[1], 2);
memcpy(&length32, &header[1], 4);
rep->data_size = length;
rep->data = talloc_size(ctx, length);
rep->data_size = length32;
rep->data = talloc_size(ctx, length32);
if (rep->data == NULL) {
fprintf(stderr, "memory error\n");
ret = -1;
goto fail;
}
ret = force_read_timeout(ctx->fd, rep->data, length, DEFAULT_TIMEOUT);
ret = force_read_timeout(ctx->fd, rep->data, length32, DEFAULT_TIMEOUT);
if (ret == -1) {
e = errno;
talloc_free(rep->data);
@@ -1063,7 +1064,7 @@ int handle_events_cmd(struct unix_ctx *ctx, const char *arg, cmd_params_st *para
struct cmd_reply_st raw;
UserListRep *rep1 = NULL;
TopUpdateRep *rep2 = NULL;
uint16_t length;
uint32_t slength;
unsigned data_size;
uint8_t *data = NULL;
char *groupname;
@@ -1113,7 +1114,7 @@ int handle_events_cmd(struct unix_ctx *ctx, const char *arg, cmd_params_st *para
if (ret == -1) {
int e = errno;
fprintf(stderr, "top: select: %s\n", strerror(e));
fprintf(stderr, "events: select: %s\n", strerror(e));
ret = -1;
break;
}
@@ -1129,46 +1130,46 @@ int handle_events_cmd(struct unix_ctx *ctx, const char *arg, cmd_params_st *para
if (!FD_ISSET(ctx->fd, &rfds))
continue;
ret = read(ctx->fd, header, 3);
ret = force_read_timeout(ctx->fd, header, 1+sizeof(slength), DEFAULT_TIMEOUT);
if (ret == -1) {
int e = errno;
fprintf(stderr, "top: read1: %s\n", strerror(e));
fprintf(stderr, "events: read1: %s\n", strerror(e));
ret = -1;
break;
}
if (ret == 0) {
fprintf(stderr, "top: server closed the connection\n");
fprintf(stderr, "events: server closed the connection\n");
ret = 0;
break;
}
if (ret != 3) {
fprintf(stderr, "top: short read %d\n", ret);
if (ret != 1+sizeof(slength)) {
fprintf(stderr, "events: short read %d\n", ret);
ret = -1;
break;
}
if (header[0] != CTL_CMD_TOP_UPDATE_REP) {
fprintf(stderr, "top: Unexpected message '%d', expected '%d'\n", (int)header[0], (int)CTL_CMD_TOP_UPDATE_REP);
fprintf(stderr, "events: Unexpected message '%d', expected '%d'\n", (int)header[0], (int)CTL_CMD_TOP_UPDATE_REP);
ret = -1;
break;
}
memcpy(&length, &header[1], 2);
memcpy(&slength, &header[1], sizeof(slength));
data_size = length;
data = talloc_size(ctx, length);
data_size = slength;
data = talloc_size(ctx, slength);
if (data == NULL) {
fprintf(stderr, "top: memory error\n");
fprintf(stderr, "events: memory error\n");
ret = -1;
break;
}
ret = read(ctx->fd, data, data_size);
ret = force_read(ctx->fd, data, data_size);
if (ret == -1) {
int e = errno;
fprintf(stderr, "top: read: %s\n", strerror(e));
fprintf(stderr, "events: read: %s\n", strerror(e));
ret = -1;
break;
}

18
src/sec-mod-auth.c
View File

@@ -94,7 +94,7 @@ void sec_mod_add_score_to_ip(sec_mod_st *sec, client_entry_st *e, const char *ip
return;
}
ret = send_msg(lpool, sec->cmd_fd, SM_CMD_AUTH_BAN_IP, &msg,
ret = send_msg16(lpool, sec->cmd_fd, SM_CMD_AUTH_BAN_IP, &msg,
(pack_size_func) ban_ip_msg__get_packed_size,
(pack_func) ban_ip_msg__pack);
if (ret < 0) {
@@ -178,7 +178,7 @@ int send_sec_auth_reply(int cfd, sec_mod_st * sec, client_entry_st * entry, AUTH
msg.dtls_session_id.data = entry->dtls_session_id;
msg.dtls_session_id.len = sizeof(entry->dtls_session_id);
ret = send_msg(entry, cfd, SM_CMD_AUTH_REP,
ret = send_msg16(entry, cfd, SM_CMD_AUTH_REP,
&msg,
(pack_size_func)
sec_auth_reply_msg__get_packed_size,
@@ -186,7 +186,7 @@ int send_sec_auth_reply(int cfd, sec_mod_st * sec, client_entry_st * entry, AUTH
} else {
msg.reply = AUTH__REP__FAILED;
ret = send_msg(entry, cfd, SM_CMD_AUTH_REP,
ret = send_msg16(entry, cfd, SM_CMD_AUTH_REP,
&msg,
(pack_size_func)
sec_auth_reply_msg__get_packed_size,
@@ -222,7 +222,7 @@ int send_sec_auth_reply_msg(int cfd, sec_mod_st * sec, client_entry_st * e)
msg.sid.data = e->sid;
msg.sid.len = sizeof(e->sid);
ret = send_msg(e, cfd, SM_CMD_AUTH_REP, &msg,
ret = send_msg16(e, cfd, SM_CMD_AUTH_REP, &msg,
(pack_size_func) sec_auth_reply_msg__get_packed_size,
(pack_func) sec_auth_reply_msg__pack);
if (ret < 0) {
@@ -389,7 +389,7 @@ int send_failed_session_open_reply(sec_mod_st *sec, int fd)
return ERR_BAD_COMMAND;
}
ret = send_msg(lpool, fd, SM_CMD_AUTH_SESSION_REPLY, &rep,
ret = send_msg16(lpool, fd, SM_CMD_AUTH_SESSION_REPLY, &rep,
(pack_size_func) sec_auth_session_reply_msg__get_packed_size,
(pack_func) sec_auth_session_reply_msg__pack);
if (ret < 0) {
@@ -476,7 +476,7 @@ int handle_sec_auth_session_open(sec_mod_st *sec, int fd, const SecAuthSessionMs
}
}
ret = send_msg(lpool, fd, SM_CMD_AUTH_SESSION_REPLY, &rep,
ret = send_msg16(lpool, fd, SM_CMD_AUTH_SESSION_REPLY, &rep,
(pack_size_func) sec_auth_session_reply_msg__get_packed_size,
(pack_func) sec_auth_session_reply_msg__pack);
if (ret < 0) {
@@ -510,14 +510,14 @@ int handle_sec_auth_session_close(sec_mod_st *sec, int fd, const SecAuthSessionM
char tmp[BASE64_ENCODE_RAW_LENGTH(SID_SIZE) + 1];
oc_base64_encode((char *)req->sid.data, req->sid.len, (char *)tmp, sizeof(tmp));
seclog(sec, LOG_INFO, "session close but with non-existing SID: %s", tmp);
return send_msg(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
return send_msg16(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
(pack_size_func) cli_stats_msg__get_packed_size,
(pack_func) cli_stats_msg__pack);
}
if (e->status < PS_AUTH_COMPLETED) {
seclog(sec, LOG_DEBUG, "session close received in unauthenticated client %s "SESSION_STR"!", e->acct_info.username, e->acct_info.psid);
return send_msg(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
return send_msg16(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
(pack_size_func) cli_stats_msg__get_packed_size,
(pack_func) cli_stats_msg__pack);
}
@@ -544,7 +544,7 @@ int handle_sec_auth_session_close(sec_mod_st *sec, int fd, const SecAuthSessionM
rep.secmod_tlsdb_entries = sec->tls_db.entries;
rep.has_secmod_tlsdb_entries = 1;
ret = send_msg(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
ret = send_msg16(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
(pack_size_func) cli_stats_msg__get_packed_size,
(pack_func) cli_stats_msg__pack);
if (ret < 0) {

6
src/sec-mod.c
View File

@@ -188,7 +188,7 @@ static int send_refresh_cookie_key(sec_mod_st * sec, void *key_data, unsigned ke
msg.key.data = key_data;
msg.key.len = key_size;
ret = send_msg(sec, sec->cmd_fd, SM_CMD_REFRESH_COOKIE_KEY, &msg,
ret = send_msg16(sec, sec->cmd_fd, SM_CMD_REFRESH_COOKIE_KEY, &msg,
(pack_size_func) sec_refresh_cookie_key__get_packed_size,
(pack_func) sec_refresh_cookie_key__pack);
if (ret < 0) {
@@ -207,7 +207,7 @@ static int handle_op(void *pool, int cfd, sec_mod_st * sec, uint8_t type, uint8_
msg.data.data = rep;
msg.data.len = rep_size;
ret = send_msg(pool, cfd, type, &msg,
ret = send_msg16(pool, cfd, type, &msg,
(pack_size_func) sec_op_msg__get_packed_size,
(pack_func) sec_op_msg__pack);
if (ret < 0) {
@@ -404,7 +404,7 @@ int process_packet(void *pool, int cfd, pid_t pid, sec_mod_st * sec, cmd_request
}
ret =
send_msg(pool, cfd, RESUME_FETCH_REP, &msg,
send_msg16(pool, cfd, RESUME_FETCH_REP, &msg,
(pack_size_func)
session_resume_reply_msg__get_packed_size,
(pack_func)

4
src/tlslib.c
View File

@@ -636,14 +636,14 @@ int key_cb_common_func (gnutls_privkey_t key, void* userdata, const gnutls_datum
msg.data.data = raw_data->data;
msg.data.len = raw_data->size;
ret = send_msg(userdata, sd, type, &msg,
ret = send_msg16(userdata, sd, type, &msg,
(pack_size_func)sec_op_msg__get_packed_size,
(pack_func)sec_op_msg__pack);
if (ret < 0) {
goto error;
}
ret = recv_msg(userdata, sd, type, (void*)&reply,
ret = recv_msg16(userdata, sd, type, (void*)&reply,
(unpack_func)sec_op_msg__unpack,
DEFAULT_SOCKET_TIMEOUT);
if (ret < 0) {

4
src/worker-auth.c
View File

@@ -533,7 +533,7 @@ static int recv_cookie_auth_reply(worker_st * ws)
AuthReplyMsg *msg = NULL;
PROTOBUF_ALLOCATOR(pa, ws);
ret = recv_socket_msg(ws, ws->cmd_fd, AUTH_COOKIE_REP, &socketfd,
ret = recv_socket_msg16(ws, ws->cmd_fd, AUTH_COOKIE_REP, &socketfd,
(void *)&msg,
(unpack_func) auth_reply_msg__unpack,
DEFAULT_SOCKET_TIMEOUT);
@@ -674,7 +674,7 @@ static int recv_auth_reply(worker_st * ws, int sd, char **txt, unsigned *pcounte
SecAuthReplyMsg *msg = NULL;
PROTOBUF_ALLOCATOR(pa, ws);
ret = recv_msg(ws, sd, SM_CMD_AUTH_REP,
ret = recv_msg16(ws, sd, SM_CMD_AUTH_REP,
(void *)&msg, (unpack_func) sec_auth_reply_msg__unpack,
DEFAULT_SOCKET_TIMEOUT);
if (ret < 0) {

2
src/worker-resume.c
View File

@@ -47,7 +47,7 @@ static int recv_resume_fetch_reply(worker_st *ws, int sd, gnutls_datum_t *sdata)
SessionResumeReplyMsg *resp;
PROTOBUF_ALLOCATOR(pa, ws);
ret = recv_msg(ws, sd, RESUME_FETCH_REP, (void*)&resp,
ret = recv_msg16(ws, sd, RESUME_FETCH_REP, (void*)&resp,
(unpack_func)session_resume_reply_msg__unpack, DEFAULT_SOCKET_TIMEOUT);
if (ret < 0) {
oclog(ws, LOG_ERR, "error receiving resumption reply (fetch)");

4
src/worker-vpn.c
View File

@@ -283,7 +283,7 @@ void ws_add_score_to_ip(worker_st *ws, unsigned points, unsigned final)
msg.ip = ws->remote_ip_str;
msg.score = points;
ret = send_msg(ws, ws->cmd_fd, CMD_BAN_IP, &msg,
ret = send_msg16(ws, ws->cmd_fd, CMD_BAN_IP, &msg,
(pack_size_func) ban_ip_msg__get_packed_size,
(pack_func) ban_ip_msg__pack);
if (ret < 0) {
@@ -295,7 +295,7 @@ void ws_add_score_to_ip(worker_st *ws, unsigned points, unsigned final)
if (final != 0)
return;
ret = recv_msg(ws, ws->cmd_fd, CMD_BAN_IP_REPLY,
ret = recv_msg16(ws, ws->cmd_fd, CMD_BAN_IP_REPLY,
(void *)&reply, (unpack_func) ban_ip_reply_msg__unpack, DEFAULT_SOCKET_TIMEOUT);
if (ret < 0) {
oclog(ws, LOG_ERR, "error receiving BAN IP reply message");

4
src/worker.h
View File

@@ -348,7 +348,7 @@ int send_msg_to_secmod(worker_st * ws, int sd, uint8_t cmd,
oclog(ws, LOG_DEBUG, "sending message '%s' to secmod",
cmd_request_to_str(cmd));
return send_msg(ws, sd, cmd, msg, get_size, pack);
return send_msg16(ws, sd, cmd, msg, get_size, pack);
}
inline static
@@ -356,7 +356,7 @@ int send_msg_to_main(worker_st *ws, uint8_t cmd,
const void* msg, pack_size_func get_size, pack_func pack)
{
oclog(ws, LOG_DEBUG, "sending message '%s' to main", cmd_request_to_str(cmd));
return send_msg(ws, ws->cmd_fd, cmd, msg, get_size, pack);
return send_msg16(ws, ws->cmd_fd, cmd, msg, get_size, pack);
}
int parse_proxy_proto_header(struct worker_st *ws, int fd);