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

/* Reset for ground state. */voidinput_ground(struct input_ctx *ictx){	evbuffer_drain(ictx->since_ground, EVBUFFER_LENGTH(ictx->since_ground));	if (ictx->input_space > INPUT_BUF_START) {		ictx->input_space = INPUT_BUF_START;		ictx->input_buf = xrealloc(ictx->input_buf, INPUT_BUF_START);	}}

voidevtag_marshal_msg(struct evbuffer *evbuf, ev_uint32_t tag, const struct msg *msg){  struct evbuffer *_buf = evbuffer_new();  assert(_buf != NULL);  evbuffer_drain(_buf, -1);  msg_marshal(_buf, msg);  evtag_marshal(evbuf, tag, EVBUFFER_DATA(_buf), EVBUFFER_LENGTH(_buf));  evbuffer_free(_buf);}

voidtr_peerIoWriteBuf( tr_peerIo         * io,                   struct evbuffer   * buf,                   tr_bool             isPieceData ){    /* FIXME(libevent2): loop through calls to evbuffer_get_contiguous_space() + evbuffer_drain() */    const size_t n = EVBUFFER_LENGTH( buf );    tr_peerIoWrite( io, EVBUFFER_DATA( buf ), n, isPieceData );    evbuffer_drain( buf, n );}

static void auto_event_error(struct bufferevent *buffev, short what, void *_arg){	redsocks_client *client = _arg;	autoproxy_client * aclient = (void*)(client + 1) + client->instance->relay_ss->payload_len;	int saved_errno = errno;	assert(buffev == client->relay || buffev == client->client);			redsocks_touch_client(client);				redsocks_log_errno(client, LOG_DEBUG, "%s errno(%d), State: %d, what: " event_fmt_str, 							buffev == client->client?"client":"relay",							saved_errno, aclient->state, event_fmt(what));	if (buffev == client->relay)	{				if ( aclient->state == AUTOPROXY_NEW 		&& what == (EVBUFFER_WRITE|EVBUFFER_TIMEOUT))		{			on_connection_blocked(client);				/* In case timeout occurs while connecting relay, we try to connect			to target via SOCKS5 proxy. It is possible that the connection to			target can be set up a bit longer than the timeout value we set. 			However, it is still better to make connection via proxy. */			auto_retry(client, 1);			return;		}		if (aclient->state == AUTOPROXY_NEW  && saved_errno == ECONNRESET)			if (!auto_retry_or_drop(client))				return;		if (aclient->state == AUTOPROXY_CONNECTED && what == (EVBUFFER_READ|EVBUFFER_ERROR) 				&& saved_errno == ECONNRESET )		{			if (!auto_retry_or_drop(client))				return;		}	}		if (what == (EVBUFFER_READ|EVBUFFER_EOF)) {		struct bufferevent *antiev;		if (buffev == client->relay)			antiev = client->client;		else			antiev = client->relay;					redsocks_shutdown(client, buffev, SHUT_RD);				if (antiev != NULL && EVBUFFER_LENGTH(antiev->output) == 0)			redsocks_shutdown(client, antiev, SHUT_WR);	}	else {		redsocks_drop_client(client);	}}																		

