From 1b1801f155f996cd5a9921c9c1ab43fa70995f4a Mon Sep 17 00:00:00 2001 From: Russell Bryant Date: Fri, 12 Dec 2008 18:52:14 +0000 Subject: [PATCH] Merged revisions 163670 via svnmerge from 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 --- channels/chan_sip.c | 146 +++++++++++++++++++++++--------------------- main/tcptls.c | 122 ++++++++++++++++++------------------ 2 files changed, 136 insertions(+), 132 deletions(-) diff --git a/channels/chan_sip.c b/channels/chan_sip.c index 39739b1428..711dc3183d 100644 --- a/channels/chan_sip.c +++ b/channels/chan_sip.c @@ -784,7 +784,7 @@ struct sip_socket { enum sip_transport type; int fd; 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 @@ -1566,7 +1566,7 @@ struct sip_registry { struct sip_threadinfo { int stop; 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 */ 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); /*-- 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 *); /*--- Constructing requests and responses */ @@ -2196,13 +2196,13 @@ static struct ast_rtp_protocol sip_rtp = { /*! \brief SIP TCP connection handler */ 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 */ -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; 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; me->threadid = pthread_self(); - me->ser = ser; - if (ser->ssl) + me->tcptls_session = tcptls_session; + if (tcptls_session->ssl) me->type = SIP_TRANSPORT_TLS; else 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_INSERT_TAIL(&threadl, me, list); 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.debug = 0; - req.socket.fd = ser->fd; - if (ser->ssl) { + req.socket.fd = tcptls_session->fd; + if (tcptls_session->ssl) { req.socket.type = SIP_TRANSPORT_TLS; req.socket.port = htons(ourport_tls); } else { req.socket.type = SIP_TRANSPORT_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) { - 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; } /* Read in headers one line at a time */ while (req.len < 4 || strncmp((char *)&req.data + req.len - 4, "\r\n\r\n", 4)) { - ast_mutex_lock(&ser->lock); - if (!fgets(buf, sizeof(buf), ser->f)) { - ast_mutex_unlock(&ser->lock); + ast_mutex_lock(&tcptls_session->lock); + if (!fgets(buf, sizeof(buf), tcptls_session->f)) { + ast_mutex_unlock(&tcptls_session->lock); goto cleanup; } - ast_mutex_unlock(&ser->lock); + ast_mutex_unlock(&tcptls_session->lock); if (me->stop) goto cleanup; 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); if (sscanf(get_header(&reqcpy, "Content-Length"), "%d", &cl)) { while (cl > 0) { - ast_mutex_lock(&ser->lock); - if (!fread(buf, (cl < sizeof(buf)) ? cl : sizeof(buf), 1, ser->f)) { - ast_mutex_unlock(&ser->lock); + ast_mutex_lock(&tcptls_session->lock); + if (!fread(buf, (cl < sizeof(buf)) ? cl : sizeof(buf), 1, tcptls_session->f)) { + ast_mutex_unlock(&tcptls_session->lock); goto cleanup; } - ast_mutex_unlock(&ser->lock); + ast_mutex_unlock(&tcptls_session->lock); if (me->stop) goto cleanup; 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.socket.ser = ser; - handle_request_do(&req, &ser->requestor); + req.socket.tcptls_session = tcptls_session; + handle_request_do(&req, &tcptls_session->requestor); } cleanup: @@ -2285,12 +2287,14 @@ cleanup: AST_LIST_UNLOCK(&threadl); ast_free(me); cleanup2: - fclose(ser->f); - ser->f = NULL; - ser->fd = -1; + fclose(tcptls_session->f); + tcptls_session->f = NULL; + tcptls_session->fd = -1; - ao2_ref(ser, -1); - ser = NULL; + ast_debug(2, "Shutting down thread for %s server\n", tcptls_session->ssl ? "SSL" : "TCP"); + + ao2_ref(tcptls_session, -1); + tcptls_session = 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) return XMIT_ERROR; - if (p->socket.ser) - ast_mutex_lock(&p->socket.ser->lock); + if (p->socket.tcptls_session) + ast_mutex_lock(&p->socket.tcptls_session->lock); if (p->socket.type & SIP_TRANSPORT_UDP) res = sendto(p->socket.fd, data, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in)); else { - if (p->socket.ser->f) - res = ast_tcptls_server_write(p->socket.ser, data, len); + if (p->socket.tcptls_session->f) + res = ast_tcptls_server_write(p->socket.tcptls_session, data, len); 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) - ast_mutex_unlock(&p->socket.ser->lock); + if (p->socket.tcptls_session) + ast_mutex_unlock(&p->socket.tcptls_session->lock); if (res == -1) { switch (errno) { @@ -3577,9 +3581,9 @@ static void sip_destroy_peer(struct sip_peer *peer) ast_dnsmgr_release(peer->dnsmgr); clear_peer_mailboxes(peer); - if (peer->socket.ser) { - ao2_ref(peer->socket.ser, -1); - peer->socket.ser = NULL; + if (peer->socket.tcptls_session) { + ao2_ref(peer->socket.tcptls_session, -1); + peer->socket.tcptls_session = NULL; } 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) { - if (to_sock->ser) { - ao2_ref(to_sock->ser, -1); - to_sock->ser = NULL; + if (to_sock->tcptls_session) { + ao2_ref(to_sock->tcptls_session, -1); + to_sock->tcptls_session = NULL; } - if (from_sock->ser) { - ao2_ref(from_sock->ser, +1); + if (from_sock->tcptls_session) { + ao2_ref(from_sock->tcptls_session, +1); } *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); - if (p->socket.ser) { - ao2_ref(p->socket.ser, -1); - p->socket.ser = NULL; + if (p->socket.tcptls_session) { + ao2_ref(p->socket.tcptls_session, -1); + p->socket.tcptls_session = NULL; } 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_LIST_LOCK(&threadl); AST_LIST_TRAVERSE(&threadl, th, list) { - ast_cli(a->fd, FORMAT, ast_inet_ntoa(th->ser->requestor.sin_addr), - ntohs(th->ser->requestor.sin_port), + ast_cli(a->fd, FORMAT, ast_inet_ntoa(th->tcptls_session->requestor.sin_addr), + ntohs(th->tcptls_session->requestor.sin_port), get_transport(th->type), - (th->ser->client ? "Client" : "Server")); + (th->tcptls_session->client ? "Client" : "Server")); } AST_LIST_UNLOCK(&threadl); @@ -14689,9 +14693,9 @@ static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req) } while(0); s = remove_uri_parameters(s); - if (p->socket.ser) { - ao2_ref(p->socket.ser, -1); - p->socket.ser = NULL; + if (p->socket.tcptls_session) { + ao2_ref(p->socket.tcptls_session, -1); + p->socket.tcptls_session = NULL; } 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.type = SIP_TRANSPORT_UDP; - req.socket.ser = NULL; + req.socket.tcptls_session = NULL; req.socket.port = bindaddr.sin_port; 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_TRAVERSE(&threadl, th, list) { - if ((s->sin_family == th->ser->requestor.sin_family) && - (s->sin_addr.s_addr == th->ser->requestor.sin_addr.s_addr) && - (s->sin_port == th->ser->requestor.sin_port)) { - tcptls_instance = (ao2_ref(th->ser, +1), th->ser); + if ((s->sin_family == th->tcptls_session->requestor.sin_family) && + (s->sin_addr.s_addr == th->tcptls_session->requestor.sin_addr.s_addr) && + (s->sin_port == th->tcptls_session->requestor.sin_port)) { + tcptls_instance = (ao2_ref(th->tcptls_session, +1), th->tcptls_session); break; } } @@ -18773,7 +18777,7 @@ static int sip_prepare_socket(struct sip_pvt *p) { struct sip_socket *s = &p->socket; static const char name[] = "SIP socket"; - struct ast_tcptls_session_instance *ser; + struct ast_tcptls_session_instance *tcptls_session; struct server_args ca = { .name = name, .accept_fd = -1, @@ -18793,18 +18797,18 @@ static int sip_prepare_socket(struct sip_pvt *p) ca.sin = *(sip_real_dst(p)); - if ((ser = sip_tcp_locate(&ca.sin))) { - s->fd = ser->fd; - if (s->ser) { - ao2_ref(s->ser, -1); - s->ser = NULL; + if ((tcptls_session = sip_tcp_locate(&ca.sin))) { + s->fd = tcptls_session->fd; + if (s->tcptls_session) { + ao2_ref(s->tcptls_session, -1); + s->tcptls_session = NULL; } - s->ser = ser; + s->tcptls_session = tcptls_session; return s->fd; } - if (s->ser && s->ser->parent->tls_cfg) { - ca.tls_cfg = s->ser->parent->tls_cfg; + if (s->tcptls_session && s->tcptls_session->parent->tls_cfg) { + ca.tls_cfg = s->tcptls_session->parent->tls_cfg; } else { if (s->type & SIP_TRANSPORT_TLS) { 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 ... */ } 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) ast_free(ca.tls_cfg); return -1; @@ -18831,11 +18835,11 @@ static int sip_prepare_socket(struct sip_pvt *p) s->fd = ca.accept_fd; /* 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); - ao2_ref(s->ser, -1); + ao2_ref(s->tcptls_session, -1); close(ca.accept_fd); s->fd = ca.accept_fd = -1; } diff --git a/main/tcptls.c b/main/tcptls.c index f51a447012..bffa31ac2a 100644 --- a/main/tcptls.c +++ b/main/tcptls.c @@ -81,34 +81,34 @@ static int ssl_close(void *cookie) } #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"); errno = EIO; return -1; } #ifdef DO_SSL - if (ser->ssl) - return ssl_read(ser->ssl, buf, count); + if (tcptls_session->ssl) + return ssl_read(tcptls_session->ssl, buf, count); #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"); errno = EIO; return -1; } #ifdef DO_SSL - if (ser->ssl) - return ssl_write(ser->ssl, buf, count); + if (tcptls_session->ssl) + return ssl_write(tcptls_session->ssl, buf, count); #endif - return write(ser->fd, buf, count); + return write(tcptls_session->fd, buf, count); } static void session_instance_destructor(void *obj) @@ -123,7 +123,7 @@ void *ast_tcptls_server_root(void *data) int fd; struct sockaddr_in sin; socklen_t sinlen; - struct ast_tcptls_session_instance *ser; + struct ast_tcptls_session_instance *tcptls_session; pthread_t launched; for (;;) { @@ -141,27 +141,27 @@ void *ast_tcptls_server_root(void *data) ast_log(LOG_WARNING, "Accept failed: %s\n", strerror(errno)); continue; } - ser = ao2_alloc(sizeof(*ser), session_instance_destructor); - if (!ser) { + tcptls_session = ao2_alloc(sizeof(*tcptls_session), session_instance_destructor); + if (!tcptls_session) { ast_log(LOG_WARNING, "No memory for new session: %s\n", strerror(errno)); close(fd); continue; } - ast_mutex_init(&ser->lock); + ast_mutex_init(&tcptls_session->lock); flags = fcntl(fd, F_GETFL); fcntl(fd, F_SETFL, flags & ~O_NONBLOCK); - ser->fd = fd; - ser->parent = desc; - memcpy(&ser->requestor, &sin, sizeof(ser->requestor)); + tcptls_session->fd = fd; + tcptls_session->parent = desc; + 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)); - close(ser->fd); - ao2_ref(ser, -1); + close(tcptls_session->fd); + ao2_ref(tcptls_session, -1); } } 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) { int flags; - struct ast_tcptls_session_instance *ser = NULL; + struct ast_tcptls_session_instance *tcptls_session = NULL; /* Do nothing if nothing has changed */ 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; } - if (!(ser = ao2_alloc(sizeof(*ser), session_instance_destructor))) + if (!(tcptls_session = ao2_alloc(sizeof(*tcptls_session), session_instance_destructor))) goto error; - ast_mutex_init(&ser->lock); + ast_mutex_init(&tcptls_session->lock); flags = fcntl(desc->accept_fd, F_GETFL); fcntl(desc->accept_fd, F_SETFL, flags & ~O_NONBLOCK); - ser->fd = desc->accept_fd; - ser->parent = desc; - ser->parent->worker_fn = NULL; - memcpy(&ser->requestor, &desc->sin, sizeof(ser->requestor)); + tcptls_session->fd = desc->accept_fd; + tcptls_session->parent = desc; + tcptls_session->parent->worker_fn = NULL; + memcpy(&tcptls_session->requestor, &desc->sin, sizeof(tcptls_session->requestor)); - ser->client = 1; + tcptls_session->client = 1; if (desc->tls_cfg) { desc->tls_cfg->enabled = 1; __ssl_setup(desc->tls_cfg, 1); } - ao2_ref(ser, +1); - if (!ast_make_file_from_fd(ser)) + ao2_ref(tcptls_session, +1); + if (!ast_make_file_from_fd(tcptls_session)) goto error; - return ser; + return tcptls_session; error: close(desc->accept_fd); desc->accept_fd = -1; - if (ser) - ao2_ref(ser, -1); + if (tcptls_session) + ao2_ref(tcptls_session, -1); return NULL; } @@ -377,9 +377,9 @@ void ast_tcptls_server_stop(struct server_args *desc) */ 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 - int (*ssl_setup)(SSL *) = (ser->client) ? SSL_connect : SSL_accept; + int (*ssl_setup)(SSL *) = (tcptls_session->client) ? SSL_connect : SSL_accept; int ret; char err[256]; #endif @@ -387,37 +387,37 @@ void *ast_make_file_from_fd(void *data) /* * open a FILE * as appropriate. */ - if (!ser->parent->tls_cfg) - ser->f = fdopen(ser->fd, "w+"); + if (!tcptls_session->parent->tls_cfg) + tcptls_session->f = fdopen(tcptls_session->fd, "w+"); #ifdef DO_SSL - else if ( (ser->ssl = SSL_new(ser->parent->tls_cfg->ssl_ctx)) ) { - SSL_set_fd(ser->ssl, ser->fd); - if ((ret = ssl_setup(ser->ssl)) <= 0) { + else if ( (tcptls_session->ssl = SSL_new(tcptls_session->parent->tls_cfg->ssl_ctx)) ) { + SSL_set_fd(tcptls_session->ssl, tcptls_session->fd); + 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)); } else { #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 */ static const cookie_io_functions_t cookie_funcs = { 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 /* could add other methods here */ - ast_debug(2, "no ser->f methods attempted!"); + ast_debug(2, "no tcptls_session->f methods attempted!"); #endif - if ((ser->client && !ast_test_flag(&ser->parent->tls_cfg->flags, AST_SSL_DONT_VERIFY_SERVER)) - || (!ser->client && ast_test_flag(&ser->parent->tls_cfg->flags, AST_SSL_VERIFY_CLIENT))) { + if ((tcptls_session->client && !ast_test_flag(&tcptls_session->parent->tls_cfg->flags, AST_SSL_DONT_VERIFY_SERVER)) + || (!tcptls_session->client && ast_test_flag(&tcptls_session->parent->tls_cfg->flags, AST_SSL_VERIFY_CLIENT))) { X509 *peer; long res; - peer = SSL_get_peer_certificate(ser->ssl); + peer = SSL_get_peer_certificate(tcptls_session->ssl); if (!peer) 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) 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; unsigned char *str2; 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)); ASN1_STRING_to_UTF8(&str2, str); if (str2) { - if (!strcasecmp(ser->parent->hostname, (char *) str2)) + if (!strcasecmp(tcptls_session->parent->hostname, (char *) str2)) 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); } if (found) break; } 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) X509_free(peer); - fclose(ser->f); + fclose(tcptls_session->f); return NULL; } } @@ -453,21 +453,21 @@ void *ast_make_file_from_fd(void *data) X509_free(peer); } } - if (!ser->f) /* no success opening descriptor stacking */ - SSL_free(ser->ssl); + if (!tcptls_session->f) /* no success opening descriptor stacking */ + SSL_free(tcptls_session->ssl); } #endif /* DO_SSL */ - if (!ser->f) { - close(ser->fd); + if (!tcptls_session->f) { + close(tcptls_session->fd); ast_log(LOG_WARNING, "FILE * open failed!\n"); - ao2_ref(ser, -1); + ao2_ref(tcptls_session, -1); return NULL; } - if (ser && ser->parent->worker_fn) - return ser->parent->worker_fn(ser); + if (tcptls_session && tcptls_session->parent->worker_fn) + return tcptls_session->parent->worker_fn(tcptls_session); else - return ser; + return tcptls_session; }