conn.h File Reference

#include <openssl/x509.h>
#include <openssl/ssl.h>

Include dependency graph for conn.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	conn_register(conn, fdset, callback, data)   conn_register_real(conn, fdset, callback, data, NULL)
Typedefs
typedef Connection	Connection
typedef void	conn_callback_t (Connection *conn, void *data)
typedef void	conn_callback_data_destroyer_t (void *data)
Functions
void	conn_config_ssl (CfgGroup *grp)
Connection *	conn_open_tcp (Octstr *host, int port, Octstr *our_host)
Connection *	conn_open_tcp_with_port (Octstr *host, int port, int our_port, Octstr *our_host)
Connection *	conn_open_tcp_nb (Octstr *host, int port, Octstr *our_host)
Connection *	conn_open_tcp_nb_with_port (Octstr *host, int port, int our_port, Octstr *our_host)
int	conn_is_connected (Connection *conn)
int	conn_get_connect_result (Connection *conn)
Connection *	conn_wrap_fd (int fd, int ssl)
void	conn_destroy (Connection *conn)
void	conn_claim (Connection *conn)
long	conn_outbuf_len (Connection *conn)
long	conn_inbuf_len (Connection *conn)
int	conn_eof (Connection *conn)
int	conn_error (Connection *conn)
void	conn_set_output_buffering (Connection *conn, unsigned int size)
int	conn_register_real (Connection *conn, FDSet *fdset, conn_callback_t callback, void *data, conn_callback_data_destroyer_t destroyer)
void	conn_unregister (Connection *conn)
int	conn_wait (Connection *conn, double seconds)
int	conn_flush (Connection *conn)
int	conn_write (Connection *conn, Octstr *data)
int	conn_write_data (Connection *conn, unsigned char *data, long length)
int	conn_write_withlen (Connection *conn, Octstr *data)
Octstr *	conn_read_everything (Connection *conn)
Octstr *	conn_read_fixed (Connection *conn, long length)
Octstr *	conn_read_line (Connection *conn)
Octstr *	conn_read_withlen (Connection *conn)
Octstr *	conn_read_packet (Connection *conn, int startmark, int endmark)
int	conn_get_id (Connection *conn)

---

Define Documentation

#define conn_register (  conn, fdset, callback, data   )     conn_register_real(conn, fdset, callback, data, NULL)

Definition at line 215 of file conn.h. Referenced by http_send_reply(), server_thread(), and write_request_thread().

---

Typedef Documentation

typedef void conn_callback_data_destroyer_t(void *data)

Definition at line 113 of file conn.h. Referenced by conn_unregister().

typedef void conn_callback_t(Connection *conn, void *data)

Definition at line 105 of file conn.h.

typedef struct Connection Connection

Definition at line 95 of file conn.h.

---

Function Documentation

void conn_claim (  Connection *  conn  )