intrelay_dns_request(struct rsession *con){	struct relay		*rlay = con->se_relay;	struct relay_dns_priv	*priv = con->se_priv;	u_int8_t		*buf = EVBUFFER_DATA(con->se_out.output);	size_t			 len = EVBUFFER_LENGTH(con->se_out.output);	struct relay_dnshdr	*hdr;	socklen_t		 slen;	if (buf == NULL || priv == NULL || len < 1)		return (-1);	if (debug)		relay_dns_log(con, buf, len);	getmonotime(&con->se_tv_start);	if (!TAILQ_EMPTY(&rlay->rl_tables)) {		if (relay_from_table(con) != 0)			return (-1);	} else if (con->se_out.ss.ss_family == AF_UNSPEC) {		bcopy(&rlay->rl_conf.dstss, &con->se_out.ss,		    sizeof(con->se_out.ss));		con->se_out.port = rlay->rl_conf.dstport;	}	if ((con->se_out.s = relay_udp_socket(&con->se_out.ss,	    con->se_out.port, rlay->rl_proto)) == -1)		return (-1);	slen = con->se_out.ss.ss_len;	hdr = (struct relay_dnshdr *)buf;	hdr->dns_id = htons(priv->dp_inkey); retry:	if (sendto(con->se_out.s, buf, len, 0,	    (struct sockaddr *)&con->se_out.ss, slen) == -1) {		if (con->se_retry) {			con->se_retry--;			log_debug("%s: session %d: "			    "forward failed: %s, %s", __func__,			    con->se_id, strerror(errno),			    con->se_retry ? "next retry" : "last retry");			goto retry;		}		log_debug("%s: session %d: forward failed: %s", __func__,		    con->se_id, strerror(errno));		return (-1);	}	event_again(&con->se_ev, con->se_out.s, EV_TIMEOUT|EV_READ,	    relay_udp_response, &con->se_tv_start, &env->sc_timeout, con);	return (0);}

/* Add window pane tabs. */voidformat_window_pane_tabs(struct format_tree *ft, struct window_pane *wp){	struct evbuffer	*buffer;	u_int		 i;	buffer = evbuffer_new();	for (i = 0; i < wp->base.grid->sx; i++) {		if (!bit_test(wp->base.tabs, i))			continue;		if (EVBUFFER_LENGTH(buffer) > 0)			evbuffer_add(buffer, ",", 1);		evbuffer_add_printf(buffer, "%d", i);	}	format_add(ft, "pane_tabs", "%.*s", (int) EVBUFFER_LENGTH(buffer),	    EVBUFFER_DATA(buffer));	evbuffer_free(buffer);}

static void on_client_read_stream(struct bufferevent *bev, void *ctx){  Client *cl = ctx;  size_t bytes = EVBUFFER_LENGTH(EVBUFFER_INPUT(bev));  char *buffer = EVBUFFER_DATA(EVBUFFER_INPUT(bev));  prcl_trace(cl, "received %d bytes from client", bytes);  bufferevent_write(cl->server.bufev, buffer, bytes);  evbuffer_drain(EVBUFFER_INPUT(bev), bytes);}

void TEvhttpClientChannel::finish(struct evhttp_request* req) {  if (req == NULL) {    return cob_();  } else if (req->response_code != 200) {    return cob_();  }  recvBuf_->resetBuffer(      EVBUFFER_DATA(req->input_buffer),      EVBUFFER_LENGTH(req->input_buffer));  return cob_();}

static void direct_relay_readcb_helper(redsocks_client *client, struct bufferevent *from, struct bufferevent *to){	if (EVBUFFER_LENGTH(to->output) < to->wm_write.high) {		if (bufferevent_write_buffer(to, from->input) == -1)			redsocks_log_errno(client, LOG_ERR, "bufferevent_write_buffer");	}	else {		if (bufferevent_disable(from, EV_READ) == -1)			redsocks_log_errno(client, LOG_ERR, "bufferevent_disable");	}}

const void *LibEventTransport::getPostData(int &size) {  if (m_sendEnded) {    size = 0;    return 0;  }  evbuffer *buf = m_request->input_buffer;  assert(buf);  size = EVBUFFER_LENGTH(buf);  return EVBUFFER_DATA(buf);}

