static size_t
uim_curl_write_func(void *ptr, size_t size, size_t nmemb, void *data)
{
struct curl_memory_struct *mem = (struct curl_memory_struct *)data;
size_t realsize = size * nmemb;
/*
* We know that it isn't possible to overflow during multiplication if
* neither operand uses any of the most significant half of the bits in
* a size_t.
*/
if((unsigned long long)((nmemb | size) &
((unsigned long long)SIZE_MAX << (sizeof(size_t) << 2))) &&
(realsize / size != nmemb))
return 0;
if(SIZE_MAX - mem->size - 1 < realsize)
realsize = SIZE_MAX - mem->size - 1;
if(mem->str != NULL)
mem->str = uim_realloc(mem->str, mem->size + realsize + 1);
else
mem->str = uim_malloc(realsize + 1);
if(mem->str != NULL) {
memcpy(&(mem->str[mem->size]), ptr, realsize);
mem->size += realsize;
mem->str[mem->size] = '\0';
}
return realsize;
}
/**
* @return 1 if success, 0 if error.
*/
static int
read_command()
{
ssize_t len;
char rbuf[DEFAULT_MESSAGE_SIZE];
debug_printf(DEBUG_NOTE, "read command\n");
do {
len = read(STDIN_FILENO, rbuf, sizeof(rbuf) - 1);
if (len == -1) {
debug_printf(DEBUG_NOTE, "stdin is corrupt: %s\n", strerror (errno));
return 0;
}
if (len == 0) {
debug_printf(DEBUG_NOTE, "unexpected EOF\n");
return 0;
}
rbuf[len] = '\0';
if (strlen(cmdbuf) + len + 1 > cmdbuf_len) {
cmdbuf_len += DEFAULT_MESSAGE_SIZE;
cmdbuf = uim_realloc(cmdbuf, cmdbuf_len);
debug_printf(DEBUG_NOTE, "cmdbuf has extended\n");
}
strcat(cmdbuf, rbuf);
} while (!command_exists_in_cmdbuf());
return 1;
}
static void
pushback_input_method(MInputMethod *im, char *lang, char *name)
{
im_array = uim_realloc(im_array,
sizeof(struct im_) * (nr_input_methods + 1));
im_array[nr_input_methods].im = im;
im_array[nr_input_methods].name = uim_strdup(name);
im_array[nr_input_methods].lang = uim_strdup(lang);
nr_input_methods++;
}
static uim_lisp
im_pushback_mode_list(uim_lisp uc_, uim_lisp str_)
{
uim_context uc;
const char *str;
uc = retrieve_uim_context(uc_);
str = REFER_C_STR(str_);
uc->modes = uim_realloc(uc->modes, sizeof(char *) * (uc->nr_modes + 1));
uc->modes[uc->nr_modes] = uc->conv_if->convert(uc->outbound_conv, str);
uc->nr_modes++;
return uim_scm_f();
}
char *
uim_helper_buffer_append(char *buf, const char *fragment, size_t fragment_size)
{
size_t buf_size, extended_size;
if (buf) {
buf_size = strlen(buf);
extended_size = buf_size + fragment_size + 1;
buf = uim_realloc(buf, extended_size);
memcpy(&buf[buf_size], fragment, fragment_size);
buf[extended_size - 1] = '\0';
}
return buf;
}
static struct client *
get_unused_client(void)
{
int i;
for (i = 0; i < nr_client_slots; i++) {
if (clients[i].fd == -1)
return &clients[i];
}
nr_client_slots++;
clients = uim_realloc(clients, sizeof(struct client) * nr_client_slots);
clients[nr_client_slots - 1].rbuf = uim_strdup("");
clients[nr_client_slots - 1].wbuf = uim_strdup("");
return &clients[nr_client_slots - 1];
}
static int
unused_ic_id(void)
{
int i;
for (i = 0; i < nr_input_contexts; i++) {
if (!ic_array[i].mic)
return i;
}
ic_array = uim_realloc(ic_array,
sizeof(struct ic_) * (nr_input_contexts + 1));
ic_array[nr_input_contexts].mic = NULL;
nr_input_contexts++;
return nr_input_contexts - 1;
}
static int
uim_eb_strappend(char **dest, const char *append, size_t append_len)
{
if (*dest) {
char *str;
size_t dest_len = strlen(*dest);
size_t len = dest_len + append_len;
str = uim_realloc(*dest, len + 1);
memcpy(&str[dest_len], append, append_len);
str[len] = '\0';
*dest = str;
} else {
char *str;
str = uim_malloc(append_len + 1);
memcpy(str, append, append_len);
str[append_len] = '\0';
*dest = str;
}
return 1;
}
static char *
mana_ipc_send_command(pid_t *pid,
FILE **read_fp, FILE **write_fp,
const char *str)
{
char *tmp = uim_strdup("");
char buf[8192];
struct sigaction act, oact;
act.sa_handler = SIG_IGN;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGPIPE, &act, &oact);
fputs(str, *write_fp);
again:
if (fflush(*write_fp) != 0) {
switch (errno) {
case EINTR:
goto again;
case EPIPE:
while (!feof(*read_fp)) {
fgets(buf, sizeof(buf), *read_fp);
if (buf != NULL) {
if (strcmp(buf, "err") == 0)
uim_notify_fatal(N_("uim-mana: Command 'mana' not found."));
else
uim_notify_fatal("uim-mana: %s", buf);
}
}
*pid = 0;
fclose(*read_fp);
fclose(*write_fp);
*read_fp = NULL;
*write_fp = NULL;
sigaction(SIGPIPE, &oact, NULL);
free(tmp);
return NULL;
default:
sigaction(SIGPIPE, &oact, NULL);
free(tmp);
return NULL;
}
}
sigaction(SIGPIPE, &oact, NULL);
if (feof(*read_fp)) {
*pid = 0;
fclose(*read_fp);
fclose(*write_fp);
*read_fp = NULL;
*write_fp = NULL;
free(tmp);
return NULL;
}
while (fgets (buf, sizeof(buf), *read_fp) != NULL) {
tmp = uim_realloc(tmp, strlen(tmp) + strlen(buf) + 1);
strcat(tmp, buf);
if (strchr( buf, '\n' )) {
break;
}
}
return tmp;
}
/*
* strから属性を変更するエスケープシーケンスを探す
* len > 0
*/
static void set_attr(const char *str, int len)
{
/* エスケープシーケンスの開始 */
const char *start;
const char *free_str = NULL;
/* TRUEのときfree_strをfreeする必要がある */
int must_free = FALSE;
const char *end = str + len;
/* 前回の途中のバッファがあるか */
if (s_escseq_buf != NULL) {
const char *tmp_str = str;
/* s_escseq_buf には'\0'は含まれない */
int escseq_buf_len = strlen(s_escseq_buf);
must_free = TRUE;
free_str = str = uim_malloc(escseq_buf_len + len + 1);
memcpy((char *)str, s_escseq_buf, escseq_buf_len);
memcpy((char *)str + escseq_buf_len, tmp_str, len);
((char *)str)[escseq_buf_len + len] = '\0';
free(s_escseq_buf);
s_escseq_buf = NULL;
end = str + escseq_buf_len + len;
}
while ((start = str = memchr(str, ESCAPE_CODE, end - str)) != NULL) {
str++;
if (str == end) {
int escseq_buf_len = end - start;
s_escseq_buf = uim_malloc(escseq_buf_len + 1);
memcpy(s_escseq_buf, start, escseq_buf_len);
s_escseq_buf[escseq_buf_len] = '\0';
}
else if (str[0] == '[') {
int nr_params = 1;
/* ^[[1;2;3の1, 2, 3を入れる */
int *params = uim_malloc(sizeof(int));
params[0] = 0;
str++;
while (isdigit((unsigned char)str[0]) || str[0] == ';') {
if (isdigit((unsigned char)str[0])) {
int n = 0;
while (isdigit((unsigned char)str[0])) {
n = n * 10 + str[0] - '0';
str++;
}
params[nr_params - 1] = n;
}
if (str[0] == ';') {
nr_params++;
params = uim_realloc(params, sizeof(int) * nr_params);
params[nr_params - 1] = 0;
str++;
}
}
if (str == end) {
int escseq_buf_len = end - start;
s_escseq_buf = uim_malloc(escseq_buf_len + 1);
memcpy(s_escseq_buf, start, escseq_buf_len);
s_escseq_buf[escseq_buf_len] = '\0';
}
else if (str[0] == 'm') {
int i;
str++;
for (i = 0; i < nr_params; i++) {
if (params[i] == 0) {
/* 属性消去 */
s_attr = s_attr_none;
} else if (s_enter_underline_num != NULL && params[i] == atoi(s_enter_underline_num)) {
s_attr.underline = TRUE;
} else if (s_exit_underline_num != NULL && params[i] == atoi(s_exit_underline_num)) {
s_attr.underline = FALSE;
} else if (s_enter_standout_num != NULL && params[i] == atoi(s_enter_standout_num)) {
s_attr.standout = TRUE;
} else if (s_exit_standout_num != NULL && params[i] == atoi(s_exit_standout_num)) {
s_attr.standout = FALSE;
} else if (s_bold_num != NULL && params[i] == atoi(s_bold_num)) {
s_attr.bold = TRUE;
} else if (s_blink_num != NULL && params[i] == atoi(s_blink_num)) {
s_attr.blink = TRUE;
} else if (s_orig_pair_num != NULL && params[i] == atoi(s_orig_pair_num)) {
s_attr.foreground = s_attr.background = FALSE;
} else if (s_orig_fore_num != NULL && params[i] == atoi(s_orig_fore_num)) {
s_attr.foreground = FALSE;
} else if (s_orig_back_num != NULL && params[i] == atoi(s_orig_back_num)) {
s_attr.background = FALSE;
} else if (params[i] == 22) {
s_attr.bold = FALSE;
} else if (params[i] == 25) {
s_attr.blink = FALSE;
} else if ((30 <= params[i] && params[i] <= 37) || (90 <= params[i] && params[i] <= 97)) {
s_attr.foreground = params[i];
} else if ((40 <= params[i] && params[i] <= 47) || (100 <= params[i] && params[i] <= 107)) {
s_attr.background = params[i];
}
}
}
free(params);
}
}
if (must_free) {
free((char *)free_str);
}
s_attr_pty = s_attr;
}
static char *
uim_iconv_code_conv(void *obj, const char *instr)
{
iconv_t cd = (iconv_t)obj;
size_t ins;
const char *in;
size_t outbufsiz, outs;
char *outbuf = NULL, *out;
size_t ret = 0;
size_t nconv = 0;
size_t idx = 0;
char *str = NULL;
if (UIM_CATCH_ERROR_BEGIN())
return NULL;
if (!instr)
goto err;
if (!obj) {
UIM_CATCH_ERROR_END();
return uim_strdup(instr);
}
ins = strlen(instr);
in = instr;
outbufsiz = (ins + sizeof("")) * MBCHAR_LEN_MAX;
out = outbuf = uim_malloc(outbufsiz);
while (ins > 0) {
out = outbuf;
outs = outbufsiz;
ret = iconv(cd, (ICONV_CONST char **)&in, &ins, &out, &outs);
nconv = outbufsiz - outs;
if (ret == (size_t)-1) {
switch (errno) {
case EINVAL:
goto err;
case E2BIG:
outbufsiz *= 2;
out = uim_realloc(outbuf, outbufsiz);
outbuf = out;
break;
default:
goto err;
}
} else {
/* XXX: irreversible characters */
}
if (nconv > 0) {
if (str == NULL)
str = uim_malloc(nconv + 1);
else
str = uim_realloc(str, idx + nconv + 1);
memcpy(&str[idx], outbuf, nconv);
idx += nconv;
}
}
do {
out = outbuf;
outs = outbufsiz;
ret = iconv(cd, NULL, NULL, &out, &outs);
nconv = outbufsiz - outs;
if (ret == (size_t)-1) {
outbufsiz *= 2;
out = uim_realloc(outbuf, outbufsiz);
outbuf = out;
} else {
/* XXX: irreversible characters */
}
if (nconv > 0) {
if (str == NULL)
str = uim_malloc(nconv + 1);
else
str = uim_realloc(str, idx + nconv + 1);
memcpy(&str[idx], outbuf, nconv);
idx += nconv;
}
} while (ret == (size_t)-1);
if (str == NULL)
str = uim_strdup("");
else
str[idx] = '\0';
free(outbuf);
UIM_CATCH_ERROR_END();
return str;
err:
free(str);
free(outbuf);
UIM_CATCH_ERROR_END();
return uim_strdup("");
}
