コード例 #1
0
ファイル: evbuffer.c プロジェクト: qtekfun/htcDesire820Kernel
int
bufferevent_write(struct bufferevent *bufev, const void *data, size_t size)
{
	int res;

	res = evbuffer_add(bufev->output, data, size);

	if (res == -1)
		return (res);

	
	if (size > 0 && (bufev->enabled & EV_WRITE))
		bufferevent_add(&bufev->ev_write, bufev->timeout_write);

	return (res);
}
コード例 #2
0
void buffered_on_read(struct bufferevent *bev, void *arg) {
	client_t *client = (client_t *)arg;
	char data[4096];
	int nbytes;

	while (bev->input->off > 0) {
		nbytes = (bev->input->off > 4096) ? 4096 : bev->input->off;
		evbuffer_remove(bev->input, data, nbytes);
		evbuffer_add(client->output_buffer, data, nbytes);

	}

	if (bufferevent_write_buffer(bev, client->output_buffer)) {
		errorOut("Error sending data to client on fd %d\n", client->fd);
		closeClient(client);
	}
}
コード例 #3
0
void Subscriber::send_old_msgs(){
	std::vector<std::string>::iterator it = channel->msg_list.end();
	int msg_seq_min = channel->seq_next - channel->msg_list.size();
	if (Channel::SEQ_GT(this->seq_next, channel->seq_next) || Channel::SEQ_LT(this->seq_next, msg_seq_min))
	{
		this->seq_next = msg_seq_min;
	}
	log_info("send old msg:[%d, %d]", this->seq_next, channel->seq_next - 1);
	it -= (channel->seq_next - this->seq_next);
	struct evbuffer *buf = evbuffer_new();
	if (this->type == POLL){
		if (!this->callback.empty()){
			evbuffer_add_printf(buf, "%s(", this->callback.c_str());
		}
		evbuffer_add_printf(buf, "[");
		for (; it != channel->msg_list.end(); it++, this->seq_next++)
		{
			std::string &msg = *it;
			evbuffer_add_printf(buf,
				"{\"type\":\"data\",\"cname\":\"%s\",\"seq\":%d,\"content\":\"%s\"}",
				this->channel->name.c_str(),
				this->channel->seq_next,
				msg.c_str());
			if (this->seq_next != channel->seq_next - 1)
			{
				evbuffer_add(buf, ",", 1);
			}
		}
		evbuffer_add_printf(buf, "]");
		if (!this->callback.empty())
		{
			evbuffer_add_printf(buf, ");");
		}
		evbuffer_add_printf(buf, "\n");
		evhttp_send_reply_chunk(this->req, buf);
		this->close();
	}
	else if (this->type == IFRAME || this->type == STREAM){
		for (; it != channel->msg_list.end(); it++, this->seq_next++)
		{
			std::string &msg = *it;
			this->send_chunk(this->seq_next, "data", msg.c_str());
		}
	}
	evbuffer_free(buf);
}
コード例 #4
0
void SocketLibEvent::write(const char* data, size_t data_len) {
	if (closing_) return;

	auto output = bufferevent_get_output(bev_);
	auto retval = evbuffer_add(output, data, data_len);

	if (retval != 0) {
		onSocketClose(true);
		return;
	}

	if (evbuffer_get_length(output) > MAX_OUTPUT_BUFFER_SIZE) {
        /* LogApiSock("WsApiEnviar MAX_OUTPUT_BUFFER_SIZE"); */
        onSocketClose(true);
		return;
	}
}
コード例 #5
0
ファイル: nbd.c プロジェクト: KristineMcNerney/gammaray
static void nbd_old_conn(struct evconnlistener *conn, evutil_socket_t sock,
                         struct sockaddr *addr, int len, void * handle)
{
    struct event_base* eb = evconnlistener_get_base(conn);
    struct bufferevent* bev = bufferevent_socket_new(eb, sock,
                                                     BEV_OPT_CLOSE_ON_FREE);
    struct evbuffer* out = bufferevent_get_output(bev);
    struct nbd_old_handshake hdr = { .magic        =
                                            htobe64(GAMMARAY_NBD_MAGIC),
                                     .protocol     =
                                            htobe64(GAMMARAY_NBD_OLD_PROTOCOL),
                                     .size         =
                                            htobe64(
                                          ((struct nbd_handle*) handle)->size),
                                     .flags        =
                                            htobe32(NBD_FLAG_HAS_FLAGS |
                                                    NBD_FLAG_SEND_FLUSH |
                                                    NBD_FLAG_SEND_FUA |
                                                    NBD_FLAG_SEND_TRIM),
                                     .zeros         = {0}
                                   };
    struct nbd_client* client = (struct nbd_client*)
                                    malloc(sizeof(struct nbd_client));

