void socket_stub_accept()
{
uint32_t mask;
mask = 0x1;
event_write(&accept_events, &mask, sizeof(mask));
}
static int sendqueue(int sock, acetables *g_ape)
{
int t_bytes = 0, r_bytes, n = 0;
struct _socks_bufout *bufout = &g_ape->bufout[sock];
if (bufout->buf == NULL) {
return 1;
}
r_bytes = bufout->buflen;
while(t_bytes < bufout->buflen) {
n = event_write(g_ape->events, sock, bufout->buf + t_bytes, r_bytes);
if (n == -1) {
if (errno == EAGAIN && r_bytes > 0) {
/* Still not complete */
memmove(bufout->buf, bufout->buf + t_bytes, r_bytes);
/* TODO : avoid memmove */
bufout->buflen = r_bytes;
return 0;
}
break;
}
t_bytes += n;
r_bytes -= n;
}
bufout->buflen = 0;
free(bufout->buf);
bufout->buf = NULL;
return 1;
}
static int socket_send_buffer(struct socket *sock, struct socket_message *ret) {
assert(socket_buffer_list_complete(&sock->low));
if (socket_send_buffer_list(sock, &sock->high, ret) == SOCKET_CLOSE) {
return SOCKET_CLOSE;
}
if (sock->high.head == 0) {
if (sock->low.head != 0) {
if (socket_send_buffer_list(sock, &sock->low, ret) == SOCKET_CLOSE) {
return SOCKET_CLOSE;
}
if (!socket_buffer_list_complete(&sock->low)) {
struct buffer_list *high;
struct buffer_list *low = &sock->low;
struct buffer *tmp = low->head;
low->head = tmp->next;
if (low->head == 0) {
low->tail = 0;
}
high = &sock->high;
assert(high->head == 0);
tmp->next = 0;
high->head = high->tail = tmp;
}
} else {
event_write(S.event_fd, sock->fd, sock, 0);
if (sock->type == SOCKET_TYPE_HALFCLOSE) {
socket_force_close(sock, ret);
return SOCKET_CLOSE;
}
}
}
return -1;
}
static int socket_try_open(struct socket *sock, struct socket_message *msg) {
int error, code;
socklen_t len = sizeof(error);
code = getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, (char *)&error, &len);
if (code < 0 || error) {
socket_force_close(sock, msg);
msg->data = strerror(errno);
return SOCKET_ERR;
} else {
union sockaddr_all u;
socklen_t slen = sizeof(u);
sock->type = SOCKET_TYPE_OPENED;
if (sock->high.head == 0 && sock->low.head == 0) {
event_write(S.event_fd, sock->fd, sock, 0);
}
if (getpeername(sock->fd, &u.s, &slen) == 0) {
void *sin_addr = (u.s.sa_family == AF_INET) ? (void *)&u.v4.sin_addr : (void *)&u.v6.sin6_addr;
int sin_port = ntohs((u.s.sa_family == AF_INET) ? u.v4.sin_port : u.v6.sin6_port);
char tmp[INET6_ADDRSTRLEN];
if (inet_ntop(u.s.sa_family, sin_addr, tmp, sizeof(tmp))) {
snprintf(S.buffer, sizeof(S.buffer), "%s:%d", tmp, sin_port);
msg->data = S.buffer;
}
}
return SOCKET_OPEN;
}
}
/**
* The connection thread serves a client for the duration of the
* socket lifetime.
*/
static void *connection_main(void *arg_p)
{
struct http_server_connection_t *connection_p = arg_p;
struct http_server_t *self_p = connection_p->self_p;
uint32_t mask;
/* thrd_init_env(buf, sizeof(buf)); */
/* thrd_set_env("CWD", self_p->root_path_p); */
thrd_set_name(connection_p->thrd.name_p);
/* Wait for a connection from the listener. */
while (1) {
log_object_print(NULL,
LOG_DEBUG,
FSTR("Connection thread '%s' waiting for a new connection.\r\n"),
thrd_get_name());
mask = 0x1;
event_read(&connection_p->events, &mask, sizeof(mask));
if (mask & 0x1) {
handle_request(self_p, connection_p);
socket_close(&connection_p->socket);
/* Add thread to the free list. */
sys_lock();
connection_p->state = http_server_connection_state_free_t;
sys_unlock();
mask = 0x1;
event_write(&self_p->events, &mask, sizeof(mask));
}
}
return (NULL);
}
int socket_close(struct socket_t *self_p)
{
uint32_t mask;
mask = 0x1;
event_write(&closed_events, &mask, sizeof(mask));
return (0);
}
int music_player_song_stop(struct music_player_t *self_p)
{
uint32_t mask;
mask = EVENT_STOP;
event_write(&self_p->event, &mask, sizeof(mask));
return (0);
}
int music_player_song_pause(struct music_player_t *self_p)
{
uint32_t mask;
mask = EVENT_PAUSE;
event_write(&self_p->event, &mask, sizeof(mask));
return (0);
}
static int handle_accept(struct http_server_t *self_p,
struct http_server_connection_t *connection_p)
{
uint32_t mask;
mask = 0x1;
event_write(&connection_p->events, &mask, sizeof(mask));
return (0);
}
/* TODO : add "nowrite" flag to avoid write syscall when calling several time sendbin() */
int sendbin(int sock, const char *bin, unsigned int len, unsigned int burn_after_writing, acetables *g_ape)
{
int t_bytes = 0, r_bytes, n = 0;
r_bytes = len;
if (sock != 0) {
while(t_bytes < len) {
if (g_ape->bufout[sock].buf == NULL) {
n = event_write(g_ape->events, sock, bin + t_bytes, r_bytes);
} else {
n = -2;
}
if (n < 0) {
if ((errno == EAGAIN && r_bytes > 0) || (n == -2)) {
if (g_ape->bufout[sock].buf == NULL) {
g_ape->bufout[sock].allocsize = r_bytes + 128; /* add padding to prevent extra data to be reallocated */
g_ape->bufout[sock].buf = xmalloc(sizeof(char) * g_ape->bufout[sock].allocsize);
g_ape->bufout[sock].buflen = r_bytes;
} else {
g_ape->bufout[sock].buflen += r_bytes;
if (g_ape->bufout[sock].buflen > g_ape->bufout[sock].allocsize) {
g_ape->bufout[sock].allocsize = g_ape->bufout[sock].buflen + 128;
g_ape->bufout[sock].buf = xrealloc(g_ape->bufout[sock].buf, sizeof(char) * g_ape->bufout[sock].allocsize);
}
}
memcpy(g_ape->bufout[sock].buf + (g_ape->bufout[sock].buflen - r_bytes), bin + t_bytes, r_bytes);
if (burn_after_writing) {
g_ape->co[sock]->burn_after_writing = 1;
}
return 0;
}
break;
}
t_bytes += n;
r_bytes -= n;
}
}
if (burn_after_writing) {
shutdown(sock, 2);
}
return 1;
}
/**
* def write(self, mask)
*/
static mp_obj_t class_event_write(mp_obj_t self_in, mp_obj_t mask_in)
{
struct class_event_t *self_p;
uint32_t mask;
self_p = MP_OBJ_TO_PTR(self_in);
mask = mp_obj_get_int(mask_in);
if (event_write(&self_p->event, &mask, sizeof(mask)) != sizeof(mask)) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"failed to write event mask"));
}
return (mp_const_none);
}
/* We're all done sorting. Write out the logfile.
* Format:
* Magic number 0x43 0x9f 0x22 0x53
* Number of elements
* Array of absolute offsets from the start of the file
* Magic number 0xa4 0xc3 0x2d 0xe5
* Array of events
*/
static int st_write(struct state *st) {
int jump_offset;
struct evt_file_header file_header;
uint32_t offset;
qDebug() << "Writing out...";
st->out_fdh->seek(0);
offset = 0;
// Write out the file header
memset(&file_header, 0, sizeof(file_header));
memcpy(file_header.magic1, EVENT_HDR_1, strlen(EVENT_HDR_1));
file_header.version = _ntohl(1);
file_header.count = _htonl(hdr_count);
offset += st->out_fdh->write((char *)&file_header, sizeof(file_header));
// Advance the offset past the jump table
offset += hdr_count*sizeof(offset);
// Read in the jump table entries
st->fdh->seek(0);
for (jump_offset=0; jump_offset<hdr_count; jump_offset++) {
union evt evt;
uint32_t offset_swab = _htonl(offset);
st->out_fdh->write((char *)&offset_swab, sizeof(offset_swab));
st->fdh->seek(hdrs[jump_offset].pos);
memset(&evt, 0, sizeof(evt));
event_get_next(st, &evt);
if (evt.header.size > 32768)
return 1;
offset += evt.header.size;
}
offset += st->out_fdh->write(EVENT_HDR_2, 4);
// Now copy over the exact events
for (jump_offset=0; jump_offset<hdr_count; jump_offset++) {
union evt evt;
st->fdh->seek(hdrs[jump_offset].pos);
event_get_next(st, &evt);
event_write(st, &evt);
}
sstate_set(st, ST_DONE);
return 1;
}
static int socket_req_send(struct _send_req *req, struct socket_message *msg, const uint8_t *udp_address) {
struct socket * sock = &S.slot[HASH_ID(req->id)];
struct socket_send_object so;
socket_send_object_init(&so, req->data, req->size);
if (sock->type == SOCKET_TYPE_INVALID || sock->id != req->id || sock->type == SOCKET_TYPE_HALFCLOSE
|| sock->type == SOCKET_TYPE_PACCEPT) {
so.free(req->data);
return -1;
}
if (sock->type == SOCKET_TYPE_PLISTEN || sock->type == SOCKET_TYPE_LISTEN) {
fprintf(stderr, "socket_req_send: write to listen fd:%d\n", sock->id);
so.free(req->data);
return -1;
}
if (sock->high.head == 0 && sock->low.head == 0 && sock->type == SOCKET_TYPE_OPENED) {
if (sock->protocol == PROTOCOL_TCP) {
int n = write(sock->fd, so.data, so.size);
if (n < 0) {
switch (errno) {
case EINTR:
case EAGAIN:
n = 0;
break;
default:
fprintf(stderr, "socket_req_send: write to %d (fd=%d) error:%d\n", sock->id, sock->fd, errno);
socket_force_close(sock, msg);
so.free(req->data);
return SOCKET_CLOSE;
}
}
if (n == so.size) {
so.free(req->data);
return -1;
}
socket_append_sendbuffer(sock, req, n);
} else {
int n;
union sockaddr_all sa;
socklen_t sa_size;
if (!udp_address) {
udp_address = sock->p.udp_address;
}
sa_size = udp_socket_address(sock, udp_address, &sa);
n = sendto(sock->fd, so.data, so.size, 0, &sa.s, sa_size);
if (n != req->size) {
socket_append_udp_sendbuffer(sock, req, udp_address);
} else {
so.free(req->data);
return -1;
}
}
event_write(S.event_fd, sock->fd, sock, 1);
} else {
if (sock->protocol == PROTOCOL_TCP) {
socket_append_sendbuffer(sock, req, 0);
} else {
if (!udp_address) {
udp_address = sock->p.udp_address;
}
socket_append_udp_sendbuffer(sock, req, udp_address);
}
}
if (sock->wb_size > 1024 * 1024) {
msg->id = sock->id;
msg->size = (int)(sock->wb_size / 1024);
msg->data = 0;
msg->ud = sock->ud;
return SOCKET_WARNING;
}
return -1;
}
static int socket_req_open(struct _open_req *req, struct socket_message *msg) {
struct socket *sock;
int status;
int fd = -1;
struct addrinfo ai_hints;
struct addrinfo *ai_list = 0;
struct addrinfo *ai_ptr = 0;
char port[16];
msg->id = req->id;
msg->ud = req->ud;
sprintf(port, "%d", req->port);
memset(&ai_hints, 0, sizeof(ai_hints));
ai_hints.ai_family = AF_UNSPEC;
ai_hints.ai_socktype = SOCK_STREAM;
ai_hints.ai_protocol = IPPROTO_TCP;
status = getaddrinfo(req->host, port, &ai_hints, &ai_list);
if (status != 0) {
msg->data = (void *)gai_strerror(status);
goto _failed;
}
for (ai_ptr = ai_list; ai_ptr != 0; ai_ptr = ai_ptr->ai_next) {
fd = socket(ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
if (fd < 0) {
continue;
}
socket_keepalive(fd);
socket_nonblocking(fd);
status = connect(fd, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
if (status != 0 && errno != EINPROGRESS) {
close(fd);
fd = -1;
continue;
}
break;
}
if (fd < 0) {
msg->data = strerror(errno);
goto _failed;
}
sock = socket_new(fd, req->id, PROTOCOL_TCP, req->ud, 1);
if (sock == 0) {
close(fd);
msg->data = "socket limit";
goto _failed;
}
if (status == 0) {
sock->type = SOCKET_TYPE_OPENED;
struct sockaddr *addr = ai_ptr->ai_addr;
void *sin_addr = (ai_ptr->ai_family == AF_INET) ? (void *)&((struct sockaddr_in *)addr)->sin_addr : (void *)&((struct sockaddr_in6 *)addr)->sin6_addr;
int sin_port = ntohs((ai_ptr->ai_family == AF_INET) ? ((struct sockaddr_in *)addr)->sin_port : ((struct sockaddr_in6 *)addr)->sin6_port);
char tmp[INET6_ADDRSTRLEN];
if (inet_ntop(ai_ptr->ai_family, sin_addr, tmp, sizeof(tmp))) {
snprintf(S.buffer, sizeof(S.buffer), "%s:%d", tmp, sin_port);
msg->data = S.buffer;
}
freeaddrinfo(ai_list);
return SOCKET_OPEN;
} else {
sock->type = SOCKET_TYPE_OPENING;
event_write(S.event_fd, sock->fd, sock, 1);
}
freeaddrinfo(ai_list);
return -1;
_failed:
freeaddrinfo(ai_list);
S.slot[HASH_ID(req->id)].type = SOCKET_TYPE_INVALID;
return SOCKET_ERR;
}
VkResult intel_event_reset(struct intel_event *event)
{
return event_write(event, 0);
}
