static ssize_t
tls_write_intern(struct wrap_io *wio, const void *buf, size_t size)
{
struct gnutella_socket *s = wio->ctx;
ssize_t ret;
g_assert((0 == s->tls.snarf) ^ (NULL == buf));
g_assert((0 == s->tls.snarf) ^ (0 == size));
size = tls_adjust_send_size(s, size);
ret = gnutls_record_send(tls_socket_get_session(s), buf, size);
if (ret < 0) {
switch (ret) {
case GNUTLS_E_INTERRUPTED:
case GNUTLS_E_AGAIN:
if (0 == s->tls.snarf) {
s->tls.snarf = size;
ret = size;
} else {
errno = VAL_EAGAIN;
ret = -1;
}
break;
case GNUTLS_E_PULL_ERROR:
case GNUTLS_E_PUSH_ERROR:
/* Logging already done by tls_transport_debug() */
errno = (SOCK_F_CONNRESET & s->flags) ? ECONNRESET : EIO;
ret = -1;
goto finish;
default:
if (GNET_PROPERTY(tls_debug)) {
g_carp("tls_write(): gnutls_record_send(fd=%d) failed: "
"host=%s snarf=%zu error=\"%s\"",
s->file_desc, host_addr_port_to_string(s->addr, s->port),
s->tls.snarf, gnutls_strerror(ret));
}
errno = EIO;
ret = -1;
goto finish;
}
} else {
if (s->tls.snarf) {
g_assert(s->tls.snarf >= (size_t) ret);
s->tls.snarf -= ret;
errno = VAL_EAGAIN;
ret = -1;
goto finish;
}
}
if (s->tls.snarf) {
tls_socket_evt_change(s, INPUT_EVENT_WX);
}
finish:
g_assert(ret == (ssize_t) -1 || (size_t) ret <= size);
return ret;
}
static ssize_t gnutls_Send (vlc_tls_t *tls, const void *buf, size_t length)
{
gnutls_session_t session = tls->sys;
ssize_t val = gnutls_record_send (session, buf, length);
return (val < 0) ? gnutls_Error (tls, val) : val;
}
static void client(int sock)
{
int err = 0;
time_t started = time(0);
const char* line = "foobar!";
char buffer[8192];
int len;
session_init(sock, 0);
killtimer_set();
do {
err = process_error(gnutls_handshake(session));
if (err != 0) {
int t = gnutls_dtls_get_timeout(session);
await(sock, t ? t : 100);
}
} while (err != 0);
process_error_or_timeout(err, time(0) - started);
killtimer_set();
die_on_error(gnutls_record_send(session, line, strlen(line)));
do {
await(sock, -1);
len = process_error(gnutls_record_recv(session, buffer, sizeof(buffer)));
} while (len < 0);
if (len > 0 && strncmp(line, buffer, len) == 0) {
exit(0);
} else {
exit(1);
}
}
static void server(int sock)
{
int err;
time_t started = time(0);
char buffer[8192];
int len;
session_init(sock, 1);
await(sock, -1);
killtimer_set();
do {
err = process_error(gnutls_handshake(session));
if (err != 0) {
int t = gnutls_dtls_get_timeout(session);
await(sock, t ? t : 100);
}
} while (err != 0);
process_error_or_timeout(err, time(0) - started);
killtimer_set();
do {
await(sock, -1);
len = process_error(gnutls_record_recv(session, buffer, sizeof(buffer)));
} while (len < 0);
die_on_error(gnutls_record_send(session, buffer, len));
exit(0);
}
static int
tls_send (struct ikstls_data *data, const char *buf, size_t size)
{
if (gnutls_record_send (data->sess, buf, size) < 0)
return IKS_NET_RWERR;
return IKS_OK;
}
int
tls_write(const uschar *buff, size_t len)
{
int outbytes;
int left = len;
DEBUG(D_tls) debug_printf("tls_do_write(%lx, %d)\n", (long) buff, left);
while (left > 0)
{
DEBUG(D_tls) debug_printf("gnutls_record_send(SSL, %lx, %d)\n", (long)buff,
left);
outbytes = gnutls_record_send(tls_session, CS buff, left);
DEBUG(D_tls) debug_printf("outbytes=%d\n", outbytes);
if (outbytes < 0)
{
record_io_error(outbytes, US"send", NULL);
return -1;
}
if (outbytes == 0)
{
record_io_error(0, US"send", US"TLS channel closed on write");
return -1;
}
left -= outbytes;
buff += outbytes;
}
return len;
}
static void do_reflect_stuff(gnutls_session_t session)
{
char buf[64];
unsigned buf_size;
int ret;
do {
ret = gnutls_record_recv(session, buf, sizeof(buf));
if (ret < 0) {
fail("server: recv failed: %s\n", gnutls_strerror(ret));
terminate();
}
if (ret == 0)
break;
buf_size = ret;
if (debug) {
fprintf(stderr, "server received: %.*s\n", buf_size, buf);
}
ret = gnutls_record_send(session, buf, buf_size);
if (ret < 0) {
fail("server: send failed: %s\n", gnutls_strerror(ret));
terminate();
}
} while(1);
/* do not wait for the peer to close the connection.
*/
gnutls_bye(session, GNUTLS_SHUT_WR);
}
int TlsSocket::Send(const char* buffer, int size)
{
#ifdef HAVE_LIBGNUTLS
m_retCode = gnutls_record_send((gnutls_session_t)m_session, buffer, size);
#endif /* HAVE_LIBGNUTLS */
#ifdef HAVE_OPENSSL
m_retCode = SSL_write((SSL*)m_session, buffer, size);
#endif /* HAVE_OPENSSL */
if (m_retCode < 0)
{
#ifdef HAVE_OPENSSL
if (ERR_peek_error() == 0)
{
ReportError("Could not write to TLS-Socket: Connection closed by remote host");
}
else
#endif /* HAVE_OPENSSL */
ReportError("Could not write to TLS-Socket");
return -1;
}
return m_retCode;
}
/* Send string to peer, via UDP/TCP/TLS, reporting any errors. */
void
kdc_send1 (struct listenspec *ls)
{
ssize_t sent_bytes;
do
#ifdef USE_STARTTLS
if (ls->usetls)
sent_bytes = gnutls_record_send (ls->session, ls->buf, ls->bufpos);
else
#endif
sent_bytes = sendto (ls->sockfd, ls->buf, ls->bufpos,
0, &ls->addr, ls->addrlen);
while (sent_bytes == -1 && errno == EAGAIN);
if (sent_bytes < 0)
syslog (LOG_ERR, "Error writing %d bytes to %s on socket %d: %s",
ls->bufpos, ls->str, ls->sockfd, strerror (errno));
else if ((size_t) sent_bytes > ls->bufpos)
syslog (LOG_ERR, "Overlong write (%d > %d) to %s on socket %d",
sent_bytes, ls->bufpos, ls->str, ls->sockfd);
else if ((size_t) sent_bytes < ls->bufpos)
syslog (LOG_ERR, "Short write (%d < %d) to %s on socket %d",
sent_bytes, ls->bufpos, ls->str, ls->sockfd);
}
static ssize_t mailstream_low_ssl_write(mailstream_low * s,
const void * buf, size_t count)
{
struct mailstream_ssl_data * ssl_data;
int r;
ssl_data = (struct mailstream_ssl_data *) s->data;
r = wait_write(s);
if (r <= 0)
return r;
r = gnutls_record_send(ssl_data->session, buf, count);
if (r > 0)
return r;
switch (r) {
case 0:
return -1;
case GNUTLS_E_AGAIN:
case GNUTLS_E_INTERRUPTED:
return 0;
default:
return r;
}
}
ssize_t dtls_send(worker_st *ws, const void *data,
size_t data_size)
{
int ret;
int left = data_size;
const uint8_t* p = data;
while(left > 0) {
ret = gnutls_record_send(ws->dtls_session, p, data_size);
if (ret < 0) {
if (ret != GNUTLS_E_AGAIN && ret != GNUTLS_E_INTERRUPTED) {
return ret;
} else {
/* do not cause mayhem */
ms_sleep(20);
}
}
if (ret > 0) {
left -= ret;
p += ret;
}
}
return data_size;
}
size_t TLSSocket_GnuTLS::sendRawNonBlocking(const byte_t* buffer, const size_t count) {
m_status &= ~(STATUS_WANT_WRITE | STATUS_WANT_READ);
resetException();
ssize_t ret = gnutls_record_send(
*m_session->m_gnutlsSession,
buffer, static_cast <size_t>(count)
);
throwException();
if (ret < 0) {
if (ret == GNUTLS_E_AGAIN) {
if (gnutls_record_get_direction(*m_session->m_gnutlsSession) == 0) {
m_status |= STATUS_WANT_READ;
} else {
m_status |= STATUS_WANT_WRITE;
}
return 0;
}
TLSSession_GnuTLS::throwTLSException("gnutls_record_send", static_cast <int>(ret));
}
return static_cast <size_t>(ret);
}
apr_status_t send_answer(socket_thread_data_t *td, const char *answer)
{
apr_size_t msglen;
apr_size_t sent;
apr_size_t total_sent = 0;
apr_status_t res;
msglen = strlen(answer);
if(td->tls_session == NULL)
{
while(total_sent < msglen)
{
sent = msglen;
res = apr_socket_send(td->socket, answer + total_sent, &sent);
if(res != APR_SUCCESS)
return res;
total_sent += sent;
}
}
else
{
if(gnutls_record_send (*(td->tls_session), answer, msglen) < 0)
{
syslog(LOG_ERR, "gnutls_record_send error");
return APR_EGENERAL;
}
}
return APR_SUCCESS;
}
static ssize_t
rb_ssl_read_or_write(int r_or_w, rb_fde_t *F, void *rbuf, const void *wbuf, size_t count)
{
ssize_t ret;
gnutls_session_t *ssl = F->ssl;
if(r_or_w == 0)
ret = gnutls_record_recv(*ssl, rbuf, count);
else
ret = gnutls_record_send(*ssl, wbuf, count);
if(ret < 0)
{
switch (ret)
{
case GNUTLS_E_AGAIN:
case GNUTLS_E_INTERRUPTED:
if(rb_ignore_errno(errno))
{
if(gnutls_record_get_direction(*ssl) == 0)
return RB_RW_SSL_NEED_READ;
else
return RB_RW_SSL_NEED_WRITE;
break;
}
default:
F->ssl_errno = ret;
errno = EIO;
return RB_RW_IO_ERROR;
}
}
return ret;
}
int tls_connection_encrypt(void *ssl_ctx, struct tls_connection *conn,
const u8 *in_data, size_t in_len,
u8 *out_data, size_t out_len)
{
ssize_t res;
#ifdef GNUTLS_IA
if (conn->tls_ia)
res = gnutls_ia_send(conn->session, (char *) in_data, in_len);
else
#endif /* GNUTLS_IA */
res = gnutls_record_send(conn->session, in_data, in_len);
if (res < 0) {
wpa_printf(MSG_INFO, "%s: Encryption failed: %s",
__func__, gnutls_strerror(res));
return -1;
}
if (conn->push_buf == NULL)
return -1;
if (conn->push_buf_len < out_len)
out_len = conn->push_buf_len;
else if (conn->push_buf_len > out_len) {
wpa_printf(MSG_INFO, "GnuTLS: Not enough buffer space for "
"encrypted message (in_len=%lu push_buf_len=%lu "
"out_len=%lu",
(unsigned long) in_len,
(unsigned long) conn->push_buf_len,
(unsigned long) out_len);
}
os_memcpy(out_data, conn->push_buf, out_len);
os_free(conn->push_buf);
conn->push_buf = NULL;
conn->push_buf_len = 0;
return out_len;
}
static size_t
ssl_gnutls_write(PurpleSslConnection *gsc, const void *data, size_t len)
{
PurpleSslGnutlsData *gnutls_data = PURPLE_SSL_GNUTLS_DATA(gsc);
ssize_t s = 0;
/* XXX: when will gnutls_data be NULL? */
if(gnutls_data)
s = gnutls_record_send(gnutls_data->session, data, len);
if(s == GNUTLS_E_AGAIN || s == GNUTLS_E_INTERRUPTED) {
s = -1;
errno = EAGAIN;
} else if(s < 0) {
purple_debug_error("gnutls", "send failed: %s\n",
gnutls_strerror(s));
s = -1;
/*
* TODO: Set errno to something more appropriate. Or even
* better: allow ssl plugins to keep track of their
* own error message, then add a new ssl_ops function
* that returns the error message.
*/
errno = EIO;
}
return s;
}
int GnuTlsStream::sslWrite(const char* buffer, int bufsize) const
{
int ret;
fdInfo.timeout = getTimeout();
// non-blocking/with timeout
while (true)
{
log_debug("gnutls_record_send");
ret = gnutls_record_send(session, buffer, bufsize);
log_debug("gnutls_record_send => " << ret);
if (ret > 0)
break;
if (ret == GNUTLS_E_AGAIN)
throw cxxtools::IOTimeout();
if (ret != GNUTLS_E_INTERRUPTED)
throw GnuTlsException("gnutls_record_send", ret);
}
return ret;
}
void server(int sock)
{
gnutls_session_t s = session(sock, 1);
int err;
time_t started = time(0);
write(sock, &sock, 1);
setup_killtimer();
do {
await(sock);
err = log(gnutls_handshake(s));
reset_killtimer();
} while (err != 0 && !gnutls_error_is_fatal(err));
log_error(err, started);
for (;;) {
char buffer[8192];
int len;
do {
await(sock);
len = gnutls_record_recv(s, buffer, sizeof(buffer));
reset_killtimer();
} while (len < 0 && !gnutls_error_is_fatal(len));
log_error(len, started);
gnutls_record_send(s, buffer, len);
exit(0);
}
}
/**
* tls_socket_write - Write data to a TLS socket - Implements Connection::conn_write()
*/
static int tls_socket_write(struct Connection *conn, const char *buf, size_t count)
{
struct TlsSockData *data = conn->sockdata;
size_t sent = 0;
if (!data)
{
mutt_error(_("Error: no TLS socket open"));
return -1;
}
do
{
int ret;
do
{
ret = gnutls_record_send(data->state, buf + sent, count - sent);
} while ((ret == GNUTLS_E_AGAIN) || (ret == GNUTLS_E_INTERRUPTED));
if (ret < 0)
{
mutt_error("tls_socket_write (%s)", gnutls_strerror(ret));
return -1;
}
sent += ret;
} while (sent < count);
return sent;
}
/**
* gnutls_record_uncork:
* @session: is a #gnutls_session_t structure.
* @flags: Could be zero or %GNUTLS_RECORD_WAIT
*
* This resets the effect of gnutls_record_cork(), and flushes any pending
* data. If the %GNUTLS_RECORD_WAIT flag is specified then this
* function will block until the data is sent or a fatal error
* occurs (i.e., the function will retry on %GNUTLS_E_AGAIN and
* %GNUTLS_E_INTERRUPTED).
*
* If the flag %GNUTLS_RECORD_WAIT is not specified and the function
* is interrupted then the %GNUTLS_E_AGAIN or %GNUTLS_E_INTERRUPTED
* errors will be returned. To obtain the data left in the corked
* buffer use gnutls_record_check_corked().
*
* Returns: On success the number of transmitted data is returned, or
* otherwise a negative error code.
*
* Since: 3.1.9
**/
int gnutls_record_uncork(gnutls_session_t session, unsigned int flags)
{
int ret;
ssize_t total = 0;
if (session->internals.record_flush_mode == RECORD_FLUSH)
return 0; /* nothing to be done */
session->internals.record_flush_mode = RECORD_FLUSH;
while (session->internals.record_presend_buffer.length > 0) {
if (flags == GNUTLS_RECORD_WAIT) {
do {
ret =
gnutls_record_send(session,
session->internals.
record_presend_buffer.
data,
session->internals.
record_presend_buffer.
length);
}
while (ret < 0 && (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED));
} else {
ret =
gnutls_record_send(session,
session->internals.
record_presend_buffer.data,
session->internals.
record_presend_buffer.
length);
}
if (ret < 0)
goto fail;
session->internals.record_presend_buffer.data += ret;
session->internals.record_presend_buffer.length -= ret;
total += ret;
}
return total;
fail:
session->internals.record_flush_mode = RECORD_CORKED;
return ret;
}
int tls_write(tls_t *tls, const void * const buff, const size_t len)
{
int ret;
ret = gnutls_record_send(tls->session, buff, len);
return ret;
}
static int send_command(load_reference lLoad, socket_reference rReference,
remote_connection sSocket, const char *dData, ssize_t sSize)
{
gnutls_transport_set_ptr(get_session(rReference),
(gnutls_transport_ptr_t) sSocket);
int outcome = gnutls_record_send(get_session(rReference), dData, sSize);
return outcome;
}
int tls_write(tls_t *tls, const void * const buff, const size_t len)
{
int ret;
ret = gnutls_record_send(tls->session, buff, len);
tls->lasterror = ret < 0 ? ret : 0;
return ret;
}
/*****************************************************************************
* tls_Send:
*****************************************************************************
* Sends data through a TLS session.
*****************************************************************************/
static int
gnutls_Send( tls_session_t *p_session, const char *buf, int i_length )
{
int val;
val = gnutls_record_send( *(gnutls_session *)(p_session->p_sys),
buf, i_length );
return val < 0 ? -1 : val;
}
void TLSSocket::sendRaw(const char* buffer, const size_type count)
{
gnutls_record_send
(*m_session->m_gnutlsSession,
buffer, static_cast <size_t>(count));
if (m_ex)
internalThrow();
}
/* Ugly, sending could fail and other horrible things may happen. */
int smtp_quit(gnutls_session_t session) {
char buffer[] = "QUIT\n";
int sent = GNUTLS_E_AGAIN;
sent = gnutls_record_send(session, buffer, sizeof(buffer));
ssl_smtp_expect(session, "221 ");
/* TODO: Better (read: some) error handling. */
return 0;
}
static int tls_write(URLContext *h, const uint8_t *buf, int size)
{
TLSContext *c = h->priv_data;
int ret = gnutls_record_send(c->session, buf, size);
if (ret > 0)
return ret;
if (ret == 0)
return AVERROR_EOF;
return print_tls_error(h, ret);
}
bool mrutils::TLSServer::send(const char * msg, int len) {
if (!connected_) return false;
if (len == 0) len = strlen(msg);
mrutils::mutexAcquire(windowsMutex);
int ret = gnutls_record_send (session, msg, len);
mrutils::mutexRelease(windowsMutex);
return (ret == len);
}
gint
_lm_ssl_send (LmSSL *ssl, const gchar *str, gint len)
{
gint bytes_written;
bytes_written = gnutls_record_send (ssl->gnutls_session, str, len);
while (bytes_written < 0) {
if (bytes_written != GNUTLS_E_INTERRUPTED &&
bytes_written != GNUTLS_E_AGAIN) {
return -1;
}
bytes_written = gnutls_record_send (ssl->gnutls_session,
str, len);
}
return bytes_written;
}
ssize_t TCPStream::send(const char* buffer, size_t len)
{
if(secure) {
return gnutls_record_send(*m_session, buffer, len);
}
else {
return write(m_sd, buffer, len);
}
}