/* copy event buffer from source to destination as much as possible.  * If parameter skip is not zero, copy will start from the number of skip bytes. */size_t copy_evbuffer(struct bufferevent * dst, const struct bufferevent * src, size_t skip){    int n, i;    size_t written = 0;    struct evbuffer_iovec *v;    struct evbuffer_iovec quick_v[5];/* a vector with 5 elements is usually enough */    size_t maxlen = dst->wm_write.high - EVBUFFER_LENGTH(dst->output);    maxlen = EVBUFFER_LENGTH(src->input) - skip> maxlen?maxlen: EVBUFFER_LENGTH(src->input)-skip;    n = evbuffer_peek(src->input, maxlen+skip, NULL, NULL, 0);    if (n>sizeof(quick_v)/sizeof(struct evbuffer_iovec))        v = malloc(sizeof(struct evbuffer_iovec)*n);    else        v = quick_v;    n = evbuffer_peek(src->input, maxlen+skip, NULL, v, n);    for (i=0; i<n; ++i) {        size_t len = v[i].iov_len;        if (skip >= len)        {            skip -= len;            continue;        }        else         {            len -= skip;        }        if (written + len > maxlen)            len = maxlen - written;        if (bufferevent_write(dst, v[i].iov_base+skip, len))            break;        skip = 0;        /* We keep track of the bytes written separately; if we don't,        *  we may write more than we need if the last chunk puts            * us over the limit. */        written += len;    }    if (n>sizeof(quick_v)/sizeof(struct evbuffer_iovec))        free(v);    return written;}

