tlibc_error_code_t tlibc_csv_read_bool(tlibc_abstract_reader_t *super, bool *val)
{
tlibc_error_code_t ret = E_TLIBC_NOERROR;
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
if(self->field == NULL)
{
ret = E_TLIBC_NOT_FOUND;
goto done;
}
if(strcmp(self->field, "true") == 0)
{
*val = true;
}
else if(strcmp(self->field, "false") == 0)
{
*val = false;
}
else
{
ret = E_TLIBC_MISMATCH;
goto done;
}
done:
return ret;
}
tlibc_error_code_t tlibc_csv_read_int32(tlibc_abstract_reader_t *super, int32_t *val)
{
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
int64_t i64;
tlibc_error_code_t ret;
if(self->read_enum_name_once)
{
self->read_enum_name_once = false;
ret = E_TLIBC_PLEASE_READ_ENUM_NAME;
goto done;
}
ret = tlibc_csv_read_int64(super, &i64);
if(ret != E_TLIBC_NOERROR)
{
goto done;
}
*val = (int32_t)i64;
if(*val != i64)
{
return E_TLIBC_INTEGER_OVERFLOW;
}
done:
return ret;
return E_TLIBC_NOERROR;
}
tlibc_error_code_t tlibc_csv_read_vector_begin(tlibc_abstract_reader_t *super, const char* vec_name)
{
char *ch;
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
int32_t index;
index = get_field_index(self, self->col);
if((index < 0) || (index >= TLIBC_CSV_FIELD_NUM))
{
return E_TLIBC_NOT_FOUND;
}
self->pre_read_uint32 = true;
self->field = self->cur_line_fields[index];
if((self->field == NULL) || (*self->field == 0))
{
self->pre_u32 = 0;
}
else
{
self->pre_u32 = 1;
for(ch = self->field; *ch; ++ch)
{
if(*ch == ';')
{
++self->pre_u32;
}
}
}
return E_TLIBC_NOERROR;
}
tlibc_error_code_t tlibc_csv_read_vector_element_begin(tlibc_abstract_reader_t *super, const char* var_name, uint32_t index)
{
tlibc_error_code_t ret = E_TLIBC_NOERROR;
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
TLIBC_UNUSED(var_name);
if(self->field == NULL)
{
ret = E_TLIBC_NOT_FOUND;
goto done;
}
if(*self->field == '\0')
{
goto done;
}
self->field_end = self->field;
while((*self->field_end != ';') && (*self->field_end != 0))
{
++self->field_end;
}
if(*self->field_end == ';')
{
*self->field_end = 0;
}
else
{
self->field_end = NULL;
}
done:
return ret;
}
tlibc_error_code_t tlibc_csv_read_double(tlibc_abstract_reader_t *super, double *val)
{
tlibc_error_code_t ret = E_TLIBC_NOERROR;
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
if(self->field == NULL)
{
ret = E_TLIBC_NOT_FOUND;
goto done;
}
if(*self->field == '\0')
{
*val = 0;
goto done;
}
errno = 0;
*val = strtod(self->field, NULL);
if(errno != 0)
{
ret = E_TLIBC_ERRNO;
goto done;
}
return E_TLIBC_NOERROR;
done:
return ret;
}
tlibc_error_code_t tlibc_csv_read_enum_begin(tlibc_abstract_reader_t *super, const char *enum_name)
{
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
TLIBC_UNUSED(enum_name);
self->read_enum_name_once = true;
return E_TLIBC_NOERROR;
}
void tconnd_listen_fini()
{
tlibc_list_head_t *iter;
tcond_socket_destruct(&g_listen);
for(iter = g_socket_pool.mempool_entry.used_list.next; iter != &g_socket_pool.mempool_entry.used_list; iter = iter->next)
{
tconnd_socket_t *s = TLIBC_CONTAINER_OF(iter, tconnd_socket_t, mempool_entry.used_list);
tconnd_socket_delete(s);
}
}
tlibc_error_code_t tlibc_csv_read_field_end(tlibc_abstract_reader_t *super, const char *var_name)
{
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
if(self->pre_read_uint32)
{
self->pre_read_uint32 = false;
}
else
{
++self->col;
}
return E_TLIBC_NOERROR;
}
void tlibc_hash_clear(tlibc_hash_t *self)
{
tlibc_list_head_t *iter = self->used_bucket_list.next;
uint32_t i;
for(i = 0; i < self->used_bucket_list_num; iter = iter->next, ++i)
{
tlibc_hash_bucket_t *bucket = TLIBC_CONTAINER_OF(iter, tlibc_hash_bucket_t, used_bucket_list);
tlibc_list_init(&bucket->data_list);
bucket->data_list_num = 0;
}
tlibc_list_init(&self->used_bucket_list);
self->used_bucket_list_num = 0;
}
tlibc_error_code_t tlibc_binary_write_uint8(tlibc_abstract_writer_t *super, const uint8_t *val)
{
tlibc_binary_writer_t *self = TLIBC_CONTAINER_OF(super, tlibc_binary_writer_t, super);
if(WRITER_CAPACITY(self) < sizeof(uint8_t))
{
goto not_enough_bytebuff_size;
}
*(uint8_t*)WRITER_PTR(self) = *val;
self->offset += (uint32_t)sizeof(uint8_t);
return E_TLIBC_NOERROR;
not_enough_bytebuff_size:
return E_TLIBC_OUT_OF_MEMORY;
}
tlibc_error_code_t tlibc_csv_read_char(tlibc_abstract_reader_t *super, char *val)
{
tlibc_error_code_t ret = E_TLIBC_NOERROR;
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
if(self->field == NULL)
{
ret = E_TLIBC_NOT_FOUND;
goto done;
}
*val = *self->field;
done:
return ret;
}
tlibc_error_code_t tlibc_csv_read_vector_element_end(tlibc_abstract_reader_t *super, const char* var_name, uint32_t index)
{
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
TLIBC_UNUSED(var_name);
TLIBC_UNUSED(index);
if(self->field_end == NULL)
{
self->field = NULL;
}
else
{
self->field = self->field_end + 1;
}
return E_TLIBC_NOERROR;
}
tlibc_hash_head_t* tlibc_hash_find(tlibc_hash_t *self, const char *key, uint32_t key_size)
{
uint32_t key_hash = tlibc_hash_key(key, key_size);
uint32_t key_index = key_hash % self->size;
const tlibc_hash_bucket_t *bucket = &self->buckets[key_index];
tlibc_list_head_t *iter = iter = bucket->data_list.next;
uint32_t i;
for(i = 0; i < bucket->data_list_num; iter = iter->next, ++i)
{
tlibc_hash_head_t *ele = TLIBC_CONTAINER_OF(iter, tlibc_hash_head_t, data_list);
if((ele->key_size == key_size ) && (memcmp(ele->key, key, key_size) == 0))
{
return ele;
}
}
return NULL;
}
tlibc_error_code_t tlibc_csv_read_field_begin(tlibc_abstract_reader_t *super, const char *var_name)
{
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
int32_t index;
if(self->pre_read_uint32)
{
return E_TLIBC_NOERROR;
}
TLIBC_UNUSED(var_name);
index = get_field_index(self, self->col);
if((index < 0) || (index >= TLIBC_CSV_FIELD_NUM))
{
return E_TLIBC_NOT_FOUND;
}
self->field = self->cur_line_fields[index];
return E_TLIBC_NOERROR;
}
tlibc_error_code_t tlibc_binary_write_string(tlibc_abstract_writer_t *super, const char* str, uint32_t str_length)
{
tlibc_binary_writer_t *self = TLIBC_CONTAINER_OF(super, tlibc_binary_writer_t, super);
uint32_t str_len = 0;
tlibc_error_code_t ret= E_TLIBC_NOERROR;
TLIBC_UNUSED(str_length);
for(; self->offset < self->size; )
{
char c = (self->addr[self->offset++] = str[str_len++]);
if(c == 0)
{
goto done;
}
}
ret = E_TLIBC_OUT_OF_MEMORY;
done:
return ret;
}
tlibc_error_code_t tlibc_csv_read_string(tlibc_abstract_reader_t *super, char *str, uint32_t str_len)
{
tlibc_error_code_t ret = E_TLIBC_NOERROR;
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
size_t slen = 0;
if(self->field == NULL)
{
ret = E_TLIBC_NOT_FOUND;
goto done;
}
slen = strlen(self->field);
if(slen >= str_len)
{
ret = E_TLIBC_OUT_OF_MEMORY;
goto done;
}
memcpy(str, self->field, slen + 1);
done:
return ret;
}
tlibc_error_code_t tlibc_csv_read_uint32(tlibc_abstract_reader_t *super, uint32_t *val)
{
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
tlibc_error_code_t ret = E_TLIBC_NOERROR;
uint64_t ui64;
if(self->pre_read_uint32)
{
*val = self->pre_u32;
goto done;
}
ret = tlibc_csv_read_uint64(super, &ui64);
if(ret != E_TLIBC_NOERROR)
{
goto done;
}
*val = (uint32_t)ui64;
if(*val != ui64)
{
return E_TLIBC_INTEGER_OVERFLOW;
}
done:
return ret;
}
static error_code_t on_definition(generator_t *super, const YYLTYPE *yylloc, const syn_definition_t *definition)
{
generator_reader_c_t *self = TLIBC_CONTAINER_OF(super, generator_reader_c_t, super);
TLIBC_UNUSED(yylloc);
switch(definition->type)
{
case E_DT_IMPORT:
return _on_import(self, &definition->definition.de_import);
case E_DT_CONST:
return E_TD_NOERROR;
case E_DT_ENUM:
return _on_enum(self, &definition->definition.de_enum);
case E_DT_STRUCT:
return _on_struct(self, &definition->definition.de_struct);
case E_DT_UNION:
return _on_union(self, &definition->definition.de_union);
case E_DT_TYPEDEF:
return E_TD_NOERROR;
case E_DT_UNIX_COMMENT:
return E_TD_NOERROR;
default:
return E_TD_ERROR;
}
}
tlibc_error_code_t tlibc_csv_read_vector_end(tlibc_abstract_reader_t *super, const char* vec_name)
{
tlibc_csv_reader_t *self = TLIBC_CONTAINER_OF(super, tlibc_csv_reader_t, super);
++self->col;
return E_TLIBC_NOERROR;
}
tlibc_error_code_t tconnd_epool_proc()
{
int i;
tlibc_error_code_t ret = E_TLIBC_WOULD_BLOCK;
tlibc_list_head_t *iter, *next;
if(tlibc_list_empty(&readable_list))
{
struct epoll_event events[TCONND_EPOLL_MAX_EVENTS];
int events_num;
events_num = epoll_wait(g_epollfd, events, TCONND_EPOLL_MAX_EVENTS, 0);
if(events_num == -1)
{
//有可能被时钟打断
if(errno == EINTR)
{
ret = E_TLIBC_NOERROR;
goto done;
}
ERROR_LOG("epoll_wait errno[%d], %s.", errno, strerror(errno));
ret = E_TLIBC_ERRNO;
goto done;
}
for(i = 0; i < events_num; ++i)
{
tconnd_epoll_data_type_t *etype = events[i].data.ptr;
if(*etype == e_ted_socket)
{
tconnd_socket_t *socket = TLIBC_CONTAINER_OF(etype, tconnd_socket_t, etype);
if(socket->readable)
{
ERROR_LOG("socket [%u, %"PRIu64"] already readable.", socket->id, socket->mempool_entry.sn);
assert(0);
ret = E_TLIBC_ERROR;
goto done;
}
socket->readable = true;
tlibc_list_init(&socket->readable_list);
tlibc_list_add_tail(&socket->readable_list, &readable_list);
}
else if(*etype == e_ted_timer)
{
tconnd_timer_on_tick();
ret = E_TLIBC_NOERROR;
}
}
}
if(tlibc_list_empty(&readable_list))
{
ret = E_TLIBC_WOULD_BLOCK;
goto done;
}
for(iter = readable_list.next; iter != &readable_list; iter = next)
{
tlibc_error_code_t r;
tconnd_socket_t *socket = TLIBC_CONTAINER_OF(iter, tconnd_socket_t, readable_list);
next = iter->next;
if(socket == &g_listen)
{
r = tconnd_listen();
}
else
{
r = tconnd_socket_recv(socket);
}
switch(r)
{
case E_TLIBC_NOERROR:
ret = E_TLIBC_NOERROR;
break;
case E_TLIBC_TBUS_NOT_ENOUGH_SPACE:
ret = E_TLIBC_WOULD_BLOCK;
goto done;
case E_TLIBC_TOO_MANY_SOCKET:
break;
case E_TLIBC_WOULD_BLOCK:
break;
case E_TLIBC_ERRNO:
switch(errno)
{
case EAGAIN:
socket->readable = false;
tlibc_list_del(iter);
break;
case EINTR:
break;
default:
ret = E_TLIBC_ERRNO;
goto done;
}
break;
case E_TLIBC_NO_MEMORY:
{
tconnd_socket_t *sock = NULL;
if(tlibc_list_empty(&g_package_socket_list))
{
ret = E_TLIBC_NO_MEMORY;
ERROR_LOG("Not enough package buff.");
break;
}
sock = TLIBC_CONTAINER_OF(g_package_socket_list.next, tconnd_socket_t, g_package_socket_list);
assert(sock->package_buff != NULL);
WARN_LOG("close socket [%u, %"PRIu64"] to release package buff.", sock->id, sock->mempool_entry.sn);
tconnd_socket_delete(sock);
}
break;
case E_TLIBC_CLOSE:
tconnd_socket_delete(socket);
break;
default:
ret = r;
goto done;
}
}
done:
return ret;
}
tlibc_error_code_t process_input_tbus()
{
tlibc_error_code_t ret = E_TLIBC_NOERROR;
struct iovec iov[TCONND_IOV_NUM];
size_t iov_num;
tlibc_list_head_t writable_list;
tlibc_list_head_t *iter;
tbus_atomic_size_t tbus_head;
size_t iov_index;
tlibc_list_init(&writable_list);
iov_num = TCONND_IOV_NUM;
tbus_head = tbus_read_begin(g_input_tbus, iov, &iov_num);
if(iov_num == 0)
{
if(tbus_head == g_input_tbus->head_offset)
{
ret = E_TLIBC_WOULD_BLOCK;
}
goto read_end;
}
for(iov_index = 0; iov_index < iov_num; ++iov_index)
{
uint32_t i;
const sip_rsp_t *head = NULL;
size_t head_size = 0;
char* body_addr = NULL;
size_t body_size = 0;
head = (const sip_rsp_t*)iov[iov_index].iov_base;
head_size = SIZEOF_SIP_RSP_T(head);
if(iov[iov_index].iov_len < head_size)
{
ERROR_LOG("can not decode sip_rst_t.");
goto flush_socket;
}
if(head->cmd == e_sip_rsp_cmd_send)
{
body_size = head->size;
body_addr = (char*)iov[iov_index].iov_base + head_size;
if(head_size + body_size > iov[iov_index].iov_len)
{
ERROR_LOG("sip_rst_t.size out of range.");
goto flush_socket;
}
}
else
{
body_addr = NULL;
body_size = 0;
}
for(i = 0; i < head->cid_list_num; ++i)
{
tconnd_socket_t *socket = NULL;
if(i >= SIP_BROADCAST_NUM)
{
ERROR_LOG("cid [%u] >= SIP_BROADCAST_NUM [%u]", head->cid_list_num, SIP_BROADCAST_NUM);
break;
}
if(!tlibc_mempool_id_test(&g_socket_pool, head->cid_list[i].id))
{
DEBUG_LOG("head->cmd = %d [%u, %"PRIu64"] , head->cid_list[i].id[%u] > g_socket_pool->unit_num[%zu]."
, head->cmd, head->cid_list[i].id, head->cid_list[i].sn, head->cid_list[i].id, g_socket_pool.unit_num);
continue;
}
socket = (tconnd_socket_t*)tlibc_mempool_id2ptr(&g_socket_pool, head->cid_list[i].id);
if(!tlibc_mempool_ptr_test(socket, mempool_entry, head->cid_list[i].sn))
{
DEBUG_LOG("socket [%u, %"PRIu64"] head->cmd = %d [%u, %"PRIu64"] mismatch."
, head->cid_list[i].id, socket->mempool_entry.sn, head->cmd, head->cid_list[i].id, head->cid_list[i].sn);
continue;
}
if(tconnd_socket_push_pkg(socket, head, body_addr, body_size) == E_TLIBC_CLOSE)
{
if(socket->writable)
{
socket->writable = false;
tlibc_list_del(&socket->writable_list);
}
tconnd_socket_delete(socket);
}
else
{
if(!socket->writable)
{
socket->writable = true;
tlibc_list_add_tail(&socket->writable_list, &writable_list);
}
}
}
}
flush_socket:
for(iter = writable_list.next; iter != &writable_list; iter = iter->next)
{
tconnd_socket_t *socket = TLIBC_CONTAINER_OF(iter, tconnd_socket_t, writable_list);
tlibc_error_code_t r = tconnd_socket_flush(socket);
socket->writable = false;
if(r == E_TLIBC_CLOSE)
{
tconnd_socket_delete(socket);
}
}
read_end:
tbus_read_end(g_input_tbus, tbus_head);
return ret;
}
