void
fill_ev_table(char *input) {
char *str1, *str2, *str3, *str4,
*token, *subtoken, *kommatoken, *dptoken;
char *saveptr1=NULL,
*saveptr2=NULL,
*saveptr3=NULL,
*saveptr4=NULL;
int j, i=0, k=0;
long eid=0;
handlerf *ah=0;
for (j = 1, str1 = input; ; j++, str1 = NULL) {
token = strtok_r(str1, ";", &saveptr1);
if (token == NULL)
break;
for (str2 = token; ; str2 = NULL) {
subtoken = strtok_r(str2, "=", &saveptr2);
if (subtoken == NULL)
break;
if( (str2 == token) && ((eid = get_ev_id(subtoken)) != -1))
;
else if(eid == -1)
break;
for (str3 = subtoken; ; str3 = NULL) {
kommatoken = strtok_r(str3, ",", &saveptr3);
if (kommatoken == NULL)
break;
for (str4 = kommatoken; ; str4 = NULL) {
dptoken = strtok_r(str4, ":", &saveptr4);
if (dptoken == NULL) {
break;
}
if(str4 == kommatoken && str4 != token && eid != -1) {
if((ah = get_action_handler(dptoken)) != NULL) {
new_event(eid);
add_handler(eid, i, ah);
i++;
}
}
else if(str4 != token && eid != -1 && ah) {
add_option(eid, i-1, k, dptoken);
k++;
}
else if(!ah)
break;
}
k=0;
}
new_event(eid);
add_handler(eid, i, NULL);
i=0;
}
}
}
XCamReturn
CL3aImageProcessor::create_handlers ()
{
SmartPtr<CLImageHandler> image_handler;
SmartPtr<CLContext> context = get_cl_context ();
XCAM_ASSERT (context.ptr ());
/* black leve as first */
image_handler = create_cl_blc_image_handler (context);
_black_level = image_handler;
XCAM_FAIL_RETURN (
WARNING,
image_handler.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create blc handler failed");
add_handler (image_handler);
/* hdr */
if (_enable_hdr) {
image_handler = create_cl_hdr_image_handler (context, CL_HDR_TYPE_RGB);
_hdr = image_handler;
XCAM_FAIL_RETURN (
WARNING,
_hdr.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create hdr handler failed");
add_handler (image_handler);
}
/* demosaic */
image_handler = create_cl_demosaic_image_handler (context);
_demosaic = image_handler.dynamic_cast_ptr<CLBayer2RGBImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_demosaic.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create demosaic handler failed");
add_handler (image_handler);
/* color space conversion */
if (_out_smaple_type == OutSampleYuv) {
image_handler = create_cl_csc_image_handler (context, CL_CSC_TYPE_RGBATONV12);
_csc = image_handler.dynamic_cast_ptr<CLCscImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_csc .ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create csc handler failed");
add_handler (image_handler);
} else if (_out_smaple_type == OutSampleRGB) {
_demosaic->set_output_format (_output_fourcc);
}
return XCAM_RETURN_NO_ERROR;
}
int cli_answer_cb(int fd, void *arg)
{
int done, res = 0;
cli_conn_t *cli;
buf_t *buf;
my_conn_t *my;
conn_t *c;
cli = (cli_conn_t *)arg;
c = cli->conn;
buf = &(c->buf);
my = c->my;
if( (res = my_real_write(fd, buf, &done)) < 0 ){
log_err(g_log, "conn:%u my_real_write error\n", c->connid);
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ){
log(g_log, "conn:%u del_handler error\n", c->connid);
goto end;
}
res = add_handler(fd, EPOLLIN, cli_query_cb, cli);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
goto end;
}
res = add_handler(my->fd, EPOLLIN, my_answer_cb, my);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
goto end;
}
gettimeofday(&(c->tv_end), NULL);
buf_reset(buf);
}
return res;
end:
conn_close(c);
return res;
}
static int my_use_db_prepare(conn_t *c)
{
int fd, len, res = 0;
buf_t *buf;
my_conn_t *my;
cli_com_t com;
my = c->my;
fd = my->fd;
buf = &(my->buf);
com.pktno = 0;
com.comno = COM_INIT_DB;
len = strlen(c->curdb);
memcpy(com.arg, c->curdb, len);
com.len = len;
make_com(buf, &com);
res = add_handler(fd, EPOLLOUT, my_use_db_req_cb, my);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
}
buf_rewind(buf);
return res;
}
static int cli_com_forward(conn_t *c)
{
int res = 0, fd;
my_conn_t *my;
buf_t *buf;
cli_conn_t *cli;
my_node_t *node;
my = c->my;
fd = my->fd;
buf = &(c->buf);
cli = c->cli;
node = my->node;
log(g_log, "conn:%u mysql[%s:%s], sql:%s\n", c->connid, node->host, node->srv, c->arg );
res = add_handler(fd, EPOLLOUT, my_query_cb, my);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
return res;
}
buf_rewind(buf);
return res;
}
/*
START_HANDLER (default_handler, GET, "", res, 0, matches) {
response_add_header(res, "content-type", "text/html");
response_write(res, "default page");
} END_HANDLER
*/
int main() {
void *data;
void (*proc)(void *);
extern void worker_process(void *);
int n,i;
handler h = {simple_func, GET, "simple/\\([0-9]*$\\)", {0}, 2};
add_handler(&h);
/*
app_init();
// add_handler(simple);
// add_handler(default_handler);
data = &globals_r;
proc = &worker_process;
n = 1;
for(i=0;i<n;i++){
spawn_worker(data, proc);
}
(*proc)(data);
app_close(0);
*/
stone_run();
return 0;
}
int load_handlers_from_dir( char *base_dir, struct _handler ***outbound_list, int count ) {
struct dirent **namelist;
syslog( LOG_ERR, "Scan dir for handlers: %s", base_dir);
int filecount = scandir( base_dir, &namelist, handler_filter, NULL);
if (filecount < 0) {
syslog( LOG_ERR, "An error occured scanning: %s, for handlers", base_dir );
return count;
} else if ( filecount == 0 ) {
syslog( LOG_ERR, "No handlers found in: %s", base_dir );
return count;
}
syslog( LOG_ERR, "At least one handler found, so process what we found");
struct _handler **list = *outbound_list;
int n;
for( n=0;n<filecount;n++ ) {
char path[2048];
path[0] = '\0';
strcat(path, base_dir );
strcat(path, namelist[n]->d_name );
count = add_handler( &list, count, path );
free(namelist[n]);
}
free(namelist);
*outbound_list = list;
return count;
}
static gboolean on_socket_connected(GIOChannel *chan, GIOCondition cond,
gpointer user)
{
struct sockaddr saddr;
unsigned int len = sizeof(saddr);
int fd;
GIOChannel *client_io = NULL;
struct sock_server *data = user;
if (cond != G_IO_IN)
goto error;
fd = accept(data->server_sock, &saddr, &len);
if (fd == -1)
goto error;
client_io = g_io_channel_unix_new(fd);
server = g_at_server_new(client_io);
g_io_channel_unref(client_io);
if (server == NULL)
goto error;
add_handler(server);
return TRUE;
error:
g_free(data);
return FALSE;
}
TEST_F(SchedUtilTest, TestTimerWheel)
{
m_hook_ewait = true;
auto sch_impl = std::dynamic_pointer_cast<crx::scheduler_impl>(m_sch.m_impl);
auto tw = m_sch.get_timer_wheel();
auto tw_impl = std::dynamic_pointer_cast<crx::timer_wheel_impl>(tw.m_impl);
for (int i = 0; i < tw_impl->m_slots.size(); i++) { // 0-24hour 1-60minutes 2-60seconds 3-10#100millis
auto& slot = tw_impl->m_slots[i];
slot.slot_idx = rand()%slot.elems.size();
}
int timer_fd = std::dynamic_pointer_cast<crx::timer_impl>(tw_impl->m_milli_tmr.m_impl)->fd;
for (int i = 2; i < tw_impl->m_slots.size(); i++) { // 0-测试小时级别(不测试) 1-测试分钟级别(不测试) 2-测试秒级别 3-测试微妙级别
for (int j = 0; j < 16; j++) {
m_rand_adder = rand()%100;
int step_result = m_start_seed+m_rand_adder;
size_t delay = 0;
for (int k = i; k < tw_impl->m_slots.size(); k++) {
auto& slot = tw_impl->m_slots[k];
delay += (rand()%(slot.elems.size()-1)+1)*slot.tick;
}
delay += rand()%100;
m_efd_cnt.emplace_back(std::make_pair(timer_fd, 0));
size_t new_delay = (size_t)(ceil(delay/100.0)*100);
int inter_start = -1;
for (int k = 1; k < tw_impl->m_slots.size(); k++) {
auto& slot = tw_impl->m_slots[k];
if (new_delay < slot.tick)
continue;
if (-1 == inter_start)
inter_start = k;
int quotient = (int)(new_delay/slot.tick);
m_efd_cnt[0].second += quotient*slot.tick/100;
new_delay -= slot.tick*quotient;
}
for (int k = inter_start+1; k < tw_impl->m_slots.size(); k++) {
auto& nslot = tw_impl->m_slots[k];
m_efd_cnt[0].second += nslot.slot_idx*nslot.tick/100;
}
tw.add_handler(delay, std::bind(&SchedUtilTest::timer_wheel_helper, this, _1));
sch_impl->main_coroutine();
ASSERT_EQ(m_start_seed, step_result);
m_efd_cnt.clear();
}
}
}
boolean_t
test_add_progress_handler()
{
boolean_t retval = B_FALSE;
char *loggername = "mylogger";
const char *host = "localhost";
int port = 2333;
nvlist_t *handler_args = NULL;
logger_t *pLogger = NULL;
printf("Test: test_add_progress_handler\n");
pLogger = (logger_t *)test_setup();
if (pLogger == NULL) {
printf("Failed to get a Logger\n");
printf("Cannot proceed with test\n");
return (retval);
}
if (nvlist_alloc(&handler_args, NVATTRS, 0) != 0) {
printf("Cannot allocate space for handler args\n");
return (retval);
}
if (handler_args == NULL) {
printf("nvlist_alloc failed.\n");
printf("Cannot proceed with test\n");
return (retval);
}
/* Create a list of arguments for a ProgressHandler */
if ((nvlist_add_string(handler_args, HANDLER, PROGRESS_HANDLER) != 0) ||
(nvlist_add_string(handler_args, HOST, host) != 0) ||
(nvlist_add_int32(handler_args, PORT, port) != 0)) {
nvlist_free(handler_args);
printf("Cannot create handler args\n");
return (retval);
}
retval = add_handler(pLogger, handler_args, LOGGING_PROGRESS_HDLR);
nvlist_free(handler_args);
if (!retval) {
printf("test_add_progress_handler: Fail\n");
} else {
printf("test_add_progress_handler: Pass\n");
retval = B_TRUE;
}
Py_XDECREF(pLogger);
return (retval);
}
int cli_hs_stage1_prepare(conn_t *c)
{
int res = 0;
cli_conn_t *cli;
buf_t *buf;
my_auth_init_t init;
my_info_t *info;
my_node_t *node;
my_conn_t *my;
cli = c->cli;
if( (res = conn_alloc_my_conn(c)) < 0 ){
log(g_log, "conn:%u conn_alloc_my_conn error\n", c->connid);
return -1;
}
my = c->my;
node = my->node;
info = node->info;
buf = &(cli->buf);
bzero(&init, sizeof(init));
init.pktno = 0;
init.prot_ver = info->protocol;
strncpy(init.srv_ver, info->ver, sizeof(init.srv_ver) - 1);
init.srv_ver[sizeof(init.srv_ver) - 1] = '\0';
init.tid = c->connid;
memcpy(init.scram, cli->scram, 8);
init.cap = info->cap;
init.lang = 8;//info->lang;
init.status = info->status;
strncpy(init.plug, cli->scram + 8, 12);
init.scram_len = 21;
init.plug[12] = '\0';
if( (res = make_init(buf, &init)) < 0 ){
log(g_log, "conn:%u make_init error\n", c->connid);
return res;
}
res = add_handler(cli->fd, EPOLLOUT, cli_hs_stage1_cb, cli);
if(res < 0){
log(g_log, "conn:%u add_handler fail\n", c->connid);
return -1;
}
return res;
}
void
SignalHandler::add_handler(
const std::string & signal,
CallbackBase & callback)
{
int isignal = convert_name_to_signal(signal);
if (isignal >= 0) {
add_handler(isignal, callback);
}
else if (isignal == -1)
throw std::runtime_error("signal cannot be handled");
else if (isignal == -2)
throw std::runtime_error("signal name invalid");
else
throw std::logic_error("invalid value from convert_node_to_signal()");
}
/* Function: al_init_video_addon
*/
bool al_init_video_addon(void)
{
if (video_inited)
return true;
#ifdef ALLEGRO_CFG_VIDEO_HAVE_OGV
add_handler(".ogv", _al_video_ogv_vtable());
#endif
if (handlers == NULL) {
ALLEGRO_WARN("No video handlers available!\n");
return false;
}
_al_add_exit_func(al_shutdown_video_addon, "al_shutdown_video_addon");
return true;
}
int my_answer_cb(int fd, void *arg)
{
int res = 0;
my_conn_t *my;
cli_conn_t *cli;
conn_t *c;
buf_t *buf;
my = (my_conn_t *)arg;
c = my->conn;
buf = &(c->buf);
cli = c->cli;
if( (res = my_real_read_result_set(fd, buf)) < 0 ){
log_err(g_log, "conn:%u my_real_read_result_set error\n", c->connid);
goto end;
}
if( (res = del_handler(fd)) < 0 ){
log(g_log, "conn:%u del_handler error\n", c->connid);
goto end;
}
if( (res = del_handler(cli->fd)) < 0 ){
log(g_log, "conn:%u del_handler error\n", c->connid);
goto end;
}
res = add_handler(cli->fd, EPOLLOUT, cli_answer_cb, cli);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
goto end;
}
buf_rewind(buf);
return res;
end:
conn_close_with_my(c);
return res;
}
static int cli_com_ok_write_cb(int fd, void *arg)
{
int done, res = 0;
cli_conn_t *cli;
buf_t *buf;
my_conn_t *my;
conn_t *c;
cli = (cli_conn_t *)arg;
c = cli->conn;
buf = &(c->buf);
my = c->my;
if( (res = my_real_write(fd, buf, &done)) < 0 ){
log_err(g_log, "conn:%u my_real_write error\n", c->connid);
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ){
log(g_log, "conn:%u del_handler error\n", c->connid);
goto end;
}
res = add_handler(fd, EPOLLIN, cli_query_cb, cli);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
goto end;
}
buf_reset(buf);
conn_state_set_reading_client(c);
}
return res;
end:
conn_close(c);
return res;
}
static int my_use_db_resp_cb(int fd, void *arg)
{
int res = 0, done;
my_conn_t *my;
conn_t *c;
buf_t *buf;
my = (my_conn_t *)arg;
c = my->conn;
buf = &(my->buf);
if( (res = my_real_read(fd, buf, &done)) < 0 ){
log_err(g_log, "conn:%u my_real_read error\n", c->connid);
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ){
log(g_log, "conn:%u del_handler fd[%d] error\n", c->connid, fd);
goto end;
}
strncpy(my->ctx.curdb, c->curdb, sizeof(my->ctx.curdb) - 1);
my->ctx.curdb[sizeof(my->ctx.curdb) - 1] = '\0';
res = add_handler(fd, EPOLLOUT, my_query_cb, arg);
if(res < 0){
log(g_log, "conn:%u add_handler fd[%d] error\n", c->connid, fd);
goto end;
}
buf_reset(buf);
conn_state_set_writing_mysql(c);
}
return res;
end:
conn_close_with_my(c);
return res;
}
// set the int 0 timer to trigger a bit more than every ~53ms
void setup_timer() {
// 1.193182 MHz input clock
// divide by 1193 (0x04a9) to get around 1000Hz (~1000.15256 Hz)
kdebug("setting int0 timer ");
pic_mask_interrupt(INT_TIMER);
outb(0x43, 0x34); // 00110100b - chan 0, freq. divider, set lo/hi byte
outb(0x40, 0xa9); // Low byte of divider to chan 0 reload value
outb(0x40, 0x04); // High byte of divider to chan 0 reload value
kdebug("initialising ktimers");
/* Say we call it every 1000 useconds, when we really do every 999.847 useconds) */
ktimer_init(1000);
add_handler(INTR_BASE + INT_TIMER, &early_timer_isr);
pic_unmask_interrupt(INT_TIMER);
}
int cli_hs_stage3_cb(int fd, void *arg)
{
int done, res = 0;
cli_conn_t *cli;
conn_t *c;
buf_t *buf;
cli = (cli_conn_t *)arg;
buf = &(cli->buf);
c = cli->conn;
if( (res = my_real_write(fd, buf, &done)) < 0 ){
log_err(g_log, "conn:%u my_real_write error\n", c->connid);
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ){
log(g_log, "conn:%u del_handler error\n", c->connid);
goto end;
}
res = add_handler(fd, EPOLLIN, cli_query_cb, arg);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
goto end;
}
buf_reset(buf);
buf_reset(&(c->buf));
conn_state_set_idle(c);
}
return res;
end:
//fix me
conn_close(c);
return res;
}
static void test_server(int type)
{
switch (type) {
case 0:
if (create_tty("/phonesim1") == FALSE)
exit(1);
add_handler(server);
break;
case 1:
if (create_tcp("/phonesim1", DEFAULT_TCP_PORT) == FALSE)
exit(1);
break;
case 2:
if (create_unix("/phonesim1", DEFAULT_SOCK_PATH) == FALSE)
exit(1);
break;
}
}
int my_query_cb(int fd, void *arg)
{
int done, res = 0;
my_conn_t *my;
conn_t *c;
buf_t *buf;
my = (my_conn_t *)arg;
c = my->conn;
buf = &(c->buf);
if( (res = my_real_write(fd, buf, &done)) < 0 ){
log_err(g_log, "conn:%u my_real_write error\n", c->connid);
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ){
log(g_log, "conn:%u del_handler error\n", c->connid);
goto end;
}
res = add_handler(fd, EPOLLIN, my_answer_cb, my);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
goto end;
}
buf_reset(buf);
conn_state_set_read_mysql_write_client(c);
}
return res;
end:
conn_close_with_my(c);
return res;
}
XCamReturn
X3aAnalyzeTuner::create_tuning_handlers ()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
SmartPtr<AeHandler> ae_handler = _analyzer->get_ae_handler ();
SmartPtr<AwbHandler> awb_handler = _analyzer->get_awb_handler();
SmartPtr<X3aCiqTuningHandler> tuning_handler = new X3aCiqTnrTuningHandler ();
if (tuning_handler.ptr ()) {
tuning_handler->set_ae_handler (ae_handler);
tuning_handler->set_awb_handler (awb_handler);
add_handler (tuning_handler);
} else {
ret = XCAM_RETURN_ERROR_PARAM;
}
return ret;
}
XCamReturn
CLCscImageProcessor::create_handlers ()
{
SmartPtr<CLImageHandler> image_handler;
SmartPtr<CLContext> context = get_cl_context ();
XCAM_ASSERT (context.ptr ());
/* color space conversion */
image_handler = create_cl_csc_image_handler (context, CL_CSC_TYPE_YUYVTORGBA);
_csc = image_handler.dynamic_cast_ptr<CLCscImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_csc .ptr (),
XCAM_RETURN_ERROR_CL,
"CLCscImageProcessor create csc handler failed");
image_handler->set_pool_type (CLImageHandler::CLVideoPoolType);
add_handler (image_handler);
return XCAM_RETURN_NO_ERROR;
}
static int cli_com_ignored(conn_t *c)
{
#define CLI_COM_IGNORE_OK_PKT_SIZE 7
int res = 0, fd;
uint32_t pktlen;
uint8_t pktno;
buf_t *buf;
cli_conn_t *cli;
char *ptr;
pktlen = 0;
pktno = 1;
buf = &(c->buf);
cli = c->cli;
fd = cli->fd;
buf_reset(buf);
ptr = buf->ptr;
bzero(ptr + 4, CLI_COM_IGNORE_OK_PKT_SIZE);
pktlen = CLI_COM_IGNORE_OK_PKT_SIZE;
memcpy(ptr, &pktlen, 3);
memcpy(ptr + 3, &pktno, 1);
buf->used += (CLI_COM_IGNORE_OK_PKT_SIZE + 4);
buf->pos += (CLI_COM_IGNORE_OK_PKT_SIZE + 4);
buf_rewind(buf);
res = add_handler(fd, EPOLLOUT, cli_com_ok_write_cb, cli);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
return res;
}
return 0;
}
static int my_use_db_req_cb(int fd, void *arg)
{
int res = 0, done;
my_conn_t *my;
conn_t *c;
buf_t *buf;
my = (my_conn_t *)arg;
c = my->conn;
buf = &(my->buf);
if( (res = my_real_write(fd, buf, &done)) < 0 ){
log_err(g_log, "conn:%u my_real_write error\n", c->connid);
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ){
log(g_log, "conn:%u del_handler fd[%d] error\n", c->connid, fd);
goto end;
}
res = add_handler(fd, EPOLLIN,my_use_db_resp_cb,arg);
if(res < 0){
log(g_log, "conn:%u add_handler fd[%d] error\n", c->connid, fd);
goto end;
}
buf_reset(buf);
}
return res;
end:
conn_close_with_my(c);
return res;
}
int my_ping_prepare(my_conn_t *my)
{
int fd, len, res = 0;
buf_t *buf;
cli_com_t com;
fd = my->fd;
buf = &(my->buf);
com.pktno = 0;
com.comno = COM_PING;
com.len = 0;
make_com(buf, &com);
res = add_handler(fd, EPOLLOUT, my_ping_req_cb, my);
if(res < 0){
log(g_log, "add_handler error\n");
}
buf_rewind(buf);
return res;
}
int my_hs_stage2_cb(int fd, void *arg)
{//给服务器发送认证数据，并且注册读取结果回调
int done, res = 0;
my_conn_t *my;
buf_t *buf;
my = (my_conn_t *)arg;
buf = &(my->buf);
if( (res = my_real_write(fd, buf, &done)) < 0 ){
log_err(g_log, "my_real_write error[%d], errno:%d, errmsg:%s\n", res, errno, strerror(errno) );
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ){
log(g_log, "del_handler fd[%d] error\n", fd);
goto end;
}
//认证数据发送完成后，下一步进行结果验证，登陆结果
if( (res = add_handler(fd, EPOLLIN, my_hs_stage3_cb, arg)) < 0 ){
log(g_log, "add_handler fd[%d] error\n", fd);
goto end;
}
buf_reset(buf);
}
return res;
end:
-- ((my_node_t*)my->node)->cur_connecting_cnt ;
my_conn_close_on_fail(my);
return res;
}
static int my_ping_req_cb(int fd, void *arg)
{
int res = 0, done;
my_conn_t *my;
buf_t *buf;
my = (my_conn_t *)arg;
buf = &(my->buf);
if( (res = my_real_write(fd, buf, &done)) < 0 ){
log_err(g_log, "my_real_write error\n");
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ){
log(g_log, "del_handler fd[%d] error\n", fd);
goto end;
}
res = add_handler(fd, EPOLLIN,my_ping_resp_cb,arg);
if(res < 0){
log(g_log, "add_handler fd[%d] error\n", fd);
goto end;
}
buf_reset(buf);
}
return res;
end:
my_conn_close(my);
return res;
}
XCamReturn
CL3aImageProcessor::create_handlers ()
{
SmartPtr<CLImageHandler> image_handler;
SmartPtr<CLContext> context = get_cl_context ();
XCAM_ASSERT (context.ptr ());
#if 1
/* bayer pipeline */
image_handler = create_cl_bayer_pipe_image_handler (context);
_bayer_pipe = image_handler.dynamic_cast_ptr<CLBayerPipeImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
image_handler.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create bayer pipe handler failed");
_bayer_pipe->set_stats_callback (_stats_callback);
#if 0
if (get_profile () >= AdvancedPipelineProfile) {
_bayer_pipe->set_output_format (V4L2_PIX_FMT_ABGR32);
}
#endif
_bayer_pipe->enable_denoise (XCAM_DENOISE_TYPE_BNR & _snr_mode);
_bayer_pipe->enable_gamma (_enable_gamma);
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE * 2);
add_handler (image_handler);
if(_capture_stage == BasicbayerStage)
return XCAM_RETURN_NO_ERROR;
#else
/* black leve as first */
image_handler = create_cl_blc_image_handler (context);
_black_level = image_handler.dynamic_cast_ptr<CLBlcImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
image_handler.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create blc handler failed");
add_handler (image_handler);
image_handler = create_cl_dpc_image_handler (context);
_dpc = image_handler.dynamic_cast_ptr<CLDpcImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
image_handler.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create dpc handler failed");
_dpc->set_kernels_enable(_enable_dpc);
add_handler (image_handler);
image_handler = create_cl_bnr_image_handler (context);
_bnr = image_handler.dynamic_cast_ptr<CLBnrImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_bnr.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create bnr handler failed");
_bnr->set_kernels_enable (XCAM_DENOISE_TYPE_BNR & _snr_mode);
add_handler (image_handler);
image_handler = create_cl_3a_stats_image_handler (context);
_x3a_stats_calculator = image_handler.dynamic_cast_ptr<CL3AStatsCalculator> ();
XCAM_FAIL_RETURN (
WARNING,
_x3a_stats_calculator.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create 3a stats calculator failed");
_x3a_stats_calculator->set_stats_callback (_stats_callback);
add_handler (image_handler);
image_handler = create_cl_wb_image_handler (context);
_wb = image_handler.dynamic_cast_ptr<CLWbImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_wb.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create whitebalance handler failed");
add_handler (image_handler);
/* gamma */
image_handler = create_cl_gamma_image_handler (context);
_gamma = image_handler.dynamic_cast_ptr<CLGammaImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_gamma.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create gamma handler failed");
_gamma->set_kernels_enable (_enable_gamma);
add_handler (image_handler);
/* hdr */
image_handler = create_cl_hdr_image_handler (context, CL_HDR_DISABLE);
_hdr = image_handler.dynamic_cast_ptr<CLHdrImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_hdr.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create hdr handler failed");
if(_hdr_mode == CL_HDR_TYPE_RGB)
_hdr->set_mode (_hdr_mode);
add_handler (image_handler);
/* demosaic */
image_handler = create_cl_demosaic_image_handler (context);
_demosaic = image_handler.dynamic_cast_ptr<CLBayer2RGBImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_demosaic.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create demosaic handler failed");
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE);
add_handler (image_handler);
#endif
/* hdr-lab*/
image_handler = create_cl_hdr_image_handler (context, CL_HDR_DISABLE);
_hdr = image_handler.dynamic_cast_ptr<CLHdrImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_hdr.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create hdr handler failed");
if(_hdr_mode == CL_HDR_TYPE_LAB)
_hdr->set_mode (_hdr_mode);
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE);
add_handler (image_handler);
/* bilateral noise reduction */
image_handler = create_cl_denoise_image_handler (context);
_binr = image_handler.dynamic_cast_ptr<CLDenoiseImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_binr.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create denoise handler failed");
_binr->set_kernels_enable (XCAM_DENOISE_TYPE_BILATERAL & _snr_mode);
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE);
add_handler (image_handler);
#if 0
image_handler = create_cl_rgb_pipe_image_handler (context);
_rgb_pipe = image_handler.dynamic_cast_ptr<CLRgbPipeImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_rgb_pipe.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create rgb pipe handler failed");
_rgb_pipe->set_kernels_enable (get_profile () >= AdvancedPipelineProfile);
add_handler (image_handler);
/* Temporal Noise Reduction (RGB domain) */
image_handler = create_cl_tnr_image_handler(context, CL_TNR_TYPE_RGB);
_tnr_rgb = image_handler.dynamic_cast_ptr<CLTnrImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_tnr_rgb.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create tnr handler failed");
_tnr_rgb->set_mode (CL_TNR_TYPE_RGB & _tnr_mode);
add_handler (image_handler);
#else
/* simple noise reduction */
image_handler = create_cl_snr_image_handler (context);
_snr = image_handler.dynamic_cast_ptr<CLSnrImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_snr.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create snr handler failed");
_snr->set_kernels_enable (XCAM_DENOISE_TYPE_SIMPLE & _snr_mode);
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE);
add_handler (image_handler);
#endif
/* tone mapping*/
image_handler = create_cl_tonemapping_image_handler (context);
_tonemapping = image_handler.dynamic_cast_ptr<CLTonemappingImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_tonemapping.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create tonemapping handler failed");
_tonemapping->set_kernels_enable (_enable_tonemapping);
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE);
add_handler (image_handler);
#if 1
image_handler = create_cl_yuv_pipe_image_handler (context);
_yuv_pipe = image_handler.dynamic_cast_ptr<CLYuvPipeImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_yuv_pipe.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create macc handler failed");
_yuv_pipe->set_tnr_enable (_tnr_mode & CL_TNR_TYPE_RGB, _tnr_mode & CL_TNR_TYPE_YUV);
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE);
add_handler (image_handler);
#else
/* macc */
image_handler = create_cl_macc_image_handler (context);
_macc = image_handler.dynamic_cast_ptr<CLMaccImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_macc.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create macc handler failed");
_macc->set_kernels_enable (_enable_macc);
add_handler (image_handler);
/* color space conversion */
image_handler = create_cl_csc_image_handler (context, CL_CSC_TYPE_RGBATONV12);
_csc = image_handler.dynamic_cast_ptr<CLCscImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_csc .ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create csc handler failed");
image_handler->set_pool_type (CLImageHandler::DrmBoPoolType);
add_handler (image_handler);
/* Temporal Noise Reduction (YUV domain) */
image_handler = create_cl_tnr_image_handler(context, CL_TNR_TYPE_YUV);
_tnr_yuv = image_handler.dynamic_cast_ptr<CLTnrImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_tnr_yuv.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create tnr handler failed");
_tnr_yuv->set_mode (CL_TNR_TYPE_YUV & _tnr_mode);
image_handler->set_pool_type (CLImageHandler::DrmBoPoolType);
add_handler (image_handler);
#endif
/* ee */
image_handler = create_cl_ee_image_handler (context);
_ee = image_handler.dynamic_cast_ptr<CLEeImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_ee.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create ee handler failed");
_ee->set_kernels_enable (XCAM_DENOISE_TYPE_EE & _snr_mode);
image_handler->set_pool_type (CLImageHandler::DrmBoPoolType);
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE);
add_handler (image_handler);
/* biyuv */
image_handler = create_cl_biyuv_image_handler (context);
_biyuv = image_handler.dynamic_cast_ptr<CLBiyuvImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_biyuv.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create biyuv handler failed");
_biyuv->set_kernels_enable (XCAM_DENOISE_TYPE_BIYUV & _snr_mode);
image_handler->set_pool_type (CLImageHandler::DrmBoPoolType);
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE);
add_handler (image_handler);
/* image scaler */
image_handler = create_cl_image_scaler_handler (context, V4L2_PIX_FMT_NV12);
_scaler = image_handler.dynamic_cast_ptr<CLImageScaler> ();
XCAM_FAIL_RETURN (
WARNING,
_scaler.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create scaler handler failed");
_scaler->set_scaler_factor (XCAM_CL_3A_IMAGE_SCALER_FACTOR);
_scaler->set_buffer_callback (_stats_callback);
image_handler->set_pool_type (CLImageHandler::DrmBoPoolType);
image_handler->set_kernels_enable (false);
add_handler (image_handler);
if (_out_smaple_type == OutSampleRGB) {
image_handler = create_cl_csc_image_handler (context, CL_CSC_TYPE_NV12TORGBA);
_csc = image_handler.dynamic_cast_ptr<CLCscImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_csc .ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create csc handler failed");
image_handler->set_pool_type (CLImageHandler::DrmBoPoolType);
image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE);
add_handler (image_handler);
}
return XCAM_RETURN_NO_ERROR;
}
int cli_hs_stage2_cb(int fd, void *arg)
{
int done, res = 0;
cli_conn_t *cli;
conn_t *c;
buf_t *buf;
my_auth_result_t result;
cli_auth_login_t login;
my_result_error_t error;
char token[128];
cli = (cli_conn_t *)arg;
c = cli->conn;
buf = &(cli->buf);
if( (res = my_real_read(fd, buf, &done)) < 0 ){
log_err(g_log, "conn:%u my_real_read error\n", c->connid);
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ){
log(g_log, "conn:%u del_handler error\n", c->connid);
goto end;
}
if( (res = parse_login(buf, &login)) < 0 ){
log(g_log, "conn:%u parse login error\n", c->connid);
goto end;
}
if(!strcmp(login.user, g_conf.user)){
scramble(token, cli->scram, g_conf.passwd);
if(memcmp(token, login.scram, 20) == 0){
strncpy(c->curdb, login.db, sizeof(c->curdb) - 1);
result.pktno = 2;
if( (res = make_auth_result(buf, &result)) < 0 ){
log(g_log, "conn:%u make auth result error\n", c->connid);
goto end;
}
res = add_handler(fd, EPOLLOUT, cli_hs_stage3_cb, arg);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
goto end;
}
return res;
}
}
log(g_log, "login auth fail, wrong user or passwd\n");
error.pktno = 2;
error.field_count = 0xff;
error.err = 1045;
error.marker = '#';
memcpy(error.sqlstate, "28000", 5);
strncpy(error.msg, "Access denied", sizeof(error.msg) - 1);
error.msg[sizeof(error.msg) - 1] = '\0';
make_result_error(buf, &error);
res = add_handler(fd, EPOLLOUT, cli_hs_auth_fail_cb, arg);
if(res < 0){
log(g_log, "conn:%u add_handler error\n", c->connid);
goto end;
}
}
return res;
end:
conn_close(c);
return res;
}
int my_hs_stage1_cb(int fd, void *arg)
{//读取mysql的连接认证原始数据
int done, res = 0;
my_conn_t *my;
buf_t *buf;
char *user, *pass, token[64], message[64];
my_node_t *node;
my_auth_init_t init;
cli_auth_login_t login;
my_info_t *info;
my = (my_conn_t *)arg;
node = my->node;
buf = &(my->buf);
user = node->user;
pass = node->pass;
info = node->info;
if( (res = my_real_read(fd, buf, &done)) < 0 ){
log_err(g_log, "read mysql error res[%d]\n", res);
goto end;
}
if(done){
if( (res = del_handler(fd)) < 0 ) {
log(g_log, "del_handler fd[%d] error\n", fd);
goto end;
}
res = add_handler(fd, EPOLLOUT, my_hs_stage2_cb, arg);
if(res < 0){
log(g_log, "add_handler fd[%d] error\n", fd);
goto end;
}
if( (res = parse_init(buf, &init)) < 0 ){
log(g_log, "parse init packet error\n");
goto end;
}
memcpy(message, init.scram, 8);
memcpy(message + 8, init.plug, 12);
//memcpy(message, "%@R[SoWC", 8);
//memcpy(message + 8, "+L|LG_+R={tV", 12);
message[8+12] = '\0';
my_info_set(init.prot_ver, init.lang, init.status, init.cap, init.srv_ver, strlen(init.srv_ver));
login.pktno = 1;
login.client_flags = init.cap & (~cap_umask);
login.max_pkt_size = 16777216;
login.charset = init.lang;
strncpy(login.user, user, sizeof(login.user) - 1);
login.user[sizeof(login.user) - 1] = '\0';
if(pass[0] == '\0'){
login.scram[0] = 0;
} else {
login.scram[0] = 20;
scramble(token, message, pass);
memcpy(login.scram + 1, token, 20);
}
strncpy(login.db, "", sizeof(login.db) - 1);
login.db[sizeof(login.db) - 1] = '\0';
if( (res = make_login(buf, &login)) < 0 ){
log(g_log, "make login packet error\n");
goto end;
}
}
return res;
end:
-- node->cur_connecting_cnt ;
my_conn_close_on_fail(my);
return res;
}