    client->handle = handle;
    client->state = NBD_DATA_PUSHING;
    client->socket = sock;
    client->write_count = 0;
    client->write_bytes = 0;
    client->buf = NULL;

    bufferevent_setcb(bev, &nbd_client_handler, NULL, &nbd_ev_handler, client);
    evbuffer_add(out, &hdr, sizeof(hdr));
    bufferevent_enable(bev, EV_READ|EV_WRITE);
}

static void nbd_event_error(struct evconnlistener* conn, void* ptr)
{
    struct event_base* eb = evconnlistener_get_base(conn);
    event_base_loopexit(eb, NULL);
}

void nbd_run_loop(struct nbd_handle* handle)
{
    event_base_dispatch(handle->eb);
}
コード例 #6
0
void COnlineConnManager::SendPacketToClent(evutil_socket_t fd, const char* buf, int iBufSize)
{
	if (!buf || iBufSize == 0 || iBufSize > emMaxBuffLen)
	{
		return;
	}
	Conn *pConn = GetConn(fd);
	if (pConn)
	{
		if (pConn->bufev)
		{
			struct evbuffer * output = bufferevent_get_output(pConn->bufev);
			evbuffer_add(output, buf, iBufSize);
			printf("LOGIN_SC_IN has send!\n");
		}
	}
}
コード例 #7
0
ファイル: miner.c プロジェクト: ewust/DDoSCoin
void new_connection(struct config *conf)
{
    struct conn_state *st = calloc(1, sizeof(struct conn_state));
    st->state = WAIT_HELLO;
    st->conf = conf;

    st->sock = socket(AF_INET, SOCK_STREAM, 0);
    int optval = 1;
    setsockopt(st->sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));

    evutil_make_socket_nonblocking(st->sock);
    struct bufferevent *bev;
    bev = bufferevent_socket_new(conf->base, st->sock, BEV_OPT_CLOSE_ON_FREE);
    // TODO: error check
    struct timeval read_to;
    read_to.tv_sec = TIMEOUT_SECS;
    read_to.tv_usec = 0;
    bufferevent_set_timeouts(bev, &read_to, &read_to);
    st->bev = bev;

    // Generate client random
    generate_nonce(conf, st->nonce);
    generate_client_random(conf->prev_block_hash, conf->merkle_root,
                           st->nonce, st->client_random);

    // Generte client hello and send it
    uint8_t *client_hello;
    size_t client_hello_len = make_client_hello(st->client_random, &client_hello);

    evbuffer_add(bufferevent_get_output(bev), client_hello, client_hello_len);
    free(client_hello);

    bufferevent_setcb(bev, readcb, NULL, eventcb, st);
    // TODO: error check
    bufferevent_enable(bev, EV_READ | EV_WRITE);

    if (bufferevent_socket_connect(bev, (struct sockaddr *)&conf->sin,
                                   sizeof(conf->sin)) < 0) {

        perror("socket connected failed: ");
        printf("Run `sudo sysctl -w net.ipv4.tcp_tw_recycle=1`\n");
        cleanup(st);
    }

    conf->num_connections++;
}
コード例 #8
0
ファイル: sock.cpp プロジェクト: littletiny/corotouine
// 参考sock_recv
ssize_t sock_send(int fd, char *buf, size_t size)
{
    coro_sock *sock = find_sock_by_fd(fd);
    if ( !sock ) {
        return -1;
    }
    sock->op = WRITING;
    ssize_t status = 0;
    uthread_t cur = coro_current_uthread();
    if ( TEST_WAIT_WRITE(sock->status) ) {
        if ( TEST_EOF(sock->status) ) {
            status = -1;
        }
        else {
            set_pending_status(sock, keep_status, cur, set_wait_write_status);
            sock->writequeue->push(cur);
            status = coro_schedule_uthread(cur, 0);
        }
    }
    int ret = status;
    sock = find_sock_by_fd(fd);
    if ( status >= 0 && sock ) {
        // 1. 协程没有进行调度,那么肯定可写
        // 2. 协程唤醒以后
        //   1) 写事件成功,那么一定可写
        //   2) 写事件失败,那么status < 0,不可写
        //      这种情况下,一定执行过调度的环节
        //      调度环节执行前已经设置了等待写状态
        //      因此,status < 0的情况不需要设置了
        SET_WRITE(sock->status);
        clear_pending_status(sock, cur);

        size_t cnt = 0;
        struct evbuffer *output;
        bufferevent * bev = sock->bev;
        output = bufferevent_get_output(bev);
        if ( sock->hwm ) {
            size_t buflen = evbuffer_get_length(output);
            cnt = sock->hwm - buflen;
            size = size > cnt ? cnt : size;
        }
        ret = evbuffer_add(output, buf, size);
        ret = !ret ? size : -1;
    }
    return ret;
}
コード例 #9
0
		void HttpServer::readCb(bufferevent *bev, void *ctx) {
			size_t length = evbuffer_get_length(bufferevent_get_input(bev));
			char *data = (char *) malloc(sizeof(char) * length);

			evbuffer_remove(bufferevent_get_input(bev), data, length);
			HttpRequestParser requestParser;
			HttpRequest request;
			HttpResponse response;

			requestParser.reset();
			requestParser.parse(request, data, length);
			HttpRequestHandler requestHandler(rootDir_);
			requestHandler.handleRequest(&request, &response);
			evbuffer_add(bufferevent_get_output(bev), response.toString().c_str(), response.toString().length());

			free(data);
		}
