示例#1
0
文件: http.c 项目: SuperrSonic/ULGX
// 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;
}
示例#2
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;
}
示例#3
0
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;
}
示例#4
0
/* 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;
}
示例#5
0
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;
}
示例#6
0
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;
	}
}
示例#7
0
文件: ssl.c 项目: hhool/libwebsockets
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;
}
示例#8
0
文件: ssl.c 项目: N0NB/aprx
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;
}
示例#9
0
int TLSConnection::send_all(char *data, int length)
{
    if ((_sock_fd < 0) || !_is_connected)
        return -1;

    return ssl_write(&_ssl, (uint8_t*)data, length);
}
示例#10
0
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;
}
示例#11
0
/**
 * 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;
}
示例#13
0
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 );
}
示例#14
0
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;
}
示例#15
0
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);
}
示例#16
0
文件: proc.c 项目: Lembed/uTLS
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);
    }
}
示例#17
0
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;
}
示例#18
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;
}
示例#19
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);
    }
}
示例#20
0
文件: io.c 项目: AustinWise/mongrel2
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;
}
示例#21
0
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;
}
示例#22
0
文件: init.c 项目: maxux/z03
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);
}
示例#23
0
// 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;
}
示例#24
0
/**
  * @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 );
}
示例#25
0
文件: ssl.c 项目: BuGlessRB/hiawatha
/* 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;
}
示例#26
0
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;
}
示例#27
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);
  }
}
示例#28
0
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;
}
示例#29
0
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);
}
示例#30
0
文件: ssl.c 项目: FPiriz/uperf
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));
}