int load_redis_conf(const char * buff)
{
int retv;
retv = read_profile_string("redis", "server", &g_server.server_addr, "localhost", buff);
if (retv == FAIL) {
zlog_error(logger, "redis server addr fetch failed");
return FAIL;
}
zlog_debug(logger, "redis server addr: %s", g_server.server_addr);
g_server.server_port = read_profile_int("redis", "port", 6379, buff);
if (g_server.server_port == FAIL) {
zlog_error(logger, "redis server port fetch failed");
free(g_server.server_addr);
return FAIL;
}
zlog_debug(logger, "redis server port: %d", g_server.server_port);
g_server.db_choice = read_profile_int("redis", "db", 0, buff);
if (g_server.db_choice == FAIL) {
zlog_error(logger, "redis server db fetch failed");
free(g_server.server_addr);
return FAIL;
}
zlog_debug(logger, "redis db choice: %d", g_server.db_choice);
g_server.timeout.tv_sec = 2;
g_server.timeout.tv_usec = 0;
g_server.conn = NULL;
return OK;
}
void* fre_os_bind_lib(FRE_LIBDATA* libx, char* funcname) {
char* errorptr;
void* funcvec;
if((funcvec = GetProcAddress((HMODULE)libx->libvector, (LPCSTR)funcname)) == NULL) {
zlog_error("fre_os_bind_lib: GetProcAddress() failed to bind \"%a\" from [%s].\n",funcname, libx->libname);
zlog_error("fre_os_bind_lib: %s\n",GetLastError());
return NULL;
}
return funcvec;
}
ssize_t cmi_intf_write_msg(cmi_intf_t* intf, void* buf, size_t buf_size)
{
ssize_t size = 0;
if (!cmi_intf_is_connected(intf)) {
return(SPKERR_BADSEQ);
}
if (!cmi_msg_is_valid(buf, buf_size)) {
zlog_error(cmi_zc, "try to send illegal message");
cmi_msg_dump(ZLOG_LEVEL_ERROR, buf, buf_size);
return(SPKERR_PARAM);
}
pthread_mutex_lock(&intf->conn_lock);
switch(intf->intf_type) {
case cmi_intf_tcp:
size = cmi_tcp_write_msg(intf->conn_sockfd,
intf->endian_cur,
buf,
buf_size);
break;
case cmi_intf_udp:
size = cmi_udp_write_msg(intf->conn_sockfd,
intf->endian_cur,
buf,
buf_size,
(struct sockaddr*)&intf->conn_addr);
break;
default:
assert(0);
break;
}
pthread_mutex_unlock(&intf->conn_lock);
if (size == 0) {
// no data
} else if (size < 0) {
// error
zlog_error(cmi_zc, "failed to write/send: sock=%d, ret=%ld, errmsg=\'%s\'",
intf->conn_sockfd, size, strerror(errno));
size = SPKERR_RESETSYS;
} else {
assert(size == buf_size);
}
return(size);
}
void UpdateCoapclient(List *list)
{
ListElmt* ptr;
pid_t pid;
if(list->size > 0)
{
for(ptr = list_head(list); ptr!=NULL; ptr=ptr->next )
{
//向子进程发送终止信号
int res = kill( ((coapIP*)(ptr->data))->pid, COAP_CLOSE_SIGNAL );
if(res == -1)
{
printf("kill signal error!\r\n");
zlog_error(zc, "kill process stop signal error!");
}
else
{
zlog_debug(zc, "kill process stop signal success!");
}
//等待进程退出
pid = wait(NULL);
printf("%d process exit!\r\n", pid);
}
}
CreatCoapclient(list);
}
int zlog_test()
{
int rc;
zlog_category_t *c;
rc = zlog_init("d:\\tmp\\zlog.conf");
if (rc) {
printf("init failed\n");
return -1;
}
c = zlog_get_category("my_cat");
if (!c) {
printf("get cat fail\n");
zlog_fini();
return -2;
}
zlog_info(c, "hello, zlog");
zlog_debug(c, "hello, zlog");
zlog_error(c, "hello, zlog");
zlog_fini();
printf("exit.\n");
return 0;
}
int melsec_read_wcd(char* fname) {
FILE* fhand;
MC_WCD_HEADER thead;
MC_WCD_LENT tent;
MC_WCD_STRTAB ttab;
if((fhand = fopen(fname,"rb")) == NULL) {
zlog_error("melsec_read_wcd(): Failed to open file [%s]\n",fname);
return 1;
}
zlog_debug("melsec_read_wcd(): Opened file successfully! Parsing...\n");
// get header
if(!fread(&thead,sizeof(thead),1,fhand)) {
zlog_debug("failed to read header!\n");
return 1;
}
zlog_debug(">> dlist_size = %u bytes / dlist_num = %hu\n",thead.dlist_size,thead.dlist_num);
// read listing
for(int i = 0; i < thead.dlist_num; i++) {
if(!fread(&tent,sizeof(tent),1,fhand)) {
zlog_debug("failed to read list entry!\n");
return 1;
}
zlog_debug("[%i] %s%u -> # %u\n",i,mc_get_dev_from_val(tent.dtype),tent.devnum,tent.dcount);
}
// read string table
fclose(fhand);
return 0;
}
int main(int argc, char** argv)
{
int rc = 0;
int j = 100;
rc = zlog_init("change_rule.conf");
if (rc){
printf("init failed\n");
return 2;
}
zlog_category_t *zc;
zc = zlog_get_category("yang");
pthread_t tid;
pthread_create(&tid, NULL, work, (void*)("yang"));
while(j-- > 0) {
zlog_debug(zc, "debuglog");
zlog_info(zc, "infolog");
zlog_error(zc, "errorlog");
sleep(1);
}
pthread_join(tid, NULL);
zlog_fini();
return 0;
}
int main(int argc, char** argv)
{
int rc;
zlog_category_t *zc;
rc = zlog_init("test_syslog.conf");
if (rc) {
printf("init failed\n");
return -1;
}
zc = zlog_get_category("my_cat");
if (!zc) {
printf("get cat fail\n");
zlog_fini();
return -2;
}
zlog_info(zc, "hello, zlog -- info");
zlog_error(zc, "hello, zlog -- error");
zlog_fini();
return 0;
}
int ips_chan_config(ips_pcctx_t* pcctx, char* config_buf, size_t buf_sz)
{
IPS_EPID epid = IPS_GET_MYEPID(pcctx);
int pc_id = pcctx->pc_id;
ips_mailbox_t ack;
int ret = -1;
assert(buf_sz <= sizeof(ips_pl_config_t));
if (pcctx->phase != IPS_PHASE_IDLE) {
zlog_error(ips_zc, " unexpected sequence: phase=%s", ips_desc_phase2str(pcctx->phase));
ret = SPKERR_BADSEQ;
goto out;
}
// construct PKT_CMD_CONFIG
ips_pl_config_t payload;
memcpy(&payload, config_buf, buf_sz);
ret = ips_cmd_dispatch(pcctx, IPS_OPCMD_CONFIG, &payload, sizeof(ips_pl_config_t), &ack);
if (ret != SPK_SUCCESS) {
IPS_LOGFATAL(epid, "failed to config channel: pc=%d, ret=%d", pc_id, ret);
goto out;
}
IPS_LOGNOTICE(epid, "channel config done: pc=%d", pc_id);
ret = SPK_SUCCESS;
out:
return(ret);
}
ssize_t cmi_intf_read_msg(cmi_intf_t* intf, void* buf, size_t buf_size)
{
ssize_t size = 0;
if (!cmi_intf_is_connected(intf)) {
return(SPKERR_BADSEQ);
}
switch(intf->intf_type) {
case cmi_intf_tcp:
size = cmi_tcp_read_msg(intf->conn_sockfd,
&intf->endian_cur,
buf,
buf_size);
break;
case cmi_intf_udp:
size = cmi_udp_read_msg(intf->conn_sockfd,
&intf->endian_cur,
buf,
buf_size,
(struct sockaddr *)&intf->conn_addr);
break;
default:
assert(0);
break;
}
if (size == 0) {
// no data
} else if (size < 0) {
// error
zlog_error(cmi_zc, "failed to recv/read: sock=%d, ret=%ld, errmsg=\'%s\'",
intf->conn_sockfd, size, strerror(errno));
size = SPKERR_RESETSYS;
} else {
// got a packet
zlog_info(cmi_zc, "got packet: size=%zu", size);
if (!cmi_msg_is_valid(buf, size)) {
zlog_error(cmi_zc, "got illegal message");
cmi_msg_dump(ZLOG_LEVEL_ERROR, buf, size);
size = 0;
}
}
return(size);
}
int ips_chan_start(ips_pcctx_t* pcctx, SPK_DIR dir)
{
IPS_EPID epid = IPS_GET_MYEPID(pcctx);
int pc_id = pcctx->pc_id;
int mode = IPS_EPID_2_MODE(epid);
ips_mailbox_t ack;
int ret = -1;
if (mode != IPS_EPMODE_MASTER) {
zlog_error(ips_zc, " unexpected sequence: phase=%s", ips_desc_phase2str(pcctx->phase));
ret = SPKERR_BADSEQ;
goto out;
}
assert(dir == SPK_DIR_READ || dir == SPK_DIR_WRITE);
if (pcctx->phase != IPS_PHASE_IDLE) {
zlog_error(ips_zc, " unexpected sequence: phase=%s", ips_desc_phase2str(pcctx->phase));
ret = SPKERR_BADSEQ;
goto out;
}
// start DX
if (dir == SPK_DIR_READ) {
ips_chan_shift_phase(pcctx, IPS_PHASE_RX);
} else {
ips_chan_shift_phase(pcctx, IPS_PHASE_TX);
}
pcctx->dir = dir;
IPS_LOGNOTICE(epid, "start data transfer: pc=%d", pc_id);
// construct PKT_CMD_START
ips_pl_start_t payload;
memset(&payload, 0, sizeof(ips_pl_start_t));
payload.dir = dir;
ret = ips_cmd_dispatch(pcctx, IPS_OPCMD_START, &payload, sizeof(ips_pl_start_t), &ack);
if (ret != SPK_SUCCESS) {
IPS_LOGFATAL(epid, "start data transfer failed: pc_id=%d, ret=%d", pc_id, ret);
goto out;
}
IPS_LOGNOTICE(epid, "data transfer started: pc=%d", pc_id);
ret = SPK_SUCCESS;
out:
return(ret);
}
/* Architecture note: For the time being (as of early 2014, at least),
* we're using libuv to handle asynchronous I/O stuff. It would be
* lovely if we could "embed" libuv's event loop in the yield logic.
* Unfortunately, libuv embedding is not totally solidified yet. So
* we're going to have a separate thread for running the I/O event
* loop. Eventually we should be able to get rid of that.
*
* ... On the other hand, having a separate thread for the event loop
* means that we can do the heartbeat timer there and not have to worry
* about signal handling junk. Seems like that might be a nicer way to
* go for many systems. In the long term, probably should support
* both. */
int main( int argc, char **argv, char **env )
{
/* Okay to stack-allocate these here because the I/O thread should
* always be the last thing running in a Charcoal process.
* TODO: Document why we need these for the I/O thread */
int rc;
if( ( rc = zlog_init( zlog_config_full_filename ) ) )
{
return -1;
}
if( !( crcl(c) = zlog_get_category( "main_cat" ) ) )
{
zlog_error( crcl(c), "Failure: Missing logging category\n" );
zlog_fini();
return -2;
}
__argc = argc;
__argv = argv;
__env = env;
if( ( rc = crcl(init_io_loop)( start_application_main ) ) )
{
zlog_error( crcl(c), "Failure: Initialization of the I/O loop: %d\n", rc );
return rc;
}
if( ( rc = uv_run( crcl(evt_loop), UV_RUN_DEFAULT ) ) )
{
zlog_error( crcl(c), "Failure: Running the I/O loop: %d", rc );
return rc;
}
zlog_info( crcl(c), "switch cnt: %ld", crcl(switch_cnt) );
zlog_info( crcl(c), "Charcoal application finished. Exit code: %d",
crcl(process_exit_code) );
zlog_fini();
return crcl(process_exit_code);
}
static int redis_connect_timeout(void)
{
redis_server_info * server = &g_server;
redisReply * reply = NULL;
server->conn = redisConnectWithTimeout(server->server_addr, server->server_port, server->timeout);
if (server->conn->err) {
zlog_error(logger, "connect to redis server[%s:%d] failed: %s",
server->server_addr, server->server_port, server->conn->errstr);
redisFree(server->conn);
server->conn = NULL;
return -1;
}
reply = redisCommand(server->conn, "SELECT %d", server->db_choice);
freeReplyObject(reply);
return 0;
}
int atlas_mgmt_fifo_tx(char* odat, int dsz) {
int rrv = 0;
ATLS_FENTER();
ATLS_ASSERT_NULLPTR(odat,-1);
ATLS_ASSERT_NONPOS(dsz,-1);
if(mgmt_fifo_out.status == STATUS_READY) {
if((rrv = write(mgmt_fifo_out.fifoHandle,odat,dsz)) == 0) {
zlog_error("atlas_mgmt_fifo_tx(): Failed to write %i bytes to management FIFO!\n",dsz);
return -1;
}
return rrv;
}
ATLS_FLEAVE();
return -1;
}
int dfv_repo_delete(struct dfv_repo* repo, int slot_id)
{
dfv_fmeta_t* fmeta = dfv_fmeta_get(repo, slot_id);
dfv_rmeta_t* rmeta = dfv_rmeta_get(repo);
if (!fmeta) {
return(SPKERR_EACCESS);
}
pthread_mutex_lock(&fmeta->open_cnt_lock);
if (fmeta->open_cnt > 0) {
zlog_error(dfv_zc, "file busy: id=%d, slot=%d, open_cnt=%d",
repo->repo_id, slot_id, fmeta->open_cnt);
pthread_mutex_unlock(&fmeta->open_cnt_lock);
return(SPKERR_EAGAIN);
}
char pathname[SPK_MAX_PATHNAME];
#if 1
int i;
char mnt_path[SPK_MAX_PATHNAME];
strcpy(mnt_path, repo->mnt_path);
for (i=0; i<fmeta->slice_num; i++) {
sprintf(pathname, " rm /%s/%s/%s/%d -Rf", DFV_PREFIX_PATH, mnt_path, DFV_POSTFIX_PATH, slot_id);
spk_os_exec(pathname);
mnt_path[2]++;
}
#else
sprintf(pathname, "rm %s/%d -Rf", repo->root_path, slot_id);
spk_os_exec(pathname);
#endif
rmeta->fmeta_tbl[slot_id] = NULL;
pthread_mutex_unlock(&fmeta->open_cnt_lock);
SAFE_RELEASE(fmeta);
zlog_notice(dfv_zc, "file deleted: id=%d, slot=%d", repo->repo_id, slot_id);
return(SPK_SUCCESS);
}
int dfv_repo_format_common(dfv_repo_t* repo)
{
char cmd[SPK_MAX_PATHNAME];
#if 0
int ret;
assert(repo);
sprintf(cmd, "rm %s -Rf", repo->root_path);
ret = spk_os_exec(cmd);
ret = mkdir(repo->root_path, 0666);
if (ret) {
zlog_error(dfv_zc, "failed to create repo dir: path=%s, errmsg=\'%s\'\n",
repo->root_path, strerror(errno));
return(SPKERR_BADRES);
}
#else
int i;
char mnt_path[SPK_MAX_PATHNAME];
strcpy(mnt_path, repo->mnt_path);
for (i=0; i<repo->dev_num; i++) {
sprintf(cmd, "rm /%s/%s/%s/* -Rf", DFV_PREFIX_PATH, mnt_path, DFV_POSTFIX_PATH);
// sprintf(cmd, "rm %s/"DFV_SLICE_FILEPATH"/* -Rf", repo->root_path, i+1);
mnt_path[2]++;
spk_os_exec(cmd);
}
#endif
dfv_rmeta_reset(&repo->rmeta);
dfv_rmeta_save(&repo->rmeta, repo->meta_path);
zlog_notice(dfv_zc, "repo formatted (common): id=%d, root=%s",
repo->repo_id, repo->root_path);
return(SPK_SUCCESS);
}
void* CoapClient(void* parg)
{
socklen_t sin_size;
struct sockaddr_in addr_remote;
uint16_t message_id_counter;
ssize_t bytes_sent;
ssize_t bytes_recv;
uint8_t msg_buf[MSG_BUF_LEN];
int msg_len;
int fifo_fd;
char fifo[64] = {'\0'};
struct timeval timeout;
timeout.tv_sec = 3;
timeout.tv_usec = 0;
coapIP *ipdata = (coapIP *)parg;
//注册信号
(void)signal(COAP_CLOSE_SIGNAL, Close_Sig);
(void)signal(FIFO_CREATE_SIGNAL, Fifo_Create_Sig);
// CoAP Message Setup
uint8_t msg_send_buf[MSG_BUF_LEN];
coap_pdu msg_send = {msg_send_buf, 0, MSG_BUF_LEN};
uint8_t msg_recv_buf[MSG_BUF_LEN];
coap_pdu msg_recv = {msg_recv_buf, 0, MSG_BUF_LEN};
srand(time(NULL));
message_id_counter = rand();
//创建套接字
if( (ipdata->coapSocket = socket(AF_INET, SOCK_DGRAM, 0))==-1 )
{
zlog_error(zc, "create socket error!");
exit(-1);
}
addr_remote.sin_family = AF_INET;
addr_remote.sin_port = htons(COAP_PORT);
addr_remote.sin_addr.s_addr = inet_addr( ipdata->ip );
memset(addr_remote.sin_zero, 0, 8);
zlog_debug(zc, "coap client socket is %d, ip is %s,path is %s", ipdata->coapSocket, ipdata->ip, ipdata->path);
//设置接收超时
setsockopt(ipdata->coapSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(struct timeval));
GetfifoName( fifo, sizeof(fifo), getpid() );
//等待fifo创建好的信号
//pause();
//以只读方式打开FIFO，返回文件描述符fd
fifo_fd = open(fifo,O_RDONLY);
if( fifo_fd == -1 )
{
printf("Open fifo error!\n");
exit(1);
}
printf("coap client %d open fifo %s\r\n", getpid(), fifo);
while(1)
{
//清空缓存
memset(msg_send.buf, '\0', MSG_BUF_LEN);
msg_send.len = 0;
//从管道读数据
msg_len = read(fifo_fd, msg_buf, MSG_BUF_LEN);
//printf("fifo read is %s", msg_buf);
// Build Message
coap_init_pdu(&msg_send);
coap_set_version(&msg_send, COAP_V1);
coap_set_type(&msg_send, CT_CON);
coap_set_code(&msg_send, CC_GET); // or POST to write
coap_set_mid(&msg_send, message_id_counter++);
coap_set_token(&msg_send, rand(), 2);
coap_add_option(&msg_send, CON_URI_PATH, (uint8_t*)ipdata->path, strlen(ipdata->path));
// to write, set payload:
coap_set_payload( &msg_send, (uint8_t *)msg_buf, msg_len );
// Send Message
if ( (bytes_sent = sendto(ipdata->coapSocket, msg_send.buf, msg_send.len, 0,
(struct sockaddr*)&addr_remote, sizeof(struct sockaddr_in))) == -1 )
zlog_error(zc, "Failed to Send Message!");
else
{
//发送成功
//printf("Sent.\n");
//coap_pretty_print(&msg_send);
sin_size = sizeof(struct sockaddr);
// Wait for Response
bytes_recv = recvfrom(ipdata->coapSocket, (void *)msg_recv.buf, msg_recv.max, 0, (struct sockaddr*)&addr_remote, &sin_size);
if (bytes_recv < 0)
{
zlog_error(zc, "Failed to socket recv Message!");
continue;
}
/*
msg_recv.len = bytes_recv;
if(coap_validate_pkt(&msg_recv) == CE_NONE)
{
printf("Got Valid CoAP Packet\n");
if(coap_get_mid(&msg_recv) == coap_get_mid(&msg_send) && coap_get_token(&msg_recv) == coap_get_token(&msg_send))
{
printf("Is Response to Last Message\n");
coap_pretty_print(&msg_recv);
}
}
else
{
printf("Received %zi Bytes, Not Valid CoAP\n", msg_recv.len);
hex_dump(msg_recv.buf, msg_recv.len);
}
*/
}
}
}
static int update_serial_task_info(const char * task_info)
{
retransmit_info * info = NULL;
info = calloc(1, sizeof(retransmit_info));
if (info == NULL) {
zlog_error(logger, "memory allocated failed");
return FAIL;
}
cJSON * root = NULL;
cJSON * inner = NULL;
root = cJSON_Parse(task_info);
if (root == NULL) {
zlog_error(logger, "json string parse failed");
return FAIL;
}
char num[3];
int size;
if ((size = cJSON_GetArraySize(root)) == 2) {
memset(num, '\0', sizeof(num));
int i = 1;
snprintf(num, sizeof(num), "%d", i);
cJSON * inner;
inner = cJSON_GetObjectItem(root, num);
if (inner == NULL) {
zlog_error(logger, "json string parse failed");
return FAIL;
}
if (cJSON_GetObjectItem(inner, "dst_node") == NULL) {
zlog_error(logger, "fetch dst_node failed\n");
cJSON_Delete(root);
free(info);
return FAIL;
}
info->dst_addr = strdup(cJSON_GetObjectItem(inner, "dst_node")->valuestring);
}
redis_server_info * server = &g_server;
int ret = 0;
if (server->conn == NULL) {
ret = redis_connect_timeout();
if (ret < 0) {
return -1;
}
}
char new_time[32];
memset(new_time, '\0', sizeof(new_time));
info->create_time = time(NULL);
sprintf(new_time, "%ld", info->create_time);
redisReply * reply;
reply = redisCommand(server->conn, "select 1");
freeReplyObject(reply);
reply = redisCommand(server->conn, "LPUSH %s %s", new_time, task_info);
freeReplyObject(reply);
reply = redisCommand(server->conn, "SET %s %s", info->dst_addr, new_time);
zlog_debug(logger, "LPUSH %s %s", new_time, task_info);
zlog_debug(logger, "[REDIS COMMAND] SET %s %s", info->dst_addr, new_time);
freeReplyObject(reply);
reply = redisCommand(server->conn, "select 0");
freeReplyObject(reply);
cJSON_Delete(root);
cJSON_Delete(inner);
free(info->dst_addr);
free(info);
return OK;
}
int cmi_intf_write_flist(cmi_intf_t* intf, cmi_data_filelist_t* dfl,
uint32_t req_frag)
{
ssize_t written;
cmi_data_t msg_data;
int ret = -1;
if (req_frag == (uint32_t)-1) {
// fast mode
size_t xferred = 0;
int frag_id = 0;
while(xferred < sizeof(cmi_data_filelist_t)) {
size_t xfer_sz = MIN(CMI_MAX_FRAGSIZE,
sizeof(cmi_data_filelist_t) - xferred);
int is_eof = (xferred+xfer_sz == sizeof(cmi_data_filelist_t));
cmi_msg_build_datafrag(&msg_data,
data_type_flist,
((char*)dfl)+xferred,
xfer_sz,
frag_id++,
is_eof);
written = cmi_intf_write_msg(intf,
&msg_data,
sizeof(cmi_data_t));
if (written != sizeof(cmi_data_t)) {
ret = SPKERR_RESETSYS;
goto out;
}
xferred += xfer_sz;
}
zlog_notice(cmi_zc, "flist sent: mode=fast, written=%ld", xferred);
ret = SPK_SUCCESS;
} else {
// slow mode
uint64_t frag_start = (uint64_t)req_frag * CMI_MAX_FRAGSIZE;
uint64_t frag_end = frag_start + CMI_MAX_FRAGSIZE;
if (frag_start >= sizeof(cmi_data_filelist_t)) {
zlog_warn(cmi_zc, "invalid req_frag: req_frag = %u", req_frag);
ret = SPKERR_PARAM;
goto out;
}
frag_end = MIN(frag_end, sizeof(cmi_data_filelist_t));
int is_eof = (frag_end == sizeof(cmi_data_filelist_t));
cmi_msg_build_datafrag(&msg_data,
data_type_flist,
((char*)dfl)+frag_start,
frag_end - frag_start,
req_frag,
is_eof);
written = cmi_intf_write_msg(intf,
&msg_data,
sizeof(cmi_data_t));
if (written != sizeof(cmi_data_t)) {
ret = SPKERR_RESETSYS;
goto out;
}
if (is_eof) {
zlog_notice(cmi_zc, "flist sent: mode=slow, written=%ld",
frag_end - frag_start);
}
ret = SPK_SUCCESS;
}
out:
if (ret != SPK_SUCCESS) {
zlog_error(cmi_zc, "failed to sent flist: ret=%d", ret);
}
return(ret);
}
int load_redis_task(const char * time_str, struct ae_event_loop * ev_loop)
{
redis_server_info * server = &g_server;
int ret = 0;
if (server->conn == NULL) {
ret = redis_connect_timeout();
if (ret < 0) {
zlog_error(logger, "redis connect failed");
return -1;
}
}
redisReply * reply;
reply = redisCommand(server->conn, "LRANGE %s 0 -1", time_str);
if (reply == NULL) {
zlog_error(logger, "No elements with 'LRANGE %s 0 -1'", time_str);
redisFree(server->conn);
server->conn = NULL;
return -1;
}
if (reply->type == REDIS_REPLY_NIL) {
zlog_error(logger, "No elements with 'LRANGE %s 0 -1'", time_str);
freeReplyObject(reply);
return -1;
}
int cnt = reply->elements;
if (cnt == 0) {
zlog_error(logger, "No elements with 'LRANGE %s 0 -1'", time_str);
freeReplyObject(reply);
return -1;
}
int j; char buf[2048];
cJSON * root = NULL;
cJSON * type_field = NULL;
int task_type;
for (j = 0; j < cnt; j++) {
memset(buf, '\0', sizeof(buf));
if (reply->element[j]->str == NULL)
continue;
strcpy(buf, reply->element[j]->str);
zlog_debug(logger, "[NEW_TASK_INFO] %s", buf);
root = cJSON_Parse(buf);
if (root == NULL) {
zlog_error(logger, "cJSON_Parse failed");
continue;
}
int size;
if((size = cJSON_GetArraySize(root)) > 2) {
type_field = cJSON_GetObjectItem(root, "task_type");
if (type_field == NULL) {
zlog_error(logger, "[%s] cJSON_GetObjectItem of task_type failed", buf);
continue;
}
task_type = type_field->valueint;
if (task_type == FETCH_CFG)
execute_retransmit_task(buf, ev_loop);
else if(task_type == AUTO_OPTIMIZE)
execute_retransmit_task(buf, ev_loop);
else if(task_type == SINGLE_AUDIT)
execute_single_audit_task(buf, ev_loop);
} else if(size == 2) {
char num[3];
int i;
for(i = 1; i <= size; i++) {
memset(num, '\0', sizeof(num));
snprintf(num, sizeof(num), "%d", i);
cJSON * inner;
inner = cJSON_GetObjectItem(root, num);
type_field = cJSON_GetObjectItem(inner, "task_type");
if (type_field == NULL) {
zlog_error(logger, "[%s] cJSON_GetObjectItem of task_type failed", buf);
continue;
}
task_type = type_field->valueint;
char * ptr;
ptr = cJSON_PrintUnformatted(inner);
if (ptr != NULL) {
zlog_info(logger, "[SPLIT TASK] %s", ptr);
if (task_type == FETCH_CFG)
execute_retransmit_task(ptr, ev_loop);
else if(task_type == AUTO_OPTIMIZE)
execute_retransmit_task(ptr, ev_loop);
else if(task_type == SINGLE_AUDIT)
execute_single_audit_task(ptr, ev_loop);
free(ptr);
}
sleep(3);
}
update_serial_task_info(buf);
}
cJSON_Delete(root);
}
freeReplyObject(reply);
reply = redisCommand(server->conn, "DEL %s", time_str);
freeReplyObject(reply);
return 0;
}
void hustlog_write_error(zlog_category_t * category, const char * data)
{
zlog_error(category, "%s", data);
}
static int sys_func_dl_prepare(int slot_id, uint64_t blk_start, uint64_t blk_num, uint32_t req_frag)
{
int ret;
sys_ctx_t* ctx = &sys_ctx;
int repo_num = ctx->vault->repo_num;
size_t cache_sz = SYS_CACHE_SIZE;
int i, j;
int interlace_sz = SYS_INTERLACE_SIZE;
sys_cache_t* file_cache = ctx->file_cache;
assert(file_cache);
assert(file_cache->data);
// get slot_sz
ssize_t slot_sz;
if (file_cache->slot_id == slot_id ) {
slot_sz = file_cache->slot_sz;
} else {
slot_sz = dfv_vault_get_slotsize(ctx->vault, slot_id);
if (slot_sz < 0) {
zlog_error(sys_zc, "bad file size: slot_id=%d", slot_id);
return(SPKERR_BADRES);
}
}
// request region
uint64_t req_start = blk_start * SYS_CACHE_SIZE;
uint64_t req_end = (blk_num>0)?(req_start + blk_num * SYS_CACHE_SIZE):slot_sz;
// frag region
uint64_t frag_start = req_start + (uint64_t)req_frag * CMI_MAX_FRAGSIZE;
uint64_t frag_end = frag_start + CMI_MAX_FRAGSIZE;
// check if region is valid
if (frag_start > slot_sz) {
zlog_error(sys_zc, "illegal frag_start: slot_id=%d, slot_sz=%zu, "
"frag_start=%lu, req_frag=%u",
slot_id, slot_sz, frag_start, req_frag);
return(SPKERR_PARAM);
}
if (frag_end > slot_sz) {
zlog_warn(sys_zc, "truncate frag: slot_id=%d, slot_sz=%zu, "
"frag=%lu+%lu",
slot_id, slot_sz, frag_start, frag_end);
frag_end = slot_sz;
}
// check cache hit
int cache_hit = 0;
do {
if (file_cache->slot_id != slot_id) {
// slot not match
break;
}
if (frag_start < file_cache->offset ||
frag_end > file_cache->offset + file_cache->len) {
break;
}
cache_hit = 1;
} while(0);
if (cache_hit) {
return(SPK_SUCCESS);
}
// do caching
cache_sz = MIN(SYS_CACHE_SIZE, slot_sz - frag_start);
size_t cache_sz_repo = cache_sz / repo_num;
zlog_notice(sys_zc, "cache file: slot_id=%d, slot_sz=%zu, req_frag=%u, "
"req=%lu+%lu, frag=%lu+%lu, cache_sz=%zu, blk=%lu+%lu",
slot_id, slot_sz, req_frag,
req_start, req_end-req_start,
frag_start, frag_end-frag_start,
cache_sz, blk_start, blk_num);
struct dfv_file* file_ctx = NULL;
void* file_buffer = memalign(SYS_INTERLACE_SIZE, cache_sz_repo);
for (i=0; i<repo_num; i++) {
struct dfv_repo * repo = ctx->vault->repo_tbl[i];
assert(repo);
file_ctx = dfv_file_open(repo, slot_id, SPK_DIR_READ, NULL, 12+4*i);
if (!file_ctx) {
ret = SPKERR_BADRES;
goto out;
}
ret = dfv_file_seek(file_ctx, frag_start / repo_num);
if (ret) {
goto out;
}
ssize_t read_sz = dfv_file_read(file_ctx, file_buffer, cache_sz_repo);
if (read_sz != cache_sz_repo) {
ret = SPKERR_BADRES;
goto out;
}
dfv_file_close(file_ctx);
file_ctx = NULL;
// do interlace while copy data
for (j=0; j<cache_sz_repo/interlace_sz; j++) {
memcpy(file_cache->data+(j*repo_num+i)*interlace_sz,
file_buffer+j*interlace_sz,
interlace_sz);
}
}
// cache done
file_cache->slot_id = slot_id;
file_cache->offset = frag_start;
file_cache->len = cache_sz;
file_cache->slot_sz = slot_sz;
zlog_notice(sys_zc, "cache done: slot_id=%d, slot_sz=%lu, cache=%lu+%lu",
slot_id, slot_sz, file_cache->offset,
file_cache->len);
ret = SPK_SUCCESS;
out:
if (file_ctx) {
dfv_file_close(file_ctx);
file_ctx = NULL;
}
SAFE_RELEASE(file_buffer);
return(ret);
}
static int __sys_job_do_playback(sys_wkr_ctx_t* wkr_ctx,
IPS_EPID src_id, int pc_id, size_t ips_sec_sz,
dfv_slot_def_t* slot_def, uint64_t slot_sz)
{
int ret = -1;
#ifdef ARCH_ppc64
struct ips_pcctx* pcctx = NULL;
int wkr_id = wkr_ctx->wkr_id;
spk_stats_t* stats = &wkr_ctx->stats;
struct dfvcm_ctx* dfvcm = NULL;
void * txbuf = NULL;
size_t txbuf_sz = 0;
int i;
int dfv_cpu_base = 12+4*wkr_ctx->wkr_id;
zlog_notice(sys_zc, "wkr#%d> prepare for playback: ips={0x%x:%d}, "
"dfv={repo={%d:%d}, sz=%lu, cpu_base=%d}",
wkr_id,
src_id, pc_id,
dfv_repo_get_id(slot_def->repo), slot_def->slot_id,
slot_sz, dfv_cpu_base);
// reset stats
spk_stats_reset(stats);
// open ips srio
pcctx = ips_chan_open(src_id, pc_id);
if (!pcctx) {
zlog_fatal(sys_zc, "wkr#%d> failed to open ips channel", wkr_id);
ret = SPKERR_EACCESS;
goto out;
}
ret = ips_chan_start(pcctx, SPK_DIR_WRITE);
if (ret != SPK_SUCCESS) {
zlog_fatal(sys_zc, "wkr#%d> failed to start ips channel", wkr_id);
goto out;
}
zlog_info(sys_zc, "wkr#%d> ips channel started for writing", wkr_id);
// clean stats
if (!(sys_env.features & SYSFEA_USE_LOCALSTATS)) {
stats = ips_chan_get_stats(pcctx);
}
int dfvcm_buf_nodes = DFVCM_BUF_NODE_NUM;//
// we use ips's tx_buffers directly (for zero-copy)
// scratch bufs from ips
txbuf = ips_chan_get_txbuf(pcctx, &txbuf_sz);
// WARNING: IPS must allocated enough tx_buffer, so check it
assert(txbuf && txbuf_sz >= dfvcm_buf_nodes*DFV_CHUNK_SIZE);
// open dfv cache manager for read
dfvcm = dfvcm_open(wkr_id, slot_def, SPK_DIR_READ, NULL, dfv_cpu_base);
assert(dfvcm);
dfv_bufq_node_t *local_node[DFVCM_BUF_NODE_NUM];
for (i=0; i<dfvcm_buf_nodes; i++) {
// initialize buf nodes
local_node[i] = malloc(sizeof(dfv_bufq_node_t));
assert(local_node[i]);
memset(local_node[i], 0, sizeof(dfv_bufq_node_t));
// points to txbuf
local_node[i]->buf_ptr = txbuf + i*DFV_CHUNK_SIZE;
local_node[i]->buf_sz = DFV_CHUNK_SIZE;
// enqueue to dfvcm's freeq
// dfvcm will start reading immediatly
dfv_bufq_enqueue(dfvcm_get_freeq(dfvcm), local_node[i]);
zlog_notice(sys_zc, "wkr#%d> enqueue node to dfvcm: buf={%p+%zu}",
wkr_id, local_node[i]->buf_ptr, local_node[i]->buf_sz);
}
// start playback
zlog_notice(sys_zc, "wkr#%d> ---------- start playback ----------", wkr_id);
uint64_t now = spk_get_tick_count();
uint64_t tm_log = now;
ret = SPK_SUCCESS;
uint64_t use_buf_num = 0;
int current_buf_num = DFVCM_BUF_NODE_NUM;
int dfv_status = 0;
while(!wkr_ctx->reset_req) {
// dequeue buffers from dfvcm
if (dfvcm_get_eof(dfvcm)) {
dfv_status=1;
}
dfv_bufq_node_t* node = dfv_bufq_dequeue(dfvcm_get_workq(dfvcm));
if (syslk_ips_mode.dma_use_chain) {
if(current_buf_num <= (DFVCM_BUF_NODE_NUM/2)) {
int free_buf_num = ips_chan_get_tx_freebn(pcctx, DFV_CHUNK_SIZE);
if(free_buf_num > 0) {
for(i=0; i<free_buf_num; i++) {
int index = (use_buf_num % (DFVCM_BUF_NODE_NUM));
dfv_bufq_enqueue(dfvcm_get_freeq(dfvcm), local_node[index]);
use_buf_num++;
current_buf_num++;
}
}
}
}
if (!node) {
if (dfvcm_get_eof(dfvcm) && (dfv_status)) {
break;
}
continue;
}
// got one node
assert(node->valid_sz);
// write to ips
uint64_t tmout = spk_get_tick_count() + 5*1000; // timeout 5secs
while(!wkr_ctx->reset_req) {
ssize_t xfer = ips_chan_write(pcctx, node->buf_ptr, node->valid_sz);
if (xfer == node->valid_sz) {
// done
if (!syslk_ips_mode.dma_use_chain) {
spk_stats_inc_xfer(stats, node->valid_sz, 1);
// recycle buffer to dfvcm
dfv_bufq_enqueue(dfvcm_get_freeq(dfvcm), node);
} else {
spk_stats_inc_xfer(stats,node->valid_sz, 1);
current_buf_num--;;
}
break;
}
if (xfer != 0) {
zlog_error(sys_zc, "wkr#%d> failed to write to ips: xfer=%ld, expect=%ld",
wkr_id, xfer, node->valid_sz);
ret = SPKERR_EACCESS;
goto out;
}
// nothing written
spk_stats_inc_drop(stats, 0, 1); // just recored retried times
if (spk_get_tick_count() > tmout) {
// timeout
zlog_error(sys_zc, "wkr#%d> write to ips timeout: xfer=%ld, expect=%ld",
wkr_id, xfer, node->valid_sz);
ret = SPKERR_EACCESS;
goto out;
}
usleep(100);
};
now = spk_get_tick_count();
if (now > tm_log) {
zlog_notice(sys_zc, " wkr#%d> time=%lu pkts=%lu bytes=%lu spd:%.3f MBPS retried=%lu",
wkr_id,
spk_stats_get_time_elapsed(stats)/1000,
spk_stats_get_xfer_pkts(stats),
spk_stats_get_xfer_bytes(stats),
BYTE2MB(spk_stats_get_bps_overall(stats)),
spk_stats_get_drop_pkts(stats));
tm_log = now + 10*1000;
}
}
if (wkr_ctx->reset_req || dfvcm_get_eof(dfvcm) > 0)
ret = SPK_SUCCESS;
else
ret = dfvcm_get_eof(dfvcm);
out:
zlog_notice(sys_zc, "wkr#%d> ---------- stop playback ---------- ret=%d", wkr_id, ret);
if (stats) {
zlog_notice(sys_zc, "wkr#%d> elapsed=%lu, pkts=%lu, bytes=%lu, retried=%lu",
wkr_id, spk_stats_get_time_elapsed(stats)/1000,
stats->xfer.pkts, stats->xfer.bytes, stats->drop.bytes);
}
// close dfv cache manager
if (dfvcm) {
dfvcm_close(dfvcm, 0);
dfvcm = NULL;
}
// close ips srio
if (pcctx) {
ips_chan_close(pcctx);
pcctx = NULL;
}
#endif
return(ret);
}
int frz_gfx_bind_glext() {
char lastext[64];
char arbfunc[64];
int lastext_found = 0;
int load_ok = 0;
int loaded_good = 0;
int loaded_fail = 0;
lastext[0] = 0;
// iterate through ogl_extmap and map functions while checking for availability
for(int i = 0; i < 1024; i++) {
if(!ogl_extmap[i].extname[0]) break;
if(!strcmp(lastext, ogl_extmap[i].extname) && lastext_found) {
load_ok = 1;
} else {
lastext_found = frz_gfx_check_ext(ogl_extmap[i].extname);
strcpy(lastext, ogl_extmap[i].extname);
if(!lastext_found) {
load_ok = 0;
ogl_extmap[i].reqs |= FRZX_NG;
if(ogl_extmap[i].reqs & FRZX_REQD) {
zlog_error("frz_gfx_bind_glext: [%s] Required extension not available!\n",ogl_extmap[i].extname);
} else {
zlog_error("frz_gfx_bind_glext: [%s] Extension not available (optional)\n",ogl_extmap[i].extname);
}
} else {
load_ok = 1;
}
}
// First attempt
if(load_ok && ogl_extmap[i].funcname[0]) {
// map vector to appropriate func pointer
if(((*ogl_extmap[i].funcvec) = (void*)OGLX_GetProcAddress((GLubyte*)ogl_extmap[i].funcname)) == NULL) {
zlog_error("frz_gfx_bind_glext: OGLX_GetProcAddress() failed to retrieve function vector for %s()!\n",ogl_extmap[i].funcname);
load_ok = 2;
}
}
// Second attempt, ARB functions
if(load_ok == 2 && ogl_extmap[i].reqs & FRZX_ARB) {
// Try appending "ARB" to function name for older OGL implementations
sprintf(arbfunc,"%sARB",ogl_extmap[i].funcname);
zlog_error("frz_gfx_bind_glext: Attempting to bind to %s() instead...\n",arbfunc);
if(((*ogl_extmap[i].funcvec) = (void*)OGLX_GetProcAddress((GLubyte*)arbfunc)) == NULL) {
zlog_error("frz_gfx_bind_glext: OGLX_GetProcAddress() failed to retrieve function vector for %s()!\n",arbfunc);
load_ok = 0;
} else {
// If that works, then modify funcname with ARB suffix
strcpy(ogl_extmap[i].funcname,arbfunc);
load_ok = 1;
}
}
if(load_ok == 1 && !ogl_extmap[i].funcname[0]) {
ogl_extmap[i].reqs |= FRZX_LOADED;
zlog_debug("frz_gfx_bind_glext: [%s] Extension supported!\n",ogl_extmap[i].extname);
} else if(load_ok == 1) {
ogl_extmap[i].reqs |= FRZX_LOADED;
zlog_debug("frz_gfx_bind_glext: [%s] %s() hooked func vec OK!\n",ogl_extmap[i].extname,ogl_extmap[i].funcname);
loaded_good++;
} else {
ogl_extmap[i].reqs |= FRZX_NG;
loaded_fail++;
}
}
zlog_debug("frz_gfx_bind_glext: Bound to %i functions successfully! (%i failed)\n",loaded_good,loaded_fail);
return loaded_good;
}
int frz_gfx_init(int ctx) {
int rval;
if(rval = frz_subsys_init_display(ctx)) {
zlog_error("frz_gfx_init: Failed to initialize graphics subsystem! frz_subsys_init_display() failed with %i rval.\n",rval);
return 1;
}
// Renderer info
zlog_info("*** Rendering subsystem information **\n"
" Renderer : %s\n"
" Vendor : %s\n"
" OpenGL Version : %s\n"
,glGetString(GL_RENDERER),glGetString(GL_VENDOR),glGetString(GL_VERSION)
);
// OGL Extension caps
char* ext_ptr;
int ext_strlen;
if((ext_ptr = strdup((char*)glGetString(GL_EXTENSIONS))) == NULL) {
zlog_error("frz_gfx_init: Failed to retrieve GL_EXTENSIONS descriptor!\n");
return 1;
}
ext_strlen = strlen(ext_ptr);
ogl_ext_sz = 0;
int cz = 0;
// Explode into array
for(int z = 0; z < ext_strlen; z++) {
if(ext_ptr[z] == ' ' || ext_ptr[z] == '\n') {
ogl_ext_list[ogl_ext_sz][cz] = 0;
cz = 0;
ogl_ext_sz++;
} else {
ogl_ext_list[ogl_ext_sz][cz] = ext_ptr[z];
cz++;
}
}
// GLX Extension caps
// frz_subsys_enum_oglext()
char* glx_ext_ptr;
int glx_ext_strlen;
if((glx_ext_ptr = strdup(frz_subsys_enum_oglext(ctx))) == NULL) {
zlog_error("frz_gfx_init: glXQueryExtensionsString() failed!\n");
return 1;
}
glx_ext_strlen = strlen(glx_ext_ptr);
cz = 0;
// Explode into array - continue where OGL extensions left off
for(int z = 0; z < glx_ext_strlen; z++) {
if(glx_ext_ptr[z] == ' ' || glx_ext_ptr[z] == '\n') {
ogl_ext_list[ogl_ext_sz][cz] = 0;
cz = 0;
ogl_ext_sz++;
} else {
ogl_ext_list[ogl_ext_sz][cz] = glx_ext_ptr[z];
cz++;
}
}
// Echo array to log
zlog_info("** Extensions : %i enumerated.\n",ogl_ext_sz);
for(int z = 0; z < ogl_ext_sz; z++) {
zlog_info("%s\n",ogl_ext_list[z]);
}
// Check for required extensions and bind GLEXT functions
frz_gfx_bind_glext();
// Check number of texture units
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB,&tex_units);
zlog_info("** Texture Units : %i\n",tex_units);
glEnable(GL_DEPTH_TEST);
return 0;
}
int dfv_repo_format_sps(dfv_repo_t* repo)
{
char cmd[SPK_MAX_PATHNAME];
int ret;
#if 1
int i;
char devname[SPK_MAX_PATHNAME];
char pathname[SPK_MAX_PATHNAME];
char mnt_path[SPK_MAX_PATHNAME];
int devlen = 0;
strcpy(devname, repo->dev_path);
devlen = strlen(repo->dev_path);
strcpy(mnt_path, repo->mnt_path);
assert(devlen > 0);
for (i=0; i<repo->dev_num; i++) {
sprintf(cmd, "/dev/%s", devname);
ret = access(cmd, W_OK);
if (!ret) {
sprintf(cmd, "umount /dev/%s", devname);
spk_os_exec(cmd);
sprintf(cmd, "mkfs.ext4 /dev/%s", devname);
spk_os_exec(cmd);
spk_os_exec(pathname);
sprintf(cmd, "mount /dev/%s /%s/%s", mnt_path, DFV_PREFIX_PATH, mnt_path);
mnt_path[2]++;
spk_os_exec(cmd);
}
devname[devlen-1]++;
}
dfv_rmeta_reset(&repo->rmeta);
dfv_rmeta_save(&repo->rmeta, repo->meta_path);
#else
assert(strlen(repo->dev_path) > 0);
ret = access(DFV_SPS_FMTTOOL, X_OK);
if (!ret) {
sprintf(cmd, "/dev/%s", repo->dev_path);
ret = access(cmd, W_OK);
if (!ret) {
sprintf(cmd, "./%s -fy /dev/%s", DFV_SPS_FMTTOOL, repo->dev_path);
spk_os_exec(cmd);
sprintf(cmd, "umount /dev/%s", repo->mnt_path);
spk_os_exec(cmd);
sprintf(cmd, "mkfs.ext4 /dev/%s", repo->mnt_path);
spk_os_exec(cmd);
sprintf(cmd, "mount /dev/%s /%s/%s", repo->mnt_path, DFV_PREFIX_PATH, repo->mnt_path);
spk_os_exec(cmd);
ret = mkdir(repo->root_path, 0666);
if (ret) {
zlog_error(dfv_zc, "failed to create repo: path=%s, errmsg=\'%s\'\n",
repo->root_path, strerror(errno));
return(SPKERR_BADRES);
}
dfv_rmeta_reset(&repo->rmeta);
dfv_rmeta_save(&repo->rmeta, repo->meta_path);
}
}
#endif
zlog_notice(dfv_zc, "repo formatted (SPS): id=%d root=%s",
repo->repo_id, repo->root_path);
return(SPK_SUCCESS);
}
int sys_cmd_exec(cmi_cmd_t* cmd, size_t size)
{
int cmdtype = cmd->cmd_type;
int ret = -1;
zlog_info(sys_zc, "> executing cmd: type=%s", cmi_desc_cmdtype2str(cmdtype));
// pre-exec
switch(cmdtype) {
case cmd_type_start_rec:
ret = sys_cmd_exec_startrec(cmd);
break;
case cmd_type_stop_rec:
ret = sys_cmd_exec_stop(cmd, SYS_MAX_PIPES, sys_state_rec);
break;
case cmd_type_start_play:
ret = sys_cmd_exec_startplay(cmd);
break;
case cmd_type_stop_play:
ret = sys_cmd_exec_stop(cmd, SYS_MAX_PIPES, sys_state_play);
break;
case cmd_type_snapshot:
ret = sys_cmd_exec_snapshot(cmd);
break;
case cmd_type_stop_dl:
ret = sys_cmd_exec_stop(cmd, 1, sys_state_dl);
break;
case cmd_type_start_ul:
ret = sys_cmd_exec_startul(cmd);
break;
case cmd_type_stop_ul:
ret = sys_cmd_exec_stopul(cmd);
break;
case cmd_type_sync_time:
ret = sys_cmd_exec_synctime(cmd);
break;
case cmd_type_delete:
ret = sys_cmd_exec_delete(cmd);
break;
case cmd_type_config:
ret = sys_cmd_exec_config(cmd);
break;
case cmd_type_sysdown:
ret = sys_cmd_exec_sysdown(cmd);
break;
case cmd_type_upgrade:
ret = sys_cmd_exec_upgrade(cmd);
break;
case cmd_type_init:
case cmd_type_filelist:
case cmd_type_inquiry:
case cmd_type_format:
case cmd_type_start_dl:
// nothing to do
ret = SPK_SUCCESS;
break;
default:
assert(0);
break;
}
// send resp
cmi_cmdresp_t cmdresp;
memset(&cmdresp, 0, sizeof(cmi_cmdresp_t));
cmi_msg_build_hdr((cmi_msg_hdr_t*)&cmdresp,
msg_code_cmdresp,
sizeof(cmi_cmdresp_t));
cmdresp.cmd_type = cmd->cmd_type;
if (ret == SPK_SUCCESS) {
cmdresp.success = CMI_CMDEXEC_SUCC;
if (cmd->cmd_type == cmd_type_init) {
cmdresp.u.version.sys_ver = SYS_VERSION_INT;
} else if (cmd->cmd_type == cmd_type_config) {
memcpy(cmdresp.u.all.words, &sys_fpga_stat[0], sizeof(sys_fpga_stat[0]));
}
} else {
zlog_error(sys_zc, "failed to exec cmd: type=%s, ret=%d",
cmi_desc_cmdtype2str(cmd->cmd_type), ret);
cmdresp.success = CMI_CMDEXEC_FAIL;
}
ssize_t written = cmi_intf_write_msg(sys_ctx.cmi_intf,
&cmdresp,
sizeof(cmi_cmdresp_t));
zlog_info(sys_zc, "> cmdresp sent: written=%ld", written);
if (written != sizeof(cmi_cmdresp_t)) {
ret = SPKERR_RESETSYS;
goto out;
}
// post-exec
if (ret == SPK_SUCCESS) {
switch(cmdtype) {
case cmd_type_inquiry:
ret = sys_cmd_send_status(cmd);
break;
case cmd_type_filelist:
ret = sys_cmd_send_filelist(cmd);
break;
case cmd_type_start_dl:
ret = sys_cmd_exec_startdl(cmd);
break;
case cmd_type_snapshot:
ret = sys_cmd_send_snapshot(cmd);
break;
case cmd_type_format:
ret = sys_cmd_exec_format(cmd);
break;
case cmd_type_sysdown:
sys_ctx.sysdown_req = 1;
break;
case cmd_type_init:
case cmd_type_delete:
case cmd_type_sync_time:
case cmd_type_start_rec:
case cmd_type_stop_rec:
case cmd_type_start_play:
case cmd_type_stop_play:
case cmd_type_stop_dl:
case cmd_type_start_ul:
case cmd_type_stop_ul:
case cmd_type_config:
case cmd_type_upgrade:
// nothing to do
break;
default:
assert(0);
break;
}
}
out:
zlog_info(sys_zc, "> cmd executed: type=%s, frag_id=%u, ret=%d",
cmi_desc_cmdtype2str(cmdtype),
cmd->u.all.words[0], ret);
return(ret);
}
static void
gps_insert_to_log_db(gps_client_t *client,
gint longitude, gint latitude, gint altitude, gint speed, gint azimuth)
{
int ret;
sqlite3_stmt *stmt;
GDateTime *now;
gchar *msg;
gboolean update_ok;
zmsg_t *zmsg;
now = g_date_time_new_now_local();
sqlite3_prepare_v2(gps_log_db, "insert into history("
"psn, time, longitude, latitude, altitude, speed, azimuth)"
"values(?, ?, ?, ?, ?, ?, ?)", -1, &stmt, NULL);
sqlite3_bind_int(stmt, 1, client->psn);
sqlite3_bind_int64(stmt, 2, g_date_time_to_unix(now));
sqlite3_bind_int(stmt, 3, longitude);
sqlite3_bind_int(stmt, 4, latitude);
sqlite3_bind_int(stmt, 5, altitude);
sqlite3_bind_int(stmt, 6, speed);
sqlite3_bind_int(stmt, 7, azimuth);
ret = sqlite3_step(stmt);
if (ret != SQLITE_DONE)
{
zlog_error(zc, "insert into history error: %d\n", ret);
}
sqlite3_finalize(stmt);
// 更新 last 表
sqlite3_prepare_v2(gps_log_db, "update last set "
"time = ?, longitude = ?, latitude = ?, "
"altitude = ?, speed = ?, azimuth = ? "
"where (psn = ?)", -1, &stmt, NULL);
sqlite3_bind_int64(stmt, 1, g_date_time_to_unix(now));
sqlite3_bind_int(stmt, 2, longitude);
sqlite3_bind_int(stmt, 3, latitude);
sqlite3_bind_int(stmt, 4, altitude);
sqlite3_bind_int(stmt, 5, speed);
sqlite3_bind_int(stmt, 6, azimuth);
sqlite3_bind_int(stmt, 7, client->psn);
sqlite3_step(stmt);
update_ok = sqlite3_changes(gps_log_db) > 0;
sqlite3_finalize(stmt);
if (!update_ok)
{
sqlite3_prepare_v2(gps_log_db, "insert into last("
"psn, time, longitude, latitude, altitude, speed, azimuth)"
"values(?, ?, ?, ?, ?, ?, ?)", -1, &stmt, NULL);
sqlite3_bind_int(stmt, 1, client->psn);
sqlite3_bind_int64(stmt, 2, g_date_time_to_unix(now));
sqlite3_bind_int(stmt, 3, longitude);
sqlite3_bind_int(stmt, 4, latitude);
sqlite3_bind_int(stmt, 5, altitude);
sqlite3_bind_int(stmt, 6, speed);
sqlite3_bind_int(stmt, 7, azimuth);
ret = sqlite3_step(stmt);
if (ret != SQLITE_DONE)
{
zlog_error(zc, "insert into last error: %d\n", ret);
}
sqlite3_finalize(stmt);
}
msg = g_strdup_printf("{\
\"type\": \"gps\", \
\"time\": \"%d-%02d-%02d %02d:%02d:%02d\", \
\"psn\": %d, \
\"longitude\": %d, \
\"latitude\": %d, \
\"altitude\": %d, \
\"speed\": %d, \
\"azimuth\": %d}",
static int __sys_msg_parse_data_upgrade(cmi_data_t* msg, size_t msg_sz)
{
sys_ctx_t* ctx = &sys_ctx;
int ret = -1;
if (DATA_DATATYPE(msg) != data_type_upgrade) {
assert(0);
}
if (ctx->sys_state != sys_state_upgrade) {
// ignore
zlog_warn(sys_zc, "found upgrade msg while not in upgrade state");
ret = SPKERR_BADSEQ;
goto errout;
}
assert(ctx->upgrd_ctx);
if (sys_ctx.upgrd_ctx->buf_sz + DATA_FRAGLEN(msg) > SYS_MAX_UPGRD_SCRIPT_SZ) {
ret = SPKERR_EACCESS;
goto errout;
}
memcpy(ctx->upgrd_ctx->script_buf + ctx->upgrd_ctx->buf_sz,
DATA_FRAGDATA(msg),
DATA_FRAGLEN(msg));
ctx->upgrd_ctx->buf_sz += DATA_FRAGLEN(msg);
if (DATA_EOF(msg)) {
zlog_notice(sys_zc, "found upgrade EOF: file_sz=%zu", ctx->upgrd_ctx->buf_sz);
// execute
FILE* file;
file = fopen("/opt/sys_upgrade.tar.gz", "w+");
if (!file) {
zlog_error(sys_zc, "failed to open upgrade script file");
ret = SPKERR_EACCESS;
goto errout;
}
ssize_t xfer = fwrite(ctx->upgrd_ctx->script_buf,
1,
ctx->upgrd_ctx->buf_sz,
file);
fclose(file);
if (xfer != ctx->upgrd_ctx->buf_sz) {
zlog_error(sys_zc, "failed to write upgrade script file");
ret = SPKERR_EACCESS;
goto errout;
}
zlog_notice(sys_zc, "upgrade script written: size=%ld", xfer);
spk_os_exec("rm -Rf /opt/sys_upgrade");
spk_os_exec("tar xzf /opt/sys_upgrade.tar.gz -C /opt");
spk_os_exec("cd /opt/sys_upgrade ; ./install.sh");
sys_change_state(sys_state_idle);
}
return(SPK_SUCCESS);
errout:
if (ctx->upgrd_ctx) {
if (ctx->upgrd_ctx->script_buf) {
SAFE_RELEASE(ctx->upgrd_ctx->script_buf);
ctx->upgrd_ctx->buf_sz = 0;
}
SAFE_RELEASE(ctx->upgrd_ctx);
sys_change_state(sys_state_idle);
}
return(ret);
}
int main(int argc, char** argv)
{
int rc;
pid_t pid;
//注册信号
(void)signal(TFTP_SIGNAL, Tftp_Sig);
//初始化缓存队列
queue_init(&coapMsgQ, free);
//初始化信号量，初始值为0
rc = sem_init(&msgQSem, 0, 0);
if(rc == -1)
{
printf("init msgQSem error!\r\n");
exit(-1);
}
//初始化互斥量
rc = pthread_mutex_init(&msgQ_mutex, NULL);
if(rc != 0)
{
printf("msgQ_mutex init error!\r\n");
exit(-1);
}
//打开数据库
Open_db("CoapMsg.db", &db);
rc = zlog_init("log.conf");
if (rc)
{
printf("init failed\n");
return -1;
}
zc = zlog_get_category("my_cat");
if (!zc)
{
printf("get cat fail\n");
zlog_fini();
return -2;
}
zlog_info(zc, "Start!");
zlog_info(zc, "Uart_Init!");
//初始化串口
Uart_Init(115200);
//创建串口读取数据线程
rc = pthread_create(&uartRd_Thread, NULL, Uart_ReadThread, NULL);
if(0!=rc)
{
zlog_error(zc, "uartRd_Thread create error!");
exit(-1);
}
else
{
zlog_debug(zc, "uartRd_Thread create success!");
}
//创建分发数据线程
rc = pthread_create(&transMsg_Thread, NULL, TransMsgThread, NULL);
if(0!=rc)
{
zlog_error(zc, "TransMsgThread create error!");
exit(-1);
}
else
{
zlog_debug(zc, "TransMsgThread create success!");
}
//初始化链表
list_init( &iplist, free);
zlog_debug(zc, "list_init success!");
//创建tftp Server进程
pid = fork();
if(pid == 0)
{
printf("enter tftp server,pid = %d\r\n", getpid());
zlog_debug(zc, "enter tftp server,pid = %d", getpid());
tftpd_init(NULL);
}
else if(pid<0)
{
printf("create tftp server process error!\r\n");
zlog_error(zc, "create tftp server process error!");
}
else if(pid > 0)
{
//记录tftp子进程的pid
tftp_pid = pid;
}
//创建coapclient任务
CreatCoapclient(&iplist);
//创建coap Server进程
pid = fork();
if(pid == 0)
{
printf("enter coap server,pid = %d\r\n", getpid());
zlog_debug(zc, "enter coap server,pid = %d", getpid());
CoapServ(NULL);
}
else if(pid<0)
{
printf("create coap server process error!\r\n");
zlog_error(zc, "create coap server process error!");
}
else if(pid > 0)
{
//记录coap server子进程的pid
coap_serv_pid = pid;
}
while(1)
{
sleep(1);
}
return 0;
}