const void *LibEventTransport::getMorePostData(int &size) {#ifdef EVHTTP_PORTABLE_READ_LIMITING  if (m_request->ntoread == 0) {    if (m_eventBasePostData != nullptr) {      event_base_free(m_eventBasePostData);      m_eventBasePostData = nullptr;    }    size = 0;    return nullptr;  }  evbuffer *buf = m_request->input_buffer;  assert(buf);  evbuffer_drain(buf, EVBUFFER_LENGTH(buf));  if (evhttp_get_more_post_data(m_request, &m_eventBasePostData,                                &m_moreDataRead)) {    buf = m_request->input_buffer;    assert(buf);    size = EVBUFFER_LENGTH(buf);    if (m_request->ntoread == 0) {      if (m_eventBasePostData != nullptr) {        event_base_free(m_eventBasePostData);        m_eventBasePostData = nullptr;      }      evhttp_get_post_data_done(m_request);    }    return EVBUFFER_DATA(buf);  }  if (m_eventBasePostData != nullptr) {    event_base_free(m_eventBasePostData);    m_eventBasePostData = nullptr;  }  evhttp_get_post_data_done(m_request);  size = 0;  return nullptr;#else  size = 0;  return nullptr;#endif}

static voidwebResponseFunc( tr_session    * session,                 long            response_code,                 const void    * response,                 size_t          response_byte_count,                 void          * vw ){    tr_webseed * w = vw;    tr_torrent * tor = tr_torrentFindFromHash( session, w->hash );    const int    success = ( response_code == 206 );/*fprintf( stderr, "server responded with code %ld and %lu bytes/n",  response_code, (unsigned long)response_byte_count );*/    if( !success )    {        /* FIXME */    }    else if( tor != NULL )    {        evbuffer_add( w->content, response, response_byte_count );        if( !w->dead )        {            fireClientGotData( w, response_byte_count );            tr_rcTransferred( &w->rateDown, response_byte_count );        }        if( EVBUFFER_LENGTH( w->content ) < w->byteCount )            requestNextChunk( w );        else {            tr_ioWrite( tor, w->pieceIndex, w->pieceOffset, w->byteCount, EVBUFFER_DATA(w->content) );            evbuffer_drain( w->content, EVBUFFER_LENGTH( w->content ) );            w->busy = 0;            if( w->dead )                tr_webseedFree( w );            else  {                fireClientGotBlock( w, w->pieceIndex, w->pieceOffset, w->byteCount );                fireNeedReq( w );            }        }    }}

voidcmd_run_shell_callback(struct job *job){	struct cmd_run_shell_data	*cdata = job->data;	struct cmd_ctx			*ctx = &cdata->ctx;	char				*cmd, *msg, *line;	size_t				 size;	int				 retcode;	u_int				 lines;	if (ctx->cmdclient != NULL && ctx->cmdclient->flags & CLIENT_DEAD)		return;	if (ctx->curclient != NULL && ctx->curclient->flags & CLIENT_DEAD)		return;	lines = 0;	do {		if ((line = evbuffer_readline(job->event->input)) != NULL) {			ctx->print(ctx, "%s", line);			lines++;		}	} while (line != NULL);	size = EVBUFFER_LENGTH(job->event->input);	if (size != 0) {		line = xmalloc(size + 1);		memcpy(line, EVBUFFER_DATA(job->event->input), size);		line[size] = '/0';		ctx->print(ctx, "%s", line);		lines++;		xfree(line);	}	cmd = cdata->cmd;	msg = NULL;	if (WIFEXITED(job->status)) {		if ((retcode = WEXITSTATUS(job->status)) != 0)			xasprintf(&msg, "'%s' returned %d", cmd, retcode);	} else if (WIFSIGNALED(job->status)) {		retcode = WTERMSIG(job->status);		xasprintf(&msg, "'%s' terminated by signal %d", cmd, retcode);	}	if (msg != NULL) {		if (lines != 0)			ctx->print(ctx, "%s", msg);		else			ctx->info(ctx, "%s", msg);		xfree(msg);	}}

LibEventTransport::LibEventTransport(LibEventServer *server,                                     evhttp_request *request,                                     int workerId)  : m_server(server), m_request(request), m_eventBasePostData(nullptr),    m_workerId(workerId), m_sendStarted(false), m_sendEnded(false) {  // HttpProtocol::PrepareSystemVariables needs this  evbuffer *buf = m_request->input_buffer;  assert(buf);  m_requestSize = EVBUFFER_LENGTH(buf);  m_remote_host = m_request->remote_host;  m_remote_port = m_request->remote_port;  {    char buf[6];    snprintf(buf, 6, "%d.%d", m_request->major, m_request->minor);    m_http_version = buf;  }  switch (m_request->type) {  case EVHTTP_REQ_GET:    m_method = Transport::Method::GET;    m_requestSize += 3;    break;  case EVHTTP_REQ_POST:    m_method = Transport::Method::POST;    m_requestSize += 4;    break;  case EVHTTP_REQ_HEAD:    m_method = Transport::Method::HEAD;    m_requestSize += 4;    break;  default:    assert(false);    m_method = Transport::Method::Unknown;    break;  }  m_extended_method = m_request->ext_method;  assert(m_request->input_headers);  for (evkeyval *p = ((m_evkeyvalq*)m_request->input_headers)->tqh_first; p;       p = p->next.tqe_next) {    if (p->key && p->value) {      m_requestHeaders[p->key].push_back(p->value);      //key, value, ": " and CR/LF      m_requestSize += strlen(p->key) + strlen(p->value) + 4;    }  }  m_url = m_request->uri;  m_requestSize += m_url.size();  m_requestSize += m_http_version.size(); //version number in "HTTP/x.y"  m_requestSize += 11; // HTTP/=5, 2 spaces for url, and CR/LF x2 (first+last)}

static voidtask_finish( struct tr_web_task * task, long response_code ){    dbgmsg( "finished a web task... response code is %ld", response_code );    dbgmsg( "===================================================" );    task->done_func( task->session,                     response_code,                     EVBUFFER_DATA( task->response ),                     EVBUFFER_LENGTH( task->response ),                     task->done_func_user_data );    task_free( task );}

static voidbufferevent_readcb(int fd, short event, void *arg){	struct bufferevent *bufev = arg;	int res = 0;	short what = EVBUFFER_READ;	size_t len;	if (event == EV_TIMEOUT) {		what |= EVBUFFER_TIMEOUT;		goto error;	}	res = evbuffer_read(bufev->input, fd, -1);	if (res == -1) {		if (errno == EAGAIN || errno == EINTR)			goto reschedule;		/* error case */		what |= EVBUFFER_ERROR;	} else if (res == 0) {		/* eof case */		what |= EVBUFFER_EOF;	}	if (res <= 0)		goto error;	bufferevent_add(&bufev->ev_read, bufev->timeout_read);	/* See if this callbacks meets the water marks */	len = EVBUFFER_LENGTH(bufev->input);	if (bufev->wm_read.low != 0 && len < bufev->wm_read.low)		return;	if (bufev->wm_read.high != 0 && len > bufev->wm_read.high) {		struct evbuffer *buf = bufev->input;		event_del(&bufev->ev_read);		/* Now schedule a callback for us */		evbuffer_setcb(buf, bufferevent_read_pressure_cb, bufev);		return;	}	/* Invoke the user callback - must always be called last */	(*bufev->readcb)(bufev, bufev->cbarg);	return; reschedule:	bufferevent_add(&bufev->ev_read, bufev->timeout_read);	return; error:	(*bufev->errorcb)(bufev, what, bufev->cbarg);}

size_ttr_peerIoGetWriteBufferSpace( const tr_peerIo * io, uint64_t now ){    const size_t desiredLen = getDesiredOutputBufferSize( io, now );    const size_t currentLen = EVBUFFER_LENGTH( io->outbuf );    size_t freeSpace = 0;    if( desiredLen > currentLen )        freeSpace = desiredLen - currentLen;    return freeSpace;}

/** * Called when a message is sent on the HTTP channel pipe. */voidon_http_message_chunk(struct evhttp_request *req, void *ptr) {	struct reader_thread *rt = ptr;	if(req->response_code == HTTP_OK) {		size_t sz = EVBUFFER_LENGTH(req->input_buffer);		process_message(rt, sz);	} else {		fprintf(stderr, "CHUNK FAIL (ret=%d)/n", req->response_code);	}}

static voidtask_finish( struct tr_web_task * task, long response_code ){    dbgmsg( "finished web task %lu; got %ld", task->tag, response_code );    if( task->done_func != NULL )        task->done_func( task->session,                         response_code,                         EVBUFFER_DATA( task->response ),                         EVBUFFER_LENGTH( task->response ),                         task->done_func_user_data );    task_free( task );}

void source_callback (struct evhttp_request *req, void *arg){    if (DEBUG) fprintf(stdout, "source_callback/n");    // enum message_read_status done;    evhttp_clear_headers(req->input_headers);    evhttp_parse_headers(req, req->input_buffer);    char *content_len;    content_len = (char *) evhttp_find_header(req->input_headers, "Content-Length");    if (!content_len){return;}        int len = atoi(content_len);    size_t len_size;        len_size = (size_t)len;    if (DEBUG) fprintf(stdout, "received content_length:%d buffer has:%d/n", len, EVBUFFER_LENGTH(req->input_buffer));    struct global_data *client_data = (struct global_data *)arg;    struct evhttp_request *evhttp_target_request = NULL;    evhttp_target_request = evhttp_request_new(http_post_done, NULL);    evhttp_add_header(evhttp_target_request->output_headers, "Host", client_data->target_address);    char *data = calloc(len, sizeof(char *));    evbuffer_remove(req->input_buffer, data, len);    if (DEBUG)fprintf(stdout, "data has %d bytes/n", strlen(data));    if (DEBUG)fprintf(stdout, "data=%s/n", data);    // empty buffer    evbuffer_drain(req->input_buffer, EVBUFFER_LENGTH(req->input_buffer));    // write to output buffer    int flag = (*client_data->cb)(data, evhttp_target_request->output_buffer, &client_data->target_path, client_data->cbarg);    free(data);    if (!flag){return;} // don't make the request    if (evhttp_make_request(client_data->evhttp_target_connection, evhttp_target_request, EVHTTP_REQ_POST, client_data->target_path) == -1) {        fprintf(stdout, "FAILED make_request/n");        exit(1);    }}

voidcmd_run_shell_callback(struct job *job){	struct cmd_run_shell_data	*cdata = job->data;	struct cmd_q			*cmdq = cdata->cmdq;	char				*cmd, *msg, *line;	size_t				 size;	int				 retcode;	u_int				 lines;	if (cmdq->dead)		return;	cmd = cdata->cmd;	lines = 0;	do {		if ((line = evbuffer_readline(job->event->input)) != NULL) {			cmd_run_shell_print(job, line);			free(line);			lines++;		}	} while (line != NULL);	size = EVBUFFER_LENGTH(job->event->input);	if (size != 0) {		line = xmalloc(size + 1);		memcpy(line, EVBUFFER_DATA(job->event->input), size);		line[size] = '/0';		cmd_run_shell_print(job, line);		lines++;		free(line);	}	msg = NULL;	if (WIFEXITED(job->status)) {		if ((retcode = WEXITSTATUS(job->status)) != 0)			xasprintf(&msg, "'%s' returned %d", cmd, retcode);	} else if (WIFSIGNALED(job->status)) {		retcode = WTERMSIG(job->status);		xasprintf(&msg, "'%s' terminated by signal %d", cmd, retcode);	}	if (msg != NULL) {		if (lines == 0)			cmdq_info(cmdq, "%s", msg);		else			cmd_run_shell_print(job, msg);		free(msg);	}}

/* * Adds the given (scaled) artwork image to the artwork cache * * @param cmd->arg.persistentid persistent songalbumid or songartistid * @param cmd->arg.max_w maximum image width * @param cmd->arg.max_h maximum image height * @param cmd->arg.format ART_FMT_PNG for png, ART_FMT_JPEG for jpeg or 0 if no artwork available * @param cmd->arg.filename the full path to the artwork file (could be an jpg/png image or a media file with embedded artwork) or empty if no artwork available * @param cmd->arg.evbuf event buffer containing the (scaled) image * @return 0 if successful, -1 if an error occurred */static intcache_artwork_add_impl(struct cache_command *cmd){  sqlite3_stmt *stmt;  char *query;  uint8_t *data;  int datalen;  int ret;  query = "INSERT INTO artwork (id, persistentid, max_w, max_h, format, filepath, db_timestamp, data) VALUES (NULL, ?, ?, ?, ?, ?, ?, ?);";  ret = sqlite3_prepare_v2(g_db_hdl, query, -1, &stmt, 0);  if (ret != SQLITE_OK)    {      DPRINTF(E_LOG, L_CACHE, "Could not prepare statement: %s/n", sqlite3_errmsg(g_db_hdl));      return -1;    }#ifdef HAVE_LIBEVENT2  datalen = evbuffer_get_length(cmd->arg.evbuf);  data = evbuffer_pullup(cmd->arg.evbuf, -1);#else  datalen = EVBUFFER_LENGTH(cmd->arg.evbuf);  data = EVBUFFER_DATA(cmd->arg.evbuf);#endif  sqlite3_bind_int64(stmt, 1, cmd->arg.peristentid);  sqlite3_bind_int(stmt, 2, cmd->arg.max_w);  sqlite3_bind_int(stmt, 3, cmd->arg.max_h);  sqlite3_bind_int(stmt, 4, cmd->arg.format);  sqlite3_bind_text(stmt, 5, cmd->arg.path, -1, SQLITE_STATIC);  sqlite3_bind_int(stmt, 6, (uint64_t)time(NULL));  sqlite3_bind_blob(stmt, 7, data, datalen, SQLITE_STATIC);  ret = sqlite3_step(stmt);  if (ret != SQLITE_DONE)    {      DPRINTF(E_LOG, L_CACHE, "Error stepping query for artwork add: %s/n", sqlite3_errmsg(g_db_hdl));      sqlite3_finalize(stmt);      return -1;    }  ret = sqlite3_finalize(stmt);  if (ret != SQLITE_OK)    {      DPRINTF(E_LOG, L_CACHE, "Error finalizing query for artwork add: %s/n", sqlite3_errmsg(g_db_hdl));      return -1;    }  return 0;}

intkill_unmarshal(struct kill *tmp,  struct evbuffer *evbuf){  ev_uint32_t tag;  while (EVBUFFER_LENGTH(evbuf) > 0) {    if (evtag_peek(evbuf, &tag) == -1)      return (-1);    switch (tag) {      case KILL_WEAPON:        if (tmp->weapon_set)          return (-1);        if (evtag_unmarshal_string(evbuf, KILL_WEAPON, &tmp->weapon_data) == -1) {          event_warnx("%s: failed to unmarshal weapon", __func__);          return (-1);        }        tmp->weapon_set = 1;        break;      case KILL_ACTION:        if (tmp->action_set)          return (-1);        if (evtag_unmarshal_string(evbuf, KILL_ACTION, &tmp->action_data) == -1) {          event_warnx("%s: failed to unmarshal action", __func__);          return (-1);        }        tmp->action_set = 1;        break;      case KILL_HOW_OFTEN:        if (tmp->how_often_set)          return (-1);        if (evtag_unmarshal_int(evbuf, KILL_HOW_OFTEN, &tmp->how_often_data) == -1) {          event_warnx("%s: failed to unmarshal how_often", __func__);          return (-1);        }        tmp->how_often_set = 1;        break;      default:        return -1;    }  }  if (kill_complete(tmp) == -1)    return (-1);  return (0);}

LibEventTransport::LibEventTransport(LibEventServer *server,                                     evhttp_request *request,                                     int workerId)  : m_server(server), m_request(request), m_eventBasePostData(NULL),    m_workerId(workerId), m_sendStarted(false), m_sendEnded(false) {  // HttpProtocol::PrepareSystemVariables needs this  evbuffer *buf = m_request->input_buffer;  ASSERT(buf);  int size = EVBUFFER_LENGTH(buf);  if (size) {    evbuffer_expand(buf, size + 1); // allowing NULL termination    // EVBUFFER_DATA(buf) might change after evbuffer_expand    ((char*)EVBUFFER_DATA(buf))[size] = '/0';  }  m_remote_host = m_request->remote_host;  m_remote_port = m_request->remote_port;  {    char buf[6];    snprintf(buf, 6, "%d.%d", m_request->major, m_request->minor);    m_http_version = buf;  }  switch (m_request->type) {  case EVHTTP_REQ_GET:    m_method = Transport::GET;    break;  case EVHTTP_REQ_POST:    m_method = Transport::POST;    break;  case EVHTTP_REQ_HEAD:    m_method = Transport::HEAD;    break;  default:    ASSERT(false);    m_method = Transport::UnknownMethod;    break;  }  m_extended_method = m_request->ext_method;  ASSERT(m_request->input_headers);  for (evkeyval *p = ((m_evkeyvalq*)m_request->input_headers)->tqh_first; p;       p = p->next.tqe_next) {    if (p->key && p->value) {      m_requestHeaders[p->key].push_back(p->value);    }  }  m_url = m_request->uri;}

voidrecord_marshal(struct evbuffer *evbuf, struct record *record){	struct evbuffer *addr = evbuffer_new();	struct hash *hash;	if (timerisset(&record->tv_start))		tag_marshal_timeval(evbuf, REC_TV_START, &record->tv_start);	if (timerisset(&record->tv_end))		tag_marshal_timeval(evbuf, REC_TV_END, &record->tv_end);	/* Encode an address */	evbuffer_drain(addr, EVBUFFER_LENGTH(addr));	addr_marshal(addr, &record->src);	tag_marshal(evbuf, REC_SRC, EVBUFFER_DATA(addr), EVBUFFER_LENGTH(addr));	evbuffer_drain(addr, EVBUFFER_LENGTH(addr));	addr_marshal(addr, &record->dst);	tag_marshal(evbuf, REC_DST, EVBUFFER_DATA(addr), EVBUFFER_LENGTH(addr));	tag_marshal_int(evbuf, REC_SRC_PORT, record->src_port);	tag_marshal_int(evbuf, REC_DST_PORT, record->dst_port);	tag_marshal_int(evbuf, REC_PROTO, record->proto);	tag_marshal_int(evbuf, REC_STATE, record->state);	if (record->os_fp != NULL)		tag_marshal_string(evbuf, REC_OS_FP, record->os_fp);	TAILQ_FOREACH(hash, &record->hashes, next)	    tag_marshal(evbuf, REC_HASH, hash->digest, sizeof(hash->digest));	if (record->bytes)		tag_marshal_int(evbuf, REC_BYTES, record->bytes);	if (record->flags)		tag_marshal_int(evbuf, REC_FLAGS, record->flags);	evbuffer_free(addr);}

/* Called when output buffer falls below low watermark (default is 0). */voidjob_write_callback(unused struct bufferevent *bufev, void *data){	struct job	*job = data;	size_t		 len = EVBUFFER_LENGTH(EVBUFFER_OUTPUT(job->event));	log_debug("job write %p: %s, pid %ld, output left %zu", job, job->cmd,	    (long) job->pid, len);	if (len == 0) {		shutdown(job->fd, SHUT_WR);		bufferevent_disable(job->event, EV_WRITE);	}}

void simplehttp_log(const char *host, struct evhttp_request *req, uint64_t req_time, const char *id, int display_post){    // NOTE: this is localtime not gmtime    time_t now;    struct tm *tm_now;    char datetime_buf[64];    char code;    const char *method;    char *uri;    int response_code;    int type;        time(&now);    tm_now = localtime(&now);    strftime(datetime_buf, 64, "%y%m%d %H:%M:%S", tm_now);        if (req) {        if (req->response_code >= 500 && req->response_code < 600) {            code = 'E';        } else if (req->response_code >= 400 && req->response_code < 500) {            code = 'W';        } else {            code = 'I';        }        response_code = req->response_code;        method = simplehttp_method(req);        uri = req->uri;        type = req->type;    } else {        code = 'E';        response_code = 0;        method = "NA";        uri = "";        type = -1;    }        fprintf(stdout, "[%c %s %s] %d %s %s%s", code, datetime_buf, id, response_code, method, host, uri);        if (display_post && (type == EVHTTP_REQ_POST)) {        if (req->input_buffer == NULL || EVBUFFER_DATA(req->input_buffer) == NULL) {            fprintf(stdout, "<ERROR req->input_buffer=%p, EVBUFFER_DATA=%p>", req->input_buffer, /* must be */ NULL);        } else {            fprintf(stdout, "?");            fwrite(EVBUFFER_DATA(req->input_buffer), EVBUFFER_LENGTH(req->input_buffer), 1, stdout);        }    }        fprintf(stdout, " %.3fms/n", req_time / 1000.0);}

static char*makeURL( tr_webseed *    w,         const tr_file * file ){    char *            ret;    struct evbuffer * out = tr_getBuffer( );    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] == '/' )    {        const char * str = file->name;        /* this is like curl_escape() but doesn't munge the         * '/' directory separators in the path */        while( str && *str )        {            switch( *str )            {                case ',': case '-': case '.': case '/':                case '0': case '1': case '2': case '3': case '4':                case '5': case '6': case '7': case '8': case '9':                case 'a': case 'b': case 'c': case 'd': case 'e':                case 'f': case 'g': case 'h': case 'i': case 'j':                case 'k': case 'l': case 'm': case 'n': case 'o':                case 'p': case 'q': case 'r': case 's': case 't':                case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':                case 'A': case 'B': case 'C': case 'D': case 'E':                case 'F': case 'G': case 'H': case 'I': case 'J':                case 'K': case 'L': case 'M': case 'N': case 'O':                case 'P': case 'Q': case 'R': case 'S': case 'T':                case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':                    evbuffer_add( out, str, 1 );                    break;                default:                    evbuffer_add_printf( out, "%%%02X", *str );                    break;            }            str++;        }    }    ret = tr_strndup( EVBUFFER_DATA( out ), EVBUFFER_LENGTH( out ) );    tr_releaseBuffer( out );    return ret;}

static voidtask_finish_func( void * vtask ){    struct tr_web_task * task = vtask;    dbgmsg( "finished web task %p; got %ld", task, task->code );    if( task->done_func != NULL )        task->done_func( task->session,                         task->code,                         EVBUFFER_DATA( task->response ),                         EVBUFFER_LENGTH( task->response ),                         task->done_func_user_data );    task_free( task );}