/**
* Free internally allocated memory in config.
* @param[in] zconf
*/
void zero_config_free(struct zero_config *zconf)
{
if (zconf->radius_config_file) free(zconf->radius_config_file);
if (zconf->radius_nas_identifier) free(zconf->radius_nas_identifier);
if (zconf->rc_listen_addr) free(zconf->rc_listen_addr);
utarray_done(&zconf->ip_whitelist);
utarray_done(&zconf->interfaces);
}
/**
* Free internally allocated memory in config.
* @param[in] zconf
*/
void zconfig_destroy(zconfig_t *zconf)
{
utarray_done(&zconf->interfaces);
if (zconf->remotectl_listen) free(zconf->remotectl_listen);
for (size_t i = 0; i < utarray_len(&zconf->scopes); i++) {
zconfig_scope_t *scope = *(zconfig_scope_t **) utarray_eltptr(&zconf->scopes, i);
zconfig_scope_destroy(scope);
free(scope);
}
utarray_done(&zconf->scopes);
}
void zconfig_scope_destroy(zconfig_scope_t *scope)
{
if (scope->name) free(scope->name);
if (scope->radius.config) free(scope->radius.config);
if (scope->radius.nas_id) free(scope->radius.nas_id);
if (scope->blacklist.file) free(scope->blacklist.file);
utarray_done(&scope->ports_whitelist);
utarray_done(&scope->client_subnets);
utarray_done(&scope->local_subnets);
utarray_done(&scope->local_subnets_exclusions);
zclient_rules_destroy(&scope->default_client_rules);
}
void MergeRules(FcitxXkbRules* rules, FcitxXkbRules* rulesextra)
{
utarray_concat(rules->modelInfos, rulesextra->modelInfos);
utarray_concat(rules->optionGroupInfos, rulesextra->optionGroupInfos);
FcitxXkbLayoutInfo* layoutInfo;
UT_array toAdd;
utarray_init(&toAdd, fcitx_ptr_icd);
for (layoutInfo = (FcitxXkbLayoutInfo*) utarray_front(rulesextra->layoutInfos);
layoutInfo != NULL;
layoutInfo = (FcitxXkbLayoutInfo*) utarray_next(rulesextra->layoutInfos, layoutInfo))
{
FcitxXkbLayoutInfo* l = FindByName(rules, layoutInfo->name);
if (l) {
utarray_concat(l->languages, layoutInfo->languages);
utarray_concat(l->variantInfos, layoutInfo->variantInfos);
}
else
utarray_push_back(&toAdd, &layoutInfo);
}
unsigned int i;
for(i = 0;i < utarray_len(&toAdd);i++) {
FcitxXkbLayoutInfo* p = *(FcitxXkbLayoutInfo**)utarray_eltptr(&toAdd, i);
utarray_push_back(rules->layoutInfos, p);
}
utarray_done(&toAdd);
FcitxXkbRulesFree(rulesextra);
}
void
py_enhance_py_destroy(PinyinEnhance *pyenhance)
{
if (pyenhance->py_list.icd) {
utarray_done(&pyenhance->py_list);
}
}
/**
* Load uint16 array.
* @param[in] option Configuration option.
* @param[in,out] array Resulting array.
* @return <0 - error. 0 - success. >0 - not found.
*/
static int zcfg_load_uint16_array(const config_setting_t *option, UT_array *array)
{
utarray_init(array, &ut_uint16_icd);
if (!option) {
return 1;
}
if (CONFIG_TYPE_ARRAY != option->type) {
return -1;
}
int count = config_setting_length(option);
for (int i = 0; i < count; i++) {
int item = config_setting_get_int_elem(option, i);
if ((item < 0) || (item > UINT16_MAX)) {
ZLOG(LOG_ERR, "config:%s:%s: invalid port: %d", option->parent->name, option->name, item);
utarray_done(array);
return -1;
}
uint16_t port = (uint16_t) item;
utarray_push_back(array, &port);
}
if (utarray_len(array)) {
utarray_sort(array, uint16_cmp);
}
return 0;
}
/**
* Destroy and free monitor instance.
* @param[in] mon Monitor instance.
*/
void zmonitor_free(struct zmonitor *mon)
{
for (size_t i = 0; i < utarray_len(&mon->monitors); i++) {
struct zmonitor_conn *conn = *(struct zmonitor_conn **) utarray_eltptr(&mon->monitors, i);
zmonitor_conn_free(conn);
}
pthread_rwlock_destroy(&mon->lock);
token_bucket_destroy(&mon->band);
utarray_done(&mon->monitors);
free(mon);
}
/**
* Destroy firewall instance.
* @param[in] fwd Firewall handle.
*/
void zfwall_destroy(struct zfirewall *fire)
{
pthread_spin_destroy(&fire->lock);
for (int proto = 0; proto < PROTO_MAX; proto++) {
for (int rule = 0; rule < PORT_MAX; rule++) {
utarray_done(&fire->rules[proto][rule]);
}
}
free(fire);
}
/**
* Load interfaces section.
* @param[in] option Option name.
* @param[in,out] array Resulting array.
* @return <0 - error. 0 - success. >0 - not found.
*/
int zcfg_load_interfaces(const config_setting_t *option, UT_array *array)
{
utarray_init(array, &ut_zif_pair_icd);
if (!option) {
return 1;
}
if (CONFIG_TYPE_LIST != option->type) {
return -1;
}
u_int count = (u_int) config_setting_length(option);
for (u_int i = 0; i < count; i++) {
zifpair_t if_pair;
const char *str;
config_setting_t *entry = config_setting_get_elem(option, i);
if (!config_setting_lookup_string(entry, ZCFG_LAN, &str)) {
ZLOG(LOG_ERR, "config:%s:%s: invalid or missing 'lan' property", option->parent->name, option->name);
goto fail;
}
strncpy(if_pair.lan, str, sizeof(if_pair.lan));
if (!config_setting_lookup_string(entry, ZCFG_WAN, &str)) {
ZLOG(LOG_ERR, "config:%s:%s: invalid or missing 'wan' property", option->parent->name, option->name);
goto fail;
}
strncpy(if_pair.wan, str, sizeof(if_pair.wan));
int affinity = 0;
if (!config_setting_lookup_int(entry, ZCFG_AFFINITY, &affinity)) {
ZLOG(LOG_ERR, "config:%s:%s: invalid or missing 'affinity' property", option->parent->name, option->name);
goto fail;
}
if ((affinity < 0) || affinity >= UINT16_MAX) {
ZLOG(LOG_ERR, "config:%s:%s: invalid 'affinity' value", option->parent->name, option->name);
goto fail;
}
if_pair.affinity = (uint16_t) affinity;
utarray_push_back(array, &if_pair);
}
return 0;
fail:
utarray_done(array);
return -1;
}
/**
* Load subnet array.
* @param[in] cfg Config section.
* @param[in] option Option name.
* @param[in,out] array Resulting array.
* @return <0 - error. 0 - success. >0 - not found.
*/
static int zcfg_load_subnet_list(const config_setting_t *option, zsubnet_group_t *array)
{
utarray_init(array, &ut_ip_range_icd);
if (!option) {
return 1;
}
if (CONFIG_TYPE_LIST != option->type) {
return -1;
}
int count = config_setting_length(option);
for (int i = 0; i < count; i++) {
ip_range_t range;
char ip_str[INET_ADDRSTRLEN];
const char *item = config_setting_get_string_elem(option, i);
const char *cidr_pos = strchr(item, '/');
// search CIDR, and make sure, that ip part is not bigger than buffer size
if (cidr_pos && (((size_t) (cidr_pos - item) < sizeof(ip_str)))) {
strncpy(ip_str, item, cidr_pos - item);
ip_str[cidr_pos - item] = '\0';
struct in_addr ip_addr;
if (0 < inet_pton(AF_INET, ip_str, &ip_addr)) {
uint8_t cidr = 0;
if ((0 == str_to_u8(cidr_pos + 1, &cidr)) && (cidr <= CIDR_MAX)) {
range.ip_start = ntohl(ip_addr.s_addr);
range.ip_end = IP_RANGE_END(range.ip_start, cidr);
utarray_push_back(array, &range);
continue;
}
}
}
// error handler
ZLOG(LOG_ERR, "config:%s:%s: invalid subnet: %s", option->parent->name, option->name, item);
utarray_done(array);
return -1;
}
if (count) {
utarray_sort(array, ip_range_cmp);
}
return 0;
}
/**
* Load uint16 array from config.
* @param[in] cfg Configuration option.
* @param[in] option Option name.
* @param[in,out] array Resulting array.
* @return Zero on success.
*/
static int load_uint16_list(const config_setting_t *cfg, const char *option, UT_array *array)
{
config_setting_t *cfg_list = config_setting_get_member(cfg, option);
if (!cfg_list) {
ZERO_LOG(LOG_ERR, "config: missing %s entry", option);
return 0;
}
if (config_setting_type(cfg_list) != CONFIG_TYPE_LIST) {
ZERO_LOG(LOG_ERR, "config: invalid %s entry", option);
return -1;
}
int count = config_setting_length(cfg_list);
if (0 >= count) {
return 0;
}
utarray_init(array, &ut_uint16_icd);
for (int i = 0; i < count; i++) {
int entry = config_setting_get_int_elem(cfg_list, i);
if (!entry) {
ZERO_LOG(LOG_ERR, "config: failed to get next %s record", option);
continue;
}
if (entry < UINT16_MAX) {
uint16_t port = entry;
utarray_push_back(array, &port);
continue;
}
// if we here, then entry is invalid
ZERO_LOG(LOG_ERR, "config: invalid %s item: %d", option, entry);
utarray_done(array);
return -1;
}
utarray_sort(array, uint16_cmp);
return 0;
}
FCITX_EXPORT_API
void FcitxMenuFinalize(FcitxUIMenu* menu)
{
utarray_done(&menu->shell);
}
/**
* Load ip-mask array.
* @param[in] cfg Config section.
* @param[in] option Option name.
* @param[in,out] array Resulting array.
* @return Zero on success.
*/
static int load_ip_mask_list(const config_setting_t *cfg, const char *option, UT_array *array)
{
config_setting_t *cfg_list = config_setting_get_member(cfg, option);
if (!cfg_list) {
ZERO_LOG(LOG_ERR, "config: missing %s entry", option);
return 0;
}
if (config_setting_type(cfg_list) != CONFIG_TYPE_LIST) {
ZERO_LOG(LOG_ERR, "config: invalid %s entry", option);
return -1;
}
int count = config_setting_length(cfg_list);
if (0 >= count) {
return 0;
}
utarray_init(array, &ut_ip_range_icd);
for (int i = 0; i < count; i++) {
struct ip_range range;
const char *entry = config_setting_get_string_elem(cfg_list, i);
if (!entry) {
ZERO_LOG(LOG_ERR, "config: failed to get next %s record", option);
continue;
}
char ip_str[INET_ADDRSTRLEN];
const char *cidr_pos = strchr(entry, '/');
// we search for CIDR, and make sure, that ip part is not bigger than allowed size
if (cidr_pos && ((size_t)(cidr_pos - entry) < sizeof(ip_str))) {
strncpy(ip_str, entry, cidr_pos - entry);
ip_str[cidr_pos - entry] = '\0';
struct in_addr ip_addr;
if (0 < inet_pton(AF_INET, ip_str, &ip_addr)) {
u_long cidr = strtoul(cidr_pos + 1, NULL, 10);
if (cidr != ULONG_MAX && cidr <= 32) {
range.ip_start = ntohl(ip_addr.s_addr);
range.ip_end = IP_RANGE_END(range.ip_start, cidr);
utarray_push_back(array, &range);
continue;
}
}
}
// if we here, then entry is invalid
ZERO_LOG(LOG_ERR, "config: invalid %s item: %s", option, entry);
utarray_done(array);
return -1;
}
utarray_sort(array, ip_range_cmp);
return 0;
}
/**
Load interfaces section.
* @param[in] cfg Config section.
* @param[in] option Option name.
* @param[in,out] array Resulting array.
* @return Zero on success.
*/
int load_interfaces(const config_setting_t *cfg, const char *option, UT_array *array)
{
config_setting_t *cfg_list = config_setting_get_member(cfg, option);
if (!cfg_list) {
ZERO_LOG(LOG_ERR, "config: missing %s entry", option);
return -1;
}
if (config_setting_type(cfg_list) != CONFIG_TYPE_LIST) {
ZERO_LOG(LOG_ERR, "config: invalid %s entry", option);
return -1;
}
int count = config_setting_length(cfg_list);
if (0 >= count) {
ZERO_LOG(LOG_ERR, "config: empty %s entry", option);
return -1;
}
utarray_init(array, &ut_zif_pair_icd);
for (int i = 0; i < count; i++) {
struct zif_pair if_pair;
const char *str;
config_setting_t *entry = config_setting_get_elem(cfg_list, i);
if (NULL == entry) {
ZERO_LOG(LOG_ERR, "config: failed to read %u-th group of %s entry", i, option);
goto fail;
}
if (!config_setting_lookup_string(entry, ZCFG_LAN, &str)) {
ZERO_LOG(LOG_ERR, "config: failed to read '%s' property of %u-th group of %s entry", ZCFG_LAN, i, option);
goto fail;
}
strncpy(if_pair.lan, str, sizeof(if_pair.lan));
if (!config_setting_lookup_string(entry, ZCFG_WAN, &str)) {
ZERO_LOG(LOG_ERR, "config: failed to read '%s' property of %u-th group of %s entry", ZCFG_WAN, i, option);
goto fail;
}
strncpy(if_pair.wan, str, sizeof(if_pair.wan));
int affinity = 0;
if (!config_setting_lookup_int(entry, ZCFG_AFFINITY, &affinity)) {
ZERO_LOG(LOG_ERR, "config: failed to read '%s' property of %u-th group of %s entry", ZCFG_AFFINITY, i, option);
goto fail;
}
if ((affinity < 0) || affinity >= UINT16_MAX) {
ZERO_LOG(LOG_ERR, "config: invalid value in '%s' property of %u-th group of %s entry", ZCFG_AFFINITY, i, option);
goto fail;
}
if_pair.affinity = (uint16_t)affinity;
utarray_push_back(array, &if_pair);
}
return 0;
fail:
utarray_done(array);
return -1;
}
int main(int argc, char **argv)
{
FILE *fout = stdout;
char c;
boolean alternativeOrder = false;
while ((c = getopt(argc, argv, "ao:h")) != -1) {
switch (c) {
case 'a':
alternativeOrder = true;
break;
case 'o':
fout = fopen(optarg, "w");
if (!fout) {
fprintf(stderr, "Cannot open file: %s\n", optarg);
return 1;
}
break;
case 'h':
default:
usage();
break;
}
}
if (optind >= argc) {
usage();
return 1;
}
FILE *fp = fopen(argv[optind], "r");
if (!fp) {
fprintf(stderr, "Cannot open file: %s\n", argv[optind]);
return 1;
}
char buf[BUFLEN], bufout[BUFLEN];
size_t count = fread(buf, 1, HEADER_SIZE, fp);
if (count < HEADER_SIZE || memcmp(buf, header_str, HEADER_SIZE) != 0) {
fprintf(stderr, "format error.\n");
fclose(fp);
return 1;
}
conv = iconv_open("utf-8", "unicode");
if (conv == (iconv_t) -1) {
fprintf(stderr, "iconv error.\n");
return 1;
}
fseek(fp, DESC_START, SEEK_SET);
fread(buf, 1, DESC_LENGTH, fp);
IconvStr in = buf;
char *out = bufout;
size_t inlen = DESC_LENGTH, outlen = BUFLEN;
iconv(conv, &in, &inlen, &out, &outlen);
fprintf(stderr, "%s\n", bufout);
fread(buf, 1, LDESC_LENGTH, fp);
in = buf;
out = bufout;
inlen = LDESC_LENGTH;
outlen = BUFLEN;
iconv(conv, &in, &inlen, &out, &outlen);
fprintf(stderr, "%s\n", bufout);
fread(buf, 1, NEXT_LENGTH, fp);
in = buf;
out = bufout;
inlen = NEXT_LENGTH;
outlen = BUFLEN;
iconv(conv, &in, &inlen, &out, &outlen);
fprintf(stderr, "%s\n", bufout);
count = fread(buf, 1, PINYIN_SIZE, fp);
if (count < PINYIN_SIZE || memcmp(buf, pinyin_str, PINYIN_SIZE) != 0) {
fprintf(stderr, "format error.\n");
fclose(fp);
return 1;
}
UT_array pys;
utarray_init(&pys, &py_icd);
for (; ;) {
int16_t index;
int16_t count;
fread(&index, 1, sizeof(int16_t), fp);
fread(&count, 1, sizeof(int16_t), fp);
ScelPinyin py;
memset(buf, 0, sizeof(buf));
memset(&py, 0, sizeof(ScelPinyin));
fread(buf, count, sizeof(char), fp);
in = buf;
out = py.pinyin;
inlen = count * sizeof(char);
outlen = 10;
iconv(conv, &in, &inlen, &out, &outlen);
utarray_push_back(&pys, &py);
if (strcmp(py.pinyin, "zuo") == 0)
break;
}
while (!feof(fp)) {
int16_t symcount;
int16_t count;
int16_t wordcount;
fread(&symcount, 1, sizeof(int16_t), fp);
if (feof(fp))
break;
fread(&count, 1, sizeof(int16_t), fp);
wordcount = count / 2;
int16_t* pyindex = malloc(sizeof(int16_t) * wordcount);
fread(pyindex, wordcount, sizeof(int16_t), fp);
int s;
for (s = 0; s < symcount ; s++) {
memset(buf, 0, sizeof(buf));
memset(bufout, 0, sizeof(bufout));
fread(&count, 1, sizeof(int16_t), fp);
fread(buf, count, sizeof(char), fp);
in = buf;
out = bufout;
inlen = count * sizeof(char);
outlen = BUFLEN;
iconv(conv, &in, &inlen, &out, &outlen);
if (alternativeOrder) {
fprintf(fout, "%s ", bufout);
}
ScelPinyin *py = (ScelPinyin*)utarray_eltptr(
&pys, (unsigned int)pyindex[0]);
fprintf(fout, "%s", py->pinyin);
int i;
for (i = 1 ; i < wordcount ; i ++) {
py = (ScelPinyin*)utarray_eltptr(&pys,
(unsigned int)pyindex[i]);
fprintf(fout, "\'%s", py->pinyin);
}
if (!alternativeOrder) {
fprintf(fout, " %s", bufout);
}
fprintf(fout, "\n");
fread(&count, 1, sizeof(int16_t), fp);
fread(buf, count, sizeof(char), fp);
}
free(pyindex);
}
iconv_close(conv);
utarray_done(&pys);
fclose(fout);
fclose(fp);
return 0;
}
static int
fxaddon_scan_addon(FILE *ifp, FILE *ofp)
{
FcitxDesktopFile dfile;
char *buff = NULL;
unsigned int i;
char **p;
if (!fcitx_desktop_file_init(&dfile, NULL, NULL))
return 1;
if (!fcitx_desktop_file_load_fp(&dfile, ifp))
return 1;
fclose(ifp);
FcitxDesktopGroup *addon_grp;
FcitxDesktopEntry *tmp_ety;
addon_grp = fcitx_desktop_file_find_group(&dfile, "FcitxAddon");
if (!addon_grp)
return 1;
tmp_ety = fcitx_desktop_group_find_entry(addon_grp, "Name");
if (!tmp_ety)
return 1;
const char *name = tmp_ety->value;
tmp_ety = fcitx_desktop_group_find_entry(addon_grp, "Prefix");
if (!tmp_ety)
return 1;
const char *prefix = tmp_ety->value;
UT_array macros;
fxaddon_load_numbered_entries(¯os, addon_grp, "Macro", false);
UT_array includes;
fxaddon_load_numbered_entries(&includes, addon_grp, "Include", false);
UT_array functions;
fxaddon_load_numbered_entries(&functions, addon_grp, "Function", true);
fxaddon_write_copyright(ofp);
size_t name_len = strlen(name);
buff = fcitx_utils_set_str_with_len(buff, name, name_len);
fxaddon_name_to_macro(buff);
_write_str(ofp, "\n#ifndef __FCITX_MODULE_");
_write_len(ofp, buff, name_len);
_write_str(ofp, "_H\n");
_write_str(ofp, "#define __FCITX_MODULE_");
_write_len(ofp, buff, name_len);
_write_str(ofp, "_H\n"
"\n"
"#ifdef __cplusplus\n"
"extern \"C\" {\n"
"#endif\n"
"\n");
for (i = 0;i < utarray_len(¯os);i++) {
p = (char**)_utarray_eltptr(¯os, i);
fxaddon_write_macro(ofp, &dfile, *p);
}
fxaddon_write_includes(ofp, &includes);
utarray_done(&includes);
_write_str(ofp, "DEFINE_GET_ADDON(\"");
_write_len(ofp, name, name_len);
_write_str(ofp, "\", ");
_write_str(ofp, prefix);
_write_str(ofp, ")\n\n");
for (i = 0;i < utarray_len(&functions);i++) {
p = (char**)_utarray_eltptr(&functions, i);
fxaddon_write_function(ofp, &dfile, prefix, *p, i);
}
_write_str(ofp, "\n"
"#ifdef __cplusplus\n"
"}\n"
"#endif\n"
"\n"
"#endif\n");
fclose(ofp);
fcitx_utils_free(buff);
fcitx_desktop_file_done(&dfile);
utarray_done(&functions);
return 0;
}
static void
fxaddon_write_function(FILE *ofp, FcitxDesktopFile *dfile, const char *prefix,
const char *func_name, int id)
{
FcitxDesktopGroup *grp;
unsigned int i;
grp = fcitx_desktop_file_find_group(dfile, func_name);
if (!grp)
return;
/* require the Name entry although not used now. */
if (!fcitx_desktop_group_find_entry(grp, "Name"))
return;
UT_array args;
fxaddon_load_numbered_entries(&args, grp, "Arg", true);
const char *type = fxaddon_function_get_return(grp);
const char *err_ret = fxaddon_function_get_error_return(grp);
boolean cache = fxaddon_function_get_cache_result(grp);
boolean enable_wrapper = fxaddon_function_get_enable_wrapper(grp);
if (cache && !type) {
FcitxLog(WARNING, "Cannot cache result of type void.");
cache = false;
}
if (!err_ret) {
_write_str(ofp, "DEFINE_GET_AND_INVOKE_FUNC(");
_write_str(ofp, prefix);
_write_str(ofp, ", ");
_write_str(ofp, func_name);
_write_str(ofp, ", ");
fprintf(ofp, "%d", id);
_write_str(ofp, ")\n");
} else {
_write_str(ofp, "DEFINE_GET_AND_INVOKE_FUNC_WITH_ERROR(");
_write_str(ofp, prefix);
_write_str(ofp, ", ");
_write_str(ofp, func_name);
_write_str(ofp, ", ");
fprintf(ofp, "%d", id);
_write_str(ofp, ", ");
_write_str(ofp, err_ret);
_write_str(ofp, ")\n");
}
if (!enable_wrapper)
_write_str(ofp, "#if 0\n");
_write_str(ofp, "static inline ");
_write_str(ofp, type ? type : "void");
_write_str(ofp, "\nFcitx");
_write_str(ofp, prefix);
_write_str(ofp, func_name);
_write_str(ofp, "(FcitxInstance *instance");
char **p;
for (i = 0;i < utarray_len(&args);i++) {
p = (char**)_utarray_eltptr(&args, i);
_write_str(ofp, ", ");
_write_str(ofp, *p);
_write_str(ofp, " arg");
fprintf(ofp, "%d", i);
}
_write_str(ofp,
")\n"
"{\n");
if (cache) {
_write_str(ofp,
" static boolean _init = false;\n"
" static void *result = NULL;\n"
" if (fcitx_likely(_init))\n"
" return (");
_write_str(ofp, type);
_write_str(ofp,
")(intptr_t)result;\n"
" _init = true;\n");
} else if (type) {
_write_str(ofp, " void *result;\n");
}
_write_str(ofp, " FCITX_DEF_MODULE_ARGS(args");
for (i = 0;i < utarray_len(&args);i++) {
_write_str(ofp, ", (void*)(intptr_t)arg");
fprintf(ofp, "%d", i);
}
_write_str(ofp,
");\n"
" ");
if (type) {
_write_str(ofp, "result = ");
}
_write_str(ofp, "Fcitx");
_write_str(ofp, prefix);
_write_str(ofp, "Invoke");
_write_str(ofp, func_name);
_write_str(ofp, "(instance, args);\n");
if (type) {
_write_str(ofp, " return (");
_write_str(ofp, type);
_write_str(ofp, ")(intptr_t)result;\n");
}
if (enable_wrapper) {
_write_str(ofp, "}\n\n");
} else {
_write_str(ofp,
"}\n"
"#endif\n\n");
}
utarray_done(&args);
}
FCITX_EXPORT_API
void FcitxCandidateWordFreeList(FcitxCandidateWordList* list)
{
utarray_done(&list->candWords);
free(list);
}
/**
@加载皮肤配置文件
*/
int LoadSkinConfig(FcitxSkin* sc, char** skinType)
{
FILE *fp;
boolean isreload = False;
int ret = 0;
if (sc->config.configFile) {
utarray_done(&sc->skinMainBar.skinPlacement);
FcitxConfigFree(&sc->config);
UnloadImage(sc);
}
memset(sc, 0, sizeof(FcitxSkin));
utarray_init(&sc->skinMainBar.skinPlacement, &place_icd);
reload:
if (!isreload) {
char *buf;
fcitx_utils_alloc_cat_str(buf, *skinType, "/fcitx_skin.conf");
fp = FcitxXDGGetFileWithPrefix("skin", buf, "r", NULL);
free(buf);
} else {
char *path = fcitx_utils_get_fcitx_path_with_filename(
"pkgdatadir", "/skin/default/fcitx_skin.conf");
fp = fopen(path, "r");
free(path);
}
if (fp) {
FcitxConfigFile *cfile;
FcitxConfigFileDesc* skinDesc = GetSkinDesc();
if (sc->config.configFile == NULL) {
cfile = FcitxConfigParseConfigFileFp(fp, skinDesc);
} else {
cfile = sc->config.configFile;
cfile = FcitxConfigParseIniFp(fp, cfile);
}
if (!cfile) {
fclose(fp);
fp = NULL;
} else {
FcitxSkinConfigBind(sc, cfile, skinDesc);
FcitxConfigBindSync((FcitxGenericConfig*)sc);
}
}
if (!fp) {
if (isreload) {
FcitxLog(FATAL, _("Can not load default skin, is installion correct?"));
perror("fopen");
ret = 1; // 如果安装目录里面也没有配置文件，那就只好告诉用户，无法运行了
} else {
perror("fopen");
FcitxLog(WARNING, _("Can not load skin %s, return to default"), *skinType);
if (*skinType)
free(*skinType);
*skinType = strdup("default");
isreload = true;
goto reload;
}
}
if (fp)
fclose(fp);
sc->skinType = skinType;
return ret;
}
DBusMessage* FcitxDBusMenuGetGroupProperties(FcitxNotificationItem* notificationitem, DBusMessage* message)
{
/* signature aias */
DBusMessageIter args;
dbus_message_iter_init(message, &args);
DBusMessage* reply = NULL;
do {
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY)
break;
DBusMessageIter sub;
dbus_message_iter_recurse(&args, &sub);
UT_array ids;
utarray_init(&ids, &ut_int32_icd);
while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_INT32) {
int32_t id;
dbus_message_iter_get_basic(&sub, &id);
utarray_push_back(&ids, &id);
dbus_message_iter_next(&sub);
}
dbus_message_iter_next(&args);
dbus_message_iter_recurse(&args, &sub);
FcitxStringHashSet* properties = NULL;
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY) {
utarray_done(&ids);
break;
}
while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING) {
char* property;
dbus_message_iter_get_basic(&sub, &property);
if (!fcitx_utils_string_hash_set_contains(properties, property)) {
properties = fcitx_utils_string_hash_set_insert(properties, property);
}
dbus_message_iter_next(&sub);
}
reply = dbus_message_new_method_return(message);
/* out put is a(ia{sv}) */
DBusMessageIter iter;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ia{sv})", &sub);
int i = 0;
for (; i < utarray_len(&ids); i ++) {
int32_t id = *(int32_t*) utarray_eltptr(&ids, i);
DBusMessageIter ssub;
dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &ssub);
dbus_message_iter_append_basic(&ssub, DBUS_TYPE_INT32, &id);
FcitxDBusMenuFillProperty(notificationitem, id, properties, &ssub);
dbus_message_iter_close_container(&sub, &ssub);
}
dbus_message_iter_close_container(&iter, &sub);
utarray_done(&ids);
fcitx_utils_free_string_hash_set(properties);
} while(0);
if (!reply) {
reply = FcitxDBusPropertyUnknownMethod(message);
}
return reply;
}
