static void timeout_handle(void *ptr)
{
epdata_t *epd = ptr;
if(epd->status == STEP_READ) {
epd->keepalive = 0;
//LOGF(ERR, "Read Timeout!");
network_send_error(epd, 400, "Timeout!");
return;
//serv_status.reading_counts--;
} else if(epd->status == STEP_SEND) {
//LOGF(ERR, "Send Timeout!");
serv_status.sending_counts--;
}
if(epd->status == STEP_PROCESS && epd->L) {
LOGF(ERR, "Process Timeout(continue)");
update_timeout(epd->timeout_ptr, STEP_PROCESS_TIMEOUT);
return;
}
epd->status = STEP_WAIT;
close_client(epd);
}
static void timeout_toggled(DBusTimeout *dbus_timeout, AVAHI_GCC_UNUSED void *userdata) {
TimeoutData *timeout;
assert(dbus_timeout);
timeout = dbus_timeout_get_data(dbus_timeout);
assert(timeout);
update_timeout(timeout);
}
void network_end_process(epdata_t *epd)
{
epd->status = STEP_WAIT;
int i = 0;
int response_code = 0;
if(epd->iov[0].iov_base) {
char *hl = strtok(epd->iov[0].iov_base, "\n");
if(hl) {
hl = strtok(hl, " ");
hl = strtok(NULL, " ");
if(hl) {
response_code = atoi(hl);
}
}
}
free(epd->iov[0].iov_base);
epd->iov[0].iov_base = NULL;
for(i = 0; i < epd->iov_buf_count; i++) {
free(epd->iov[i].iov_base);
epd->iov[i].iov_base = NULL;
epd->iov[i].iov_len = 0;
}
epd->iov_buf_count = 0;
long ttime = longtime();
if(ACCESS_LOG) log_writef(ACCESS_LOG,
"%s - - [%s] %s \"%s %s %s\" %d %d %d \"%s\" \"%s\" %.3f\n",
inet_ntoa(epd->client_addr),
now_lc,
epd->host ? epd->host : "-",
epd->method ? epd->method : "-",
epd->uri ? epd->uri : "/",
epd->http_ver ? epd->http_ver : "-",
response_code,
epd->response_content_length,
epd->response_content_length - epd->response_header_length,
epd->referer ? epd->referer : "-",
epd->user_agent ? epd->user_agent : "-",
(float)(ttime - epd->start_time) / 1000);
if(epd->keepalive == 1 && !check_process_for_exit()) {
update_timeout(epd->timeout_ptr, STEP_WAIT_TIMEOUT);
free_epd_request(epd);
} else {
close_client(epd);
return;
}
}
void MultiTimeout::set_timeout_at(int64 key, double timeout) {
LOG(DEBUG) << "Set timeout for " << key << " in " << timeout - Time::now();
auto item = items_.emplace(key);
auto heap_node = static_cast<HeapNode *>(const_cast<Item *>(&*item.first));
if (heap_node->in_heap()) {
CHECK(!item.second);
bool need_update_timeout = heap_node->is_top();
timeout_queue_.fix(timeout, heap_node);
if (need_update_timeout || heap_node->is_top()) {
update_timeout();
}
} else {
CHECK(item.second);
timeout_queue_.insert(timeout, heap_node);
if (heap_node->is_top()) {
update_timeout();
}
}
}
void MultiTimeout::timeout_expired() {
double now = Time::now_cached();
while (!timeout_queue_.empty() && timeout_queue_.top_key() < now) {
int64 key = static_cast<Item *>(timeout_queue_.pop())->key;
items_.erase(Item(key));
expired_.push_back(key);
}
if (!items_.empty()) {
update_timeout();
}
for (auto key : expired_) {
callback_(data_, key);
}
expired_.clear();
}
void MultiTimeout::cancel_timeout(int64 key) {
LOG(DEBUG) << "Cancel timeout for " << key;
auto item = items_.find(Item(key));
if (item != items_.end()) {
auto heap_node = static_cast<HeapNode *>(const_cast<Item *>(&*item));
CHECK(heap_node->in_heap());
bool need_update_timeout = heap_node->is_top();
timeout_queue_.erase(heap_node);
items_.erase(item);
if (need_update_timeout) {
update_timeout();
}
}
}
static void timeout_callback(AvahiTimeout *avahi_timeout, void *userdata) {
TimeoutData *timeout = userdata;
assert(avahi_timeout);
assert(timeout);
timeout_data_ref(timeout);
dbus_timeout_handle(timeout->dbus_timeout);
/* Ignore the return value */
if (timeout->avahi_timeout)
update_timeout(timeout);
timeout_data_unref(timeout);
}
void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
const typename Time_Traits::time_type& time,
typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
{
mutex::scoped_lock lock(mutex_);
if (shutdown_)
{
io_service_.post_immediate_completion(op, false);
return;
}
bool earliest = queue.enqueue_timer(time, timer, op);
io_service_.work_started();
if (earliest)
update_timeout();
}
static int open_watchdog(void) {
struct watchdog_info ident;
if (watchdog_fd >= 0)
return 0;
watchdog_fd = open("/dev/watchdog", O_WRONLY|O_CLOEXEC);
if (watchdog_fd < 0)
return -errno;
if (ioctl(watchdog_fd, WDIOC_GETSUPPORT, &ident) >= 0)
log_info("Hardware watchdog '%s', version %x",
ident.identity,
ident.firmware_version);
return update_timeout();
}
static int be_read(se_ptr_t *ptr)
{
epdata_t *epd = ptr->data;
int n = recv(epd->fd, &buf_4096, 4096, 0);
if(n > 0) {
update_timeout(epd->timeout_ptr, 1000);
if(network_raw_send(epd->fd, (const char *)&buf_4096, n)) {
if(buf_4096[n - 1] == '\n') {
buf_4096[n - 1] = '\0';
}
LOGF(INFO, "%s", buf_4096);
} else {
LOGF(ERR, "send error!\n");
se_delete(epd->se_ptr);
if(epd->fd > -1) {
close(epd->fd);
epd->fd = -1;
}
free(epd);
}
} else if(n == 0 || (n < 0 && NOAGAIN)) { // close connection
se_delete(epd->se_ptr);
if(epd->fd > -1) {
close(epd->fd);
epd->fd = -1;
}
free(epd);
} else {
LOGF(ERR, "read error!\n");
}
return 1;
}
void win_iocp_io_service::schedule_timer(timer_queue<Time_Traits>& queue,
const typename Time_Traits::time_type& time,
typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
{
// If the service has been shut down we silently discard the timer.
if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
{
post_immediate_completion(op, false);
return;
}
mutex::scoped_lock lock(dispatch_mutex_);
bool earliest = queue.enqueue_timer(time, timer, op);
work_started();
if (earliest)
update_timeout();
}
int watchdog_set_timeout(usec_t *usec) {
int r;
watchdog_timeout = *usec;
/* If we didn't open the watchdog yet and didn't get any
* explicit timeout value set, don't do anything */
if (watchdog_fd < 0 && watchdog_timeout == USEC_INFINITY)
return 0;
if (watchdog_fd < 0)
r = open_watchdog();
else
r = update_timeout();
*usec = watchdog_timeout;
return r;
}
void network_be_end ( epdata_t *epd ) // for lua function die
{
if ( epd->process_timeout == 1 && epd->keepalive != -1 ) {
epd->process_timeout = 0;
free_epd ( epd );
return;
}
//printf ( "network_be_end %d\n" , ((se_ptr_t*)epd->se_ptr)->fd );
update_timeout ( epd->timeout_ptr, STEP_SEND_TIMEOUT );
se_be_write ( epd->se_ptr, network_be_write );
serv_status.success_counts++;
epd->status = STEP_SEND;
serv_status.sending_counts++;
if ( epd->iov[0].iov_base == NULL && epd->iov[1].iov_base == NULL
&& epd->response_sendfile_fd == -1 ) {
serv_status.sending_counts--;
network_send_error ( epd, 417, "" );
} else if ( epd->response_sendfile_fd == -2 ) {
epd->response_sendfile_fd = -1;
serv_status.sending_counts--;
network_send_error ( epd, 404, "File Not Found!" );
} else {
int gzip_data = 0;
//printf("%d %s\n", epd->response_content_length, epd->iov[1].iov_base);
if ( epd->response_content_length > 1024 && epd->iov[1].iov_base &&
!is_binary ( epd->iov[1].iov_base, epd->iov[1].iov_len )
) {
char *p = NULL;
if ( epd->headers ) {
p = stristr ( epd->headers, "Accept-Encoding", epd->header_len );
}
if ( p ) {
p += 16;
int i = 0, m = strlen ( p );
for ( ; i < 20 && i < m; i++ ) {
if ( p[i] == '\n' ) {
break;
}
}
p[i] = '\0';
if ( strstr ( p, "deflate" ) ) {
gzip_data = 2;
} else if ( strstr ( p, "gzip" ) ) {
gzip_data = 1;
}
p[i] = '\n';
}
}
if ( gzip_data > 0 )
epd->response_content_length = gzip_iov ( gzip_data,
( struct iovec * ) &epd->iov,
epd->iov_buf_count,
&epd->iov_buf_count );
int len = 0;
if ( epd->iov[0].iov_base == NULL ) {
len = sprintf ( temp_buf,
"HTTP/1.1 200 OK\r\nServer: aLiLua/%s (%s)\r\nContent-Type: text/html; charset=UTF-8\r\nConnection: %s\r\n%sContent-Length: %d\r\n\r\n",
version, hostname, ( epd->keepalive == 1 ? "keep-alive" : "close" ),
( gzip_data == 1 ? "Content-Encoding: gzip\r\n" : ( gzip_data == 2 ?
"Content-Encoding: deflate\r\n" : "" ) ),
epd->response_content_length + ( gzip_data == 1 ? 10 : 0 ) );
epd->response_header_length = len;
} else {
//( ( char * ) ( epd->iov[0].iov_base ) ) [epd->response_header_length] = '\0';
memcpy ( temp_buf, epd->iov[0].iov_base, epd->response_header_length );
len = epd->response_header_length + sprintf ( temp_buf + epd->response_header_length,
"Server: aLiLua/%s (%s)\r\nConnection: %s\r\nDate: %s\r\n%sContent-Length: %d\r\n\r\n",
version, hostname, ( epd->keepalive == 1 ? "keep-alive" : "close" ), now_date,
( gzip_data == 1 ? "Content-Encoding: gzip\r\n" : ( gzip_data == 2 ?
"Content-Encoding: deflate\r\n" : "" ) ),
epd->response_content_length + ( gzip_data == 1 ? 10 : 0 ) );
epd->response_header_length += len;
}
if ( len < 4086 && epd->response_sendfile_fd <= -1 && epd->iov[1].iov_base
&& epd->iov[1].iov_len > 0 ) {
if ( epd->iov[0].iov_base == NULL ) {
epd->iov[0].iov_base = malloc ( EP_D_BUF_SIZE );
}
if ( epd->iov[0].iov_base == NULL ) {
epd->keepalive = 0;
network_end_process ( epd );
serv_status.sending_counts--;
return;
}
memcpy ( epd->iov[0].iov_base, temp_buf, len );
epd->iov[0].iov_len = len;
epd->response_content_length += len;
if ( gzip_data == 1 ) {
memcpy ( epd->iov[0].iov_base + len, gzip_header, 10 );
epd->iov[0].iov_len += 10;
epd->response_content_length += 10;
}
epd->iov_buf_count += 1;
} else {
network_raw_send ( epd->fd, temp_buf, len );
if ( gzip_data == 1 ) {
network_raw_send ( epd->fd, gzip_header, 10 );
}
free ( epd->iov[0].iov_base );
epd->iov[0].iov_base = NULL;
int i = 0;
for ( i = 0; i < epd->iov_buf_count; i++ ) {
epd->iov[i] = epd->iov[i + 1];
epd->iov[i + 1].iov_base = NULL;
epd->iov[i + 1].iov_len = 0;
}
}
//epd->response_header_length = 0;
//printf("%d\n", epd->response_header_length);
if ( epd->response_content_length == 0 ) {
network_end_process ( epd );
serv_status.sending_counts--;
} else {
epd->response_buf_sended = 0;
}
}
}
int frizz_ioctl_sensor(struct file_id_node *node, unsigned int cmd, unsigned long arg) {
int sensor_id;
int status = 0;
packet_t packet;
int period_ms;
sensor_enable_t sensor_enable = { 0 };
sensor_delay_t sensor_delay = { 0 };
pedometer_counter_t pedo_counter = { 0 };
batch_t batch = { 0 };
packet.header.prefix = 0xFF;
packet.header.type = 0x81;
packet.header.sen_id = HUB_MGR_ID;
switch (cmd) {
case FRIZZ_IOCTL_SENSOR_SET_ENABLE:
status = copy_from_user_sensor_enable_t(cmd, (void*) arg,
&sensor_enable);
sensor_id = convert_code_to_id(sensor_enable.code);
packet.header.num = 1;
switch (sensor_enable.flag) {
case 0:
packet.data[0] = HUB_MGR_GEN_CMD_CODE(HUB_MGR_CMD_DEACTIVATE_SENSOR,
sensor_id, 0x00, 0x00);
break;
case 1:
packet.data[0] = set_sensor_active(sensor_id);
break;
}
DEBUG_PRINT("SENSOR_SET_ENABLE %x %d \n", packet.data[0], sensor_id);
status = create_frizz_workqueue((void*) &packet);
//if is the pedometer sensor shutdown, clean the data in the firmware
if((sensor_enable.code == SENSOR_TYPE_STEP_COUNTER) && (sensor_enable.flag == 0)) {
pedo_onoff = 0;
} else if((sensor_enable.code == SENSOR_TYPE_STEP_COUNTER) && (sensor_enable.flag == 1)){
pedo_onoff = 1;
}
if(sensor_enable.code == SENSOR_TYPE_GESTURE) {
if(sensor_enable.flag == 1) {
gesture_on = 1;
}else if(sensor_enable.flag == 0) {
gesture_on = 0;
}
}
//if close the gsensor, set the Gsensor_min_delay to default
if(sensor_enable.code == SENSOR_TYPE_ACCELEROMETER && sensor_enable.flag == 0) {
Gsensor_min_delay = 10000;
}
if(sensor_enable.code == SENSOR_TYPE_ACCEL_FALL_DOWN || sensor_enable.code == SENSOR_TYPE_ACCEL_POS_DET) {
set_fall_parameter();
}
break;
case FRIZZ_IOCTL_SENSOR_SET_DELAY:
copy_from_user_sensor_delay_t(cmd, (void*) arg, &sensor_delay);
sensor_id = convert_code_to_id(sensor_delay.code);
packet.header.num = 2;
packet.data[0] = HUB_MGR_GEN_CMD_CODE(HUB_MGR_CMD_SET_SENSOR_INTERVAL,
sensor_id, 0x00, 0x00);
packet.data[1] = sensor_delay.ms;
if(sensor_delay.code == SENSOR_TYPE_ACCELEROMETER) {
if(sensor_delay.ms < Gsensor_min_delay) {
packet.data[1] = sensor_delay.ms;
Gsensor_min_delay = sensor_delay.ms;
} else {
break;
}
}
DEBUG_PRINT("SENSOR_SET_DELAY %d %x\n", sensor_id, packet.data[0]);
status = create_frizz_workqueue((void*) &packet);
break;
case FRIZZ_IOCTL_SENSOR_GET_ENABLE:
get_sensor_enable(cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SENSOR_GET_DELAY:
get_sensor_delay(cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SENSOR_GET_DATA:
get_sensor_data(node, cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SENSOR_SIMULATE_TIMEOUT:
simulate_timeout(cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SENSOR_SET_BATCH:
copy_from_user_batch_t(cmd, (void*) arg, &batch);
sensor_id = convert_code_to_id(batch.code);
DEBUG_PRINT("FIFO_FULL_FLAG %d %d \n", batch.fifo_full_flag,
batch.code);
if (batch.fifo_full_flag == 1) {
update_fifo_full_flag(batch.fifo_full_flag);
}
update_timeout(batch.timeout_ns);
if (batch.period_ns < 1000000) {
period_ms = 1;
DEBUG_PRINT("1ms\n");
} else {
period_ms = div64_u64(batch.period_ns, 1000000);
DEBUG_PRINT("period ms %d\n", period_ms);
}
DEBUG_PRINT("batch sensor id %d %d \n", sensor_id, period_ms);
packet.header.num = 2;
packet.data[0] = HUB_MGR_GEN_CMD_CODE(HUB_MGR_CMD_SET_SENSOR_INTERVAL,
sensor_id, 0x00, 0x00);
packet.data[1] = period_ms;
status = create_frizz_workqueue((void*) &packet);
packet.header.num = 1;
if (batch.timeout_ns == 0) {
packet.data[0] = HUB_MGR_GEN_CMD_CODE(HUB_MGR_CMD_DEACTIVATE_SENSOR,
sensor_id, 0x00, 0x00);
} else {
DEBUG_PRINT("enable batch\n");
packet.data[0] = HUB_MGR_GEN_CMD_CODE(
HUB_MGR_CMD_SET_SENSOR_ACTIVATE, sensor_id, 0x01, 0x00);
}
status = create_frizz_workqueue((void*) &packet);
break;
case FRIZZ_IOCTL_SENSOR_FLUSH_FIFO:
DEBUG_PRINT("FLUSH\n");
break;
case FRIZZ_IOCTL_GET_SENSOR_DATA_CHANGED:
DEBUG_PRINT("GET data changed flag\n");
get_sensor_data_changed(node, cmd, (void*) arg);
break;
case FRIZZ_IOCTL_GET_FIRMWARE_VERSION:
DEBUG_PRINT("GET firmware_version");
get_firmware_version(cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SET_PEDO_COUNTER:
copy_from_user_pedometer_counter_t(cmd, (void*)arg, &pedo_counter);
if(pedo_counter.counter < 0) {
kprint("Frizz pedo_counter EVALUE (%d)!!, ignore.",pedo_counter.counter);
break;
}
set_pedo_interval(pedo_counter.counter);
break;
default:
kprint("%s :NONE IOCTL SENSORxxx %x", __func__, cmd);
return -1;
break;
}
return status;
}
int worker_process(epdata_t *epd, int thread_at)
{
//printf("worker_process\n");
working_at_fd = epd->fd;
//network_send_error(epd, 503, "Lua Error: main function not found !!!");return 0;
//network_send(epd, "aaa", 3);network_be_end(epd);return 0;
if(epd->ssl && !epd->ssl_verify) {
network_send_error(epd, 400, "No required SSL certificate was send");
return 0;
}
lua_State *L = epd->L;
if(!L) {
epd->L = new_lua_thread(_L);
if(!epd->L) {
network_send_error(epd, 503, "Lua Error: Thread pool full !!!");
return 0;
}
lua_pushlightuserdata(epd->L, epd);
lua_setglobal(epd->L, "__epd__");
L = epd->L;
}
lua_getglobal(L, "process");
update_timeout(epd->timeout_ptr, STEP_PROCESS_TIMEOUT + 100);
int init_tables = 0;
char *pt1 = NULL, *pt2 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
int is_form_post = 0;
char *cookies = NULL;
pt1 = epd->headers;
int i = 0;
epd->uri = NULL;
epd->host = NULL;
epd->query = NULL;
epd->http_ver = NULL;
epd->referer = NULL;
epd->user_agent = NULL;
epd->if_modified_since = NULL;
//epd->start_time = longtime();
while(t1 = strtok_r(pt1, "\n", &pt1)) {
if(++i == 1) { /// first line
t2 = strtok_r(t1, " ", &t1);
t3 = strtok_r(t1, " ", &t1);
epd->http_ver = strtok_r(t1, " ", &t1);
if(!epd->http_ver) {
return 1;
} else {
if(init_tables == 0) {
lua_newtable(L); //headers
}
}
int len = strlen(epd->http_ver);
if(epd->http_ver[len - 1] == 13) { // CR == 13
epd->http_ver[len - 1] = '\0';
}
if(t2 && t3) {
for(t1 = t2 ; *t1 ; *t1 = toupper(*t1), t1++);
epd->method = t2;
lua_pushstring(L, t2);
lua_setfield(L, -2, "method");
t1 = strtok_r(t3, "?", &t3);
t2 = strtok_r(t3, "?", &t3);
epd->uri = t1;
lua_pushstring(L, t1);
lua_setfield(L, -2, "uri");
if(t2) {
epd->query = (t2 - 1);
epd->query[0] = '?';
lua_pushstring(L, epd->query);
lua_setfield(L, -2, "query");
}
}
continue;
}
t2 = strtok_r(t1, ":", &t1);
if(t2) {
if(t2[0] == '\r') {
break;
}
for(t3 = t2; *t3; ++t3) {
*t3 = *t3 >= 'A' && *t3 <= 'Z' ? *t3 | 0x60 : *t3;
}
t3 = t2 + strlen(t2) + 1; //strtok_r ( t1, ":", &t1 )
if(t3) {
int len = strlen(t3);
if(t3[len - 1] == 13) { /// 13 == CR
t3[len - 1] = '\0';
len -= 1;
}
if(len < 1) {
break;
}
lua_pushstring(L, t3 + (t3[0] == ' ' ? 1 : 0));
lua_setfield(L, -2, t2);
/// check content-type
if(t2[0] == 'h' && epd->host == NULL && strcmp(t2, "host") == 0) {
char *_t = strstr(t3, ":");
if(_t) {
_t[0] = '\0';
}
epd->host = t3 + (t3[0] == ' ' ? 1 : 0);
} else if(t2[1] == 'o' && strcmp(t2, "content-type") == 0) {
if(stristr(t3, "x-www-form-urlencoded", len)) {
is_form_post = 1;
} else if(stristr(t3, "multipart/form-data", len)) {
epd->boundary = (char *)stristr(t3, "boundary=", len - 2);
if(epd->boundary) {
epd->boundary += 9;
}
}
} else if(!cookies && t2[1] == 'o' && strcmp(t2, "cookie") == 0) {
cookies = t3 + (t3[0] == ' ' ? 1 : 0);
} else if(!epd->user_agent && t2[1] == 's' && strcmp(t2, "user-agent") == 0) {
epd->user_agent = t3 + (t3[0] == ' ' ? 1 : 0);
} else if(!epd->referer && t2[1] == 'e' && strcmp(t2, "referer") == 0) {
epd->referer = t3 + (t3[0] == ' ' ? 1 : 0);
} else if(!epd->if_modified_since && t2[1] == 'f' && strcmp(t2, "if-modified-since") == 0) {
epd->if_modified_since = t3 + (t3[0] == ' ' ? 1 : 0);
}
}
}
}
char *client_ip = inet_ntoa(epd->client_addr);
lua_pushstring(L, client_ip);
lua_setfield(L, -2, "remote-addr");
int l = sizeof(struct sockaddr);
struct sockaddr_in addr;
getsockname(epd->fd, (struct sockaddr *) &addr, &l);
lua_pushstring(L, inet_ntoa(addr.sin_addr));
lua_setfield(L, -2, "server-addr");
lua_setglobal(L, "headers");
lua_newtable(L); /// _GET
if(epd->query) { /// parse query string /?a=1&b=2
char *last = NULL;
int plen = 0;
int qlen = strlen(epd->query) - 1;
t1 = (char *)strsplit(epd->query + 1, qlen, "&", &last, &plen);
char kk[256] = {0};
while(t1) {
char *last2 = NULL;
int plen2 = 0;
int plen3 = 0;
t2 = (char *)strsplit(t1, plen, "=", &last2, &plen2);
t3 = (char *)strsplit(t1, plen, "=", &last2, &plen3);
if(t2 && plen2 > 0 && plen3 > 0 && plen2 <= 4096 && plen3 <= 4096) {
size_t dlen;
u_char *p;
u_char *src, *dst;
p = (u_char *)&buf_4096;
p[0] = '\0';
dst = p;
dlen = urldecode(&p, (u_char **)&t3, plen3, RAW_UNESCAPE_URL);
lua_pushlstring(L, (char *) p, dlen);
p[0] = '\0';
dst = p;
dlen = urldecode(&dst, (u_char **)&t2, plen2, RAW_UNESCAPE_URL);
p[dlen] = '\0';
lua_setfield(L, -2, p);
}
t1 = (char *)strsplit(epd->query + 1, qlen, "&", &last, &plen);
}
}
lua_setglobal(L, "_GET");
lua_newtable(L); /// _COOKIE
if(cookies) {
while(t1 = strtok_r(cookies, ";", &cookies)) {
t2 = strtok_r(t1, "=", &t1);
t3 = strtok_r(t1, "=", &t1);
if(t2 && t3 && strlen(t2) > 0 && strlen(t3) > 0) {
size_t len, dlen;
u_char *p;
u_char *src, *dst;
len = strlen(t3);
p = malloc(len);
p[0] = '\0';
dst = p;
dlen = urldecode(&dst, (u_char **)&t3, len, RAW_UNESCAPE_URL);
lua_pushlstring(L, (char *) p, dlen);
len = strlen(t2);
if(len > 4096) {
free(p);
p = malloc(len);
}
p[0] = '\0';
dst = p;
dlen = urldecode(&dst, (u_char **)&t2, len, RAW_UNESCAPE_URL);
p[dlen] = '\0';
lua_setfield(L, -2, p + (p[0] == ' ' ? 1 : 0));
free(p);
}
}
}
lua_setglobal(L, "_COOKIE");
lua_pushnil(L);
lua_setglobal(L, "__body_buf");
epd->vhost_root = get_vhost_root(epd->host, &epd->vhost_root_len);
memcpy(buf_4096, epd->vhost_root, epd->vhost_root_len + 1);
sprintf(buf_4096 + epd->vhost_root_len + 1, "?.lua;%s/lua-libs/?.lua;", process_chdir);
lua_pushstring(L, buf_4096);
lua_getglobal(L, "package");
lua_insert(L, -2); //-1 bufres -2 package
lua_setfield(L, -2, "path"); //-1: path -2: package
lua_pop(L, 1); //void
lua_pushlstring(L, epd->vhost_root, epd->vhost_root_len); /// host root
lua_setglobal(L, "__root");
lua_pushstring(L, epd->vhost_root + epd->vhost_root_len); /// index-route.lua file
epd->iov[0].iov_base = NULL;
epd->iov[0].iov_len = 0;
epd->iov[1].iov_base = NULL;
epd->iov[1].iov_len = 0;
lua_routed = 0;
if(lua_resume(L, 1) == LUA_ERRRUN && lua_isstring(L, -1)) {
LOGF(ERR, "Lua:error %s", lua_tostring(L, -1));
network_send_error(epd, 503, lua_tostring(L, -1));
lua_pop(L, 1);
}
return 0;
}
static int network_be_read ( se_ptr_t *ptr )
{
epdata_t *epd = ptr->data;
if ( !epd ) {
return 0;
}
int n = 0;
update_timeout ( epd->timeout_ptr, STEP_READ_TIMEOUT );
if ( epd->headers == NULL ) {
epd->headers = &epd->iov;
epd->buf_size = sizeof ( epd->iov );
} else if ( epd->data_len == epd->buf_size ) {
if ( epd->headers == &epd->iov ) {
epd->headers = malloc ( 4096 * 2 );
memcpy ( epd->headers, &epd->iov, sizeof ( epd->iov ) );
epd->buf_size = 4096 * 2;
} else {
char *_t = ( char * ) realloc ( epd->headers, epd->buf_size + 4096 );
if ( _t != NULL ) {
epd->headers = _t;
} else {
epd->iov[0].iov_base = NULL;
epd->iov[0].iov_len = 0;
epd->iov[1].iov_base = NULL;
epd->iov[1].iov_len = 0;
network_send_error ( epd, 503, "memory error!" );
close_client ( epd );
serv_status.reading_counts--;
return 0;
}
epd->buf_size += 4096;
}
}
while ( ( n = recv ( epd->fd, epd->headers + epd->data_len,
epd->buf_size - epd->data_len, 0 ) ) >= 0 ) {
if ( n == 0 ) {
close_client ( epd );
epd = NULL;
break;
}
if ( epd->data_len + n >= epd->buf_size ) {
if ( epd->headers == &epd->iov ) {
epd->headers = malloc ( 4096 * 2 );
memcpy ( epd->headers, &epd->iov, sizeof ( epd->iov ) );
epd->buf_size = 4096 * 2;
} else {
char *_t = ( char * ) realloc ( epd->headers, epd->buf_size + 4096 );
if ( _t != NULL ) {
epd->headers = _t;
} else {
epd->iov[0].iov_base = NULL;
epd->iov[0].iov_len = 0;
epd->iov[1].iov_base = NULL;
epd->iov[1].iov_len = 0;
network_send_error ( epd, 503, "memory error!" );
close_client ( epd );
serv_status.reading_counts--;
return 0;
}
epd->buf_size += 4096;
}
}
if ( epd->status != STEP_READ ) {
serv_status.reading_counts++;
epd->status = STEP_READ;
epd->data_len = n;
epd->start_time = longtime();
} else {
epd->data_len += n;
}
if ( epd->_header_length < 1 && epd->data_len >= 4 && epd->headers ) {
int _get_content_length = 0;
if ( epd->headers[epd->data_len - 1] == '\n' &&
( epd->headers[epd->data_len - 2] == '\n' ||
( epd->headers[epd->data_len - 4] == '\r' &&
epd->headers[epd->data_len - 2] == '\r' ) ) ) {
epd->_header_length = epd->data_len;
} else {
_get_content_length = 1;
unsigned char *fp2 = stristr ( epd->headers, "\r\n\r\n", epd->data_len );
if ( fp2 ) {
epd->_header_length = ( fp2 - epd->headers ) + 4;
} else {
fp2 = stristr ( epd->headers, "\n\n", epd->data_len );
if ( fp2 ) {
epd->_header_length = ( fp2 - epd->headers ) + 2;
}
}
}
if ( epd->_header_length > 0 && epd->content_length < 0 ) {
/// not POST or PUT request
if ( _get_content_length == 0 && epd->headers[0] != 'P' && epd->headers[0] != 'p' ) {
epd->content_length = 0;
} else {
int flag = 0;
unsigned char *fp = stristr ( epd->headers, "\ncontent-length:", epd->data_len );
if ( fp ) {
int fp_at = fp - epd->headers + 16;
int i = 0, _oc;
for ( i = fp_at; i < epd->data_len; i++ ) {
if ( epd->headers[i] == '\r' || epd->headers[i] == '\n' ) {
flag = 1;
fp = epd->headers + fp_at;
_oc = epd->headers[i];
epd->headers[i] = '\0';
break;
}
}
if ( flag ) {
epd->content_length = atoi ( fp );
epd->headers[i] = _oc;
}
if ( stristr ( epd->headers + ( epd->_header_length - 60 ), "100-continue",
epd->_header_length ) ) {
network_raw_send ( epd->fd, "HTTP/1.1 100 Continue\r\n\r\n", 25 );
}
}
}
}
if ( epd->_header_length > 0
&& epd->_header_length < epd->data_len
&& epd->content_length < 1 ) {
epd->iov[0].iov_base = NULL;
epd->iov[0].iov_len = 0;
epd->iov[1].iov_base = NULL;
epd->iov[1].iov_len = 0;
network_send_error ( epd, 411, "" );
close_client ( epd );
epd = NULL;
serv_status.reading_counts--;
break;
}
}
//printf("data_len = %d header_length = %d content_length = %d\n", epd->data_len, epd->_header_length, epd->content_length);
if ( epd->_header_length > 0 && ( ( epd->content_length < 1
&& epd->_header_length > 0 ) ||
epd->content_length <= epd->data_len - epd->_header_length ) ) {
/// start job
epd->header_len = epd->_header_length;
epd->headers[epd->data_len] = '\0';
epd->header_len -= 1;
epd->headers[epd->header_len] = '\0';
if ( epd->header_len + 1 < epd->data_len ) {
epd->contents = epd->headers + epd->header_len + 1;
} else {
epd->content_length = 0;
}
if ( USE_KEEPALIVE == 1 && ( epd->keepalive == 1 ||
( stristr ( epd->headers, "keep-alive", epd->header_len ) ) )
) {
epd->keepalive = 1;
}
epd->response_header_length = 0;
epd->iov_buf_count = 0;
epd->response_content_length = 0;
epd->response_sendfile_fd = -1;
/// output server status !!!!!!!!!!
{
int i, len;
char *uri = NULL;
uri = epd->headers;
for ( i = 0; i < epd->header_len; i++ )
if ( uri[i] == ' ' ) {
break;
}
for ( ; i < epd->header_len; i++ )
if ( uri[i] != ' ' ) {
break;
}
uri = epd->headers + i;
len = strlen ( uri );
for ( i = 0; i < len; i++ ) {
if ( uri[i] == '\r' || uri[i] == '\n' || uri[i] == ' ' ) {
break;
}
}
if ( i > 11 && strncmp ( "/serv-status", uri, i ) == 0 ) {
epd->process_timeout = 0;
epd->iov[0].iov_base = NULL;
epd->iov[0].iov_len = 0;
epd->iov[1].iov_base = NULL;
epd->iov[1].iov_len = 0;
network_send_status ( epd );
serv_status.reading_counts--;
break;
}
}
/// end.
se_be_pri ( epd->se_ptr, NULL ); // be wait
if ( epd->status == STEP_READ ) {
serv_status.reading_counts--;
epd->status = STEP_PROCESS;
serv_status.sec_process_counts[ ( now ) % 5]++;
serv_status.process_counts++;
epd->method = NULL;
epd->uri = NULL;
epd->host = NULL;
epd->query = NULL;
epd->http_ver = NULL;
epd->referer = NULL;
epd->user_agent = NULL;
if ( process_func ( epd, 0 ) != 0 ) {
close_client ( epd );
epd = NULL;
}
}
break;
}
}
if ( epd && n < 0 && errno != EAGAIN && errno != EWOULDBLOCK ) {
//printf("error fd %d (%d) %s\n", epd->fd, errno, strerror(errno));
close_client ( epd );
epd = NULL;
return 0;
}
return 1;
}
static int network_be_write ( se_ptr_t *ptr )
{
epdata_t *epd = ptr->data;
if ( !epd ) {
return 0;
}
int n = 0;
send_iov_count = 0;
update_timeout ( epd->timeout_ptr, STEP_SEND_TIMEOUT );
//printf ( "network_be_write\n" );
if ( epd->status == STEP_SEND ) {
int j = 0, k = 0;
n = 0;
while ( epd->response_buf_sended < epd->response_content_length && n >= 0 ) {
if ( epd->response_sendfile_fd == -1 ) {
epd->response_buf_sended += n;
{
int all = 0;
send_iov_count = 0;
size_t sended = 0;
size_t be_len = 0;
for ( j = 0; j < epd->iov_buf_count; j++ ) {
sended += epd->iov[j].iov_len;
if ( sended > epd->response_buf_sended ) {
if ( k == 0 && epd->response_buf_sended > 0 ) {
k = epd->response_buf_sended - ( sended - epd->iov[j].iov_len );
}
send_iov[send_iov_count] = epd->iov[j];
send_iov_count++;
be_len += epd->iov[j].iov_len;
}
}
if ( k > 0 ) {
send_iov[0].iov_base += k;
send_iov[0].iov_len -= k;
}
send_iov[send_iov_count + 1].iov_base = NULL;
if ( be_len < 1 ) {
//printf ( "%d writev error! %d %ld\n", epd->fd, send_iov_count, be_len );
//exit ( 1 );
}
n = writev ( epd->fd, send_iov, send_iov_count );
}
if ( epd->response_buf_sended + n >= epd->response_content_length ) {
//printf("%ld sended %ld\n", epd->response_content_length, epd->response_buf_sended+n);
network_end_process ( epd );
serv_status.sending_counts--;
break;
}
} else {
n = network_raw_sendfile ( epd->fd, epd->response_sendfile_fd,
&epd->response_buf_sended,
epd->response_content_length );
if ( epd->response_buf_sended >= epd->response_content_length ) {
close ( epd->response_sendfile_fd );
epd->response_sendfile_fd = -1;
#ifdef linux
int set = 0;
setsockopt ( epd->fd, IPPROTO_TCP, TCP_CORK, &set, sizeof ( int ) );
#endif
network_end_process ( epd );
serv_status.sending_counts--;
break;
}
}
if ( n < 0 && errno != EAGAIN && errno != EWOULDBLOCK ) {
//printf("error end\n");
epd->keepalive = 0;
if ( epd->response_sendfile_fd > -1 ) {
#ifdef linux
int set = 0;
setsockopt ( epd->fd, IPPROTO_TCP, TCP_CORK, &set, sizeof ( int ) );
#endif
close ( epd->response_sendfile_fd );
}
network_end_process ( epd );
serv_status.sending_counts--;
break;
}
}
}
}
