/* Reset for ground state. */
void
input_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);
}
}
void
evtag_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);
}
void
tr_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);
}
}
int
relay_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. */
void
format_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 void
webResponseFunc( 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 );
}
}
}
}
void
cmd_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 void
task_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 void
bufferevent_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_t
tr_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.
*/
void
on_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 void
task_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);
}
}
void
cmd_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 int
cache_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;
}
int
kill_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;
}
void
record_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). */
void
job_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 void
task_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 );
}