コード例 #10
0
ファイル: server.c プロジェクト: dividuum/infon
static void server_flush_compression(client_t *client) {
    if (!client->compress)
        return;

    char buf[1024];
    client->strm.next_in  = NULL;
    client->strm.avail_in = 0;
    do {
        client->strm.next_out  = (unsigned char*)buf;
        client->strm.avail_out = sizeof(buf);
        if (deflate(&client->strm, Z_SYNC_FLUSH) != Z_OK) {
            fprintf(stderr, "urgh. deflate (Z_SYNC_FLUSH) didn't return Z_OK");
            // XXX: handle
        }
        evbuffer_add(client->out_buf, buf, sizeof(buf) - client->strm.avail_out);
    } while (client->strm.avail_out == 0);
}
コード例 #11
0
ファイル: test-ratelim.c プロジェクト: diwakergupta/libevent
static void
loud_writecb(struct bufferevent *bev, void *ctx)
{
	struct client_state *cs = ctx;
	struct evbuffer *output = bufferevent_get_output(bev);
	char buf[1024];
#ifdef _WIN32
	int r = rand() % 256;
#else
	int r = random() % 256;
#endif
	memset(buf, r, sizeof(buf));
	while (evbuffer_get_length(output) < 8192) {
		evbuffer_add(output, buf, sizeof(buf));
		cs->queued += sizeof(buf);
	}
}
コード例 #12
0
ファイル: feed.c プロジェクト: BLepers/yt_history
int feed_consume(struct feed *feed, struct evbuffer *buf)
{
	char input[1024];
	int removed;

	if (!feed->header_sent) {
		evbuffer_add(feed->sink, HEADER, strlen(HEADER));
		feed->header_sent++;
	}

	while ((removed = evbuffer_remove(buf, input, sizeof(input))) > 0) {
		XML_Parse(feed->parser, input, removed, 0);
		/* TODO: Handle error. */
	}

	return 0;
}
コード例 #13
0
ファイル: oc_serv.c プロジェクト: cheliequan/idning-paper
void write_chunk(uint64_t chunkid, struct evhttp_request *req)
{
    DBG();
    struct evbuffer *input;
    struct evbuffer *evb = evbuffer_new();

    if (evhttp_request_get_command(req) != EVHTTP_REQ_POST) {
        reply_error(req, HTTP_BADREQUEST, "should call write with POST");
        return;
    }
    uint64_t start = 0, end;
    const char *range = evhttp_find_header(req->input_headers, "Range");

    logging(LOG_DEUBG, "write Range Header: %s", range);
    if (range) {
        sscanf(range, "bytes=%" SCNu64 "-%" SCNu64, &start, &end);
    }

    input = req->input_buffer;
    hdd_chunk *chunk = hdd_create_chunk(chunkid, 0);    //TODO

    int fd = open(chunk->path, O_WRONLY | O_CREAT, 0755);
    logging(LOG_DEUBG, "write seek to : %" PRIu64 "", start);
    logging(LOG_DEUBG, "evbuffer_get_length(input) = %d",
            evbuffer_get_length(input));
    lseek(fd, start, SEEK_SET);

    if (-1 == fd) {
        reply_error(req, HTTP_INTERNAL, "could not open file : %s",
                    chunk->path);
        return;
    }

    int rst = 0;
    while (evbuffer_get_length(input) && (rst = evbuffer_write(input, fd)) > 0) {
        ;
    }

    /*evbuffer_write(input, fd); */
    close(fd);

    evbuffer_add(evb, "success", strlen("success"));
    evhttp_send_reply(req, HTTP_OK, "OK", evb);
    evbuffer_free(evb);
}
コード例 #14
0
ファイル: http.c プロジェクト: snip/aprsc
static void http_send_reply_ok(struct evhttp_request *r, struct evkeyvalq *headers, char *data, int len, int allow_compress)
{
#ifdef HAVE_LIBZ
	char *compr = NULL;
	
	/* Gzipping files below 150 bytes can actually make them larger. */
	if (len > 150 && allow_compress) {
		/* Consider returning a compressed version */
		int compr_type = http_check_req_compressed(r);
		/*
		if (compr_type)
			hlog(LOG_DEBUG, "http_send_reply_ok, client supports transfer-encoding: %s", compr_type_strings[compr_type]);
		*/
		
		if (compr_type == HTTP_COMPR_GZIP) {
			/* for small files it's possible that the output is actually
			 * larger than the input
			 */
			int oblen = len + 60;
			compr = hmalloc(oblen);
			int olen = http_compress_gzip(data, len, compr, oblen);
			/* If compression succeeded, replace buffer with the compressed one and free the
			 * uncompressed one. Add HTTP header to indicate compressed response.
			 * If the file got larger, send uncompressed.
			 */
			if (olen > 0 && olen < len) {
				data = compr;
				len = olen;
				evhttp_add_header(headers, "Content-Encoding", "gzip");
			}
		}
	}
#endif
	
	struct evbuffer *buffer = evbuffer_new();
	evbuffer_add(buffer, data, len);
	
	evhttp_send_reply(r, HTTP_OK, "OK", buffer);
	evbuffer_free(buffer);

#ifdef HAVE_LIBZ
	if (compr)
		hfree(compr);
#endif
}
コード例 #15
0
bool TestExtNetwork::test_get_http_request_size() {
  //because no g_context in unit test,
  //instead of testing f_get_http_request_size(),
  //we test relevant code directly
  evhttp_request* r=evhttp_request_new(nullptr, nullptr);
  char* buf = "buffer";
  evbuffer_add(r->input_buffer, buf, strlen(buf));
  r->type=EVHTTP_REQ_POST;
  evhttp_add_header(r->input_headers, "Host", "www.facebook.com");
  r->uri = "/index.php";
  r->major=1;
  r->minor=1;
  r->remote_host="127.0.0.1";
  r->remote_port=1234;
  LibEventTransport t(nullptr, r,0);
  VERIFY(t.getRequestSize()==58);
  return Count(true);
}
コード例 #16
0
ファイル: mem_test.c プロジェクト: Caoxuyang/klcommon
void test_set( const struct mem_server *server )
{
	int ret = 0;
	char data[] = "some string data";	
	struct store_item item;
	item._exp_time = 0;
	NEW_ITEM_DATA( item._item, "TestSet", 0 );
	
	evbuffer_add( STORE_ITEM_BUF( item ), data, strlen( data ) );
	
	ret = mem_set( server, &item, 1 );
	if( ret == MEM_STORED )
	{
		printf( "test_set : stored.\n" );
	}

	DEL_ITEM_DATA( item._item );
}
コード例 #17
0
ファイル: http_bypass.c プロジェクト: tanec/fcache
void
proxycb(struct evhttp_request *req, void *arg)
{
  struct evbuffer *buf;

  if ((buf = evbuffer_new()) == NULL) {
    printf("failed to create response buffer");
  } else {
    tbuf resp = {0, NULL};
    zs_http_pass_req(&resp, req, host, port, req->uri, NULL);
    printf("resp: {%d, %p}\n", resp.len, resp.data);
    if (resp.data!=NULL) printf("%s\n", resp.data);
    evbuffer_add(buf, resp.data, resp.len);
    evhttp_send_reply(req, HTTP_OK, "OK", buf);
    evbuffer_free(buf);
    if (resp.data!=NULL) free(resp.data);
  }
}
コード例 #18
0
ファイル: evbuffer.c プロジェクト: poseidon1214/proxy
int main(int argc, char **argv)
{
    struct evbuffer *buf = evbuffer_new();
    size_t n;
    const char *line, *str = "GET / HTTP/1.1\r\n"
        "Host: hello.world\r\n"
        "\r\n";
    evbuffer_add(buf, str, strlen(str));
    while (1) {
        line = evbuffer_readln(buf, &n, EVBUFFER_EOL_CRLF);
        printf("line=[%s], address=[%#x], n=%d\n", line, (unsigned int)line, n);
        if (NULL == line) {
            break;
        }
        free(line);
    }
    return 0;
}
コード例 #19
0
ファイル: movid.cpp プロジェクト: AChurikov/Movid
static void web_pipeline_stream_trickle(int fd, short events, void *arg)
{
	struct evbuffer *evb = NULL;
	struct chunk_req_state *state = static_cast<chunk_req_state*>(arg);
	struct timeval when = { 0, 0 };
	long unsigned int outlen;
	unsigned char *outbuf;

	when.tv_usec = state->delay * 1000;

	if ( state->closed ) {
		// free !
		state->stream->setInput(NULL);
		delete state->stream;
		free(state);
		return;
	}

	if ( !state->stream->copy() ) {
		event_once(-1, EV_TIMEOUT, web_pipeline_stream_trickle, state, &when);
		return;
	}

	if ( state->stream->output_buffer->nChannels == 3 )
		cvCvtColor(state->stream->output_buffer, state->stream->output_buffer, CV_BGR2RGB);

	ipl2jpeg(state->stream->output_buffer, &outbuf, &outlen);

	evb = evbuffer_new();
	evbuffer_add_printf(evb, "--mjpegstream\r\n");
	evbuffer_add_printf(evb, "Content-Type: image/jpeg\r\n");
	evbuffer_add_printf(evb, "Content-Length: %lu\r\n\r\n", outlen);
	evbuffer_add(evb, outbuf, outlen);
	evhttp_send_reply_chunk(state->req, evb);
	evbuffer_free(evb);

	free(outbuf);

	event_once(-1, EV_TIMEOUT, web_pipeline_stream_trickle, state, &when);
	/**
		evhttp_send_reply_end(state->req);
		free(state);
	**/
}
コード例 #20
0
ファイル: drone.c プロジェクト: safchain/ml-stress
static void drone_interval_timer_cb(evutil_socket_t fd, short what, void *arg) {
    struct job *job = arg;
    Drone__JobIntervalResult *interval;
    u_int64_t throughtput_kbs;
    struct packet_header *ph;
    u_int8_t *data;
    u_int8_t *buffer;
    u_int64_t packet_size;
    u_int64_t data_size;

    if (job->client == NULL)
        return;

    interval = &(job->intervalresults[job->cur_interval]);

    throughtput_kbs = interval->total_bytes_read
            / (job->request->interval * 1024);

    printf("[%5d] Messages: %8" PRIu64 ", Bytes: %12" PRIu64
    ", Throughtput(KB/sec): %5" PRIu64 ", Connections: %6" PRIu64 "\n",
            job->cur_interval + 1, interval->total_messages_read,
            interval->total_bytes_read, throughtput_kbs,
            interval->total_sessions);

    data_size = drone__job_interval_result__get_packed_size(interval);
    packet_size = data_size + sizeof(struct packet_header);

    buffer = malloc(packet_size);

    ph = (struct packet_header *) buffer;
    data = buffer + sizeof(struct packet_header);

    ph->size = htonl(data_size);
    ph->type = TYPE_INTERVAL_PACKET;

    drone__job_interval_result__pack(interval, data);

    evbuffer_add(bufferevent_get_output(job->client->bev), buffer, packet_size);

    free(buffer);

    if (job->cur_interval < (job->total_intervals - 1))
        job->cur_interval++;
}
コード例 #21
0
ファイル: upload-file.c プロジェクト: simcuslee/seafile
static void
upload_progress_cb(evhtp_request_t *req, void *arg)
{
    const char *progress_id;
    const char *callback;
    Progress *progress;
    GString *buf;

    progress_id = evhtp_kv_find (req->uri->query, "X-Progress-ID");
    if (!progress_id) {
        seaf_warning ("[get pg] Progress id not found in url.\n");
        evhtp_send_reply (req, EVHTP_RES_BADREQ);
        return;
    }

    callback = evhtp_kv_find (req->uri->query, "callback");
    if (!callback) {
        seaf_warning ("[get pg] callback not found in url.\n");
        evhtp_send_reply (req, EVHTP_RES_BADREQ);
        return;
    }

    pthread_mutex_lock (&pg_lock);
    progress = g_hash_table_lookup (upload_progress, progress_id);
    pthread_mutex_unlock (&pg_lock);

    if (!progress) {
        /* seaf_warning ("[get pg] No progress found for %s.\n", progress_id); */
        evhtp_send_reply (req, EVHTP_RES_BADREQ);
        return;
    }

    /* Return JSONP formated data. */
    buf = g_string_new (NULL);
    g_string_append_printf (buf,
                            "%s({\"uploaded\": %lld, \"length\": %lld});",
                            callback, progress->uploaded, progress->size);
    evbuffer_add (req->buffer_out, buf->str, buf->len);

    seaf_debug ("JSONP: %s\n", buf->str);

    evhtp_send_reply (req, EVHTP_RES_OK);
    g_string_free (buf, TRUE);
}
コード例 #22
0
ファイル: file_io_ops.c プロジェクト: Nimain/riofs
void fileio_simple_upload (Application *app, const gchar *fname, const char *str, mode_t mode, FileIO_simple_on_upload_cb on_upload_cb, gpointer ctx)
{
    FileIOSimpleUpload *fsim;

    fsim = g_new0 (FileIOSimpleUpload, 1);
    fsim->write_buf = evbuffer_new ();
    evbuffer_add (fsim->write_buf, str, strlen (str));
    fsim->fname = g_strdup_printf ("/%s", fname);
    fsim->on_upload_cb = on_upload_cb;
    fsim->ctx = ctx;
    fsim->mode = mode;

    if (!client_pool_get_client (application_get_write_client_pool (app),
        fileio_simple_upload_on_con_cb, fsim)) {
        LOG_err (FIO_LOG, "Failed to get HTTP client !");
        fsim->on_upload_cb (ctx, FALSE);
        fileio_simple_upload_destroy (fsim);
    }
}
コード例 #23
0
ファイル: evhtp_s.cpp プロジェクト: austgl/libhttp
void
evhtp_send_reply_chunk(evhtp_request_t * request, evbuf_t * buf) {
    evbuf_t * output;

    output = bufferevent_get_output(request->conn->bev);

    if (evbuffer_get_length(buf) == 0) {
        return;
    }
    if (request->chunked) {
        evbuffer_add_printf(output, "%x\r\n",
                            (unsigned)evbuffer_get_length(buf));
    }
    evhtp_send_reply_body(request, buf);
    if (request->chunked) {
        evbuffer_add(output, "\r\n", 2);
    }
    bufferevent_flush(request->conn->bev, EV_WRITE, BEV_FLUSH);
}
コード例 #24
0
ファイル: artwork.c プロジェクト: juvenal/forked-daapd
static int
artwork_read(char *filename, struct evbuffer *evbuf)
{
  uint8_t buf[4096];
  struct stat sb;
  int fd;
  int ret;

  fd = open(filename, O_RDONLY);
  if (fd < 0)
    {
      DPRINTF(E_WARN, L_ART, "Could not open artwork file '%s': %s\n", filename, strerror(errno));

      return -1;
    }

  ret = fstat(fd, &sb);
  if (ret < 0)
    {
      DPRINTF(E_WARN, L_ART, "Could not stat() artwork file '%s': %s\n", filename, strerror(errno));

      goto out_fail;
    }

  ret = evbuffer_expand(evbuf, sb.st_size);
  if (ret < 0)
    {
      DPRINTF(E_LOG, L_ART, "Out of memory for artwork\n");

      goto out_fail;
    }

  while ((ret = read(fd, buf, sizeof(buf))) > 0)
    evbuffer_add(evbuf, buf, ret);

  close(fd);

  return 0;

 out_fail:
  close(fd);
  return -1;
}
コード例 #25
0
ファイル: regress_bufferevent.c プロジェクト: kjg/libevent
static enum bufferevent_filter_result
bufferevent_input_filter(struct evbuffer *src, struct evbuffer *dst,
    ev_ssize_t lim, enum bufferevent_flush_mode state, void *ctx)
{
	const unsigned char *buffer;
	int i;

	buffer = evbuffer_pullup(src, evbuffer_get_length(src));
	for (i = 0; i < evbuffer_get_length(src); i += 2) {
		assert(buffer[i] == 'x');
		evbuffer_add(dst, buffer + i + 1, 1);

		if (i + 2 > evbuffer_get_length(src))
			break;
	}

	evbuffer_drain(src, i);
	return (BEV_OK);
}
コード例 #26
0
ファイル: webseed.c プロジェクト: miracle2k/transmission
static char*
makeURL( tr_webseed *    w,
         const tr_file * file )
{
    char *            ret;
    struct evbuffer * out = evbuffer_new( );
    const char *      url = w->url;
    const size_t      url_len = strlen( url );

    evbuffer_add( out, url, url_len );

    /* if url ends with a '/', add the torrent name */
    if( url[url_len - 1] == '/' && file->name )
        tr_http_escape( out, file->name, strlen(file->name), FALSE );

    ret = tr_strndup( EVBUFFER_DATA( out ), EVBUFFER_LENGTH( out ) );
    evbuffer_free( out );
    return ret;
}
コード例 #27
0
ファイル: buffer.c プロジェクト: andbrain/warc-tools
int
evbuffer_add_buffer (struct evbuffer *outbuf, struct evbuffer *inbuf)
{
    int res;

    /* Short cut for better performance */

    if (outbuf->off == 0)
    {

        struct evbuffer tmp;
        size_t oldoff = inbuf->off;

        /* Swap them directly */
        SWAP (&tmp, outbuf);
        SWAP (outbuf, inbuf);
        SWAP (inbuf, &tmp);

        /*
         * Optimization comes with a price; we need to notify the
         * buffer if necessary of the changes. oldoff is the amount
         * of data that we transfered from inbuf to outbuf
         */

        if (inbuf->off != oldoff && inbuf->cb != NULL)
            (*inbuf->cb) (inbuf, oldoff, inbuf->off, inbuf->cbarg);

        if (oldoff && outbuf->cb != NULL)
            (*outbuf->cb) (outbuf, 0, oldoff, outbuf->cbarg);

        return (0);
    }

    res = evbuffer_add (outbuf, inbuf->buffer, inbuf->off);

    if (res == 0)
    {
        /* We drain the input buffer on success */
        evbuffer_drain (inbuf, inbuf->off);
    }

    return (res);
}
コード例 #28
0
ファイル: lastfm.c プロジェクト: noid1011/forked-daapd
static size_t
request_cb(char *ptr, size_t size, size_t nmemb, void *userdata)
{
  size_t realsize;
  struct https_client_ctx *ctx;
  int ret;

  realsize = size * nmemb;
  ctx = (struct https_client_ctx *)userdata;

  ret = evbuffer_add(ctx->data, ptr, realsize);
  if (ret < 0)
    {
      DPRINTF(E_LOG, L_LASTFM, "Error adding reply from LastFM to data buffer\n");
      return 0;
    }

  return realsize;
}
コード例 #29
0
static int
url_evbuffer_write(URLContext *h, unsigned char *buf, int size)
{
  struct evbuffer *evbuf;
  int ret;

  evbuf = (struct evbuffer *)h->priv_data;

  if (!evbuf)
    {
      DPRINTF(E_LOG, L_FFMPEG, "Write called on evbuffer URL with priv_data = NULL!\n");

      return -1;
    }

  ret = evbuffer_add(evbuf, buf, size);

  return (ret == 0) ? size : -1;
}
コード例 #30
0
ファイル: telnet.c プロジェクト: cracksoft/scanssh
void
telnet_readcb(struct bufferevent *bev, void *parameter)
{
	struct argument *arg = parameter;
	struct evbuffer *input = EVBUFFER_INPUT(bev);
	struct telnet_state *state = arg->a_state;

	DFPRINTF((stderr, "%s: called\n", __func__));

	if (arg->a_flags == 0) {
		int res = telnet_makeconnect(bev, arg);
		if (res == -1) {
			evbuffer_add(input, "", 1);
			printres(arg, arg->a_ports[0].port, 
			    EVBUFFER_DATA(input));
			scanhost_return(bev, arg, 0);
			return;
		} else if (res == 1) {
			arg->a_flags = TELNET_WAITING_CONNECT;
			bufferevent_disable(bev, EV_READ);
		}
	} else if (arg->a_flags & TELNET_READING_CONNECT) {
		if (evbuffer_find(input, state->connect_wait,
			strlen(state->connect_wait)) == NULL)
			return;
		evbuffer_drain(input, EVBUFFER_LENGTH(input));

		arg->a_flags = TELNET_WRITING_COMMAND;
		bufferevent_disable(bev, EV_READ);
		http_makerequest(bev, arg, socks_getword(), 0);
	} else if (arg->a_flags & TELNET_WAITING_RESPONSE) {
		int res = http_bufferanalyse(bev, arg);
		if (res == -1)
			return;
		if (res == 1) {
			postres(arg, state->response);
			scanhost_return(bev, arg, 1);
		}
	}

	return;
}