Definition at line 658 of file conn.c. References Connection::claimed, Connection::claiming_thread, gw_assert, gwthread_self(), and panic. Referenced by cgw_listener(), emi2_listener(), and fake_listener(). { gw_assert(conn != NULL); if (conn->claimed) panic(0, "Connection is being claimed twice!"); conn->claimed = 1; #ifndef NO_GWASSERT conn->claiming_thread = gwthread_self(); #endif }

Here is the call graph for this function:

void conn_config_ssl (  CfgGroup *  grp  )

Definition at line 1421 of file conn.c. References cfg_get, octstr_destroy(), octstr_imm(), use_global_client_certkey_file(), use_global_server_certkey_file(), and use_global_trusted_ca_file(). Referenced by init_bearerbox(), init_smsbox(), and init_wapbox(). { Octstr *ssl_client_certkey_file = NULL; Octstr *ssl_server_cert_file = NULL; Octstr *ssl_server_key_file = NULL; Octstr *ssl_trusted_ca_file = NULL; /* * check if SSL is desired for HTTP servers and then * load SSL client and SSL server public certificates * and private keys */ ssl_client_certkey_file = cfg_get(grp, octstr_imm("ssl-client-certkey-file")); if (ssl_client_certkey_file != NULL) use_global_client_certkey_file(ssl_client_certkey_file); ssl_server_cert_file = cfg_get(grp, octstr_imm("ssl-server-cert-file")); ssl_server_key_file = cfg_get(grp, octstr_imm("ssl-server-key-file")); if (ssl_server_cert_file != NULL && ssl_server_key_file != NULL) { use_global_server_certkey_file(ssl_server_cert_file, ssl_server_key_file); } ssl_trusted_ca_file = cfg_get(grp, octstr_imm("ssl-trusted-ca-file")); use_global_trusted_ca_file(ssl_trusted_ca_file); octstr_destroy(ssl_client_certkey_file); octstr_destroy(ssl_server_cert_file); octstr_destroy(ssl_server_key_file); octstr_destroy(ssl_trusted_ca_file); }

Here is the call graph for this function:

void conn_destroy (  Connection *  conn  )

Definition at line 614 of file conn.c. References Connection::callback_data, Connection::callback_data_destroyer, error(), Connection::fd, fdset_unregister(), Connection::inbuf, Connection::inlock, mutex_destroy(), octstr_destroy(), Connection::outbuf, Connection::outlock, Connection::peer_certificate, Connection::registered, Connection::ssl, SSL_smart_shutdown(), and unlocked_try_write(). Referenced by boxc_destroy(), cgw_listener(), cgw_open_send_connection(), cgw_sender(), check_pool_conn(), client_destroy(), close_connection_to_bearerbox_real(), conn_open_ssl(), conn_open_ssl_nb(), conn_pool_get(), conn_pool_item_destroy(), conn_wrap_fd(), emi2_idleprocessing(), emi2_idletimeout_handling(), emi2_listener(), emi2_sender(), esme_destroy(), get_connection(), handle_transaction(), io_thread(), main(), main_connection_loop(), open_send_connection(), send_request(), smasi_thread(), smpp_emu(), and smsbox_thread(). { int ret; if (conn == NULL) return; /* No locking done here. conn_destroy should not be called * if any thread might still be interested in the connection. */ if (conn->registered) { fdset_unregister(conn->registered, conn->fd); /* call data destroyer if any */ if (conn->callback_data != NULL && conn->callback_data_destroyer != NULL) conn->callback_data_destroyer(conn->callback_data); } if (conn->fd >= 0) { /* Try to flush any remaining data */ unlocked_try_write(conn); #ifdef HAVE_LIBSSL if (conn->ssl != NULL) { SSL_smart_shutdown(conn->ssl); SSL_free(conn->ssl); if (conn->peer_certificate != NULL) X509_free(conn->peer_certificate); } #endif /* HAVE_LIBSSL */ ret = close(conn->fd); if (ret < 0) error(errno, "conn_destroy: error on close"); conn->fd = -1; } octstr_destroy(conn->outbuf); octstr_destroy(conn->inbuf); mutex_destroy(conn->inlock); mutex_destroy(conn->outlock); gw_free(conn); }

Here is the call graph for this function:

int conn_eof (  Connection *  conn  )

Definition at line 692 of file conn.c. References lock_in(), Connection::read_eof, and unlock_in. Referenced by cgw_receiver(), cgw_wait_command(), check_pool_conn(), client_read_status(), conn_pool_get(), emi2_handle_smscreq(), emi2_receiver(), emi2_send_loop(), http_accept_request(), main(), main_connection_loop(), read_body_until_eof(), read_body_with_length(), read_chunked_body_crlf(), read_chunked_body_data(), read_chunked_body_len(), read_from_bearerbox_real(), read_from_box(), read_pdu(), read_some_headers(), receive_request(), receive_smpp_thread(), run_requests(), smpp_emu_reader(), smsbox_thread(), and wait_for_ack(). { int eof; lock_in(conn); eof = conn->read_eof; unlock_in(conn); return eof; }

Here is the call graph for this function:

int conn_error (  Connection *  conn  )

Definition at line 703 of file conn.c. References Connection::io_error, lock_in(), lock_out(), unlock_in, and unlock_out. Referenced by cgw_receiver(), cgw_wait_command(), check_pool_conn(), client_read_status(), conn_pool_get(), emi2_handle_smscreq(), emi2_receiver(), emi2_send_loop(), http_accept_request(), main(), main_connection_loop(), read_body_until_eof(), read_body_with_length(), read_chunked_body_crlf(), read_chunked_body_data(), read_chunked_body_len(), read_from_bearerbox_real(), read_from_box(), read_pdu(), read_some_headers(), receive_request(), receive_smpp_thread(), smpp_emu_reader(), smsbox_thread(), and wait_for_ack(). { int err; lock_out(conn); lock_in(conn); err = conn->io_error; unlock_in(conn); unlock_out(conn); return err; }

Here is the call graph for this function:

int conn_flush (  Connection *  conn  )

Definition at line 982 of file conn.c. References error(), Connection::fd, gwthread_pollfd(), lock_out(), POLLERR, POLLOUT, unlock_out, unlocked_outbuf_len(), and unlocked_write(). Referenced by boxc_sender(). { int ret; int revents; int fd; lock_out(conn); ret = unlocked_write(conn); if (ret < 0) { unlock_out(conn); return -1; } while (unlocked_outbuf_len(conn) != 0) { fd = conn->fd; unlock_out(conn); revents = gwthread_pollfd(fd, POLLOUT, -1.0); /* Note: Make sure we have the "out" lock when * going through the loop again, because the * loop condition needs it. */ if (revents < 0) { if (errno == EINTR) return 1; error(0, "conn_flush: poll failed on fd %d:", fd); return -1; } if (revents == 0) { /* We were woken up */ return 1; } if (revents & POLLNVAL) { error(0, "conn_flush: fd %d not open.", fd); return -1; } lock_out(conn); if (revents & (POLLOUT | POLLERR | POLLHUP)) { ret = unlocked_write(conn); if (ret < 0) { unlock_out(conn); return -1; } } } unlock_out(conn); return 0; }

Here is the call graph for this function:

int conn_get_connect_result (  Connection *  conn  )

Definition at line 517 of file conn.c. References Connection::connected, and Connection::fd. Referenced by handle_transaction(). { int err; socklen_t len; len = sizeof(err); if (getsockopt(conn->fd, SOL_SOCKET, SO_ERROR, &err, &len) < 0) { return -1; } if (err) { return -1; } conn->connected = yes; return 0; }

int conn_get_id (  Connection *  conn  )

Definition at line 1471 of file conn.c. References Connection::fd. Referenced by check_pool_conn(), and conn_pool_get(). { if(conn == NULL) return 0; else return conn->fd; }

long conn_inbuf_len (  Connection *  conn  )

Definition at line 681 of file conn.c. References lock_in(), unlock_in, and unlocked_inbuf_len(). { long len; lock_in(conn); len = unlocked_inbuf_len(conn); unlock_in(conn); return len; }

Here is the call graph for this function:

int conn_is_connected (  Connection *  conn  )

Definition at line 512 of file conn.c. References Connection::connected. Referenced by write_request_thread(). { return conn->connected == yes ? 0 : -1; }

Connection* conn_open_tcp (  Octstr *  host, int  port, Octstr *  our_host )

Definition at line 483 of file conn.c. References conn_open_tcp_with_port(), and port. Referenced by conn_open_ssl(), connect_to_bearerbox_real(), main(), open_receiver(), open_transceiver(), open_transmitter(), and smsbox_thread(). { return conn_open_tcp_with_port(host, port, 0, our_host); }

Here is the call graph for this function:

Connection* conn_open_tcp_nb (  Octstr *  host, int  port, Octstr *  our_host )

Definition at line 488 of file conn.c. References conn_open_tcp_nb_with_port(), and port. Referenced by conn_open_ssl_nb(), and conn_pool_get(). { return conn_open_tcp_nb_with_port(host, port, 0, our_host); }

Here is the call graph for this function:

Connection* conn_open_tcp_nb_with_port (  Octstr *  host, int  port, int  our_port, Octstr *  our_host )

Definition at line 493 of file conn.c. References conn_wrap_fd(), Connection::connected, octstr_get_cstr, port, sockfd, and tcpip_connect_nb_to_server_with_port(). Referenced by conn_open_tcp_nb(). { int sockfd; int done = -1; Connection *c; sockfd = tcpip_connect_nb_to_server_with_port(octstr_get_cstr(host), port, our_port, our_host == NULL ? NULL : octstr_get_cstr(our_host), &done); if (sockfd < 0) return NULL; c = conn_wrap_fd(sockfd, 0); if (done != 0) { c->connected = no; } return c; }

Here is the call graph for this function:

Connection* conn_open_tcp_with_port (  Octstr *  host, int  port, int  our_port, Octstr *  our_host )

Definition at line 535 of file conn.c. References conn_wrap_fd(), octstr_get_cstr, port, sockfd, and tcpip_connect_to_server_with_port(). Referenced by cgw_open_send_connection(), conn_open_tcp(), open_connection(), and open_send_connection(). { int sockfd; sockfd = tcpip_connect_to_server_with_port(octstr_get_cstr(host), port, our_port, our_host == NULL ? NULL : octstr_get_cstr(our_host)); if (sockfd < 0) return NULL; return conn_wrap_fd(sockfd, 0); }

Here is the call graph for this function:

long conn_outbuf_len (  Connection *  conn  )

Definition at line 670 of file conn.c. References lock_out(), unlock_out, and unlocked_outbuf_len(). Referenced by receive_request(). { long len; lock_out(conn); len = unlocked_outbuf_len(conn); unlock_out(conn); return len; }

Here is the call graph for this function:

Octstr* conn_read_everything (  Connection *  conn  )

Definition at line 1077 of file conn.c. References lock_in(), result, unlock_in, unlocked_get(), unlocked_inbuf_len(), and unlocked_read(). Referenced by read_body_until_eof(). { Octstr *result = NULL; lock_in(conn); if (unlocked_inbuf_len(conn) == 0) { unlocked_read(conn); if (unlocked_inbuf_len(conn) == 0) { unlock_in(conn); return NULL; } } result = unlocked_get(conn, unlocked_inbuf_len(conn)); gw_claim_area(result); unlock_in(conn); return result; }

Here is the call graph for this function:

Octstr* conn_read_fixed (  Connection *  conn, long  length )

Definition at line 1097 of file conn.c. References lock_in(), result, unlock_in, unlocked_get(), unlocked_inbuf_len(), and unlocked_read(). Referenced by read_body_with_length(), read_chunked_body_data(), smpp_pdu_read_data(), and smpp_pdu_read_len(). { Octstr *result = NULL; if (length < 1) return NULL; /* See if the data is already available. If not, try a read(), * then see if we have enough data after that. If not, give up. */ lock_in(conn); if (unlocked_inbuf_len(conn) < length) { unlocked_read(conn); if (unlocked_inbuf_len(conn) < length) { unlock_in(conn); return NULL; } } result = unlocked_get(conn, length); gw_claim_area(result); unlock_in(conn); return result; }

Here is the call graph for this function:

Octstr* conn_read_line (  Connection *  conn  )

Definition at line 1121 of file conn.c. References Connection::inbuf, Connection::inbufpos, lock_in(), octstr_delete(), octstr_get_char(), octstr_len(), octstr_search_char(), result, unlock_in, unlocked_get(), and unlocked_read(). Referenced by client_read_status(), main(), main_connection_loop(), read_chunked_body_crlf(), read_chunked_body_len(), read_some_headers(), receive_request(), and smasi_pdu_read(). { Octstr *result = NULL; long pos; lock_in(conn); /* 10 is the code for linefeed. We don't rely on \n because that * might be a different value on some (strange) systems, and * we are reading from a network connection. */ pos = octstr_search_char(conn->inbuf, 10, conn->inbufpos); if (pos < 0) { unlocked_read(conn); pos = octstr_search_char(conn->inbuf, 10, conn->inbufpos); if (pos < 0) { unlock_in(conn); return NULL; } } result = unlocked_get(conn, pos - conn->inbufpos); gw_claim_area(result); /* Skip the LF, which we left in the buffer */ conn->inbufpos++; /* If the line was terminated with CR LF, we have to remove * the CR from the result. */ if (octstr_len(result) > 0 && octstr_get_char(result, octstr_len(result) - 1) == 13) octstr_delete(result, octstr_len(result) - 1, 1); unlock_in(conn); return result; }

Here is the call graph for this function:

Octstr* conn_read_packet (  Connection *  conn, int  startmark, int  endmark )

Definition at line 1199 of file conn.c. References Connection::inbuf, Connection::inbufpos, lock_in(), octstr_len(), octstr_search_char(), result, unlock_in, unlocked_get(), and unlocked_read(). Referenced by emi2_handle_smscreq(), emi2_receiver(), and wait_for_ack(). { int startpos, endpos; Octstr *result = NULL; int try; lock_in(conn); for (try = 1; try <= 2; try++) { if (try > 1) unlocked_read(conn); /* Find startmark, and discard everything up to it */ startpos = octstr_search_char(conn->inbuf, startmark, conn->inbufpos); if (startpos < 0) { conn->inbufpos = octstr_len(conn->inbuf); continue; } else { conn->inbufpos = startpos; } /* Find first endmark after startmark */ endpos = octstr_search_char(conn->inbuf, endmark, conn->inbufpos); if (endpos < 0) continue; result = unlocked_get(conn, endpos - startpos + 1); gw_claim_area(result); break; } unlock_in(conn); return result; }

Here is the call graph for this function:

Octstr* conn_read_withlen (  Connection *  conn  )

Definition at line 1156 of file conn.c. References decode_network_long(), Connection::inbuf, Connection::inbufpos, lock_in(), octstr_get_many_chars(), result, unlock_in, unlocked_get(), unlocked_inbuf_len(), unlocked_read(), and warning(). Referenced by read_from_bearerbox_real(), read_from_box(), run_requests(), and smsbox_thread(). { Octstr *result = NULL; unsigned char lengthbuf[4]; long length = 0; /* for compiler please */ int try, retry; lock_in(conn); for (try = 1; try <= 2; try++) { if (try > 1) unlocked_read(conn); do { retry = 0; /* First get the length. */ if (unlocked_inbuf_len(conn) < 4) continue; octstr_get_many_chars(lengthbuf, conn->inbuf, conn->inbufpos, 4); length = decode_network_long(lengthbuf); if (length < 0) { warning(0, "conn_read_withlen: got negative length, skipping"); conn->inbufpos += 4; retry = 1; } } while(retry == 1); /* Then get the data. */ if (unlocked_inbuf_len(conn) - 4 < length) continue; conn->inbufpos += 4; result = unlocked_get(conn, length); gw_claim_area(result); break; } unlock_in(conn); return result; }

Here is the call graph for this function:

int conn_register_real (  Connection *  conn, FDSet *  fdset, conn_callback_t  callback, void *  data, conn_callback_data_destroyer_t  destroyer )

Referenced by conn_pool_put().

void conn_set_output_buffering (  Connection *  conn, unsigned int  size )

Definition at line 716 of file conn.c. References lock_out(), Connection::output_buffering, unlock_out, and unlocked_try_write(). { lock_out(conn); conn->output_buffering = size; /* If the buffer size is smaller, we may have to write immediately. */ unlocked_try_write(conn); unlock_out(conn); }

Here is the call graph for this function:

void conn_unregister (  Connection *  conn  )

Definition at line 845 of file conn.c. References Connection::callback, Connection::callback_data, Connection::callback_data_destroyer, conn_callback_data_destroyer_t, data, Connection::fd, fdset_unregister(), gw_assert, Connection::listening_pollin, Connection::listening_pollout, lock_in(), lock_out(), Connection::registered, unlock_in, and unlock_out. Referenced by check_pool_conn(), conn_pool_get(), handle_transaction(), port_remove(), and receive_request(). { FDSet *set = NULL; int fd = -1; void *data = NULL; conn_callback_data_destroyer_t *destroyer = NULL; gw_assert(conn != NULL); if (conn == NULL || conn->fd < 0) return; /* We need both locks to update the registration information */ lock_out(conn); lock_in(conn); if (conn->registered) { set = conn->registered; fd = conn->fd; conn->registered = NULL; conn->callback = NULL; /* * remember and don't destroy data and data_destroyer because we * may be in callback right now. So destroy only after fdset_unregister * call which guarantee us we are not in callback anymore. */ data = conn->callback_data; conn->callback_data = NULL; destroyer = conn->callback_data_destroyer; conn->callback_data_destroyer = NULL; conn->listening_pollin = 0; conn->listening_pollout = 0; } unlock_in(conn); unlock_out(conn); /* now unregister from FDSet */ if (set != NULL) fdset_unregister(set, fd); /* ok we are not in callback anymore, destroy data if any */ if (data != NULL && destroyer != NULL) destroyer(data); }

Here is the call graph for this function:

int conn_wait (  Connection *  conn, double  seconds )

Definition at line 891 of file conn.c. References error(), Connection::fd, gwthread_pollfd(), Connection::io_error, lock_in(), lock_out(), POLLERR, Connection::read_eof, unlock_in, unlock_out, unlocked_outbuf_len(), unlocked_read(), and unlocked_write(). Referenced by cgw_receiver(), cgw_wait_command(), conn_pool_get(), emi2_receiver(), emi2_wait(), http_accept_request(), io_thread(), main(), main_connection_loop(), read_from_bearerbox_real(), read_from_box(), receive_smpp_thread(), run_requests(), smasi_thread(), smpp_emu_reader(), smsbox_thread(), and wait_for_ack(). { int events; int ret; int fd; lock_out(conn); /* Try to write any data that might still be waiting to be sent */ ret = unlocked_write(conn); if (ret < 0) { unlock_out(conn); return -1; } if (ret > 0) { /* We did something useful. No need to poll or wait now. */ unlock_out(conn); return 0; } fd = conn->fd; /* Normally, we block until there is more data available. But * if any data still needs to be sent, we block until we can * send it (or there is more data available). We always block * for reading, unless we know there is no more data coming. * (Because in that case, poll will keep reporting POLLIN to * signal the end of the file). If the caller explicitly wants * to wait even though there is no data to write and we're at * end of file, then poll for new data anyway because the caller * apparently doesn't trust eof. */ events = 0; if (unlocked_outbuf_len(conn) > 0) events |= POLLOUT; /* Don't keep the connection locked while we wait */ unlock_out(conn); /* We need the in lock to query read_eof */ lock_in(conn); if ((conn->read_eof == 0 && conn->io_error == 0) || events == 0) events |= POLLIN; unlock_in(conn); ret = gwthread_pollfd(fd, events, seconds); if (ret < 0) { if (errno == EINTR) return 0; error(0, "conn_wait: poll failed on fd %d:", fd); return -1; } if (ret == 0) return 1; if (ret & POLLNVAL) { error(0, "conn_wait: fd %d not open.", fd); return -1; } if (ret & (POLLERR | POLLHUP)) { /* Call unlocked_read to report the specific error, * and handle the results of the error. We can't be * certain that the error still exists, because we * released the lock for a while. */ lock_in(conn); unlocked_read(conn); unlock_in(conn); return -1; } /* If POLLOUT is on, then we must have wanted * to write something. */ if (ret & POLLOUT) { lock_out(conn); unlocked_write(conn); unlock_out(conn); } /* Since we normally select for reading, we must * try to read here. Otherwise, if the caller loops * around conn_wait without making conn_read* calls * in between, we will keep polling this same data. */ if (ret & POLLIN) { lock_in(conn); unlocked_read(conn); unlock_in(conn); } return 0; }

Here is the call graph for this function:

Connection* conn_wrap_fd (  int  fd, int  ssl )

Definition at line 553 of file conn.c. References conn_destroy(), error(), global_server_ssl_context, Connection::inlock, mutex_create, octstr_create, and socket_set_blocking(). Referenced by accept_thread(), boxc_create(), cgw_listener(), conn_open_tcp_nb_with_port(), conn_open_tcp_with_port(), emi2_listener(), fake_listener(), server_thread(), smpp_emu(), and start_wapbox(). { Connection *conn; if (socket_set_blocking(fd, 0) < 0) return NULL; conn = gw_malloc(sizeof(*conn)); conn->inlock = mutex_create(); conn->outlock = mutex_create(); conn->claimed = 0; conn->outbuf = octstr_create(""); conn->outbufpos = 0; conn->inbuf = octstr_create(""); conn->inbufpos = 0; conn->fd = fd; conn->connected = yes; conn->read_eof = 0; conn->io_error = 0; conn->output_buffering = DEFAULT_OUTPUT_BUFFERING; conn->registered = NULL; conn->callback = NULL; conn->callback_data = NULL; conn->callback_data_destroyer = NULL; conn->listening_pollin = 0; conn->listening_pollout = 0; #ifdef HAVE_LIBSSL /* * do all the SSL magic for this connection */ if (ssl) { conn->ssl = SSL_new(global_server_ssl_context); conn->peer_certificate = NULL; /* SSL_set_fd can fail, so check it */ if (SSL_set_fd(conn->ssl, conn->fd) == 0) { /* SSL_set_fd failed, log error and return NULL */ error(errno, "SSL: OpenSSL: %.256s", ERR_error_string(ERR_get_error(), NULL)); conn_destroy(conn); return NULL; } /* SSL_set_verify(conn->ssl, 0, NULL); */ /* set read/write BIO layer to non-blocking mode */ BIO_set_nbio(SSL_get_rbio(conn->ssl), 1); BIO_set_nbio(SSL_get_wbio(conn->ssl), 1); /* set accept state , SSL-Handshake will be handled transparent while SSL_[read|write] */ SSL_set_accept_state(conn->ssl); } else { conn->ssl = NULL; conn->peer_certificate = NULL; } #endif /* HAVE_LIBSSL */ return conn; }

Here is the call graph for this function:

int conn_write (  Connection *  conn, Octstr *  data )

Definition at line 1038 of file conn.c. References data, lock_out(), octstr_append(), Connection::outbuf, unlock_out, and unlocked_try_write(). Referenced by cgwop_send(), emimsg_send(), handle_pdu(), http_send_reply(), main(), send_enquire_link(), send_logoff(), send_pdu(), send_request(), send_smpp_thread(), send_unbind(), smpp_emu_handle_pdu(), smpp_emu_writer(), sms_to_client(), and smsc_emu_submit_ack(). { int ret; lock_out(conn); octstr_append(conn->outbuf, data); ret = unlocked_try_write(conn); unlock_out(conn); return ret; }

Here is the call graph for this function:

int conn_write_data (  Connection *  conn, unsigned char *  data, long  length )

Definition at line 1050 of file conn.c. References data, lock_out(), octstr_append_data(), Connection::outbuf, unlock_out, and unlocked_try_write(). { int ret; lock_out(conn); octstr_append_data(conn->outbuf, data, length); ret = unlocked_try_write(conn); unlock_out(conn); return ret; }

Here is the call graph for this function:

int conn_write_withlen (  Connection *  conn, Octstr *  data )

Definition at line 1062 of file conn.c. References data, encode_network_long(), lock_out(), octstr_append(), octstr_append_data(), octstr_len(), Connection::outbuf, unlock_out, and unlocked_try_write(). Referenced by deliver_to_bearerbox_real(), send_msg(), send_pdu(), smsbox_thread(), and write_to_bearerbox_real(). { int ret; unsigned char lengthbuf[4]; encode_network_long(lengthbuf, octstr_len(data)); lock_out(conn); octstr_append_data(conn->outbuf, lengthbuf, 4); octstr_append(conn->outbuf, data); ret = unlocked_try_write(conn); unlock_out(conn); return ret; }

Here is the call graph for this function:

See file LICENSE for details about the license agreement for using, modifying, copying or deriving work from this software.