void
test_abort_and_quit (void)
{
const gchar *packet;
gsize packet_size;
test_envelope_recipient();
channel_free();
cut_assert_true(milter_server_context_abort(context));
pump_all_events();
milter_test_assert_state(ABORT);
milter_test_assert_status(ABORT);
cut_assert_true(milter_server_context_quit(context));
pump_all_events();
milter_test_assert_state(QUIT);
milter_test_assert_status(ABORT);
milter_command_encoder_encode_abort(encoder, &packet, &packet_size);
packet_string = g_string_new_len(packet, packet_size);
milter_command_encoder_encode_quit(encoder, &packet, &packet_size);
g_string_append_len(packet_string, packet, packet_size);
milter_test_assert_packet(channel, packet_string->str, packet_string->len);
}
static GString *
select_word_text(GntTextView *view, gchar *c)
{
gchar *start = c;
gchar *end = c;
gchar *t, *endsize;
while ((t = g_utf8_prev_char(start))) {
if (!g_ascii_isspace(*t)) {
if (start == view->string->str)
break;
start = t;
} else
break;
}
while ((t = g_utf8_next_char(end))) {
if (!g_ascii_isspace(*t))
end = t;
else
break;
}
select_start = start;
select_end = end;
endsize = g_utf8_next_char(select_end); /* End at the correct byte */
return g_string_new_len(start, endsize - start);
}
static void
t_asn1_get_oid(void) {
GError *gerr = NULL;
network_packet p;
GString *oid;
p.data = g_string_new_len(C("\x2b\x06\x01\x05\x05\x02"));
p.offset = 0;
oid = g_string_new(NULL);
g_assert_cmpint(TRUE, ==, network_asn1_proto_get_oid(&p, p.data->len, oid, &gerr));
g_assert_cmpstr("1.3.6.1.5.5.2", ==, oid->str);
g_string_assign_len(p.data, C("\x2b\x06\x01\x04\x01\x82\x37\x02\x02\x0a"));
p.offset = 0;
g_assert_cmpint(TRUE, ==, network_asn1_proto_get_oid(&p, p.data->len, oid, &gerr));
g_assert_cmpstr("1.3.6.1.4.1.311.2.2.10", ==, oid->str);
g_string_assign_len(p.data, C("\x2a\x86\x48\x82\xf7\x12\x01\x02\x02"));
p.offset = 0;
g_assert_cmpint(TRUE, ==, network_asn1_proto_get_oid(&p, p.data->len, oid, &gerr));
g_assert_cmpstr("1.2.840.48018.1.2.2", ==, oid->str);
g_string_free(p.data, TRUE);
}
static MSC_BOOL msc_server_connection_send_user_message(msc_server_connection *c, MSC_BOOL is_private, msc_server_connection *from, const char *body, size_t body_len)
{
if ((body_len > 512) || (body_len < 1)) return MSC_FALSE;
if ((!from) || (from->user->len > 64) || (from->user->len < 1)) return MSC_FALSE;
GString *hostname = msc_server_connection_remote_hostname(from);
GString *hostinfo = g_string_new("");
g_string_printf(hostinfo, "%s:%d", hostname->str, msc_server_connection_remote_port(from));
g_string_free(hostname, TRUE);
char header_buf[] = { (char)((body_len >> 8) & 0xff), (char)(body_len & 0xff), (char)(from->user->len & 0xff), (char)(hostinfo->len & 0xff) };
GString *buf = g_string_new_len(header_buf, 4);
buf = g_string_append_len(buf, from->user->str, from->user->len);
buf = g_string_append_len(buf, hostinfo->str, hostinfo->len);
buf = g_string_append_len(buf, body, body_len);
int type = (is_private) ? MSC_SERVER_MSG_OPCODE_PRIVATE : MSC_SERVER_MSG_OPCODE_CHATROOM;
msc_server_connection_send_raw_message(c, type, buf->str, buf->len);
g_string_free(buf, TRUE);
g_string_free(hostinfo, TRUE);
return MSC_TRUE;
}
static void
t_asn1_get_length(void) {
GError *gerr = NULL;
network_packet p;
ASN1Length len;
p.data = g_string_new_len(C("\x60"));
p.offset = 0;
g_assert_cmpint(TRUE, ==, network_asn1_proto_get_length(&p, &len, &gerr));
g_assert_cmpint(len, ==, 0x60);
g_string_assign_len(p.data, C("\x81\x80"));
p.offset = 0;
g_assert_cmpint(TRUE, ==, network_asn1_proto_get_length(&p, &len, &gerr));
g_assert_cmpint(len, ==, 0x80);
g_string_assign_len(p.data, C("\x82\x01\x2d"));
p.offset = 0;
g_assert_cmpint(TRUE, ==, network_asn1_proto_get_length(&p, &len, &gerr));
g_assert_cmpint(len, ==, 0x12d);
g_string_free(p.data, TRUE);
}
/**
* e_vcard_attribute_get_values_decoded:
* @attr: an #EVCardAttribute
*
* Gets the list of values from @attr, decoding them if
* necessary. The list and its contents are owned by @attr,
* and must not be freed.
*
* Return value: A list of values of type #GString.
**/
GList*
e_vcard_attribute_get_values_decoded (EVCardAttribute *attr)
{
g_return_val_if_fail (attr != NULL, NULL);
if (!attr->decoded_values) {
GList *l;
switch (attr->encoding) {
case EVC_ENCODING_RAW:
for (l = attr->values; l; l = l->next)
attr->decoded_values = g_list_prepend (attr->decoded_values, g_string_new ((char*)l->data));
attr->decoded_values = g_list_reverse (attr->decoded_values);
break;
case EVC_ENCODING_BASE64:
for (l = attr->values; l; l = l->next) {
guchar *decoded;
gsize len = 0;
decoded = g_base64_decode (l->data, &len);
attr->decoded_values = g_list_prepend (attr->decoded_values, g_string_new_len (decoded, len));
g_free (decoded);
}
attr->decoded_values = g_list_reverse (attr->decoded_values);
break;
case EVC_ENCODING_QP:
g_warning ("need to implement quoted printable decoding");
break;
}
}
return attr->decoded_values;
}
/**
* e_vcard_attribute_add_value_decoded:
* @attr: an #EVCardAttribute
* @value: an encoded value
* @len: the length of the encoded value, in bytes
*
* Decodes @value according to the encoding used for @attr, and
* adds it to @attr's list of values.
**/
void
e_vcard_attribute_add_value_decoded (EVCardAttribute *attr, const char *value, int len)
{
g_return_if_fail (attr != NULL);
switch (attr->encoding) {
case EVC_ENCODING_RAW:
g_warning ("can't add_value_decoded with an attribute using RAW encoding. you must set the ENCODING parameter first");
break;
case EVC_ENCODING_BASE64: {
char *b64_data = g_base64_encode (value, len);
GString *decoded = g_string_new_len (value, len);
/* make sure the decoded list is up to date */
e_vcard_attribute_get_values_decoded (attr);
d(printf ("base64 encoded value: %s\n", b64_data));
d(printf ("original length: %d\n", len));
attr->values = g_list_append (attr->values, b64_data);
attr->decoded_values = g_list_append (attr->decoded_values, decoded);
break;
}
case EVC_ENCODING_QP:
g_warning ("need to implement quoted printable decoding");
break;
}
}
/**
* test if we decode all valid types from EXECUTE stmt
*/
static void t_com_stmt_execute_from_packet_invalid(void) {
network_mysqld_stmt_execute_packet_t *cmd;
const char raw_packet[] =
"\x12\x00\x00\x00"
"\x17" /* COM_STMT_EXECUTE */
"\x01\x00\x00\x00" /* stmt-id */
"\x00" /* flags */
"\x01\x00\x00\x00" /* iteration count */
"\x00"
"\x01"
"\x0f\x00"
"\x03\x66\x6f\x6f";
network_packet packet;
network_mysqld_type_t *param;
int param_ndx = 0;
packet.data = g_string_new_len(C(raw_packet));
packet.offset = 0;
#define EXPECTED_NUM_PARAMS 1
cmd = network_mysqld_stmt_execute_packet_new();
g_assert_cmpint(0, ==, network_mysqld_proto_skip_network_header(&packet));
g_assert_cmpint(0, !=, network_mysqld_proto_get_stmt_execute_packet(&packet, cmd, EXPECTED_NUM_PARAMS));
#undef EXPECTED_NUM_PARAMS
network_mysqld_stmt_execute_packet_free(cmd);
}
static gchar* convertUniCharToUTF8(const UChar* characters, gint length, int from, int to)
{
gchar* utf8 = 0;
gint new_length = 0;
utf16_to_utf8(characters, length, utf8, new_length);
if (!utf8)
return NULL;
if (from > 0) {
// discard the first 'from' characters
// FIXME: we should do this before the conversion probably
gchar* str_left = g_utf8_offset_to_pointer(utf8, from);
gchar* tmp = g_strdup(str_left);
g_free(utf8);
utf8 = tmp;
}
gchar* pos = utf8;
gint len = strlen(pos);
GString* ret = g_string_new_len(NULL, len);
// replace line break by space
while (len > 0) {
gint index, start;
pango_find_paragraph_boundary(pos, len, &index, &start);
g_string_append_len(ret, pos, index);
if (index == start)
break;
g_string_append_c(ret, ' ');
pos += start;
len -= start;
}
return g_string_free(ret, FALSE);
}
static GList *
retrieve_all_keys(void)
{
grn_id hash_id;
grn_hash_cursor *cursor;
keys_free();
cursor = grn_hash_cursor_open(context, hash,
NULL, 0, NULL, 0, 0, -1,
GRN_CURSOR_DESCENDING);
hash_id = grn_hash_cursor_next(context, cursor);
while (hash_id != GRN_ID_NIL) {
grn_id *trie_id;
void *hash_key;
GString *null_terminated_key;
gchar key[GRN_PAT_MAX_KEY_SIZE];
int size;
grn_hash_cursor_get_key(context, cursor, &hash_key);
trie_id = hash_key;
size = grn_pat_get_key(context, trie, *trie_id, key, sizeof(key));
null_terminated_key = g_string_new_len(key, size);
keys = g_list_append(keys, g_string_free(null_terminated_key, FALSE));
hash_id = grn_hash_cursor_next(context, cursor);
}
grn_hash_cursor_close(context, cursor);
return keys;
}
char *
panel_util_make_exec_uri_for_desktop (const char *exec)
{
GString *str;
const char *c;
if (!exec)
return g_strdup ("");
if (!strchr (exec, ' '))
return g_strdup (exec);
str = g_string_new_len (NULL, strlen (exec));
str = g_string_append_c (str, '"');
for (c = exec; *c != '\0'; c++) {
/* FIXME: GKeyFile will add an additional backslach so we'll
* end up with toto\\" instead of toto\"
* We could use g_key_file_set_value(), but then we don't
* benefit from the other escaping that glib is doing...
*/
if (*c == '"')
str = g_string_append (str, "\\\"");
else
str = g_string_append_c (str, *c);
}
str = g_string_append_c (str, '"');
return g_string_free (str, FALSE);
}
/**
* \param procedure procedure ID
* \param data unpacked message data
* \param len data length
*
* Creates SysEx message then sends it. This function uses folowing global variables: device_id, family_id and product_id.
**/
void send_message(gint procedure, gchar *data, gint len)
{
GString *msg = g_string_new_len("\xF0" /* SysEx status byte */
"\x00\x00\x10", /* Manufacturer ID */
4);
g_string_append_printf(msg,
"%c%c%c" /* device, family, product ID */
"%c", /* procedure */
device_id, family_id, product_id,
procedure);
if (len > 0) {
GString *tmp = pack_data(data, len);
g_string_append_len(msg, tmp->str, tmp->len);
g_string_free(tmp, TRUE);
}
g_string_append_printf(msg, "%c\xF7",
calculate_checksum(&msg->str[1], msg->len - 1));
debug_msg(DEBUG_VERBOSE, "Sending %s len %d",
get_message_name(procedure), len);
send_data(msg->str, msg->len);
g_string_free(msg, TRUE);
}
void cmd_buf_handler()
{
gchar **cmd_strv;
gint strv_len, i;
do
{
cmd_strv = g_strsplit(control_service_data.cmd_buf->str, "\n", CMD_BUF_PIECES);
strv_len = g_strv_length(cmd_strv);
if (strv_len == 0)
{
g_strfreev(cmd_strv);
return;
}
for (i = 0; i < strv_len - 1; i++)
{
if (strlen(cmd_strv[i]) > 0)
{
g_print("Cmd was : \"%s\"\n", cmd_strv[i]);
cmd_handler(cmd_strv[i]);
}
}
g_string_free(control_service_data.cmd_buf, TRUE);
control_service_data.cmd_buf = g_string_new_len(cmd_strv[strv_len - 1], strlen(cmd_strv[strv_len -1]));
g_strfreev(cmd_strv);
} while (strv_len == CMD_BUF_PIECES);
}
struct stream_chunk *stream_chunk_new(void *data, uint32_t size, enum bistream_direction dir)
{
struct stream_chunk *sc = g_malloc0(sizeof(struct stream_chunk));
sc->data = g_string_new_len(data, size);
sc->direction = dir;
return sc;
}
static mc_search_cond_t *
mc_search__cond_struct_new (mc_search_t * lc_mc_search, const char *str,
gsize str_len, const char *charset)
{
mc_search_cond_t *mc_search_cond;
mc_search_cond = g_malloc0 (sizeof (mc_search_cond_t));
mc_search_cond->str = g_string_new_len (str, str_len);
mc_search_cond->charset = g_strdup (charset);
switch (lc_mc_search->search_type)
{
case MC_SEARCH_T_GLOB:
mc_search__cond_struct_new_init_glob (charset, lc_mc_search, mc_search_cond);
break;
case MC_SEARCH_T_NORMAL:
mc_search__cond_struct_new_init_normal (charset, lc_mc_search, mc_search_cond);
break;
case MC_SEARCH_T_REGEX:
mc_search__cond_struct_new_init_regex (charset, lc_mc_search, mc_search_cond);
break;
case MC_SEARCH_T_HEX:
mc_search__cond_struct_new_init_hex (charset, lc_mc_search, mc_search_cond);
break;
default:
break;
}
return mc_search_cond;
}
void t_resultset_fields_parse_high(void) {
strings packets[] = {
{ C("\1\0\0\1\2") }, /* 2 fields */
{ C("6\0\0\2\3def\0\6STATUS\0\rVariable_name\rVariable_name\f\10\0P\0\0\0\375\1\0\0\0\0") },
{ C("&\0\0\3\3def\0\6STATUS\0\5Value\5Value\f\10\0\0\2\0\0\375\1\0\0\0\0") },
{ C("&\0\0\3\3def\0\6STATUS\0\5Value\5Value\f\10\0\0\2\0\0\375\1\0\0\0\0") },
{ C("\5\0\0\4\376\0\0\"\0") }, /* EOF */
{ C("\23\0\0\5\17Aborted_clients\00298") },
{ C("\5\0\0\4\376\0\0\"\0") }, /* EOF */
{ NULL, 0 }
};
int i;
network_queue *q;
GPtrArray *fields;
q = network_queue_new();
for (i = 0; packets[i].s; i++) {
network_queue_append(q, g_string_new_len(packets[i].s, packets[i].s_len));
}
fields = g_ptr_array_new();
g_assert(NULL == network_mysqld_proto_get_fielddefs(q->chunks->head, fields));
network_queue_free(q);
}
static void
serial_command_ready (MMPortSerial *port,
GAsyncResult *res,
GSimpleAsyncResult *simple)
{
GByteArray *response_buffer;
GError *error = NULL;
GString *response;
response_buffer = mm_port_serial_command_finish (port, res, &error);
if (!response_buffer) {
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
g_object_unref (simple);
return;
}
/* Build a GString just with the response we need, and clear the
* processed range from the response buffer */
response = g_string_new_len ((const gchar *)response_buffer->data, response_buffer->len);
if (response_buffer->len > 0)
g_byte_array_remove_range (response_buffer, 0, response_buffer->len);
g_byte_array_unref (response_buffer);
g_simple_async_result_set_op_res_gpointer (simple,
response,
(GDestroyNotify)string_free);
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
static gpointer
gstring_copy (gpointer boxed)
{
const GString *src_gstring = boxed;
return g_string_new_len (src_gstring->str, src_gstring->len);
}
static gboolean reply_signal(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct synce_context *context = data;
const char *path = dbus_message_get_path(msg);
DBusMessageIter iter, array_iter;
char *value;
int length;
if (strcmp(context->conn_obj, path) != 0) {
obex_object_set_io_flags(context, G_IO_ERR, -EPERM);
context->lasterr = -EPERM;
return FALSE;
}
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &array_iter);
dbus_message_iter_get_fixed_array(&array_iter, &value, &length);
context->buffer = g_string_new_len(value, length);
obex_object_set_io_flags(context, G_IO_IN, 0);
context->lasterr = 0;
return TRUE;
}
void
test_already_launched (void)
{
const gchar *packet;
gsize packet_size;
GString *output;
GString *expected_packet;
const gchar command_line[] = "/bin/cat";
const gchar *user_name;
user_name = g_get_user_name();
milter_manager_launch_command_encoder_encode_launch(command_encoder,
&packet, &packet_size,
command_line, user_name);
cut_trace(write_packet(packet, packet_size));
cut_trace(write_packet(packet, packet_size));
pump_all_events();
milter_manager_reply_encoder_encode_success(reply_encoder,
&packet, &packet_size);
expected_packet = g_string_new_len(packet, packet_size);
milter_manager_reply_encoder_encode_error(reply_encoder,
&packet, &packet_size,
"already launched: </bin/cat>");
g_string_append_len(expected_packet, packet, packet_size);
output = gcut_string_io_channel_get_string(output_channel);
cut_assert_equal_memory(expected_packet->str, expected_packet->len,
output->str, output->len);
}
GString *msc_secure_socket_hostname(msc_secure_socket *s)
{
char addr[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(s->remote_addr.sin_addr), addr, INET_ADDRSTRLEN);
return g_string_new_len(addr, INET_ADDRSTRLEN);
}
static proxy_context* proxy_context_new(liServer *srv, GString *dest_socket) {
liSocketAddress saddr;
proxy_context* ctx;
liBackendConfig *config;
saddr = li_sockaddr_from_string(dest_socket, 0);
if (NULL == saddr.addr) {
ERROR(srv, "Invalid socket address '%s'", dest_socket->str);
return NULL;
}
config = g_slice_new0(liBackendConfig);
config->callbacks = &proxy_backend_cbs;
config->sock_addr = saddr;
config->max_connections = 0;
config->idle_timeout = 5;
config->connect_timeout = 5;
config->wait_timeout = 5;
config->disable_time = 0;
config->max_requests = 1;
config->watch_for_close = TRUE;
ctx = g_slice_new0(proxy_context);
ctx->refcount = 1;
ctx->pool = li_backend_pool_new(config);
ctx->socket_str = g_string_new_len(GSTR_LEN(dest_socket));
return ctx;
}
static gchar *
lua_map_read (rspamd_mempool_t *pool, gchar *chunk, gint len,
struct map_cb_data *data)
{
struct lua_map_callback_data *cbdata, *old;
if (data->cur_data == NULL) {
cbdata = g_slice_alloc0 (sizeof (*cbdata));
old = (struct lua_map_callback_data *)data->prev_data;
cbdata->L = old->L;
cbdata->ref = old->ref;
data->cur_data = cbdata;
}
else {
cbdata = (struct lua_map_callback_data *)data->cur_data;
}
if (cbdata->data == NULL) {
cbdata->data = g_string_new_len (chunk, len);
}
else {
g_string_append_len (cbdata->data, chunk, len);
}
return NULL;
}
static gchar* convertUniCharToUTF8(const UChar* characters, gint length, int from, int to)
{
gint newLength = 0;
GOwnPtr<gchar> utf8Text(utf16ToUtf8(characters, length, newLength));
if (!utf8Text)
return 0;
gchar* pos = utf8Text.get();
if (from > 0) {
// discard the first 'from' characters
// FIXME: we should do this before the conversion probably
pos = g_utf8_offset_to_pointer(utf8Text.get(), from);
}
gint len = strlen(pos);
GString* ret = g_string_new_len(NULL, len);
// replace line break by space
while (len > 0) {
gint index, start;
pango_find_paragraph_boundary(pos, len, &index, &start);
g_string_append_len(ret, pos, index);
if (index == start)
break;
g_string_append_c(ret, ' ');
pos += start;
len -= start;
}
return g_string_free(ret, FALSE);
}
liMemcachedRequest* li_memcached_get(liMemcachedCon *con, GString *key, liMemcachedCB callback, gpointer cb_data, GError **err) {
int_request* req;
if (!li_memcached_is_key_valid(key)) {
g_set_error(err, LI_MEMCACHED_ERROR, LI_MEMCACHED_BAD_KEY, "Invalid key: '%s'", key->str);
return NULL;
}
if (-1 == con->fd) memcached_connect(con);
if (-1 == con->fd) {
if (NULL == con->err) {
g_set_error(err, LI_MEMCACHED_ERROR, LI_MEMCACHED_DISABLED, "Not connected");
} else if (err) {
*err = g_error_copy(con->err);
}
return NULL;
}
req = g_slice_new0(int_request);
req->req.callback = callback;
req->req.cb_data = cb_data;
req->type = REQ_GET;
req->key = g_string_new_len(GSTR_LEN(key));
if (!push_request(con, req, err)) {
free_request(con, req);
return NULL;
}
return &req->req;
}
GString *
mc_search__tolower_case_str (const char *charset, const char *str, gsize str_len)
{
GString *ret;
#ifdef HAVE_CHARSET
gchar *converted_str, *tmp_str1, *tmp_str2, *tmp_str3;
gsize converted_str_len;
gsize tmp_len;
if (charset == NULL)
charset = cp_source;
tmp_str2 = converted_str =
mc_search__recode_str (str, str_len, charset, cp_display, &converted_str_len);
tmp_len = converted_str_len + 1;
tmp_str3 = tmp_str1 = g_strdup (converted_str);
while (str_tolower (tmp_str1, &tmp_str2, &tmp_len))
tmp_str1 += str_length_char (tmp_str1);
g_free (tmp_str3);
tmp_str2 =
mc_search__recode_str (converted_str, converted_str_len, cp_display, charset, &tmp_len);
g_free (converted_str);
ret = g_string_new_len (tmp_str2, tmp_len);
g_free (tmp_str2);
return ret;
#else
const gchar *tmp_str1 = str;
gchar *converted_str, *tmp_str2;
gsize converted_str_len = str_len + 1;
(void) charset;
tmp_str2 = converted_str = g_strndup (str, str_len);
while (str_tolower (tmp_str1, &tmp_str2, &converted_str_len))
tmp_str1 += str_length_char (tmp_str1);
ret = g_string_new_len (converted_str, str_len);
g_free (converted_str);
return ret;
#endif
}
void ekg_debug_handler(int level, const char *format, va_list ap) {
static GString *line = NULL;
char *tmp = NULL;
char *theme_format;
int is_UI = 0;
if (!config_debug)
return;
if (line) {
g_string_append_vprintf(line, format, ap);
if (line->len == 0 || line->str[line->len - 1] != '\n')
return;
line->str[line->len - 1] = '\0'; /* remove '\n' */
tmp = g_string_free(line, FALSE);
line = NULL;
} else {
int tmplen = g_vasprintf(&tmp, format, ap);
if (tmplen < 0 || !tmp) /* OutOfMemory? */
return;
if (tmplen == 0 || tmp[tmplen - 1] != '\n') {
line = g_string_new_len(tmp, tmplen);
g_free(tmp);
return;
}
tmp[tmplen - 1] = 0; /* remove '\n' */
}
switch(level) {
case 0: theme_format = "debug"; break;
case DEBUG_IO: theme_format = "iodebug"; break;
case DEBUG_IORECV: theme_format = "iorecvdebug"; break;
case DEBUG_FUNCTION: theme_format = "fdebug"; break;
case DEBUG_ERROR: theme_format = "edebug"; break;
case DEBUG_WHITE: theme_format = "wdebug"; break;
case DEBUG_WARN: theme_format = "warndebug"; break;
case DEBUG_OK: theme_format = "okdebug"; break;
default: theme_format = "debug"; break;
}
ekg_fix_utf8(tmp); /* debug message can contain random data */
buffer_add(&buffer_debug, theme_format, tmp);
query_emit(NULL, "ui-is-initialized", &is_UI);
if (is_UI && window_debug) {
print_window_w(window_debug, EKG_WINACT_NONE, theme_format, tmp);
}
#ifdef STDERR_DEBUG /* STDERR debug */
else
fprintf(stderr, "%s\n", tmp);
#endif
xfree(tmp);
}
static GString* _tgentransfer_getRandomString(gsize size) {
GString* buffer = g_string_new_len(NULL, (gssize)size);
for(gint i = 0; i < size; i++) {
gint n = rand() % 26;
g_string_append_c(buffer, (gchar)('a' + n));
}
return buffer;
}
GString* li_lua_togstring(lua_State *L, int ndx) {
const char *buf;
size_t len = 0;
GString *str = NULL;
if (lua_type(L, ndx) == LUA_TSTRING) {
buf = lua_tolstring(L, ndx, &len);
if (buf) str = g_string_new_len(buf, len);
} else {
lua_pushvalue(L, ndx);
buf = lua_tolstring(L, -1, &len);
if (buf) str = g_string_new_len(buf, len);
lua_pop(L, 1);
}
return str;
}
static void
process_command_output (CommandApplet *command_applet, gchar *output)
{
gtk_widget_set_tooltip_text (GTK_WIDGET (command_applet->label), command_applet->command);
if ((output == NULL) || (output[0] == 0))
{
gtk_label_set_text (command_applet->label, ERROR_OUTPUT);
return;
}
/* check if output is a custom GKeyFile */
if (g_str_has_prefix (output, "[Command]"))
{
GKeyFile *file = g_key_file_new ();
if (g_key_file_load_from_data (file, output, -1, G_KEY_FILE_NONE, NULL))
{
gchar *goutput = g_key_file_get_string (file, GK_COMMAND_GROUP, GK_COMMAND_OUTPUT, NULL);
gchar *icon = g_key_file_get_string (file, GK_COMMAND_GROUP, GK_COMMAND_ICON, NULL);
if (goutput)
{
gtk_label_set_use_markup (command_applet->label, TRUE);
gtk_label_set_markup (command_applet->label, goutput);
}
if (icon)
gtk_image_set_from_icon_name (command_applet->image, icon, 24);
g_free (goutput);
g_free (icon);
}
else
gtk_label_set_text (command_applet->label, ERROR_OUTPUT);
g_key_file_free (file);
}
else
{
/* check output length */
if (strlen(output) > command_applet->width)
{
GString *strip_output;
strip_output = g_string_new_len (output, command_applet->width);
g_free (output);
output = strip_output->str;
g_string_free (strip_output, FALSE);
}
/* remove last char if it is '\n' to avoid alignment problems */
if (g_str_has_suffix (output, "\n"))
{
output[strlen(output) - 1] = 0;
}
gtk_label_set_text (command_applet->label, output);
}
}
