kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-11-07 02:18:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merged revisions 163670 via svnmerge from

Browse Source 
https://origsvn.digium.com/svn/asterisk/trunk

........
r163670 | russell | 2008-12-12 12:45:03 -0600 (Fri, 12 Dec 2008) | 6 lines

Rename a number of tcptls_session variables.  There are no functional changes here.

The name "ser" was used in a lot of places.  However, it is a relic from when
the struct was a server_instance, not a session_instance.  It was renamed since
it represents both a server or client connection.

........


git-svn-id: https://origsvn.digium.com/svn/asterisk/branches/1.6.0@163671 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Russell Bryant
2008-12-12 18:52:14 +00:00
parent ab65296510
commit 1b1801f155
2 changed files with 136 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
channels/chan_sip.c
View File

@@ -784,7 +784,7 @@ struct sip_socket {
enum sip_transport type; enum sip_transport type;
int fd; int fd;
uint16_t port; uint16_t port;
struct ast_tcptls_session_instance *ser; struct ast_tcptls_session_instance *tcptls_session; /* If tcp or tls, a socket manager */
}; };
/*! \brief sip_request: The data grabbed from the UDP socket /*! \brief sip_request: The data grabbed from the UDP socket
@@ -1566,7 +1566,7 @@ struct sip_registry {
struct sip_threadinfo { struct sip_threadinfo {
int stop; int stop;
pthread_t threadid; pthread_t threadid;
struct ast_tcptls_session_instance *ser; struct ast_tcptls_session_instance *tcptls_session;
enum sip_transport type; /* We keep a copy of the type here so we can display it in the connection list */ enum sip_transport type; /* We keep a copy of the type here so we can display it in the connection list */
AST_LIST_ENTRY(sip_threadinfo) list; AST_LIST_ENTRY(sip_threadinfo) list;
}; };
@@ -2002,7 +2002,7 @@ static int get_msg_text(char *buf, int len, struct sip_request *req);
static int transmit_state_notify(struct sip_pvt *p, int state, int full, int timeout); static int transmit_state_notify(struct sip_pvt *p, int state, int full, int timeout);
/*-- TCP connection handling ---*/ /*-- TCP connection handling ---*/
static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_session_instance *ser); static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_session_instance *tcptls_session);
static void *sip_tcp_worker_fn(void *); static void *sip_tcp_worker_fn(void *);
/*--- Constructing requests and responses */ /*--- Constructing requests and responses */
@@ -2196,13 +2196,13 @@ static struct ast_rtp_protocol sip_rtp = {
/*! \brief SIP TCP connection handler */ /*! \brief SIP TCP connection handler */
static void *sip_tcp_worker_fn(void *data) static void *sip_tcp_worker_fn(void *data)
{ {
struct ast_tcptls_session_instance *ser = data; struct ast_tcptls_session_instance *tcptls_session = data;
return _sip_tcp_helper_thread(NULL, ser); return _sip_tcp_helper_thread(NULL, tcptls_session);
} }
/*! \brief SIP TCP thread management function */ /*! \brief SIP TCP thread management function */
static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_session_instance *ser) static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_session_instance *tcptls_session)
{ {
int res, cl; int res, cl;
struct sip_request req = { 0, } , reqcpy = { 0, }; struct sip_request req = { 0, } , reqcpy = { 0, };
@@ -2215,12 +2215,14 @@ static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_sessi
goto cleanup2; goto cleanup2;
me->threadid = pthread_self(); me->threadid = pthread_self();
me->ser = ser; me->tcptls_session = tcptls_session;
if (ser->ssl) if (tcptls_session->ssl)
me->type = SIP_TRANSPORT_TLS; me->type = SIP_TRANSPORT_TLS;
else else
me->type = SIP_TRANSPORT_TCP; me->type = SIP_TRANSPORT_TCP;
ast_debug(2, "Starting thread for %s server\n", tcptls_session->ssl ? "SSL" : "TCP");
AST_LIST_LOCK(&threadl); AST_LIST_LOCK(&threadl);
AST_LIST_INSERT_TAIL(&threadl, me, list); AST_LIST_INSERT_TAIL(&threadl, me, list);
AST_LIST_UNLOCK(&threadl); AST_LIST_UNLOCK(&threadl);
@@ -2232,28 +2234,28 @@ static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_sessi
req.ignore = 0; req.ignore = 0;
req.debug = 0; req.debug = 0;
req.socket.fd = ser->fd; req.socket.fd = tcptls_session->fd;
if (ser->ssl) { if (tcptls_session->ssl) {
req.socket.type = SIP_TRANSPORT_TLS; req.socket.type = SIP_TRANSPORT_TLS;
req.socket.port = htons(ourport_tls); req.socket.port = htons(ourport_tls);
} else { } else {
req.socket.type = SIP_TRANSPORT_TCP; req.socket.type = SIP_TRANSPORT_TCP;
req.socket.port = htons(ourport_tcp); req.socket.port = htons(ourport_tcp);
} }
res = ast_wait_for_input(ser->fd, -1); res = ast_wait_for_input(tcptls_session->fd, -1);
if (res < 0) { if (res < 0) {
ast_debug(1, "ast_wait_for_input returned %d\n", res); ast_debug(2, "SIP %s server :: ast_wait_for_input returned %d\n", tcptls_session->ssl ? "SSL": "TCP", res);
goto cleanup; goto cleanup;
} }
/* Read in headers one line at a time */ /* Read in headers one line at a time */
while (req.len < 4 || strncmp((char *)&req.data + req.len - 4, "\r\n\r\n", 4)) { while (req.len < 4 || strncmp((char *)&req.data + req.len - 4, "\r\n\r\n", 4)) {
ast_mutex_lock(&ser->lock); ast_mutex_lock(&tcptls_session->lock);
if (!fgets(buf, sizeof(buf), ser->f)) { if (!fgets(buf, sizeof(buf), tcptls_session->f)) {
ast_mutex_unlock(&ser->lock); ast_mutex_unlock(&tcptls_session->lock);
goto cleanup; goto cleanup;
} }
ast_mutex_unlock(&ser->lock); ast_mutex_unlock(&tcptls_session->lock);
if (me->stop) if (me->stop)
goto cleanup; goto cleanup;
strncat(req.data, buf, sizeof(req.data) - req.len - 1); strncat(req.data, buf, sizeof(req.data) - req.len - 1);
@@ -2262,12 +2264,12 @@ static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_sessi
parse_copy(&reqcpy, &req); parse_copy(&reqcpy, &req);
if (sscanf(get_header(&reqcpy, "Content-Length"), "%d", &cl)) { if (sscanf(get_header(&reqcpy, "Content-Length"), "%d", &cl)) {
while (cl > 0) { while (cl > 0) {
ast_mutex_lock(&ser->lock); ast_mutex_lock(&tcptls_session->lock);
if (!fread(buf, (cl < sizeof(buf)) ? cl : sizeof(buf), 1, ser->f)) { if (!fread(buf, (cl < sizeof(buf)) ? cl : sizeof(buf), 1, tcptls_session->f)) {
ast_mutex_unlock(&ser->lock); ast_mutex_unlock(&tcptls_session->lock);
goto cleanup; goto cleanup;
} }
ast_mutex_unlock(&ser->lock); ast_mutex_unlock(&tcptls_session->lock);
if (me->stop) if (me->stop)
goto cleanup; goto cleanup;
cl -= strlen(buf); cl -= strlen(buf);
@@ -2275,8 +2277,8 @@ static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_sessi
req.len = strlen(req.data); req.len = strlen(req.data);
} }
} }
req.socket.ser = ser; req.socket.tcptls_session = tcptls_session;
handle_request_do(&req, &ser->requestor); handle_request_do(&req, &tcptls_session->requestor);
} }
cleanup: cleanup:
@@ -2285,12 +2287,14 @@ cleanup:
AST_LIST_UNLOCK(&threadl); AST_LIST_UNLOCK(&threadl);
ast_free(me); ast_free(me);
cleanup2: cleanup2:
fclose(ser->f); fclose(tcptls_session->f);
ser->f = NULL; tcptls_session->f = NULL;
ser->fd = -1; tcptls_session->fd = -1;
ao2_ref(ser, -1); ast_debug(2, "Shutting down thread for %s server\n", tcptls_session->ssl ? "SSL" : "TCP");
ser = NULL;
ao2_ref(tcptls_session, -1);
tcptls_session = NULL;
return NULL; return NULL;
} }
@@ -2591,20 +2595,20 @@ static int __sip_xmit(struct sip_pvt *p, char *data, int len)
if (sip_prepare_socket(p) < 0) if (sip_prepare_socket(p) < 0)
return XMIT_ERROR; return XMIT_ERROR;
if (p->socket.ser) if (p->socket.tcptls_session)
ast_mutex_lock(&p->socket.ser->lock); ast_mutex_lock(&p->socket.tcptls_session->lock);
if (p->socket.type & SIP_TRANSPORT_UDP) if (p->socket.type & SIP_TRANSPORT_UDP)
res = sendto(p->socket.fd, data, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in)); res = sendto(p->socket.fd, data, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in));
else { else {
if (p->socket.ser->f) if (p->socket.tcptls_session->f)
res = ast_tcptls_server_write(p->socket.ser, data, len); res = ast_tcptls_server_write(p->socket.tcptls_session, data, len);
else else
ast_debug(1, "No p->socket.ser->f len=%d\n", len); ast_debug(2, "No p->socket.tcptls_session->f len=%d\n", len);
} }
if (p->socket.ser) if (p->socket.tcptls_session)
ast_mutex_unlock(&p->socket.ser->lock); ast_mutex_unlock(&p->socket.tcptls_session->lock);
if (res == -1) { if (res == -1) {
switch (errno) { switch (errno) {
@@ -3577,9 +3581,9 @@ static void sip_destroy_peer(struct sip_peer *peer)
ast_dnsmgr_release(peer->dnsmgr); ast_dnsmgr_release(peer->dnsmgr);
clear_peer_mailboxes(peer); clear_peer_mailboxes(peer);
if (peer->socket.ser) { if (peer->socket.tcptls_session) {
ao2_ref(peer->socket.ser, -1); ao2_ref(peer->socket.tcptls_session, -1);
peer->socket.ser = NULL; peer->socket.tcptls_session = NULL;
} }
ast_free(peer); ast_free(peer);
} }
@@ -3977,13 +3981,13 @@ static void set_t38_capabilities(struct sip_pvt *p)
static void copy_socket_data(struct sip_socket *to_sock, const struct sip_socket *from_sock) static void copy_socket_data(struct sip_socket *to_sock, const struct sip_socket *from_sock)
{ {
if (to_sock->ser) { if (to_sock->tcptls_session) {
ao2_ref(to_sock->ser, -1); ao2_ref(to_sock->tcptls_session, -1);
to_sock->ser = NULL; to_sock->tcptls_session = NULL;
} }
if (from_sock->ser) { if (from_sock->tcptls_session) {
ao2_ref(from_sock->ser, +1); ao2_ref(from_sock->tcptls_session, +1);
} }
*to_sock = *from_sock; *to_sock = *from_sock;
@@ -4464,9 +4468,9 @@ static int __sip_destroy(struct sip_pvt *p, int lockowner, int lockdialoglist)
ast_string_field_free_memory(p); ast_string_field_free_memory(p);
if (p->socket.ser) { if (p->socket.tcptls_session) {
ao2_ref(p->socket.ser, -1); ao2_ref(p->socket.tcptls_session, -1);
p->socket.ser = NULL; p->socket.tcptls_session = NULL;
} }
ast_free(p); ast_free(p);
@@ -12041,10 +12045,10 @@ static char *sip_show_tcp(struct ast_cli_entry *e, int cmd, struct ast_cli_args
ast_cli(a->fd, FORMAT2, "Host", "Port", "Transport", "Type"); ast_cli(a->fd, FORMAT2, "Host", "Port", "Transport", "Type");
AST_LIST_LOCK(&threadl); AST_LIST_LOCK(&threadl);
AST_LIST_TRAVERSE(&threadl, th, list) { AST_LIST_TRAVERSE(&threadl, th, list) {
ast_cli(a->fd, FORMAT, ast_inet_ntoa(th->ser->requestor.sin_addr), ast_cli(a->fd, FORMAT, ast_inet_ntoa(th->tcptls_session->requestor.sin_addr),
ntohs(th->ser->requestor.sin_port), ntohs(th->tcptls_session->requestor.sin_port),
get_transport(th->type), get_transport(th->type),
(th->ser->client ? "Client" : "Server")); (th->tcptls_session->client ? "Client" : "Server"));
} }
AST_LIST_UNLOCK(&threadl); AST_LIST_UNLOCK(&threadl);
@@ -14689,9 +14693,9 @@ static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req)
} while(0); } while(0);
s = remove_uri_parameters(s); s = remove_uri_parameters(s);
if (p->socket.ser) { if (p->socket.tcptls_session) {
ao2_ref(p->socket.ser, -1); ao2_ref(p->socket.tcptls_session, -1);
p->socket.ser = NULL; p->socket.tcptls_session = NULL;
} }
p->socket.fd = -1; p->socket.fd = -1;
@@ -18640,7 +18644,7 @@ static int sipsock_read(int *id, int fd, short events, void *ignore)
req.socket.fd = sipsock; req.socket.fd = sipsock;
req.socket.type = SIP_TRANSPORT_UDP; req.socket.type = SIP_TRANSPORT_UDP;
req.socket.ser = NULL; req.socket.tcptls_session = NULL;
req.socket.port = bindaddr.sin_port; req.socket.port = bindaddr.sin_port;
handle_request_do(&req, &sin); handle_request_do(&req, &sin);
@@ -18756,10 +18760,10 @@ static struct ast_tcptls_session_instance *sip_tcp_locate(struct sockaddr_in *s)
AST_LIST_LOCK(&threadl); AST_LIST_LOCK(&threadl);
AST_LIST_TRAVERSE(&threadl, th, list) { AST_LIST_TRAVERSE(&threadl, th, list) {
if ((s->sin_family == th->ser->requestor.sin_family) && if ((s->sin_family == th->tcptls_session->requestor.sin_family) &&
(s->sin_addr.s_addr == th->ser->requestor.sin_addr.s_addr) && (s->sin_addr.s_addr == th->tcptls_session->requestor.sin_addr.s_addr) &&
(s->sin_port == th->ser->requestor.sin_port)) { (s->sin_port == th->tcptls_session->requestor.sin_port)) {
tcptls_instance = (ao2_ref(th->ser, +1), th->ser); tcptls_instance = (ao2_ref(th->tcptls_session, +1), th->tcptls_session);
break; break;
} }
} }
@@ -18773,7 +18777,7 @@ static int sip_prepare_socket(struct sip_pvt *p)
{ {
struct sip_socket *s = &p->socket; struct sip_socket *s = &p->socket;
static const char name[] = "SIP socket"; static const char name[] = "SIP socket";
struct ast_tcptls_session_instance *ser; struct ast_tcptls_session_instance *tcptls_session;
struct server_args ca = { struct server_args ca = {
.name = name, .name = name,
.accept_fd = -1, .accept_fd = -1,
@@ -18793,18 +18797,18 @@ static int sip_prepare_socket(struct sip_pvt *p)
ca.sin = *(sip_real_dst(p)); ca.sin = *(sip_real_dst(p));
if ((ser = sip_tcp_locate(&ca.sin))) { if ((tcptls_session = sip_tcp_locate(&ca.sin))) {
s->fd = ser->fd; s->fd = tcptls_session->fd;
if (s->ser) { if (s->tcptls_session) {
ao2_ref(s->ser, -1); ao2_ref(s->tcptls_session, -1);
s->ser = NULL; s->tcptls_session = NULL;
} }
s->ser = ser; s->tcptls_session = tcptls_session;
return s->fd; return s->fd;
} }
if (s->ser && s->ser->parent->tls_cfg) { if (s->tcptls_session && s->tcptls_session->parent->tls_cfg) {
ca.tls_cfg = s->ser->parent->tls_cfg; ca.tls_cfg = s->tcptls_session->parent->tls_cfg;
} else { } else {
if (s->type & SIP_TRANSPORT_TLS) { if (s->type & SIP_TRANSPORT_TLS) {
ca.tls_cfg = ast_calloc(1, sizeof(*ca.tls_cfg)); ca.tls_cfg = ast_calloc(1, sizeof(*ca.tls_cfg));
@@ -18816,13 +18820,13 @@ static int sip_prepare_socket(struct sip_pvt *p)
} }
} }
if (s->ser) { if (s->tcptls_session) {
/* the pvt socket already has a server instance ... */ /* the pvt socket already has a server instance ... */
} else { } else {
s->ser = ast_tcptls_client_start(&ca); s->tcptls_session = ast_tcptls_client_start(&ca); /* Start a client connection to this address */
} }
if (!s->ser) { if (!s->tcptls_session) {
if (ca.tls_cfg) if (ca.tls_cfg)
ast_free(ca.tls_cfg); ast_free(ca.tls_cfg);
return -1; return -1;
@@ -18831,11 +18835,11 @@ static int sip_prepare_socket(struct sip_pvt *p)
s->fd = ca.accept_fd; s->fd = ca.accept_fd;
/* Give the new thread a reference */ /* Give the new thread a reference */
ao2_ref(s->ser, +1); ao2_ref(s->tcptls_session, +1);
if (ast_pthread_create_background(&ca.master, NULL, sip_tcp_worker_fn, s->ser)) { if (ast_pthread_create_background(&ca.master, NULL, sip_tcp_worker_fn, s->tcptls_session)) {
ast_debug(1, "Unable to launch '%s'.", ca.name); ast_debug(1, "Unable to launch '%s'.", ca.name);
ao2_ref(s->ser, -1); ao2_ref(s->tcptls_session, -1);
close(ca.accept_fd); close(ca.accept_fd);
s->fd = ca.accept_fd = -1; s->fd = ca.accept_fd = -1;
} }

122
main/tcptls.c
View File

@@ -81,34 +81,34 @@ static int ssl_close(void *cookie)
} }
#endif /* DO_SSL */ #endif /* DO_SSL */
HOOK_T ast_tcptls_server_read(struct ast_tcptls_session_instance *ser, void *buf, size_t count) HOOK_T ast_tcptls_server_read(struct ast_tcptls_session_instance *tcptls_session, void *buf, size_t count)
{ {
if (ser->fd == -1) { if (tcptls_session->fd == -1) {
ast_log(LOG_ERROR, "server_read called with an fd of -1\n"); ast_log(LOG_ERROR, "server_read called with an fd of -1\n");
errno = EIO; errno = EIO;
return -1; return -1;
} }
#ifdef DO_SSL #ifdef DO_SSL
if (ser->ssl) if (tcptls_session->ssl)
return ssl_read(ser->ssl, buf, count); return ssl_read(tcptls_session->ssl, buf, count);
#endif #endif
return read(ser->fd, buf, count); return read(tcptls_session->fd, buf, count);
} }
HOOK_T ast_tcptls_server_write(struct ast_tcptls_session_instance *ser, void *buf, size_t count) HOOK_T ast_tcptls_server_write(struct ast_tcptls_session_instance *tcptls_session, void *buf, size_t count)
{ {
if (ser->fd == -1) { if (tcptls_session->fd == -1) {
ast_log(LOG_ERROR, "server_write called with an fd of -1\n"); ast_log(LOG_ERROR, "server_write called with an fd of -1\n");
errno = EIO; errno = EIO;
return -1; return -1;
} }
#ifdef DO_SSL #ifdef DO_SSL
if (ser->ssl) if (tcptls_session->ssl)
return ssl_write(ser->ssl, buf, count); return ssl_write(tcptls_session->ssl, buf, count);
#endif #endif
return write(ser->fd, buf, count); return write(tcptls_session->fd, buf, count);
} }
static void session_instance_destructor(void *obj) static void session_instance_destructor(void *obj)
@@ -123,7 +123,7 @@ void *ast_tcptls_server_root(void *data)
int fd; int fd;
struct sockaddr_in sin; struct sockaddr_in sin;
socklen_t sinlen; socklen_t sinlen;
struct ast_tcptls_session_instance *ser; struct ast_tcptls_session_instance *tcptls_session;
pthread_t launched; pthread_t launched;
for (;;) { for (;;) {
@@ -141,27 +141,27 @@ void *ast_tcptls_server_root(void *data)
ast_log(LOG_WARNING, "Accept failed: %s\n", strerror(errno)); ast_log(LOG_WARNING, "Accept failed: %s\n", strerror(errno));
continue; continue;
} }
ser = ao2_alloc(sizeof(*ser), session_instance_destructor); tcptls_session = ao2_alloc(sizeof(*tcptls_session), session_instance_destructor);
if (!ser) { if (!tcptls_session) {
ast_log(LOG_WARNING, "No memory for new session: %s\n", strerror(errno)); ast_log(LOG_WARNING, "No memory for new session: %s\n", strerror(errno));
close(fd); close(fd);
continue; continue;
} }
ast_mutex_init(&ser->lock); ast_mutex_init(&tcptls_session->lock);
flags = fcntl(fd, F_GETFL); flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags & ~O_NONBLOCK); fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
ser->fd = fd; tcptls_session->fd = fd;
ser->parent = desc; tcptls_session->parent = desc;
memcpy(&ser->requestor, &sin, sizeof(ser->requestor)); memcpy(&tcptls_session->requestor, &sin, sizeof(tcptls_session->requestor));
ser->client = 0; tcptls_session->client = 0;
if (ast_pthread_create_detached_background(&launched, NULL, ast_make_file_from_fd, ser)) { if (ast_pthread_create_detached_background(&launched, NULL, ast_make_file_from_fd, tcptls_session)) {
ast_log(LOG_WARNING, "Unable to launch helper thread: %s\n", strerror(errno)); ast_log(LOG_WARNING, "Unable to launch helper thread: %s\n", strerror(errno));
close(ser->fd); close(tcptls_session->fd);
ao2_ref(ser, -1); ao2_ref(tcptls_session, -1);
} }
} }
return NULL; return NULL;
@@ -228,7 +228,7 @@ int ast_ssl_setup(struct ast_tls_config *cfg)
struct ast_tcptls_session_instance *ast_tcptls_client_start(struct server_args *desc) struct ast_tcptls_session_instance *ast_tcptls_client_start(struct server_args *desc)
{ {
int flags; int flags;
struct ast_tcptls_session_instance *ser = NULL; struct ast_tcptls_session_instance *tcptls_session = NULL;
/* Do nothing if nothing has changed */ /* Do nothing if nothing has changed */
if(!memcmp(&desc->oldsin, &desc->sin, sizeof(desc->oldsin))) { if(!memcmp(&desc->oldsin, &desc->sin, sizeof(desc->oldsin))) {
@@ -256,37 +256,37 @@ struct ast_tcptls_session_instance *ast_tcptls_client_start(struct server_args *
goto error; goto error;
} }
if (!(ser = ao2_alloc(sizeof(*ser), session_instance_destructor))) if (!(tcptls_session = ao2_alloc(sizeof(*tcptls_session), session_instance_destructor)))
goto error; goto error;
ast_mutex_init(&ser->lock); ast_mutex_init(&tcptls_session->lock);
flags = fcntl(desc->accept_fd, F_GETFL); flags = fcntl(desc->accept_fd, F_GETFL);
fcntl(desc->accept_fd, F_SETFL, flags & ~O_NONBLOCK); fcntl(desc->accept_fd, F_SETFL, flags & ~O_NONBLOCK);
ser->fd = desc->accept_fd; tcptls_session->fd = desc->accept_fd;
ser->parent = desc; tcptls_session->parent = desc;
ser->parent->worker_fn = NULL; tcptls_session->parent->worker_fn = NULL;
memcpy(&ser->requestor, &desc->sin, sizeof(ser->requestor)); memcpy(&tcptls_session->requestor, &desc->sin, sizeof(tcptls_session->requestor));
ser->client = 1; tcptls_session->client = 1;
if (desc->tls_cfg) { if (desc->tls_cfg) {
desc->tls_cfg->enabled = 1; desc->tls_cfg->enabled = 1;
__ssl_setup(desc->tls_cfg, 1); __ssl_setup(desc->tls_cfg, 1);
} }
ao2_ref(ser, +1); ao2_ref(tcptls_session, +1);
if (!ast_make_file_from_fd(ser)) if (!ast_make_file_from_fd(tcptls_session))
goto error; goto error;
return ser; return tcptls_session;
error: error:
close(desc->accept_fd); close(desc->accept_fd);
desc->accept_fd = -1; desc->accept_fd = -1;
if (ser) if (tcptls_session)
ao2_ref(ser, -1); ao2_ref(tcptls_session, -1);
return NULL; return NULL;
} }
@@ -377,9 +377,9 @@ void ast_tcptls_server_stop(struct server_args *desc)
*/ */
void *ast_make_file_from_fd(void *data) void *ast_make_file_from_fd(void *data)
{ {
struct ast_tcptls_session_instance *ser = data; struct ast_tcptls_session_instance *tcptls_session = data;
#ifdef DO_SSL #ifdef DO_SSL
int (*ssl_setup)(SSL *) = (ser->client) ? SSL_connect : SSL_accept; int (*ssl_setup)(SSL *) = (tcptls_session->client) ? SSL_connect : SSL_accept;
int ret; int ret;
char err[256]; char err[256];
#endif #endif
@@ -387,37 +387,37 @@ void *ast_make_file_from_fd(void *data)
/* /*
* open a FILE * as appropriate. * open a FILE * as appropriate.
*/ */
if (!ser->parent->tls_cfg) if (!tcptls_session->parent->tls_cfg)
ser->f = fdopen(ser->fd, "w+"); tcptls_session->f = fdopen(tcptls_session->fd, "w+");
#ifdef DO_SSL #ifdef DO_SSL
else if ( (ser->ssl = SSL_new(ser->parent->tls_cfg->ssl_ctx)) ) { else if ( (tcptls_session->ssl = SSL_new(tcptls_session->parent->tls_cfg->ssl_ctx)) ) {
SSL_set_fd(ser->ssl, ser->fd); SSL_set_fd(tcptls_session->ssl, tcptls_session->fd);
if ((ret = ssl_setup(ser->ssl)) <= 0) { if ((ret = ssl_setup(tcptls_session->ssl)) <= 0) {
ast_verb(2, "Problem setting up ssl connection: %s\n", ERR_error_string(ERR_get_error(), err)); ast_verb(2, "Problem setting up ssl connection: %s\n", ERR_error_string(ERR_get_error(), err));
} else { } else {
#if defined(HAVE_FUNOPEN) /* the BSD interface */ #if defined(HAVE_FUNOPEN) /* the BSD interface */
ser->f = funopen(ser->ssl, ssl_read, ssl_write, NULL, ssl_close); tcptls_session->f = funopen(tcptls_session->ssl, ssl_read, ssl_write, NULL, ssl_close);
#elif defined(HAVE_FOPENCOOKIE) /* the glibc/linux interface */ #elif defined(HAVE_FOPENCOOKIE) /* the glibc/linux interface */
static const cookie_io_functions_t cookie_funcs = { static const cookie_io_functions_t cookie_funcs = {
ssl_read, ssl_write, NULL, ssl_close ssl_read, ssl_write, NULL, ssl_close
}; };
ser->f = fopencookie(ser->ssl, "w+", cookie_funcs); tcptls_session->f = fopencookie(tcptls_session->ssl, "w+", cookie_funcs);
#else #else
/* could add other methods here */ /* could add other methods here */
ast_debug(2, "no ser->f methods attempted!"); ast_debug(2, "no tcptls_session->f methods attempted!");
#endif #endif
if ((ser->client && !ast_test_flag(&ser->parent->tls_cfg->flags, AST_SSL_DONT_VERIFY_SERVER)) if ((tcptls_session->client && !ast_test_flag(&tcptls_session->parent->tls_cfg->flags, AST_SSL_DONT_VERIFY_SERVER))
|| (!ser->client && ast_test_flag(&ser->parent->tls_cfg->flags, AST_SSL_VERIFY_CLIENT))) { || (!tcptls_session->client && ast_test_flag(&tcptls_session->parent->tls_cfg->flags, AST_SSL_VERIFY_CLIENT))) {
X509 *peer; X509 *peer;
long res; long res;
peer = SSL_get_peer_certificate(ser->ssl); peer = SSL_get_peer_certificate(tcptls_session->ssl);
if (!peer) if (!peer)
ast_log(LOG_WARNING, "No peer SSL certificate\n"); ast_log(LOG_WARNING, "No peer SSL certificate\n");
res = SSL_get_verify_result(ser->ssl); res = SSL_get_verify_result(tcptls_session->ssl);
if (res != X509_V_OK) if (res != X509_V_OK)
ast_log(LOG_ERROR, "Certificate did not verify: %s\n", X509_verify_cert_error_string(res)); ast_log(LOG_ERROR, "Certificate did not verify: %s\n", X509_verify_cert_error_string(res));
if (!ast_test_flag(&ser->parent->tls_cfg->flags, AST_SSL_IGNORE_COMMON_NAME)) { if (!ast_test_flag(&tcptls_session->parent->tls_cfg->flags, AST_SSL_IGNORE_COMMON_NAME)) {
ASN1_STRING *str; ASN1_STRING *str;
unsigned char *str2; unsigned char *str2;
X509_NAME *name = X509_get_subject_name(peer); X509_NAME *name = X509_get_subject_name(peer);
@@ -433,19 +433,19 @@ void *ast_make_file_from_fd(void *data)
str = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(name, pos)); str = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(name, pos));
ASN1_STRING_to_UTF8(&str2, str); ASN1_STRING_to_UTF8(&str2, str);
if (str2) { if (str2) {
if (!strcasecmp(ser->parent->hostname, (char *) str2)) if (!strcasecmp(tcptls_session->parent->hostname, (char *) str2))
found = 1; found = 1;
ast_debug(3, "SSL Common Name compare s1='%s' s2='%s'\n", ser->parent->hostname, str2); ast_debug(3, "SSL Common Name compare s1='%s' s2='%s'\n", tcptls_session->parent->hostname, str2);
OPENSSL_free(str2); OPENSSL_free(str2);
} }
if (found) if (found)
break; break;
} }
if (!found) { if (!found) {
ast_log(LOG_ERROR, "Certificate common name did not match (%s)\n", ser->parent->hostname); ast_log(LOG_ERROR, "Certificate common name did not match (%s)\n", tcptls_session->parent->hostname);
if (peer) if (peer)
X509_free(peer); X509_free(peer);
fclose(ser->f); fclose(tcptls_session->f);
return NULL; return NULL;
} }
} }
@@ -453,21 +453,21 @@ void *ast_make_file_from_fd(void *data)
X509_free(peer); X509_free(peer);
} }
} }
if (!ser->f) /* no success opening descriptor stacking */ if (!tcptls_session->f) /* no success opening descriptor stacking */
SSL_free(ser->ssl); SSL_free(tcptls_session->ssl);
} }
#endif /* DO_SSL */ #endif /* DO_SSL */
if (!ser->f) { if (!tcptls_session->f) {
close(ser->fd); close(tcptls_session->fd);
ast_log(LOG_WARNING, "FILE * open failed!\n"); ast_log(LOG_WARNING, "FILE * open failed!\n");
ao2_ref(ser, -1); ao2_ref(tcptls_session, -1);
return NULL; return NULL;
} }
if (ser && ser->parent->worker_fn) if (tcptls_session && tcptls_session->parent->worker_fn)
return ser->parent->worker_fn(ser); return tcptls_session->parent->worker_fn(tcptls_session);
else else
return ser; return tcptls_session;
} }