自学教程：C++ ssl_write函数代码示例

// Write our message to the serverstatic 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 intlws_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;}

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;}

intftp_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 intprotocol_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));}