// Write our message to the server static s32 tcp_write(s32 server, char *msg) { s32 bytes_transferred = 0; s32 remaining = strlen(msg); s32 res = 0; while (remaining) { if(http_port == 443) res = (bytes_transferred = ssl_write(server, msg, remaining > NET_BUFFER_SIZE ? NET_BUFFER_SIZE : remaining)); else res = (bytes_transferred = net_write(server, msg, remaining > NET_BUFFER_SIZE ? NET_BUFFER_SIZE : remaining)); if (res > 0) { remaining -= bytes_transferred; msg += bytes_transferred; usleep(20 * 1000); } else if (bytes_transferred < 0) { return bytes_transferred; } else { return -ENODATA; } } return 0; }
static int torchat_write(struct im_connection *ic, char *buf, int len) { struct torchat_data *td = ic->proto_data; struct pollfd pfd[1]; if (!td->ssl) return FALSE; pfd[0].fd = td->fd; pfd[0].events = POLLOUT; /* This poll is necessary or we'll get a SIGPIPE when we write() to * td->fd. */ poll(pfd, 1, 1000); if (pfd[0].revents & POLLHUP) { imc_logout(ic, TRUE); return FALSE; } ssl_write(td->ssl, buf, len); return TRUE; }
static ssize_t ssl_send(IOBuf *iob, char *buffer, int len) { int sent = 0; int total = 0; check(iob->use_ssl, "IOBuf not set up to use ssl"); if(!iob->handshake_performed) { int rcode = ssl_do_handshake(iob); check(rcode == 0, "SSL handshake failed: %d", rcode); } for(sent = 0; len > 0; buffer += sent, len -= sent, total += sent) { sent = ssl_write(&iob->ssl, (const unsigned char*) buffer, len); check(sent != -1, "Error sending SSL data."); check(sent <= len, "Buffer overflow. Too much data sent by ssl_write"); // make sure we don't hog the process trying to stream out if(sent < len) { taskyield(); } }; return total; error: return -1; }
/* This one is actually pretty simple... Might get more calls if we can't write the whole request at once. */ static gboolean http_connected( gpointer data, int source, b_input_condition cond ) { struct http_request *req = data; int st; if( source < 0 ) goto error; if( req->inpa > 0 ) b_event_remove( req->inpa ); sock_make_nonblocking( req->fd ); if( req->ssl ) { st = ssl_write( req->ssl, req->request + req->bytes_written, req->request_length - req->bytes_written ); if( st < 0 ) { if( ssl_errno != SSL_AGAIN ) { ssl_disconnect( req->ssl ); goto error; } } } else { st = write( source, req->request + req->bytes_written, req->request_length - req->bytes_written ); if( st < 0 ) { if( !sockerr_again() ) { closesocket( req->fd ); goto error; } } } if( st > 0 ) req->bytes_written += st; if( req->bytes_written < req->request_length ) req->inpa = b_input_add( source, req->ssl ? ssl_getdirection( req->ssl ) : B_EV_IO_WRITE, http_connected, req ); else req->inpa = b_input_add( source, B_EV_IO_READ, http_incoming_data, req ); return FALSE; error: if( req->status_string == NULL ) req->status_string = g_strdup( "Error while writing HTTP request" ); req->func( req ); http_free( req ); return FALSE; }
ssize_t gtget_ssl_write(connection_t * c, char *buf, size_t n) { int r = 0, s; sslparam_t *ssl = (sslparam_t *) c->ssl; if (timedout) return -1; alarm(c->timeout); while (n > 0 && r >= 0) { s = n < SSL_MAX_PLAINTEXT_LEN ? n : SSL_MAX_PLAINTEXT_LEN; while ((r = ssl_write(&ssl->ssl, (unsigned char *)buf, n)) <= 0) { if (POLARSSL_ERR_NET_WANT_WRITE == r) { /* */ } else if (POLARSSL_ERR_NET_WANT_READ == r) { /* */ } else { break; } } if (r < 0) return -1; n -= s; buf += s; } alarm(0); return r; }
const int IRCClientThread::SocketSend() { dlib::auto_mutex guard(m_buffermutex); if(IsConnected() && m_sendbuffer.size()>0 && m_contype==IRCClientConnection::CON_UNSECURE) { int rval=send(m_socket,&m_sendbuffer[0],m_sendbuffer.size(),0); if(rval>0) { m_sendbuffer.erase(m_sendbuffer.begin(),m_sendbuffer.begin()+rval); } else if(rval==-1) { m_log->Error("IRCClientThread::SocketSend returned -1"); } return rval; } else if(IsConnected() && m_sendbuffer.size()>0 && m_contype==IRCClientConnection::CON_SSL) { int rval=ssl_write(&(m_ssl->m_ssl),(unsigned char *)&m_sendbuffer[0],m_sendbuffer.size()); if(rval>0) { m_sendbuffer.erase(m_sendbuffer.begin(),m_sendbuffer.begin()+rval); } else { m_log->Error("IRCClientThread::SocketSend ssl_write returned <= 0."); } return rval; } else { return -1; } }
LWS_VISIBLE int lws_ssl_capable_write(struct lws *wsi, unsigned char *buf, int len) { int n; if (!wsi->ssl) return lws_ssl_capable_write_no_ssl(wsi, buf, len); #if defined(LWS_USE_POLARSSL) n = ssl_write(wsi->ssl, buf, len); #else #if defined(LWS_USE_MBEDTLS) #else n = SSL_write(wsi->ssl, buf, len); #endif #endif if (n > 0) return n; n = lws_ssl_get_error(wsi, n); if (n == SSL_ERROR_WANT_READ || n == SSL_ERROR_WANT_WRITE) { if (n == SSL_ERROR_WANT_WRITE) lws_set_blocking_send(wsi); return LWS_SSL_CAPABLE_MORE_SERVICE; } return LWS_SSL_CAPABLE_ERROR; }
int ssl_readable(struct worker_t *self, struct client_t *c) { int r; int sslerr, err; //hlog(LOG_DEBUG, "ssl_readable fd %d", c->fd); ssl_clear_error(); r = SSL_read(c->ssl_con->connection, c->ibuf + c->ibuf_end, c->ibuf_size - c->ibuf_end - 1); if (r > 0) { /* we got some data... process */ //hlog(LOG_DEBUG, "SSL_read fd %d returned %d bytes of data", c->fd, r); /* TODO: whatever the client_readable does */ return client_postread(self, c, r); } sslerr = SSL_get_error(c->ssl_con->connection, r); err = (sslerr == SSL_ERROR_SYSCALL) ? errno : 0; if (sslerr == SSL_ERROR_WANT_READ) { hlog(LOG_DEBUG, "ssl_readable fd %d: SSL_read wants to read again, doing it later", c->fd); if (c->obuf_end - c->obuf_start > 0) { /* tell the poller that we have outgoing data */ xpoll_outgoing(&self->xp, c->xfd, 1); } return 0; } if (sslerr == SSL_ERROR_WANT_WRITE) { hlog(LOG_INFO, "ssl_readable fd %d: SSL_read wants to write (peer starts SSL renegotiation?), calling ssl_write", c->fd); return ssl_write(self, c); } c->ssl_con->no_wait_shutdown = 1; c->ssl_con->no_send_shutdown = 1; if (sslerr == SSL_ERROR_ZERO_RETURN || ERR_peek_error() == 0) { hlog(LOG_DEBUG, "ssl_readable fd %d: peer shutdown SSL cleanly", c->fd); client_close(self, c, CLIERR_EOF); return -1; } if (err) { hlog(LOG_DEBUG, "ssl_readable fd %d: I/O syscall error: %s", c->fd, strerror(err)); } else { char ebuf[255]; ERR_error_string_n(sslerr, ebuf, sizeof(ebuf)); hlog(LOG_INFO, "ssl_readable fd %d failed with ret %d sslerr %d errno %d: %s (%s)", c->fd, r, sslerr, err, ebuf, ERR_reason_error_string(sslerr)); } client_close(self, c, err); return -1; }
int TLSConnection::send_all(char *data, int length) { if ((_sock_fd < 0) || !_is_connected) return -1; return ssl_write(&_ssl, (uint8_t*)data, length); }
int session_printf(session_common_t *session, const char *format, ...) { int bytes; int written; va_list args; #ifdef DEBUG_FRAMEWORK if (session == NULL || format == NULL) { lavalog("Passed an invalid pointer. This should never happen."); return -1; } #endif // Initialize our dynamic array. va_start(args, format); bytes = vsnprintf(session->out_buffer, config.out_buffer, format, args); if (session->ssl) written = ssl_write(session->ssl, session->out_buffer, bytes); else written = write(session->sock_descriptor, session->out_buffer, bytes); #ifdef DEBUG_FRAMEWORK if (written != bytes) { lavalog("Could not write %i bytes to the socket. write = %i", bytes, written); } #endif return written; }
/** * List share's information and send to client. * * @param share Share name to list * @param name The realpath of share * @param pclient data stream * @param verbose LIST or NLIST */ static void smbftpd_stat_shares(const char *share, const char *name, FILE * pclient, int verbose) { struct stat st; struct tm tmfile; char perm[11], timestr[13]; #ifdef WITH_SSL char buf[NAME_MAX+512]; #endif char convert_buf[NAME_MAX+1]; time_t t; lstat(name, (struct stat *) &st); strncpy(perm, "dr-x------", sizeof(perm)); memcpy(&tmfile, localtime(&(st.st_mtime)), sizeof(struct tm)); time(&t); if (tmfile.tm_year == localtime(&t)->tm_year){ strncpy(timestr, ctime(&(st.st_mtime)) + 4, 12); } else { strftime(timestr, sizeof(timestr), "%b %d %G", &tmfile); } timestr[12]='\0'; share = smbftpd_charset_fs2client(share, convert_buf, sizeof(convert_buf)); if (verbose) { #ifdef WITH_SSL if (smbftpd_session.ssl_ctrl.ssl_data_active_flag) { snprintf(buf, sizeof(buf), "%s %3i %s %-5s %12llu %s %s\r\n", perm , 1, "root", "users", (unsigned long long) st.st_size, timestr, share); ssl_write(ssl_data_con, buf, strlen(buf)); } else #endif fprintf(pclient, "%s %3i %s %-5s %12llu %s %s\r\n", perm , 1, "root", "users", (unsigned long long) st.st_size, timestr, share); }else{ #ifdef WITH_SSL if (smbftpd_session.ssl_ctrl.ssl_data_active_flag) { snprintf(buf, sizeof(buf), "%s\r\n", share); ssl_write(ssl_data_con, buf, strlen(buf)); } else #endif fprintf(pclient, "%s\r\n", share); } return; }
int32_t bctbx_ssl_write(bctbx_ssl_context_t *ssl_ctx, const unsigned char *buf, size_t buf_length) { int ret = ssl_write(&(ssl_ctx->ssl_ctx), buf, buf_length); /* remap some output code */ if (ret == POLARSSL_ERR_NET_WANT_WRITE) { ret = BCTBX_ERROR_NET_WANT_WRITE; } return ret; }
static int write_ssl_and_get_response( ssl_context *ssl, unsigned char *buf, size_t len ) { int ret; unsigned char data[128]; char code[4]; size_t i, idx = 0; printf("\n%s", buf); while( len && ( ret = ssl_write( ssl, buf, len ) ) <= 0 ) { if( ret != POLARSSL_ERR_NET_WANT_READ && ret != POLARSSL_ERR_NET_WANT_WRITE ) { printf( " failed\n ! ssl_write returned %d\n\n", ret ); return -1; } } do { len = sizeof( data ) - 1; memset( data, 0, sizeof( data ) ); ret = ssl_read( ssl, data, len ); if( ret == POLARSSL_ERR_NET_WANT_READ || ret == POLARSSL_ERR_NET_WANT_WRITE ) continue; if( ret == POLARSSL_ERR_SSL_PEER_CLOSE_NOTIFY ) return -1; if( ret <= 0 ) { printf( "failed\n ! ssl_read returned %d\n\n", ret ); return -1; } printf("\n%s", data); len = ret; for( i = 0; i < len; i++ ) { if( data[i] != '\n' ) { if( idx < 4 ) code[ idx++ ] = data[i]; continue; } if( idx == 4 && code[0] >= '0' && code[0] <= '9' && code[3] == ' ' ) { code[3] = '\0'; return atoi( code ); } idx = 0; } } while( 1 ); }
STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) { mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(o_in); mp_int_t r = ssl_write(o->ssl_sock, buf, size); if (r < 0) { *errcode = r; return MP_STREAM_ERROR; } return r; }
gint sock_write(SockInfo *sock, const gchar *buf, gint len) { g_return_val_if_fail(sock != NULL, -1); #if USE_SSL if (sock->ssl) return ssl_write(sock->ssl, buf, len); #endif return fd_write(sock->sock, buf, len); }
static int special_write(struct connstruct *cn, const char *buf, size_t count) { if (cn->is_ssl) { SSL *ssl = cn->ssl; return ssl ? ssl_write(ssl, (uint8_t *)buf, count) : -1; } else { return SOCKET_WRITE(cn->networkdesc, buf, count); } }
size_t WiFiClientSecure::write(const uint8_t *buf, size_t size) { if (!_ssl) return 0; int rc = ssl_write(*_ssl, buf, size); if (rc >= 0) return rc; return 0; }
static int tls_channel_send(belle_sip_channel_t *obj, const void *buf, size_t buflen){ belle_sip_tls_channel_t* channel = (belle_sip_tls_channel_t*)obj; int err = ssl_write(&channel->sslctx,buf,buflen); if (err<0){ char tmp[256]={0}; error_strerror(err,tmp,sizeof(tmp)); belle_sip_error("Channel [%p]: ssl_write() error [%i]: %s",obj,err,tmp); } return err; }
int Sys_send(int sockfd, const char* buffer, int nbytes) { if (g_enableSSL) { return ssl_write(sockfd, buffer, nbytes); } else { return send(sockfd, buffer, nbytes, 0); } }
static ssize_t ssl_send(IOBuf *iob, char *buffer, int len) { check(iob->use_ssl, "IOBuf not set up to use ssl"); if(!iob->handshake_performed) { int rcode = ssl_do_handshake(iob); check(rcode == 0, "handshake failed"); } return ssl_write(&iob->ssl, (const unsigned char*) buffer, len); error: return -1; }
static SQRESULT sq_ssl_write(HSQUIRRELVM v){ SQ_FUNC_VARS(v); GET_ssl_INSTANCE(); SQ_GET_STRING(v, 2, out_data); if(_top_ > 2) { SQ_GET_INTEGER(v, 3, size); if(size > out_data_size) return sq_throwerror(v, _SC("parameter 2 size bigger than data size")); out_data_size = size; } sq_pushinteger(v, ssl_write(self, (const uint8_t *)out_data, out_data_size)); return 1; }
void raw_socket(char *message) { char *sending = (char *) malloc(sizeof(char *) * strlen(message) + 3); printf("[+] IRC: << %s\n", message); strcpy(sending, message); strcat(sending, "\r\n"); ssl_write(ssl, sending); free(sending); }
// This function takes a buffer and writes it out to the network. It will detect // SSL sessions, and write to an SSL struct if one is found. int session_write(session_common_t *session, const stringer_t *string) { int written; int position = 0; sizer_t length; char *buffer; #ifdef DEBUG_FRAMEWORK if (session == NULL || string == NULL) { lavalog("Passed an invalid pointer. This should never happen."); return -1; } #endif // Get the length. length = used_st(string); #ifdef DEBUG_FRAMEWORK if (length == 0) { lavalog("Asked to write a zero length stringer."); return 0; } #endif buffer = data_st(string); // Loop until bytes have been written to the socket. do { if (session->ssl) written = ssl_write(session->ssl, buffer + position, length); else written = write(session->sock_descriptor, buffer + position, length); if (written > 0) { length -= written; position += written; } else { #ifdef DEBUG_FRAMEWORK lavalog("Not all of the bytes could be written to the socket."); #endif length = 0; } } while (length); #ifdef DEBUG_FRAMEWORK if (written <= 0) { lavalog("Received an error while reading from the socket."); } #endif return written; }
/** * @brief This function is used to send messages with size upper 16k bytes. * @param ssl SSL context * @param data buffer holding the data * @param len how many bytes must be written * @retval None */ void ssl_sendframes( ssl_context *ssl, char *data, int datalen ) { int index = 0; int k = 0; int lastframe, nbrframes; /* Calculate the number of frames */ nbrframes = datalen / 16000; /* Send nbrframes frames */ while(nbrframes > 0) { index = k * 16000; ssl_write( ssl, (unsigned char *)(data + index), 16000 ); nbrframes--; k++; } /* Send the last frame */ index = k * 16000; lastframe = datalen % 16000; ssl_write( ssl, (unsigned char *)(data + index), lastframe ); }
/* Send data via SSL connection */ int ssl_send(ssl_context *ssl, const char *buffer, unsigned int length) { int result; do { result = ssl_write(ssl, (unsigned char*)buffer, length); } while (result == POLARSSL_ERR_NET_WANT_WRITE); if (result < 0) { return -1; } return result; }
static int ssl_putc_flush(SSL *ssl) { if (putc_buf_pos > 0) { if (ssl_write(ssl, putc_buf, putc_buf_pos) != putc_buf_pos) { if (smbftpd_conf.debug_mode) syslog(LOG_ERR, "ssl_putc_flush: WRITE FAILED"); putc_buf_pos = 0; return -1; } } putc_buf_pos = 0; return 0; }
int ftp_write_data(const struct vsf_session* p_sess, const char* p_buf, unsigned int len) { if (p_sess->data_use_ssl) { return ssl_write(p_sess->p_data_ssl, p_buf, len); } else { return vsf_sysutil_write_loop(p_sess->data_fd, p_buf, len); } }
int CTTLS::_send(const char *buf, int iLen) { ssl_context *ssl=&((T_SSL*)pSSL)->ssl; if(!iConnected)return -1001; if(iClosed)return -1002; if(iCertFailed) { Sleep(30); return -1003; } int ret=0; int iShouldDisconnect=0; while( ( ret = ssl_write( ssl, (const unsigned char *)buf, iLen ) ) <= 0 ) { if( ret != POLARSSL_ERR_NET_WANT_READ && ret != POLARSSL_ERR_NET_WANT_WRITE ) { iShouldDisconnect=1; Sleep(5); break; } if(!iConnected)break; if(ret == POLARSSL_ERR_NET_WANT_READ) { iWaitForRead=1; for(int i=0; i<5 && iWaitForRead; i++) Sleep(20); } } void tmp_log(const char *p); char d[64]; sprintf(d, "[ssl-send=%p %.*s l=%d ret=%d]",ssl, 7,buf, iLen, ret); tmp_log(d); if(ret<0) { if(ret==POLARSSL_ERR_NET_CONN_RESET || ret==POLARSSL_ERR_NET_SEND_FAILED) { iShouldDisconnect=1; } if(iShouldDisconnect) { addrConnected.clear(); iConnected=0; tmp_log("tls_send err clear connaddr"); } error_strerror(ret,&bufErr[0],sizeof(bufErr)-1); tivi_slog(" send[%s]%d",&bufErr[0],iShouldDisconnect); } else { //TODO msg("getCS",5,void *p, int iSize); // tivi_slog( " [ Ciphersuite is %s ]\n", ssl_get_ciphersuite( ssl ) ); } return ret; }
HOOK_T ast_tcptls_server_write(struct ast_tcptls_session_instance *tcptls_session, const void *buf, size_t count) { 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 (tcptls_session->ssl) return ssl_write(tcptls_session->ssl, buf, count); #endif return write(tcptls_session->fd, buf, count); }
static int protocol_ssl_write(protocol_t * p, void *buffer, int size, void *options) { ssl_private_t *ssl_p = (ssl_private_t *) p->_protocol_p; char *host = p->host ? p->host : "Unknown"; int status = 1; int i; int bufsize = size * 10; flowop_options_t *flowop_options = (flowop_options_t *) options; uperf_debug("ssl - Writing %d bytes to %s:%d\n", size, host, p->port); return (ssl_write(ssl_p->ssl, buffer, size)); }