char *
lxl_errlog_module_init_conf(lxl_cycle_t *cycle, void *conf)
{
lxl_log_conf_t *lcf = (lxl_log_conf_t *) conf;
int fd;
fd = cycle->log->fd;
if (!lcf->use_stderr) {
lxl_log_debug(LXL_LOG_DEBUG_CORE, 0, "open log file: %s", lcf->file.data);
cycle->log->fd = open(lcf->file.data, O_CREAT|O_WRONLY|O_APPEND, 0666);
if (cycle->log->fd == -1) {
lxl_log_error(LXL_LOG_EMERG, errno, "open(%s) failed", lcf->file.data);
return LXL_CONF_ERROR;
}
} else {
cycle->log->fd = STDERR_FILENO;
}
if (close(fd) == -1) {
lxl_log_error(LXL_LOG_ALERT, errno, "close() build-in log failed");
}
cycle->log->use_flush = lcf->use_flush;
cycle->log->use_stderr = lcf->use_stderr;
cycle->log->error_level = lcf->error_level;
cycle->log->debug_level = lcf->debug_level;
memcpy(cycle->log->file, lcf->file.data, lcf->file.len + 1);
return LXL_CONF_OK;
}
static int
lxl_dfss_collect_sync_push_fid(char *base_path)
{
size_t len;
DIR *dir;
FILE *fp;
struct dirent *de;
char buf[1024], b[1024];
lxl_dfs_fid_t *dfs_fid;
lxl_log_error(LXL_LOG_INFO, 0, "dfss collect sync push fid %s", base_path);
dir = opendir(base_path);
if (dir == NULL) {
lxl_log_error(LXL_LOG_ERROR, errno, "opendir(%s) failed", base_path);
return -1;
}
while ((de = readdir(dir)) != NULL) {
if (S_ISREG(de->d_type)
&& strncmp(de->d_name, LXL_DFSS_SYNCLOG_FILE_PREFIX, strlen(LXL_DFSS_SYNCLOG_FILE_PREFIX)) == 0) {
fp = fopen(de->d_name, "r");
if (fp == NULL) {
lxl_log_error(LXL_LOG_ERROR, errno, "fopen(%s) failed", de->d_name);
goto failed;
}
while (fgets(buf, sizeof(buf), fp) != NULL) {
len = strlen(buf);
buf[len - 1] = '\0';
dfs_fid = lxl_alloc(sizeof(lxl_dfs_fid_t));
if (dfs_fid == NULL) {
fclose(fp);
goto failed;
}
dfs_fid->fid.data = lxl_alloc(len + 1);
if (dfs_fid->fid.data == NULL) {
fclose(fp);
goto failed;
}
lxl_str_memcpy(&dfs_fid->fid, buf, len);
lxl_list_add_tail(&lxl_dfss_sync_push_list, &dfs_fid->list);
}
fclose(fp);
}
}
closedir(dir);
return 0;
failed:
closedir(dir);
return -1;
}
int
lxl_dns_core_init(lxl_cycle_t *cycle)
{
lxl_dns_pool = lxl_create_pool(LXL_DEFAULT_POOL_SIZE);
if (lxl_dns_pool == NULL) {
return -1;
}
lxl_dns_root_zone = lxl_palloc(lxl_dns_pool, sizeof(lxl_dns_zone_t));
if (lxl_dns_root_zone == NULL) {
return -1;
}
lxl_log_error(LXL_LOG_INFO, 0, "dns init zone hash");
if (lxl_hash_init(&lxl_dns_hash, lxl_dns_pool, 1024000, lxl_hash_key) == -1) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns init hash failed");
return -1;
}
lxl_list_init(&lxl_dns_root_zone->rrset_list);
lxl_dns_root_zone->update_sec = lxl_current_sec;
lxl_log_error(LXL_LOG_INFO, 0, "dns load named root path conf/named.root");
lxl_dns_load_named_root("conf/named.root");
lxl_log_error(LXL_LOG_INFO, 0, "dns add root zone");
if (lxl_dns_zone_add(LXL_DNS_ROOT_LABEL, LXL_DNS_ROOT_LEN, lxl_dns_root_zone) == -1) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns add root zone failed");
return -1;
}
return 0;
}
static int
lxl_event_module_init(lxl_cycle_t *cycle)
{
void ***cf;
struct rlimit rlmt;
lxl_int_t limit;
lxl_core_conf_t *ccf;
lxl_event_conf_t *ecf;
ccf = (lxl_core_conf_t *) lxl_get_conf(cycle->conf_ctx, lxl_core_module);
cf = lxl_get_conf(cycle->conf_ctx, lxl_events_module);
ecf = (*cf)[lxl_event_core_module.ctx_index];
lxl_log_error(LXL_LOG_INFO, 0, "using the \"%s\" event method", ecf->name);
if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
lxl_log_error(LXL_LOG_ALERT, errno, "getrlimit(RLIMIT_NOFILE) failed, ignored");
} else {
if (ecf->connections > (lxl_uint_t) rlmt.rlim_cur
&& (ccf->rlimit_nofile == LXL_CONF_UNSET || ecf->connections > (lxl_uint_t) ccf->rlimit_nofile)) {
limit = (ccf->rlimit_nofile == LXL_CONF_UNSET) ? (lxl_int_t) rlmt.rlim_cur : ccf->rlimit_nofile;
lxl_log_error(LXL_LOG_WARN, 0, "%lu worker_connections exceed open file resouse limit: %ld",
ecf->connections, limit);
}
}
return 0;
}
lxl_int_t
lxl_event_connect_peer_udp(lxl_connection_t **c)
{
int fd;
lxl_connection_t *connection;
lxl_log_debug(LXL_LOG_DEBUG_EVENT, 0, "event udp connect peer");
fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd == -1) {
lxl_log_error(LXL_LOG_ERROR, errno, "socket() failed");
return -1;
}
lxl_log_debug(LXL_LOG_DEBUG_EVENT, 0, "socket %d", fd);
connection = lxl_get_connection(fd);
if (connection == NULL) {
lxl_log_error(LXL_LOG_WARN, 0, "get connection() failed");
close(fd);
return -1;
}
// nonblock
connection->udp = 1;
connection->closefd = 1;
connection->fd = fd;
//connection->sockaddr = *sa;
//connection->socklen = len;
connection->recv = lxl_recvfrom;
connection->send = lxl_sendto;
*c = connection;
return 0;
}
static int
lxl_dns_load_named_root(char *file)
{
FILE *fp;
char buf[512];
char argv[5][64];
lxl_int_t argc;
lxl_uint_t line;
fp = fopen(file, "r");
if (fp == NULL) {
lxl_log_error(LXL_LOG_ALERT, errno, "fopen(%s) failed", file);
return -1;
}
line = 0;
while ((fgets(buf, sizeof(buf), fp)) != NULL) {
++line;
#if LXL_DEBUG
//lxl_log_debug(LXL_LOG_DEBUG_DNS, 0, "source buf %s, line %lu", buf, line);
#endif
lxl_strtrim(buf, " \t\r\n");
if (buf[0] == ';' || buf[0] == '#' || buf[0] == '\0') {
continue;
} else {
#if LXL_DEBUG
//lxl_log_debug(LXL_LOG_DEBUG_DNS, 0, "line %lu trim buf: %s", line, buf);
#endif
// lxl_strtrim(buf, "#");
// lxl_dns_parse(buf, argv);
argc = sscanf(buf, "%s %s %s %s %s", argv[0], argv[1], argv[2], argv[3], argv[4]);
if (argc == -1) {
lxl_log_error(LXL_LOG_ALERT, errno, "ssconf failed");
continue;
}
if (lxl_dns_parse_root_rr(argc, argv, line, NULL) == -1) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns parse root rr failed");
fclose(fp);
return -1;
}
}
}
fclose(fp);
return 0;
}
int
lxl_dfss_parse_request(lxl_dfss_request_t *r, char *data)
{
uint16_t new_qtype;
/* time suport*/
r->new_request = 1;
snprintf(r->rid, sizeof(r->rid), "%08lx%08x", lxl_current_sec, lxl_dfss_request_seed);
++lxl_dfss_request_seed;
r->request_header.body_n = ntohl(*((uint32_t *) data));
r->request_header.flen = ntohs(*((uint16_t *) (data + 4)));
if (r->first_qtype) {
new_qtype = ntohs(*(uint16_t *) (data + 6));
if (r->request_header.qtype != new_qtype) {
lxl_log_error(LXL_LOG_WARN, 0, "dfss new qtype: %04X not same first qtype: %04X", new_qtype, r->request_header.qtype);
// rcode r->header.rcode = 1
return -1;
}
} else {
r->request_header.qtype = ntohs(*((uint16_t *) (data + 6)));
r->first_qtype = 1;
}
//snprintf(r->rid, 17, "%08lX%08X", lxl_current_sec, lxl_dfss_request_seed);
//++lxl_dfss_request_seed;
// switch(qtype)
return 0;
}
static void
lxl_dfss_writer(lxl_dfss_request_t *r)
{
int rc;
ssize_t n;
lxl_buf_t *b;
lxl_event_t *wev;
lxl_connection_t *c;
lxl_log_debug(LXL_LOG_DEBUG_DFS, 0, "dfss writer handler");
c = r->connection;
wev = c->write;
b = r->out;
if (wev->timedout) {
// delayed
lxl_log_error(LXL_LOG_INFO, 0, "client timed out");
c->timedout = 1;
lxl_dfss_finalize_request(r, LXL_DFS_REQUEST_TIMEOUT);
return;
}
n = c->send(c, b->pos, b->last - b->pos);
if (n == LXL_ERROR) {
c->error = 1;
lxl_dfss_close_request(r, 0);
return;
}
if (n == LXL_EAGAIN) {
goto done;
}
b->pos += n;
if (b->pos < b->last) {
goto done;
}
lxl_log_debug(LXL_LOG_DEBUG_DFS, 0, "dfss writer done");
lxl_dfss_finalize_request(r, LXL_OK);
return;
done:
if (!wev->timer_set) {
lxl_add_timer(wev, 6 * 1000);
}
if (lxl_handle_write_event(wev, 0) != 0) {
lxl_dfss_close_request(r, 0);
}
return;
}
void
lxl_dfss_server_start(void)
{
lxl_log_error(LXL_LOG_INFO, 0, "dfss server start");
lxl_dfss_update_system_state();
lxl_add_timer(&lxl_dfss_report_state_event, 100);
lxl_add_timer(&lxl_dfss_sync_push_event, 100);
}
static char *
lxl_event_init_conf(lxl_cycle_t *cycle, void *conf)
{
if (lxl_get_conf(cycle->conf_ctx, lxl_events_module) == NULL) {
lxl_log_error(LXL_LOG_EMERG, 0, "no \"events\" section in configueation");
return LXL_CONF_ERROR;
}
return LXL_CONF_OK;
}
void
lxl_dfss_sync_pull(void)
{
lxl_log_error(LXL_LOG_INFO, 0, "dfss sync pull");
if (lxl_list_empty(&lxl_dfss_sync_pull_list)) {
lxl_dfss_server_start();
} else {
lxl_dfss_sync_pull_handler(&lxl_dfss_sync_pull_event);
}
}
static int
lxl_daemon(void)
{
int fd;
switch (fork()) {
case -1:
lxl_log_error(LXL_LOG_EMERG, errno, "fork failed");
return -1;
case 0:
break;
default:
exit(0);
}
lxl_pid = getpid();
if (setsid() == -1) {
lxl_log_error(LXL_LOG_EMERG, errno, "setsid() failed");
return -1;
}
umask(0);
fd = open("/dev/null", O_RDWR);
if (fd == -1) {
lxl_log_error(LXL_LOG_EMERG, errno, "open(/dev/null) failed");
return -1;
}
if (dup2(fd, STDIN_FILENO) == -1) {
lxl_log_error(LXL_LOG_EMERG, errno, "dup2(STDIN_FILENO) failed");
return -1;
}
if (dup2(fd, STDOUT_FILENO) == -1) {
lxl_log_error(LXL_LOG_EMERG, errno, "dup2(STDOUT_FILENO) failed");
return -1;
}
#if 0
if (dup2(fd, STDERROR_FILENO) == -1) {
lxl_log_error(LXL_LOG_EMERG, errno, "dup2(STDERROR_FILENO) failed");
return -1;
}
#endif
if (fd > STDERR_FILENO) {
if (close(fd) == -1) {
lxl_log_error(LXL_LOG_EMERG, errno, "close failed");
return -1;
}
}
return 0;
}
static void
lxl_dfss_process_request(lxl_dfss_request_t *r)
{
lxl_int_t rc;
lxl_connection_t *c;
lxl_log_debug(LXL_LOG_DEBUG_DFS, 0, "dfss process request");
c = r->connection;
if (c->read->timer_set) {
lxl_del_timer(c->read);
}
c->read->handler = lxl_dfss_request_handler;
c->write->handler = lxl_dfss_request_handler;
r->read_event_handler = lxl_dfss_block_reading;
//r->read_event_handler = block_reading
switch (r->request_header.qtype) {
case LXL_DFS_UPLOAD:
r->handler = lxl_dfss_upload_done_handle_request;
rc = lxl_dfss_read_client_request_body(r, lxl_dfss_tracker_init);
break;
case LXL_DFS_UPLOAD_SC:
r->handler = lxl_dfss_upload_sc_sync_handle_request;
rc = lxl_dfss_read_client_request_body(r, lxl_dfss_tracker_init);
break;
case LXL_DFS_STORAGE_SYNC_PUSH:
rc = lxl_dfss_read_client_request_body(r, lxl_dfss_sync_push_done_handle_request);
break;
case LXL_DFS_DOWNLOAD:
rc = lxl_dfss_read_client_request_body(r, lxl_dfss_download_handle_request);
break;
case LXL_DFS_DELETE:
rc = LXL_DFS_NOT_IMPLEMENTED;
break;
default:
lxl_log_error(LXL_LOG_ERROR, 0, "dfss Unknow request qtype: %04X", r->request_header.qtype);
break;
}
if (rc > LXL_DFS_OK) {
lxl_dfss_finalize_request(r, rc);
}
}
static char *
lxl_event_core_init_conf(lxl_cycle_t *cycle, void *conf)
{
lxl_event_conf_t *ecf = (lxl_event_conf_t *) conf;
lxl_uint_t i;
lxl_module_t *module;
lxl_event_module_t *event_module;
module = NULL;
#if LXL_HAVE_EPOLL
module = &lxl_epoll_module;
#endif
#if LXL_HAVE_KQUEUE
/* module = &lxl_kqueue_module */
#endif
if (module == NULL) {
for (i = 0; lxl_modules[i]; ++i) {
if (lxl_modules[i]->type != LXL_EVENT_MODULE) {
continue;
}
event_module = lxl_modules[i]->ctx;
if (event_module->name->len == event_core_name.len
&& memcmp(event_module->name->data, event_core_name.data, event_core_name.len) == 0) {
continue;
}
module = lxl_modules[i];
break;
}
}
if (module == NULL) {
lxl_log_error(LXL_LOG_EMERG, 0, "no events module found");
return LXL_CONF_ERROR;
}
lxl_conf_init_uint_value(ecf->connections, DEFAULT_CONNECTIONS);
cycle->connection_n = ecf->connections;
lxl_conf_init_uint_value(ecf->use, module->ctx_index);
lxl_conf_init_value(ecf->accept_mutex, 0);
return LXL_CONF_OK;
}
static void
lxl_dfss_process_request_header(lxl_event_t *rev)
{
//int rc;
size_t nread;
ssize_t n;
lxl_buf_t *b;
lxl_connection_t *c;
lxl_dfss_request_t *r;
c = rev->data;
r = c->data;
lxl_log_debug(LXL_LOG_DEBUG_DFS, 0, "dfss process request header");
if (rev->timedout) {
lxl_log_error(LXL_LOG_ERROR, 0, "client timed out");
c->timedout = 1;
lxl_dfss_close_request(r, LXL_DFS_REQUEST_TIMEOUT);
return;
}
b = r->header_buf;
nread = b->last - b->pos;
//lxl_log_debug(LXL_LOG_DEBUG_DFS, 0, "dfss read byte:%lu", b->last - b->pos);
if (nread < sizeof(lxl_dfs_request_header_t)) {
n = lxl_dfss_read_request_header(r);
if (n == LXL_EAGAIN || n == LXL_ERROR) {
return;
}
nread = b->last - b->pos;
}
lxl_log_debug(LXL_LOG_DEBUG_DFS, 0, "dfss read byte:%lu", nread);
if (nread >= sizeof(lxl_dfs_request_header_t)) {
if (lxl_dfss_parse_request(r, b->pos) == -1) {
lxl_dfss_finalize_request(r, r->response_header.rcode);
return;
}
lxl_log_debug(LXL_LOG_DEBUG_DFS, 0, "dfss process request: %s, %u, %hu, 0x%04x",
r->rid, r->request_header.body_n, r->request_header.flen, r->request_header.qtype);
// b->pos = b->start;
// b->last = b->start;
//b->last = b->pos;
b->pos += 8;
lxl_dfss_process_request(r);
}
}
static void
lxl_start_worker_process(lxl_cycle_t *cycle, lxl_int_t n)
{
pid_t pid;
lxl_int_t i;
lxl_log_error(LXL_LOG_INFO, 0, "start worker process");
for (i = 0; i < n; ++i) {
pid = fork();
switch (pid) {
case -1:
lxl_log_error(LXL_LOG_ALERT, errno, "fork() failed");
lxl_log_flush();
return;
case 0:
lxl_pid = getpid();
lxl_worker_process_cycle(cycle, i);
default:
break;
}
}
}
static void
lxl_worker_process_init(lxl_cycle_t *cycle, lxl_int_t worker)
{
lxl_uint_t i;
lxl_log_error(LXL_LOG_INFO, 0, "worker process init");
for (i = 0; lxl_modules[i]; ++i) {
if (lxl_modules[i]->init_process) {
if (lxl_modules[i]->init_process(cycle) == -1) {
/* fatal */
lxl_log_flush();
exit(2);
}
}
}
}
int
lxl_dns_core_init(lxl_cycle_t *cycle)
{
lxl_connection_t *c;
lxl_dns_pool = lxl_create_pool(LXL_DEFAULT_POOL_SIZE);
if (lxl_dns_pool == NULL) {
return -1;
}
lxl_dns_root_zone = lxl_palloc(lxl_dns_pool, sizeof(lxl_dns_zone_t));
if (lxl_dns_root_zone == NULL) {
return -1;
}
lxl_log_error(LXL_LOG_INFO, 0, "dns init zone hash");
if (lxl_hash_init(&lxl_dns_hash, lxl_dns_pool, 1024000, lxl_hash_key) == -1) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns init hash failed");
return -1;
}
lxl_list_init(&lxl_dns_root_zone->rrset_list);
lxl_dns_root_zone->update_sec = lxl_current_sec;
lxl_log_error(LXL_LOG_INFO, 0, "dns load named root path conf/named.root");
if (lxl_dns_load_named_root("conf/named.root") == -1) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns load named root path conf/named.root failed");
return -1;
}
lxl_log_error(LXL_LOG_INFO, 0, "dns add root zone");
if (lxl_dns_zone_add(LXL_DNS_ROOT_LABEL, LXL_DNS_ROOT_LEN, lxl_dns_root_zone) == -1) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns add root zone failed");
return -1;
}
c = lxl_get_connection(-1);
if (c == NULL) {
return -1;
}
memset(&lxl_dns_event, 0x00, sizeof(lxl_event_t));
lxl_dns_event.data = c;
lxl_dns_event.handler = lxl_dns_data_rebuild_handler;
lxl_add_timer(&lxl_dns_event, 86400*1000);
#if 0
char *t;
memcpy(t, "lxl coredump test", 1000);
#endif
return 0;
}
static void
lxl_close_accepted_connection(lxl_connection_t *c, lxl_uint_t flags)
{
lxl_log_debug(LXL_LOG_DEBUG_EVENT, 0, "close accepted connection socket %d", c->fd);
lxl_free_connection(c);
if (flags == LXL_CONNECTION_CLOSE_SOCKET) {
if (close(c->fd) == -1) {
lxl_log_error(LXL_LOG_ALERT, errno, "close socket %d failed", c->fd);
}
}
c->fd = -1;
if (c->pool) {
lxl_destroy_pool(c->pool);
}
}
static int
lxl_send_lowat(lxl_connection_t *c, size_t lowat)
{
int sndlowat;
if (c->sndlowat || lowat == 0) {
return 0;
}
sndlowat = (int) lowat;
if (setsockopt(c->fd, SOL_SOCKET, SO_SNDLOWAT, &sndlowat, sizeof(int)) == -1) {
lxl_log_error(LXL_LOG_ERROR, errno, "setsockopt(SO_SNDLOWAT) failed");
return -1;
}
c->sndlowat = 1;
return 0;
}
static ssize_t
lxl_dfss_read_request_header(lxl_dfss_request_t *r)
{
ssize_t n, rc;
lxl_event_t *rev;
lxl_connection_t *c;
c = r->connection;
rev = c->read;
if (rev->ready) {
n = c->recv(c, r->header_buf->last, r->header_buf->end - r->header_buf->last);
} else {
n = LXL_EAGAIN;
}
switch (n) {
case LXL_EAGAIN:
rc = LXL_EAGAIN;
// lxl_add_timer;
if (lxl_handle_read_event(rev) != 0) {
lxl_dfss_close_request(r, LXL_DFS_SERVER_ERROR);
}
break;
case 0:
lxl_log_error(LXL_LOG_INFO, 0, "client prematurely closed connection");
case LXL_ERROR:
// base request
c->error = 1;
//lxl_dfss_finalize_request(r, LXL_ERROR);
lxl_dfss_close_request(r, 0);
rc = LXL_ERROR;
break;
default:
r->header_buf->last += n;
rc = n;
}
return rc;
}
static void
lxl_dfst_storage_init_request(lxl_dfst_request_t *r)
{
lxl_dfst_upstream_t *u;
lxl_dfst_upstream_srv_conf_t *uscf;
lxl_dfst_storage_create_request(r);
u = r->storage;
uscf = u->conf->upstream;
if (uscf == NULL) {
lxl_log_error(LXL_LOG_ALERT, 0, "no upstream configuration");
return;
}
if (uscf->peer.init(r, uscf, u) != 0) {
// lxl_dfst
}
lxl_dfst_storage_connect(r, u);
}
lxl_int_t
lxl_hash_sample(lxl_uint_t nelts)
{
char name[64];
lxl_uint_t i, len, *value;
lxl_pool_t *pool;
lxl_hash_t hash;
pool = lxl_create_pool(1024);
lxl_hash_init(&hash, pool, nelts, lxl_hash_key);
for (i = 0; i < 40; ++i) {
value = lxl_alloc(sizeof(lxl_uint_t));
*value = i;
len = snprintf((char *) name, sizeof(name), "www.%lutaobao%lu.com", i, 40 - i);
if (lxl_hash_add(&hash, name, len, value) == -1) {
lxl_log_error(LXL_LOG_DEBUG, 0, "add exist value %lu, len %lu", *value, len);
} else {
lxl_log_error(LXL_LOG_DEBUG, 0, "add value %lu, len %lu", *value, len);
}
}
for (i = 8; i < 18; ++i) {
len = snprintf((char *) name, sizeof(name), "www.%lutaobao%lu.com", i, 40 - i);
value = lxl_hash_del(&hash, name, len);
if (value) {
lxl_log_error(LXL_LOG_DEBUG,0, "hash delete name %s, key %lu", name, *value);
//lxl_free(value);
} else {
lxl_log_error(LXL_LOG_DEBUG,0, "hash not find name %s", name);
}
}
for (i = 0; i < 40; ++i) {
len = snprintf((char *) name, sizeof(name), "www.%lutaobao%lu.com", i, 40 - i);
value = lxl_hash_find(&hash, name, len);
if (value) {
lxl_log_error(LXL_LOG_DEBUG, 0, "hash find value %lu", *value);
} else {
lxl_log_error(LXL_LOG_DEBUG,0, "hash not find name %s", name);
}
}
return 0;
}
static void
lxl_dfst_storage_connect(lxl_dfst_request_t *r, lxl_dfst_upstream_t *u)
{
int rc;
lxl_connection_t *c;
rc = lxl_event_connect_peer(&u->peer);
lxl_log_debug(LXL_LOG_DEBUG_DFS, 0, "dfst storage connect: %d", rc);
if (rc == LXL_ERROR) {
// finialize
return;
}
if (rc == LXL_BUSY) {
lxl_log_error(LXL_LOG_ERROR, 0, "dfst no live storages");
lxl_dfst_storage_next(r, u, LXL_DFST_UPSTREAM_FT_NOLIVE);
return;
}
if (rc == LXL_DECLINED) {
lxl_dfst_storage_next(r, u, LXL_DFST_UPSTREAM_FT_ERROR);
return;
}
c = u->peer.connection;
c->data = r;
c->write->handler = lxl_dfst_storage_handler;
c->read->handler = lxl_dfst_storage_handler;
if (rc == LXL_EAGAIN) {
lxl_add_timer(c->write, 3000);
return;
}
lxl_dfst_storage_send_request(r, u);
}
void
lxl_event_accept_udp(lxl_event_t *ev)
{
#define LXL_UDP_SIZE 512
ssize_t n;
char buffer[LXL_UDP_SIZE], ip[INET6_ADDRSTRLEN];
socklen_t socklen;
struct sockaddr sockaddr;
struct sockaddr_in *sin;
lxl_listening_t *ls;
lxl_connection_t *c, *lc;
lc = ev->data;
ls = lc->listening;
for (; ;) {
socklen = sizeof(struct sockaddr);
n = recvfrom(lc->fd, buffer, LXL_UDP_SIZE, 0, &sockaddr, &socklen);
if (n != -1) {
c = lxl_get_connection(lc->fd);
if (c == NULL) {
return;
}
c->pool = lxl_create_pool(ls->pool_size);
if (c->pool == NULL) {
lxl_close_accepted_connection(c, LXL_CONNECTION_NOT_CLOSE_SOCKET);
return;
}
c->buffer = lxl_create_temp_buf(c->pool, LXL_UDP_SIZE);
if (c->buffer == NULL) {
lxl_close_accepted_connection(c, LXL_CONNECTION_NOT_CLOSE_SOCKET);
return;
}
memcpy(c->buffer->pos, buffer, n);
c->buffer->last += n;
c->udp = 1;
//c->closefd = 0;
c->fd_noclose = 1;
c->sockaddr = sockaddr;
c->socklen = socklen;
//c->recv = lxl_recvfrom;
c->send = lxl_sendto; /* udp only send */
c->listening = ls;
// c->write->ready = 1;
sin = (struct sockaddr_in *) &sockaddr;
lxl_log_debug(LXL_LOG_DEBUG_EVENT, 0, "recvfrom() %s fd:%d nbyte:%ld",
inet_ntop(AF_INET, &sin->sin_addr, ip, INET6_ADDRSTRLEN), lc->fd, n);
ls->handler(c);
} else {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
lxl_log_debug(LXL_LOG_DEBUG_EVENT, errno, "recvfrom() not ready");
return;
} else if (errno == EINTR) {
lxl_log_debug(LXL_LOG_DEBUG_EVENT, errno, "recvfrom() failed");
continue;
} else {
lxl_log_error(LXL_LOG_ALERT, errno, "recvfrom() failed");
return;
}
}
}
}
void
lxl_event_accept(lxl_event_t *ev)
{
int fd;
char ip[INET6_ADDRSTRLEN];
socklen_t socklen;
struct sockaddr sockaddr;
struct sockaddr_in *sin;
lxl_listening_t *ls;
lxl_connection_t *c, *lc;
lc = ev->data;
ls = lc->listening;
ev->ready = 0; // ?
for (; ;) {
// accept4();
//socklen = sizeof(struct sockaddr);
fd = accept(lc->fd, &sockaddr, &socklen);
if (fd != -1) {
c = lxl_get_connection(fd);
if (c == NULL) {
if (close(fd) == -1) {
lxl_log_error(LXL_LOG_ALERT, errno, "close() socket failed");
}
return;
}
c->pool = lxl_create_pool(ls->pool_size);
if (c->pool == NULL) {
lxl_close_accepted_connection(c, LXL_CONNECTION_CLOSE_SOCKET);
return;
}
if (lxl_nonblocking(fd) == -1) {
lxl_log_error(LXL_LOG_ALERT, errno, "nonblocking failed");
lxl_close_accepted_connection(c, LXL_CONNECTION_CLOSE_SOCKET);
return;
}
c->udp = 0;
//c->closefd = 1;
c->recv = lxl_recv;
c->send = lxl_send;
c->listening = ls;
c->write->ready = 1;
sin = (struct sockaddr_in *) &sockaddr;
lxl_log_debug(LXL_LOG_DEBUG_EVENT, 0, "accept %s fd:%d",
inet_ntop(AF_INET, &sin->sin_addr, ip, INET6_ADDRSTRLEN), fd);
ls->handler(c);
} else {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
lxl_log_debug(LXL_LOG_DEBUG_EVENT, errno, "accept() not ready");
return;
} else if (errno == EINTR || errno == ECONNABORTED) {
lxl_log_error(LXL_LOG_WARN, errno, "accept() failed");
continue;
} else {
lxl_log_error(LXL_LOG_ERROR, errno, "accept() failed");
}
return;
}
}
}
void
lxl_dns_data_dump(void)
{
int fd;
char file[32];
char buffer[4096];
snprintf(file, sizeof(file), "dump_zone_data.%u", lxl_pid);
lxl_log_error(LXL_LOG_INFO, 0, "dns dump data to file %s", file);
fd = open(file, O_CREAT|O_WRONLY|O_TRUNC, 0666);
if (fd == -1) {
lxl_log_error(LXL_LOG_ALERT, errno, "open(%s) failed", file);
return;
}
ssize_t n;
char zname[256];
lxl_uint_t i, j, count, nelts;
lxl_list_t *list1, *list2;
lxl_hash_elt_t *tmp, *next, **buckets;
lxl_dns_rr_t rr;
lxl_dns_zone_t *zone;
lxl_dns_rrset_t *rrset;
lxl_dns_rdata_t *rdata;
nelts = lxl_dns_hash.nelts;
for (i = 0; i < nelts; ++i) {
j = 0;
buckets = &lxl_dns_hash.buckets[i];
tmp = *buckets;
while (tmp){
next = tmp->next;
zone = (lxl_dns_zone_t *) tmp->value;
lxl_dns_label_to_dot(tmp->name, zname);
n = snprintf(buffer, 4096, "\nzone:[%s]\texpires:[%lu]\tbuckets:[%lu,%lu]\n", zname, lxl_current_sec - zone->update_sec, i, j);
write(fd, buffer, n);
for (list1 = lxl_list_head(&zone->rrset_list); list1 != lxl_list_sentinel(&zone->rrset_list); list1 = lxl_list_next(list1)) {
rrset = lxl_list_data(list1, lxl_dns_rrset_t, list);
rr.type = rrset->type;
rr.ttl = rrset->ttl;
rr.nlen = rrset->nlen;
rr.name = rrset->name;
for (list2 = lxl_list_head(&rrset->rdata_list); list2 != lxl_list_sentinel(&rrset->rdata_list); list2 = lxl_list_next(list2)) {
rdata = lxl_list_data(list2, lxl_dns_rdata_t, list);
rr.rdlength = rdata->rdlength;
rr.rdata = rdata->rdata;
count = lxl_dns_data_dump_rr(buffer, &rr);
if (count > 0) {
n = write(fd, buffer, count);
if (n == -1) {
lxl_log_error(LXL_LOG_ALERT, errno, "write(%d) failed", fd);
}
} else {
lxl_log_error(LXL_LOG_ALERT, 0, "lxl_dns_data_dump_rr(name:%s type:0x%04x) failed", rr.name, rr.type);
}
}
}
tmp = next;
++j;
}
}
lxl_log_error(LXL_LOG_INFO, 0, "dns data dump suceed");
}
void
lxl_dns_data_rebuild(void)
{
lxl_pool_t *new_pool;
lxl_list_t *list1, *list2;
lxl_dns_rr_t rr;
lxl_dns_zone_t *old_zone, *new_zone;
lxl_dns_rrset_t *rrset;
lxl_dns_rdata_t *rdata;
old_zone = lxl_dns_zone_find(LXL_DNS_ROOT_LABEL, LXL_DNS_ROOT_LEN);
if (old_zone == NULL) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns data rebuild root not find");
return;
}
lxl_log_error(LXL_LOG_INFO, 0, "dns data rebuild create new pool");
new_pool = lxl_create_pool(LXL_DEFAULT_POOL_SIZE);
if (new_pool == NULL) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns data rebuild create pool failed");
return;
}
lxl_log_error(LXL_LOG_INFO, 0, "dns data rebuild init hash");
if (lxl_hash_init(&lxl_dns_hash, new_pool, lxl_dns_hash.nelts, lxl_dns_hash.key) == -1) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns init hash failed");
return;
}
new_zone = lxl_palloc(new_pool, sizeof(lxl_dns_zone_t));
if (new_zone == NULL) {
return;
}
lxl_list_init(&new_zone->rrset_list);
new_zone->update_sec = lxl_current_sec;
for (list1 = lxl_list_head(&old_zone->rrset_list); list1 != lxl_list_sentinel(&old_zone->rrset_list); list1 = lxl_list_next(list1)) {
rrset = lxl_list_data(list1, lxl_dns_rrset_t, list);
rr.type = rrset->type;
rr.ttl = rrset->ttl;
rr.nlen = rrset->nlen;
rr.name = rrset->name;
rr.soa_nlen = 0;
rr.soa_flags = LXL_DNS_RRSET_NORMAL_TYPE;
rr.expires_sec = lxl_current_sec + rrset->ttl;
rr.update_flags = LXL_DNS_RR_NORMAL_TYPE;
for (list2 = lxl_list_head(&rrset->rdata_list); list2 != lxl_list_sentinel(&rrset->rdata_list); list2 = lxl_list_next(list2)) {
rdata = lxl_list_data(list2, lxl_dns_rdata_t, list);
rr.rdlength = rdata->rdlength;
rr.rdata = rdata->rdata;
if (lxl_dns_rr_add(new_pool, new_zone, &rr) == -1) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns data rebuild add rr failed");
return;
}
}
}
lxl_log_error(LXL_LOG_INFO, 0, "dns data rebuild add root zone");
if (lxl_dns_zone_add(LXL_DNS_ROOT_LABEL, LXL_DNS_ROOT_LEN, new_zone) == -1) {
lxl_log_error(LXL_LOG_ERROR, 0, "dns data rebuild add root zone failed");
//return;
}
lxl_log_error(LXL_LOG_INFO, 0, "dns data rebuild destory pool");
lxl_destroy_pool(lxl_dns_pool);
lxl_dns_pool = new_pool;
lxl_log_error(LXL_LOG_INFO, 0, "dns data rebuild succeed");
}
static int
lxl_dns_parse_root_rr(lxl_int_t argc, char (*argv)[64], lxl_uint_t line, void *args)
{
/* . ttl class type data */
uint16_t type;
size_t len;
char *dns_str_type, *data;
lxl_dns_rr_t rr;
lxl_dns_rdata_t *rdata;
if (argc == 4) {
dns_str_type = argv[2];
data = argv[3];
} else if (argc == 5) {
dns_str_type = argv[3];
data = argv[4];
} else {
lxl_log_error(LXL_LOG_EMERG, 0, "need 4 | 5 argv, line %lu argc is %ld", line, argc);
return -1;
}
type = lxl_dns_get_rr_type(dns_str_type, strlen(dns_str_type));
if (type == LXL_DNS_INVALID_TYPE) {
lxl_log_error(LXL_LOG_EMERG, 0, "unknow dns type %s, line %lu", dns_str_type, line);
return -1;
}
if(type != LXL_DNS_A && type != LXL_DNS_AAAA && type != LXL_DNS_NS) {
lxl_log_error(LXL_LOG_EMERG, 0, "root domain(.) suport A AAAA NS, not suport type %s", dns_str_type);
return -1;
}
len = strlen(data);
rdata = lxl_dns_rdata_create(data, len, type);
if (rdata == NULL) {
return -1;
}
len = strlen(argv[0]);
lxl_dns_domain_dot_to_label(argv[0], len);
if (len == 1) {
rr.nlen = 1;
} else {
rr.nlen = len + 1;
}
rr.name = argv[0];
rr.type = type;
rr.ttl = atoi(argv[1]);
LXL_DNS_CHECK_TTL(rr.ttl);
rr.expires_sec = lxl_current_sec + rr.ttl;
rr.update_flags = LXL_DNS_RR_NORMAL_TYPE;
rr.rdlength = rdata->rdlength;
rr.rdata = rdata->rdata;
rr.soa_nlen = 0;
rr.soa_flags = LXL_DNS_RRSET_NORMAL_TYPE;
if (lxl_dns_rr_add(lxl_dns_pool, lxl_dns_root_zone, &rr) == 1) {
lxl_free(rdata);
return -1;
}
lxl_free(rdata);
return 1;
}
char *
lxl_conf_parse(lxl_conf_t *cf, lxl_str_t *filename)
{
int fd;
lxl_int_t rc;
lxl_buf_t buf;
lxl_conf_file_t conf_file;
enum {
parse_file = 0,
parse_block
} type;
if (filename) {
fd = open(filename->data, O_RDONLY);
if (fd == -1) {
lxl_conf_log_error(LXL_LOG_EMERG, cf, errno, "open() \"%s\" failed", filename->data);
return LXL_CONF_ERROR;
}
cf->conf_file = &conf_file;
if (lxl_fd_info(fd, &cf->conf_file->file.info) == -1) {
lxl_log_error(LXL_LOG_EMERG, errno, lxl_fd_info_n " \"%s\" failed", filename->data);
}
cf->conf_file->buffer = &buf;
buf.start = lxl_alloc(LXL_CONF_BUFFER);
if (buf.start == NULL) {
goto failed;
}
buf.pos = buf.start;
buf.last = buf.start;
buf.end = buf.last + LXL_CONF_BUFFER;
cf->conf_file->line = 1;
cf->conf_file->file.fd = fd;
cf->conf_file->file.name.len = filename->len;
cf->conf_file->file.name.data = filename->data;
cf->conf_file->file.offset = 0;
cf->conf_file->file.sys_offset = 0;
type = parse_file;
} else {
type = parse_block;
}
for (; ;) {
rc = lxl_conf_read_token(cf);
#if 1
lxl_uint_t i, nelts;
lxl_str_t *value;
nelts = lxl_array_nelts(cf->args);
value = lxl_array_elts(cf->args);
for (i = 0; i < nelts; ++i) {
lxl_conf_log_error(LXL_LOG_EMERG, cf, 0, "args: index:%lu value:%s", i, value[i].data);
}
#endif
if (rc == LXL_ERROR) {
goto done;
}
if (rc == LXL_CONF_BLOCK_DONE) {
if (type != parse_block) {
lxl_conf_log_error(LXL_LOG_EMERG, cf, 0, "unexpected end of file, unexpected \"}\"");
}
goto done;
}
if (rc == LXL_CONF_FILE_DONE) {
if (type == parse_block) {
lxl_conf_log_error(LXL_LOG_EMERG, cf, 0, "unexpected end of file, expecting \"}\"");
goto failed;
}
goto done;
}
/*if (cf->handler) {
}*/
rc = lxl_conf_handler(cf, rc);
if (rc == -1) {
goto failed;
}
}
failed:
rc = LXL_ERROR;
done:
if (filename) {
if (cf->conf_file->buffer->start) {
lxl_free(cf->conf_file->buffer->start);
}
if (close(fd) == -1) {
lxl_log_error(LXL_LOG_ALERT, errno, "close() %s failed", filename->data);
return LXL_CONF_ERROR;
}
}
if (rc == LXL_ERROR) {
return LXL_CONF_ERROR;
}
return LXL_CONF_OK;
}
