void
have(struct Piece *piece, struct Torrent *t)
{
uint32_t have_prefix = htonl(5);
uint8_t have_id = 4;
uint32_t index = htonl(piece->index);
struct PeerNode *head = t->peer_list;
while (head != NULL) {
bufferevent_write(head->cargo->bufev, (const void *)&have_prefix, sizeof(have_prefix));
bufferevent_write(head->cargo->bufev, (const void *)&have_id, sizeof(have_id));
bufferevent_write(head->cargo->bufev, (const void *)&index, sizeof(index));
head = head->next;
}
t->have_bitfield[piece->index] = 1;
uint64_t i = pieces_remaining(t->have_bitfield, t->num_pieces);
/* if 0 pieces remain, the torrent is complete */
if (i == 0) {
complete(t);
}
#ifdef DEBUG
if (i < 5) {
print_pieces_remaining(t->have_bitfield, t->num_pieces);
}
#endif
}
static void
rrdtool_write_command(struct rrdtool_drv *drv, char *command)
{
bufferevent_write(drv->evb, command, strlen(command));
if (command[strlen(command) - 1] != '\n')
bufferevent_write(drv->evb, "\n", 1);
}
/* Add bytes to a buffer and filter '\n' according to separator. */
void
cmd_paste_buffer_filter(struct window_pane *wp,
const char *data, size_t size, const char *sep, int bracket)
{
const char *end = data + size;
const char *lf;
size_t seplen;
if (bracket)
bufferevent_write(wp->event, "\033[200~", 6);
seplen = strlen(sep);
while ((lf = memchr(data, '\n', end - data)) != NULL) {
if (lf != data)
bufferevent_write(wp->event, data, lf - data);
bufferevent_write(wp->event, sep, seplen);
data = lf + 1;
}
if (end != data)
bufferevent_write(wp->event, data, end - data);
if (bracket)
bufferevent_write(wp->event, "\033[201~", 6);
}
void
tty_putc(struct tty *tty, u_char ch)
{
const char *acs;
u_int sx;
if (tty->cell.attr & GRID_ATTR_CHARSET) {
acs = tty_acs_get(tty, ch);
if (acs != NULL)
bufferevent_write(tty->event, acs, strlen(acs));
else
bufferevent_write(tty->event, &ch, 1);
} else
bufferevent_write(tty->event, &ch, 1);
if (ch >= 0x20 && ch != 0x7f) {
sx = tty->sx;
if (tty->term->flags & TERM_EARLYWRAP)
sx--;
if (tty->cx >= sx) {
tty->cx = 1;
if (tty->cy != tty->rlower)
tty->cy++;
} else
tty->cx++;
}
if (tty->log_fd != -1)
write(tty->log_fd, &ch, 1);
}
//channel_id number
//packet lstring
static int lpacket_sender(lua_State *L)
{
int channel_id = luaL_checkint(L, 1);
struct bufferevent *bev = AllChannels[channel_id]._bev;
if (!bev) {
logging("lpacket_sender error : channel has closed");
lua_pushboolean(L, 0);
return 1;
}
size_t sz;
const char *packet = luaL_checklstring(L, 2, &sz);
if (sz > MAX_PACKET_SZ) {
logging("packet tooooo big, throw it");
lua_pushboolean(L, 0);
return 1;
}
packet_header_t packet_len = (packet_header_t)sz;
if ((bufferevent_write(bev, &packet_len, PACKET_HEADER_SZ) != -1)
&& bufferevent_write(bev, packet, packet_len) != -1) {
lua_pushboolean(L, 1);
return 1;
}
logging("write packet error");
lua_pushboolean(L, 0);
return 1;
}
static void send_bptree_result(tcp_client *c, int rv, int32_t vsize, void *v)
{
int size = sizeof(int32_t) + vsize;
bufferevent_write(c->buffer_ev, &size,sizeof(int));
bufferevent_write(c->buffer_ev, &rv,sizeof(int));
bufferevent_write(c->buffer_ev, &vsize,sizeof(int32_t));
bufferevent_write(c->buffer_ev,v,vsize);
}
void
unchoke(struct Peer *p)
{
uint32_t unchoke_prefix = htonl(1);
uint8_t unchoke_id = 1;
bufferevent_write(p->bufev, (const void *)&unchoke_prefix, sizeof(unchoke_prefix));
bufferevent_write(p->bufev, (const void *)&unchoke_id, sizeof(unchoke_id));
p->tstate.choked = 0;
}
void
not_interested(struct Peer *p)
{
uint32_t not_interested_prefix = htonl(1);
uint8_t not_interested_id = 3;
bufferevent_write(p->bufev, (const void *)¬_interested_prefix, sizeof(not_interested_prefix));
bufferevent_write(p->bufev, (const void *)¬_interested_id, sizeof(not_interested_id));
p->tstate.interested = 0;
}
void
interested(struct Peer *p)
{
uint32_t interested_prefix = htonl(1);
uint8_t interested_id = 2;
bufferevent_write(p->bufev, (const void *)&interested_prefix, sizeof(interested_prefix));
bufferevent_write(p->bufev, (const void *)&interested_id, sizeof(interested_id));
p->tstate.interested = 1;
}
static void
write_socks_request(struct conninfo *info)
{
if (info->socks == SOCKS_4) {
struct sockaddr_in *sin = (struct sockaddr_in*)&info->addr;
if (info->addr.ss_family != AF_INET) {
finish_connection(info, 0,
"SOCKS 4 can't handle ipv6!");
}
/* connection request */
bufferevent_write(info->bev, "\x04\x01", 2);
bufferevent_write(info->bev, &sin->sin_port,
sizeof(sin->sin_port));
bufferevent_write(info->bev, &sin->sin_addr.s_addr,
sizeof(sin->sin_addr.s_addr));
bufferevent_write(info->bev, "xx", 3);
} else {
ev_uint16_t port = htons(info->port);
assert(info->host != NULL);
bufferevent_write(info->bev, "\x04\x01", 2);
bufferevent_write(info->bev, &port, sizeof(port));
bufferevent_write(info->bev, "\x00\x00\x00\xff", 4);
bufferevent_write(info->bev, "xx", 3);
bufferevent_write(info->bev, info->host, strlen(info->host)+1);
}
bufferevent_enable(info->bev, EV_READ);
}
int togo_wt_send_cb(TOGO_THREAD_ITEM * socket_item)
{
int ret;
char int_str[12];
/* If sstatus equal to 3, send the big data! */
if (socket_item->sstatus == 3) {
BDATA_CALLBACK callback;
if (socket_item->bsbuf == NULL || socket_item->bssize == 0) {
return 0;
}
togo_itoa((uint32_t) socket_item->bssize, int_str, 10);
/**
* Retrun：TOGO_S10TOGO_E/r/nAAAAAAAAAA
*/
ret = bufferevent_write(socket_item->bev, TOGO_SBUF_START,
togo_strlen(TOGO_SBUF_START));
ret = bufferevent_write(socket_item->bev, int_str,
togo_strlen(int_str));
ret += bufferevent_write(socket_item->bev, TOGO_SBUF_END,
togo_strlen(TOGO_SBUF_END));
ret += bufferevent_write(socket_item->bev, socket_item->bsbuf,
socket_item->bssize);
if (ret < 0) {
togo_log(INFO, "Send data error");
}
callback = socket_item->bscb;
if (callback != NULL) {
callback(socket_item);
}
socket_item->sstatus = 0;
} else {
if (socket_item->sfd < 1 || socket_item->sbuf == NULL
|| socket_item->ssize == 0) {
return 0;
}
ret = bufferevent_write(socket_item->bev, socket_item->sbuf,
socket_item->ssize);
if (ret < 0) {
togo_log(INFO, "Send data error");
}
socket_item->ssize = 0;
}
return ret;
}
// server has produced data, relay it to the websocket client
static void server_read ( struct bufferevent* be, void* arg ) {
struct bufferevent* client = (struct bufferevent*) arg;
char buf[1024 * 10];
int n = bufferevent_read ( be, buf, sizeof buf );
if ( n > 0 ) {
bufferevent_write ( client, frame, 1 ); // start of frame
bufferevent_write ( client, buf, n );
bufferevent_write ( client, frame + 1, 1 ); // end of frame
bufferevent_enable ( client, EV_WRITE );
}
}
void send_server_message(struct bufferevent *bev, const char *msg, uint16_t len)
{
struct packet_server_message data;
data.hdr.proto = PROTO_EDONKEY;
data.hdr.length = sizeof(data) - sizeof(data.hdr) + len;
data.opcode = OP_SERVERMESSAGE;
data.msg_len = len;
bufferevent_write(bev, &data, sizeof(data));
bufferevent_write(bev, msg, len);
}
void send_found_sources(struct bufferevent *bev, const unsigned char *hash, struct file_source *sources, size_t count)
{
struct packet_found_sources data;
size_t srcs_len = count * sizeof(*sources);
data.hdr.proto = PROTO_EDONKEY;
memcpy(data.hash, hash, sizeof(data.hash));
data.hdr.length = sizeof(data) - sizeof(data.hdr) + srcs_len;
data.opcode = OP_FOUNDSOURCES;
data.count = count;
bufferevent_write(bev, &data, sizeof(data));
if (count)
bufferevent_write(bev, sources, srcs_len);
}
static ssize_t
levent_ctl_send(struct lldpd_one_client *client, int type, void *data, size_t len)
{
struct bufferevent *bev = client->bev;
struct hmsg_header hdr = { .len = len, .type = type };
bufferevent_disable(bev, EV_WRITE);
if (bufferevent_write(bev, &hdr, sizeof(struct hmsg_header)) == -1 ||
(len > 0 && bufferevent_write(bev, data, len) == -1)) {
log_warnx("event", "unable to create answer to client");
levent_ctl_free_client(client);
return -1;
}
bufferevent_enable(bev, EV_WRITE);
return len;
}
void thread_bufferread_cb_enc(struct bufferevent *bev, void *ptr)
{
P_TRANS_ITEM p_trans = (P_TRANS_ITEM)ptr;
ENC_FRAME from_f;
ENC_FRAME to_f;
struct evbuffer *input = bufferevent_get_input(bev);
struct evbuffer *output = bufferevent_get_output(bev);
if (bev == p_trans->bev_u && p_trans->bev_d)
{
st_d_print("加密转发数据包USR->REMOTE"); // 解密
from_f.len = bufferevent_read(p_trans->bev_u, from_f.dat, FRAME_SIZE);
if (from_f.len > 0)
{
decrypt(&p_trans->ctx_dec, &from_f, &to_f);
bufferevent_write(p_trans->bev_d, to_f.dat, from_f.len);
}
else
{
st_d_error("读取数据出错！");
}
}
else if (bev == p_trans->bev_d && p_trans->bev_u)
{
st_d_print("加密转发数据包REMOTE->USR"); // 加密
from_f.len = bufferevent_read(p_trans->bev_d, from_f.dat, FRAME_SIZE);
if (from_f.len > 0)
{
encrypt(&p_trans->ctx_enc, &from_f, &to_f);
bufferevent_write(p_trans->bev_u, to_f.dat, to_f.len);
}
else
{
st_d_error("读取数据出错！");
}
}
else
{
SYS_ABORT("WRRRRRR!");
}
return;
}
int
fcgi_add_param(struct server_fcgi_param *p, const char *key,
const char *val, struct client *clt)
{
struct fcgi_record_header *h;
int len = 0;
int key_len = strlen(key);
int val_len = strlen(val);
uint8_t *param;
len += key_len + val_len;
len += key_len > 127 ? 4 : 1;
len += val_len > 127 ? 4 : 1;
DPRINTF("%s: %s[%d] => %s[%d], total_len: %d", __func__, key, key_len,
val, val_len, p->total_len);
if (len > FCGI_CONTENT_SIZE)
return (-1);
if (p->total_len + len > FCGI_CONTENT_SIZE) {
bufferevent_write(clt->clt_srvbev, p->buf,
sizeof(struct fcgi_record_header) + p->total_len);
p->total_len = 0;
}
h = (struct fcgi_record_header *)p->buf;
param = p->buf + sizeof(*h) + p->total_len;
if (key_len > 127) {
*param++ = ((key_len >> 24) & 0xff) | 0x80;
*param++ = ((key_len >> 16) & 0xff);
*param++ = ((key_len >> 8) & 0xff);
*param++ = (key_len & 0xff);
} else
void client_invalid_version(Client *cl)
{
static const uint8_t message[] = {SOCKS5_VER, AUTH_METHOD_INVALID};
bufferevent_write(cl->client.bufev, message, sizeof (message));
client_disconnect(cl);
}
static void httpr_client_read_content(struct bufferevent *buffev, redsocks_client *client)
{
httpr_client *httpr = (void*)(client + 1);
static int post_buffer_len = 64 * 1024;
char *post_buffer = calloc(post_buffer_len, 1);
if (!post_buffer) {
redsocks_log_error(client, LOG_ERR, "run out of memory");
redsocks_drop_client(client);
return;
}
int error;
while (true) {
error = evbuffer_remove(buffev->input, post_buffer, post_buffer_len);
if (error < 0) {
free(post_buffer);
redsocks_log_error(client, LOG_ERR, "evbuffer_remove");
redsocks_drop_client(client);
return;
}
if (error == 0)
break;
httpr_buffer_append(&httpr->client_buffer, post_buffer, error);
if (client->relay && client->state >= httpr_request_sent) {
if (bufferevent_write(client->relay, post_buffer, error) != 0) {
free(post_buffer);
redsocks_log_error(client, LOG_ERR, "bufferevent_write");
redsocks_drop_client(client);
return;
}
}
}
free(post_buffer);
}
/* Add bytes to a buffer but change every '\n' to '\r'. */
void
cmd_paste_buffer_lf2cr(struct window_pane *wp, const char *data, size_t size)
{
const char *end = data + size;
const char *lf;
while ((lf = memchr(data, '\n', end - data)) != NULL) {
if (lf != data)
bufferevent_write(wp->event, data, lf - data);
bufferevent_write(wp->event, "\r", 1);
data = lf + 1;
}
if (end != data)
bufferevent_write(wp->event, data, end - data);
}
int bufferevent_send(struct bufferevent *bev, const void *data, uint32_t len)
{
uint32_t max_write = 0;
int sent_total = 0;
uint32_t sent = 0;
uint32_t left = len;
while(left > 0) {
max_write = bufferevent_get_max_to_write(bev);
sent = left;
if(sent > max_write) sent = max_write;
if(sent > 0){
/* LoggerDebug("@@-- sent %d/%d bytes, send:%d max:%d.", */
/* sent_total, length, sent, max_write); */
if(0 == bufferevent_write(bev, data + sent_total, sent)){
/* send OK */
sent_total += sent;
left -= sent;
/* printf("@@!! sent %d/%d bytes, send:%d max:%d.\n", */
/* sent_total, len, sent, max_write); */
} else {
log_info("bufferevent_write failed: %s", strerror(errno));
return -1;
}
} else {
log_dbg("wait...");
}
}
/* bufferevent_flush(bev, EV_WRITE, BEV_FLUSH); */
return sent_total;
}
Client::Client(struct event_base* base, evutil_socket_t fd, struct sockaddr *socket, int socket_len)
{
m_buffer = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
if (!m_buffer)
{
fprintf(stderr, "Error constructing bufferevent!");
event_base_loopbreak(base);
throw;
}
bufferevent_setcb(m_buffer, conn_readcb, conn_writecb, conn_eventcb, this);
bufferevent_enable(m_buffer, EV_READ|EV_WRITE);
// bufferevent_setwatermark(m_buffer, EV_READ, 128, 0);
struct timeval time1, time2;
// time1.tv_sec = 10;
// time2.tv_sec = 11;
// bufferevent_set_timeouts(m_buffer, &time1, &time2);
if(socket->sa_family == AF_INET)
{
struct sockaddr_in *socket4 = (struct sockaddr_in*)socket;
m_ip = string(inet_ntoa(socket4->sin_addr));
m_port = ntohs(socket4->sin_port);
}
bufferevent_write(m_buffer, "hello", strlen("hello"));//tmp
}
static err_t pipe_tcp_recv(void *ctx, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
{
struct pipe_data *data = ctx;
struct pbuf *curr;
int len;
if (!data->bev) {
pipe_tcp_free(data);
free(data);
return ERR_ABRT;
}
if (err < 0 || !p) {
pipe_tcp_kill(data);
pipe_bev_flush(data);
return ERR_ABRT;
}
if (evbuffer_get_length(bufferevent_get_output(data->bev)) >= 262144)
return ERR_WOULDBLOCK;
len = p->tot_len;
for (curr = p; curr; curr = curr->next)
bufferevent_write(data->bev, curr->payload, curr->len);
pbuf_free(p);
tcp_recved(pcb, len);
return 0;
}
struct StreamRequest *new_stream_request(const char *method, const char *source_address, int source_port, const char *path,
void (*header_cb)(struct bufferevent *bev, struct evkeyvalq *headers, void *arg),
void (*read_cb)(struct bufferevent *bev, void *arg),
void (*error_cb)(struct bufferevent *bev, void *arg),
void *arg) {
struct StreamRequest *sr;
int fd;
struct evbuffer *http_request;
fd = stream_request_connect(source_address, source_port);
if (fd == -1) {
return NULL;
}
sr = malloc(sizeof(struct StreamRequest));
sr->fd = fd;
sr->state = read_firstline;
sr->header_cb = header_cb;
sr->read_cb = read_cb;
sr->error_cb = error_cb;
sr->arg = arg;
sr->bev = bufferevent_new(sr->fd, stream_request_readcb, stream_request_writecb, stream_request_errorcb, sr);
http_request = evbuffer_new();
evbuffer_add_printf(http_request, "%s %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n", method, path, source_address);
bufferevent_write(sr->bev, (char *)EVBUFFER_DATA(http_request), EVBUFFER_LENGTH(http_request));
evbuffer_free(http_request);
return sr;
}
void Connection::write( const char* data, unsigned int length, bool close )
{
TRACE("%s", data );
bufferevent_write( m_handle, data, length );
m_close = close;
}
void
client_read(struct bufferevent *bufev, void *arg)
{
struct session *s = arg;
size_t buf_avail, read;
int n;
do {
buf_avail = sizeof s->cbuf - s->cbuf_valid;
read = bufferevent_read(bufev, s->cbuf + s->cbuf_valid,
buf_avail);
s->cbuf_valid += read;
while ((n = get_line(s->cbuf, &s->cbuf_valid)) > 0) {
logmsg(LOG_DEBUG, "#%d client: %s", s->id, linebuf);
if (!client_parse(s)) {
end_session(s);
return;
}
bufferevent_write(s->server_bufev, linebuf, linelen);
}
if (n == -1) {
logmsg(LOG_ERR, "#%d client command too long or not"
" clean", s->id);
end_session(s);
return;
}
} while (read == buf_avail);
}
/** Read from one buffer and write the results to the other */
void
pipe_cb(struct bufferevent *from_bev, void *data)
{
struct conn *c = data;
char buff[BUFFER_LEN];
size_t len;
struct bufferevent *to_bev = NULL;
if (c->local_bev == from_bev) {
#if SSL_DEBUG_LEVEL > 1
errputs(stdout, "got data from mush.");
#endif
to_bev = c->remote_bev;
} else {
#if SSL_DEBUG_LEVEL > 1
errputs(stdout, "got data from SSL");
#endif
to_bev = c->local_bev;
}
len = bufferevent_read(from_bev, buff, sizeof buff);
#if SSL_DEBUG_LEVEL > 1
errprintf(stdout, "ssl_slave: read %zu bytes.\n", len);
#endif
if (to_bev && len > 0) {
if (bufferevent_write(to_bev, buff, len) < 0)
errputs(stderr, "write failed!");
}
}
/* Translate mouse and output. */
void
input_mouse(struct window_pane *wp, struct mouse_event *m)
{
char buf[10];
size_t len;
if (wp->screen->mode & ALL_MOUSE_MODES) {
if (wp->screen->mode & MODE_MOUSE_UTF8) {
len = xsnprintf(buf, sizeof buf, "\033[M");
len += utf8_split2(m->b + 32, &buf[len]);
len += utf8_split2(m->x + 33, &buf[len]);
len += utf8_split2(m->y + 33, &buf[len]);
} else {
if (m->b > 223 || m->x >= 222 || m->y > 222)
return;
len = xsnprintf(buf, sizeof buf, "\033[M");
buf[len++] = m->b + 32;
buf[len++] = m->x + 33;
buf[len++] = m->y + 33;
}
bufferevent_write(wp->event, buf, len);
} else if ((m->b & MOUSE_BUTTON) != MOUSE_2) {
if (options_get_number(&wp->window->options, "mode-mouse") &&
window_pane_set_mode(wp, &window_copy_mode) == 0) {
window_copy_init_from_pane(wp);
if (wp->mode->mouse != NULL)
wp->mode->mouse(wp, NULL, m);
}
}
}
int
cmd_save_buffer_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct args *args = self->args;
struct client *c = ctx->cmdclient;
struct paste_buffer *pb;
const char *path;
char *cause;
int buffer;
mode_t mask;
FILE *f;
if (!args_has(args, 'b')) {
if ((pb = paste_get_top(&global_buffers)) == NULL) {
ctx->error(ctx, "no buffers");
return (-1);
}
} else {
buffer = args_strtonum(args, 'b', 0, INT_MAX, &cause);
if (cause != NULL) {
ctx->error(ctx, "buffer %s", cause);
xfree(cause);
return (-1);
}
pb = paste_get_index(&global_buffers, buffer);
if (pb == NULL) {
ctx->error(ctx, "no buffer %d", buffer);
return (-1);
}
}
path = args->argv[0];
if (strcmp(path, "-") == 0) {
if (c == NULL) {
ctx->error(ctx, "%s: can't write to stdout", path);
return (-1);
}
bufferevent_write(c->stdout_event, pb->data, pb->size);
} else {
mask = umask(S_IRWXG | S_IRWXO);
if (args_has(self->args, 'a'))
f = fopen(path, "ab");
else
f = fopen(path, "wb");
umask(mask);
if (f == NULL) {
ctx->error(ctx, "%s: %s", path, strerror(errno));
return (-1);
}
if (fwrite(pb->data, 1, pb->size, f) != pb->size) {
ctx->error(ctx, "%s: fwrite error", path);
fclose(f);
return (-1);
}
fclose(f);
}
return (0);
}
static size_t copy_evbuffer(struct bufferevent * dst, const struct bufferevent * src)
{
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)> maxlen?maxlen: EVBUFFER_LENGTH(src->input);
n = evbuffer_peek(src->input, maxlen, 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, NULL, v, n);
for (i=0; i<n; ++i) {
size_t len = v[i].iov_len;
if (written + len > maxlen)
len = maxlen - written;
if (bufferevent_write(dst, v[i].iov_base, len))
break;
/* 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;
}
