int msgfree(msg_q_t msgid)
{
int i;
INT8U perr;
for (i = 0; i < OS_MAX_QS; i++)
{
if (q_man[i].msg == msgid)
break;
}
if (i >= OS_MAX_QS)
{
p_err("msgfree: err no match msg_q %x", msgid);
return - 1;
}
OSQDel((OS_EVENT*)msgid, OS_DEL_ALWAYS, &perr);
if (OS_ERR_NONE != perr)
{
p_err("msgfree: free err %d", perr);
return - 1;
}
if (!q_man[i].q_start)
{
assert(0);
}
mem_free(q_man[i].q_start);
q_man[i].q_start = 0;
q_man[i].msg = 0;
return 0;
}
static int query_flow_dissector(struct bpf_attach_info *attach_info)
{
__u32 attach_flags;
__u32 prog_ids[1];
__u32 prog_cnt;
int err;
int fd;
fd = open("/proc/self/ns/net", O_RDONLY);
if (fd < 0) {
p_err("can't open /proc/self/ns/net: %d",
strerror(errno));
return -1;
}
prog_cnt = ARRAY_SIZE(prog_ids);
err = bpf_prog_query(fd, BPF_FLOW_DISSECTOR, 0,
&attach_flags, prog_ids, &prog_cnt);
close(fd);
if (err) {
if (errno == EINVAL) {
/* Older kernel's don't support querying
* flow dissector programs.
*/
errno = 0;
return 0;
}
p_err("can't query prog: %s", strerror(errno));
return -1;
}
if (prog_cnt == 1)
attach_info->flow_dissector_id = prog_ids[0];
return 0;
}
int msgrcv(msg_q_t msgid, void **msgbuf, unsigned int timeout)
{
INT8U perr;
if (0 == msgid)
{
p_err("msgrcv: msgid err");
return - 1;
}
if ((timeout > 0) && (timeout < 1000uL / OS_TICKS_PER_SEC))
timeout = 1000uL / OS_TICKS_PER_SEC;
timeout = timeout * OS_TICKS_PER_SEC / 1000uL;
*msgbuf = OSQPend((OS_EVENT*)msgid, (INT32U)timeout, &perr);
if (perr == OS_ERR_NONE)
return 0;
else if (perr == OS_ERR_TIMEOUT)
return 1;
p_err("msgrcv: err %d", perr);
return - 1;
}
int main()
{
int ret;
//环境初始化
inittest();
ret = syn_init();
p_err(ret);
ret = syn_rwlock_init(2);
p_err(ret);
//测试用例1
ret = syn_rwlock_destroy(2);
assert(ret == 0,"syn_rwlock_destroy Use Case 1 error");
//测试用例2
ret = syn_rwlock_init(2);
p_err(ret);
ret = syn_rwlock_destroy(64);
assert(ret == -ERR_INVAL,"syn_rwlock_destroy Use Case 2 error");
//测试用例3
ret = syn_rwlock_destroy(4);
assert(ret == -ERR_NOINIT,"syn_rwlock_destroy Use Case 3 error");
//测试用例4
ret = syn_rwlock_rd(2,SYN_RECV_BLOCK);
p_err(ret);
ret = syn_rwlock_destroy(2);
assert(ret == -ERR_BUSY,"syn_rwlock_destroy Use Case 4 error");
finaltest();
return 0;
}
int map_parse_fd(int *argc, char ***argv)
{
int fd;
if (is_prefix(**argv, "id")) {
unsigned int id;
char *endptr;
NEXT_ARGP();
id = strtoul(**argv, &endptr, 0);
if (*endptr) {
p_err("can't parse %s as ID", **argv);
return -1;
}
NEXT_ARGP();
fd = bpf_map_get_fd_by_id(id);
if (fd < 0)
p_err("get map by id (%u): %s", id, strerror(errno));
return fd;
} else if (is_prefix(**argv, "pinned")) {
char *path;
NEXT_ARGP();
path = **argv;
NEXT_ARGP();
return open_obj_pinned_any(path, BPF_OBJ_MAP);
}
p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
return -1;
}
static int do_attach(int argc, char **argv)
{
enum bpf_attach_type attach_type;
int cgroup_fd, prog_fd;
int attach_flags = 0;
int ret = -1;
int i;
if (argc < 4) {
p_err("too few parameters for cgroup attach");
goto exit;
}
cgroup_fd = open(argv[0], O_RDONLY);
if (cgroup_fd < 0) {
p_err("can't open cgroup %s", argv[1]);
goto exit;
}
attach_type = parse_attach_type(argv[1]);
if (attach_type == __MAX_BPF_ATTACH_TYPE) {
p_err("invalid attach type");
goto exit_cgroup;
}
argc -= 2;
argv = &argv[2];
prog_fd = prog_parse_fd(&argc, &argv);
if (prog_fd < 0)
goto exit_cgroup;
for (i = 0; i < argc; i++) {
if (is_prefix(argv[i], "multi")) {
attach_flags |= BPF_F_ALLOW_MULTI;
} else if (is_prefix(argv[i], "override")) {
attach_flags |= BPF_F_ALLOW_OVERRIDE;
} else {
p_err("unknown option: %s", argv[i]);
goto exit_cgroup;
}
}
if (bpf_prog_attach(prog_fd, cgroup_fd, attach_type, attach_flags)) {
p_err("failed to attach program");
goto exit_prog;
}
if (json_output)
jsonw_null(json_wtr);
ret = 0;
exit_prog:
close(prog_fd);
exit_cgroup:
close(cgroup_fd);
exit:
return ret;
}
void load_tsin_db0(char *infname, gboolean is_gtab_i)
{
char tsidxfname[512];
// dbg("cur %s %s\n", infname, current_tsin_fname);
if (current_tsin_fname && !strcmp(current_tsin_fname, infname))
return;
strcpy(tsidxfname, infname);
strcat(tsidxfname, ".idx");
// dbg("tsidxfname %s\n", tsidxfname);
FILE *fr;
if ((fr=fopen(tsidxfname,"rb+"))==NULL) {
p_err("load_tsin_db0 A Cannot open '%s'\n", tsidxfname);
}
fread(&phcount,4,1,fr);
#if 0
printf("phcount:%d\n",phcount);
#endif
a_phcount=phcount+256;
fread(&hashidx,1,sizeof(hashidx),fr);
fp_phidx = fr;
if (fph)
fclose(fph);
dbg("tsfname: %s\n", infname);
if ((fph=fopen(infname,"rb+"))==NULL)
p_err("load_tsin_db0 B Cannot open '%s'", infname);
free(current_tsin_fname);
current_tsin_fname = strdup(infname);
if (is_gtab_i) {
TSIN_GTAB_HEAD head;
fread(&head, sizeof(head), 1, fph);
if (head.keybits*head.maxkey > 32) {
ph_key_sz = 8;
tsin_hash_shift = TSIN_HASH_SHIFT_64;
}
else {
ph_key_sz = 4;
tsin_hash_shift = TSIN_HASH_SHIFT_32;
}
} else {
ph_key_sz = 2;
tsin_hash_shift = TSIN_HASH_SHIFT;
}
tsin_is_gtab = is_gtab_i;
}
void get_page(struct page *page)
{
p_dbg_enter;
if (page->addr)
p_err("addr != 0\n");
page->addr = (char*)mem_malloc(4096);
if (!page->addr)
p_err("no mem\n");
g_skb_alloc_size += 4096;
}
FILE *init_tedrc_fname(char *ftedrc, int depth)
{
FILE *fp;
char tt[256],uu[256];
#if 0
printf(" %d %s\n",depth, ftedrc);
#endif
if (cdtedrc && (fp=fopen(ftedrc,"r"))) {
return fp;
}
if (fp=fopen(
strcat(strcat(strcpy(tt,(char *)getenv("HOME")),"/.Ted/"),ftedrc), "r"
)) return fp;
if (fp=fopen(strcat(strcat(strcpy(uu, TEDDIR),"/"),ftedrc),"r"))
return fp;
if (!depth) {
FILE *tfp;
extern char *exec_name;
static char exepath[128];
int l;
if (exepath[0]) {
strcpy(tt,exepath);
} else {
sprintf(tt,"which %s",exec_name);
if ((tfp=popen(tt,"r"))==NULL)
p_err("cannot locate exec %s path",exec_name);
fgets(tt,sizeof(tt),tfp);
if ((l=strlen(tt))>0) {
int i=l-1;
while (i>=0 && tt[i]!='/') i--;
if (i>=0) tt[i]=0;
strcpy(exepath,tt);
}
}
if (fp=fopen(strcat(strcat(strcpy(uu, tt),"/"),ftedrc),"r"))
return fp;
if ((l=strlen(tt))>0) {
int i=l-1;
while (i>=0 && tt[i]!='/') i--;
if (i>=0) tt[i]=0;
strcat(tt,"/Ted");
if (fp=fopen(strcat(strcat(strcpy(uu, tt),"/"),ftedrc),"r"))
return fp;
}
if (cdtedrc)
p_err("Cannot find ./%s or %s or %s",ftedrc,tt,uu);
else
p_err("Cannot find %s or %s",ftedrc,tt,uu);
}
return fp;
}
int main()
{
FILE *fp;
char fnamein[]="pin-juyin.src";
PIN_JUYIN pinju[1024];
short pinjuN=0;
if ((fp=fopen(fnamein, "r"))==NULL)
p_err("cannot open %s", fnamein);
while (!feof(fp)) {
char tt[128];
tt[0]=0;
fgets(tt, sizeof(tt), fp);
if (strlen(tt) < 3)
break;
char pin[16], ju[64];
bzero(pin, sizeof(pin));
sscanf(tt, "%s %s",pin, ju);
phokey_t kk=0;
int len = strlen(ju);
int i=0;
while (i<len) {
kk |= lookup((u_char *)&ju[i]);
i+=utf8_sz(&ju[i]);
}
// dbg("%s '%s' %d\n", pin, ju, kk);
memcpy(pinju[pinjuN].pinyin, pin, sizeof(pinju[0].pinyin));
pinju[pinjuN].key = kk;
pinjuN++;
}
fclose(fp);
dbg("zz pinjuN:%d\n", pinjuN);
qsort(pinju, pinjuN, sizeof(PIN_JUYIN), qcmp_str);
char fnameout[]="pin-juyin.xlt";
if ((fp=fopen(fnameout, "wb"))==NULL)
p_err("cannot create %s", fnameout);
fwrite(&pinjuN, sizeof(pinjuN), 1, fp);
fwrite(pinju, sizeof(PIN_JUYIN), pinjuN, fp);
fclose(fp);
return 0;
}
static uint32_t USB_OTG_USBH_handle_nptxfempty_ISR(USB_OTG_CORE_HANDLE*pdev)
{
USB_OTG_GINTMSK_TypeDef intmsk;
USB_OTG_HNPTXSTS_TypeDef hnptxsts;
uint16_t len_words, len;
hnptxsts.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->HNPTXSTS);
#ifdef DEBUG
if (hnptxsts.b.chnum > 0)
p_err("nptxfempty:%d\n", hnptxsts.b.nptxfspcavail);
if (pdev->host.hc[hnptxsts.b.chnum].xfer_len == 0)
{
p_err("%s xfer_len == 0, %d\n", __FUNCTION__, hnptxsts.b.chnum);
USB_OTG_HC_Halt(pdev, hnptxsts.b.chnum); //test
return 0;
}
#endif
len_words = (pdev->host.hc[hnptxsts.b.chnum].xfer_len + 3) / 4;
while ((hnptxsts.b.nptxfspcavail > len_words) && (pdev
->host.hc[hnptxsts.b.chnum].xfer_len != 0))
{
len = hnptxsts.b.nptxfspcavail * 4;
if (len > pdev->host.hc[hnptxsts.b.chnum].xfer_len)
{
/* Last packet */
len = pdev->host.hc[hnptxsts.b.chnum].xfer_len;
intmsk.d32 = 0;
intmsk.b.nptxfempty = 1;
USB_OTG_MODIFY_REG32(&pdev->regs.GREGS->GINTMSK, intmsk.d32, 0);
}
len_words = (pdev->host.hc[hnptxsts.b.chnum].xfer_len + 3) / 4;
USB_OTG_WritePacket(pdev, pdev->host.hc[hnptxsts.b.chnum].xfer_buff,
hnptxsts.b.chnum, len);
pdev->host.hc[hnptxsts.b.chnum].xfer_buff += len;
pdev->host.hc[hnptxsts.b.chnum].xfer_len -= len;
pdev->host.hc[hnptxsts.b.chnum].xfer_count += len;
hnptxsts.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->HNPTXSTS);
}
return 1;
}
int init_tcp()
{
struct sockaddr_in serv_addr;
bzero((char *)&serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr=inet_addr("167.170.27.6");
serv_addr.sin_port = htons(9001);
if ((sockfd=socket(AF_INET, SOCK_STREAM, 0)) < 0)
p_err("Cannot open socket : %s",strerror(errno));
if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
p_err("Cannot connect : %s",strerror(errno));
}
static int do_show_tree(int argc, char **argv)
{
char *cgroup_root;
int ret;
switch (argc) {
case 0:
cgroup_root = find_cgroup_root();
if (!cgroup_root) {
p_err("cgroup v2 isn't mounted");
return -1;
}
break;
case 1:
cgroup_root = argv[0];
break;
default:
p_err("too many parameters for cgroup tree");
return -1;
}
if (json_output)
jsonw_start_array(json_wtr);
else
printf("%s\n"
"%-8s %-15s %-15s %-15s\n",
"CgroupPath",
"ID", "AttachType", "AttachFlags", "Name");
switch (nftw(cgroup_root, do_show_tree_fn, 1024, FTW_MOUNT)) {
case NFTW_ERR:
p_err("can't iterate over %s: %s", cgroup_root,
strerror(errno));
ret = -1;
break;
case SHOW_TREE_FN_ERR:
ret = -1;
break;
default:
ret = 0;
}
if (json_output)
jsonw_end_array(json_wtr);
if (argc == 0)
free(cgroup_root);
return ret;
}
int main(int argc, char *argv[])
{
struct sockaddr_in addr;
struct hostent *host;
int sockfd;
char buf[1024];
int ret;
unsigned int optval = 1;
if(argc != 2) {
printf("usage: %s SERVER_NAME\n", argv[0]);
exit(1);
}
/* make socket */
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
p_err("socket");
printf("socket: Success\n");
/* setsockopt */
if(setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval)) < 0)
p_err("setsockopt");
printf("setsockopt: Success\n");
/* clear s_addr */
bzero((char *)&addr, sizeof(addr));
/* set socket */
if((host = gethostbyname(argv[1])) == NULL)
p_err("gethostbyname");
bcopy(host->h_addr, &addr.sin_addr, host->h_length);
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
/* connect server */
if(connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
p_err("connect");
printf("connect: Success\n");
/* data send */
while(fgets(buf, 1024, stdin)) {
write(sockfd, buf, 1024);
ret = read(sockfd, buf, ret);
printf("-> %s", buf);
}
close(sockfd);
exit(EXIT_SUCCESS);
return(0);
}
int connect_ts_share_svr()
{
SOCKET ConnectSocket = -1;
struct addrinfo *result = NULL, *ptr = NULL, hints;
int iResult;
bzero( &hints, sizeof(hints) );
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
char port_s[8];
sprintf(port_s, "%d", TS_SHARE_SERVER_PORT);
iResult = getaddrinfo(TS_SHARE_SERVER, port_s, &hints, &result);
if ( iResult != 0 ) {
#if UNIX
p_err("getaddrinfo failed: %s\n", sys_err_strA());
#else
p_err("getaddrinfo failed: %s\n", sock_err_strA());
#endif
}
for(ptr=result; ptr != NULL ;ptr=ptr->ai_next) {
// Create a SOCKET for connecting to server
ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
if (ConnectSocket < 0) {
dbg("Error at socket(): %s\n", sys_err_strA());
continue;
}
// Connect to server.
iResult = connect( ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
if (iResult < 0) {
closesocket(ConnectSocket);
ConnectSocket = -1;
continue;
}
break;
}
if (ConnectSocket <= 0) {
p_err("cannot connect to %s:%d", TS_SHARE_SERVER, TS_SHARE_SERVER_PORT, sys_err_strA());
}
freeaddrinfo(result);
return ConnectSocket;
}
int uart1_send(u8_t *buff,u32_t size)
{
int ret;
if((size == 0) || (buff == 0))
return -1;
p_dbg("uart1 send start\n");
clear_wait_event(u1_send.wait);
OSSemSet((OS_EVENT*)u1_send.wait, 0, (INT8U*)&ret);
u1_send.cnt = size;
DMA_TxConfiguration((uint32_t*)buff, size);
again:
ret = wait_event_timeout(u1_send.wait, 2000);
if(ret != 0)
goto again;
p_dbg("uart1 send end\n");
if(u1_send.cnt)
p_err("uart1_send err:%d,%d,%d\n",ret,u1_send.cnt,size);
else
p_dbg("uart1 send a pkg:%d\n", size);
return 0;
}
ITEM64 *find_ch64(char *s, int *N)
{
ITEM64 t;
bzero(t.ch, CH_SZ);
u8cpy((char *)t.ch, s);
ITEM64 *p = (ITEM64 *)bsearch(&t, it64, itN, sizeof(ITEM64), qcmp_ch64);
if (!p)
return NULL;
ITEM64 *q = p+1;
while (p > it64 && !qcmp_ch64(p-1, &t))
p--;
ITEM64 *end = it64 + itN;
while (q < end && !qcmp_ch64(q, &t))
q++;
*N = q - p;
if (*N > 20)
p_err("err");
return p;
}
void DMA2_Stream7_IRQHandler() //发送中断
{
uint32_t irq_flag;
enter_interrupt();
DMA_Cmd(DMA2_Stream7, DISABLE);
NVIC_DisableIRQ(DMA2_Stream7_IRQn);
irq_flag = local_irq_save();
if(DMA_GetFlagStatus(DMA2_Stream7, DMA_FLAG_TEIF7))
{
p_err("uart dma err");
}
DMA_ITConfig(DMA2_Stream7, DMA_IT_TC | DMA_IT_TE | DMA_IT_HT,DISABLE);
DMA_ClearFlag(DMA2_Stream7, DMA_FLAG_TCIF7 | DMA_FLAG_TEIF7 | DMA_FLAG_HTIF7 | DMA_FLAG_DMEIF7 | DMA_FLAG_HTIF7);
u1_send.cnt = DMA2_Stream7->NDTR; //取剩余字数,应该为0
local_irq_restore(irq_flag);
USART_DMACmd(USART1, USART_DMAReq_Tx, DISABLE);
p_dbg("u_send irq\n");
wake_up(u1_send.wait); //唤醒等待线程
exit_interrupt(1);
}
void *write_thread(void *_ts) {
struct ts *ts = _ts;
struct packet *packet;
mode_t umask_val = umask(0);
dir_perm = (0777 & ~umask_val) | (S_IWUSR | S_IXUSR);
set_thread_name("tsdump-write");
while ((packet = queue_get(ts->packet_queue))) {
if (!packet->data_len)
continue;
p_dbg1(" - Got packet %d, size: %u, file_time:%lu packet_time:%lu depth:%d\n",
packet->num, packet->data_len, ALIGN_DOWN(packet->ts.tv_sec, ts->rotate_secs),
packet->ts.tv_sec, ts->packet_queue->items);
handle_files(ts, packet);
if (ts->output_fd > -1) {
p_dbg2(" - Writing into fd:%d size:%d file:%s\n", ts->output_fd, packet->data_len, ts->output_filename);
ssize_t written = write(ts->output_fd, packet->data, packet->data_len);
if (written != packet->data_len) {
p_err("Can not write data (fd:%d written %zd of %d file:%s)",
ts->output_fd, written, packet->data_len, ts->output_filename);
}
}
free_packet(packet);
}
close_output_file(ts, NO_UNLINK);
return NULL;
}
void open_xim()
{
XIMTriggerKeys triggerKeys;
im_styles.supported_styles = Styles;
im_styles.count_styles = sizeof(Styles)/sizeof(Styles[0]);
triggerKeys.count_keys = sizeof(trigger_keys)/sizeof(trigger_keys[0]);
triggerKeys.keylist = trigger_keys;
encodings.count_encodings = sizeof(chEncodings)/sizeof(XIMEncoding) - 1;
encodings.supported_encodings = chEncodings;
if ((xim_arr[0].xims = IMOpenIM(dpy,
IMServerWindow, xim_arr[0].xim_xwin, //input window
IMModifiers, "Xi18n", //X11R6 protocol
IMServerName, xim_arr[0].xim_server_name, //XIM server name
IMLocale, lc,
IMServerTransport, "X/", //Comm. protocol
IMInputStyles, &im_styles, //faked styles
IMEncodingList, &encodings,
IMProtocolHandler, hime_ProtoHandler,
IMFilterEventMask, KeyPressMask|KeyReleaseMask,
IMOnKeysList, &triggerKeys,
NULL)) == NULL) {
setenv("NO_GTK_INIT", NULL, TRUE);
p_err("IMOpenIM '%s' failed. Maybe another XIM server is running.\n",
xim_arr[0].xim_server_name);
}
}
int play_mp3_stream(uint8_t *buff, int size)
{
int ret;
if(
#if ENABLE_MP3
!mp3_format.init ||
#endif
!buff)
return -1;
if(dec_input.data_len + size <= dec_input.buff_len)
{
memcpy(dec_input.data + dec_input.data_len, buff, size);
dec_input.data_len += size;
}else{
p_err("%s,%d,%d\n", __FUNCTION__, audio_cfg.dec_input->data_len, size);
dec_input.data_len = 0;
}
#if ENABLE_MP3
ret = MpegAudioDecoder(&dec_input);
#else
ret = 0;
#endif
return ret;
}
void switch_audio_mode()
{
if(!audio_cfg.audio_dev_open)
{
p_dbg("请先打开音频");
return;
}
audio_cfg.play_mp3 = !audio_cfg.play_mp3;
if(audio_cfg.play_mp3){
p_dbg("mp3播放模式");
#if ENABLE_MP3
if(!mp3_format.init)
{
if(init_mp3_format())
p_err("init_mp3_format err\n");
}
reset_mp3_stat();
#endif
}else{
p_dbg("pcm播放模式(语音对讲)");
#if ENABLE_MP3
deinit_mp3_format();
#endif
}
}
static int audio_dev_write(uint8_t *buff, int size)
{
int i = 0;
if (!buff || !size)
return - 1;
if (!audio_cfg.audio_dev_open || !audio_cfg.dec_input)
return - 1;
#if ENABLE_MP3
if(audio_cfg.play_mp3)
{
i = play_mp3_stream(buff, size);
}
else
#endif
{
i = play_pcm_stream(buff, size);
}
if (i != 0)
{
p_err("play ret err");
audio_cfg.dec_input->type = AUDIO_TYPE_UNKOWN;
}
return 0;
}
int get_widget_xy(GtkWidget *win, GtkWidget *widget, int *rx, int *ry)
{
if (!win && !widget)
p_err("get_widget_xy err");
// gdk_flush();
GtkRequisition sz;
gtk_widget_get_preferred_size(widget, NULL, &sz);
int wx, wy;
wx=wy=0;
gtk_widget_translate_coordinates(widget, win,
0, sz.height, &wx, &wy);
gtk_widget_translate_coordinates(widget, win,
0, sz.height, &wx, &wy);
// dbg("%d wx:%d\n", index, wx);
int win_x, win_y;
gtk_window_get_position(GTK_WINDOW(win), &win_x, &win_y);
int win_xl, win_yl;
get_win_size(win, &win_xl, &win_yl);
if (wx > win_xl)
wx = win_xl;
*rx = win_x + wx;
*ry = win_y + wy;
return wx;
}
//expires ----n*ms
int mod_timer(timer_t *tmr, unsigned int expires)
{
INT8U perr, ret;
OS_TMR *tmr_t = tmr;
if (tmr_t == 0)
{
p_err("mod_timer tmr err");
return 0;
}
if (expires < 100)
expires = 100;
expires = expires * OS_TMR_CFG_TICKS_PER_SEC / 1000;
if(timer_pending(tmr)/* && (expires == tmr_t->OSTmrPeriod)*/)
return 1;
tmr_t->OSTmrDly = expires;
tmr_t->OSTmrPeriod = expires;
ret = OSTmrStart(tmr_t, &perr);
if (ret == OS_TRUE && perr == OS_ERR_NONE)
{
return 0;
}
return 0;
}
int main(int argc, char **argv)
{
int i;
gtk_init(&argc, &argv);
load_setttings();
if (argc > 1) {
p_err("Currently only support ~/.config/hime/pho.tab2");
}
pho_load();
for(i=0; i < idxnum_pho; i++) {
phokey_t key = idx_pho[i].key;
int frm = idx_pho[i].start;
int to = idx_pho[i+1].start;
int j;
for(j=frm; j < to; j++) {
prph(key);
char *str = pho_idx_str(j);
dbg(" %s %d\n", str, ch_pho[j].count);
}
}
return 0;
}
void load_ts_phrase()
{
FILE *fp = tsin_hand.fph;
int i;
for(i=0; i < phraseN; i++)
free(phrase[i]);
free(phrase); phrase = NULL;
phraseN = 0;
dbg("fname %s\n", current_tsin_fname);
int ofs = is_gtab ? sizeof(TSIN_GTAB_HEAD):0;
fseek(fp, ofs, SEEK_SET);
while (!feof(fp)) {
u_int64_t phbuf[MAX_PHRASE_LEN];
char chbuf[MAX_PHRASE_LEN * CH_SZ + 1];
u_char clen;
usecount_t usecount;
clen = 0;
fread(&clen,1,1,fp);
if (clen > MAX_PHRASE_LEN)
p_err("bad tsin db clen %d > MAX_PHRASE_LEN %d\n", clen, MAX_PHRASE_LEN);
fread(&usecount,sizeof(usecount_t), 1, fp);
fread(phbuf, ph_key_sz, clen, fp);
int tlen = 0;
for(i=0; i < clen; i++) {
int n = fread(&chbuf[tlen], 1, 1, fp);
if (n<=0)
goto stop;
int len=utf8_sz(&chbuf[tlen]);
fread(&chbuf[tlen+1], 1, len-1, fp);
tlen+=len;
}
if (clen < 2)
continue;
chbuf[tlen]=0;
phrase = trealloc(phrase, char *, phraseN+1);
phrase[phraseN++] = strdup(chbuf);
}
stop:
// fclose(fp);
qsort(phrase, phraseN, sizeof(char *), qcmp_str);
dbg("phraseN: %d\n", phraseN);
}
void toggle_im_enabled()
{
// dbg("toggle_im_enabled\n");
check_CS();
if (current_CS->in_method < 0 || current_CS->in_method > MAX_GTAB_NUM_KEY)
p_err("err found");
if (current_CS->im_state != GCIN_STATE_DISABLED) {
if (current_CS->im_state == GCIN_STATE_ENG_FULL) {
current_CS->im_state = GCIN_STATE_CHINESE;
disp_im_half_full();
return;
}
if (current_method_type() == method_type_TSIN) {
#if USE_TSIN
flush_tsin_buffer();
#endif
}
else {
output_gbuf();
reset_gtab_all();
}
hide_in_win(current_CS);
#if 0
hide_win_status();
#endif
current_CS->im_state = GCIN_STATE_DISABLED;
update_win_kbm();
#if TRAY_ENABLED
disp_tray_icon();
#endif
} else {
if (!current_method_type())
init_gtab(current_CS->in_method);
init_state_chinese(current_CS);
reset_current_in_win_xy();
#if 1
show_in_win(current_CS);
update_in_win_pos();
#else
update_in_win_pos();
show_in_win(current_CS);
#endif
update_win_kbm();
#if TRAY_ENABLED
disp_tray_icon();
#endif
}
}
/* Split command line into argument vector. */
static int make_args(char *line, char *n_argv[], int maxargs, int cmd_nb)
{
static const char ws[] = " \t\r\n";
char *cp = line;
int n_argc = 0;
while (*cp) {
/* Skip leading whitespace. */
cp += strspn(cp, ws);
if (*cp == '\0')
break;
if (n_argc >= (maxargs - 1)) {
p_err("too many arguments to command %d", cmd_nb);
return -1;
}
/* Word begins with quote. */
if (*cp == '\'' || *cp == '"') {
char quote = *cp++;
n_argv[n_argc++] = cp;
/* Find ending quote. */
cp = strchr(cp, quote);
if (!cp) {
p_err("unterminated quoted string in command %d",
cmd_nb);
return -1;
}
} else {
n_argv[n_argc++] = cp;
/* Find end of word. */
cp += strcspn(cp, ws);
if (*cp == '\0')
break;
}
/* Separate words. */
*cp++ = 0;
}
n_argv[n_argc] = NULL;
return n_argc;
}
static int do_detach(int argc, char **argv)
{
enum bpf_attach_type attach_type;
int prog_fd, cgroup_fd;
int ret = -1;
if (argc < 4) {
p_err("too few parameters for cgroup detach");
goto exit;
}
cgroup_fd = open(argv[0], O_RDONLY);
if (cgroup_fd < 0) {
p_err("can't open cgroup %s", argv[1]);
goto exit;
}
attach_type = parse_attach_type(argv[1]);
if (attach_type == __MAX_BPF_ATTACH_TYPE) {
p_err("invalid attach type");
goto exit_cgroup;
}
argc -= 2;
argv = &argv[2];
prog_fd = prog_parse_fd(&argc, &argv);
if (prog_fd < 0)
goto exit_cgroup;
if (bpf_prog_detach2(prog_fd, cgroup_fd, attach_type)) {
p_err("failed to detach program");
goto exit_prog;
}
if (json_output)
jsonw_null(json_wtr);
ret = 0;
exit_prog:
close(prog_fd);
exit_cgroup:
close(cgroup_fd);
exit:
return ret;
}
