void
msn_message_show_readable(MsnMessage *msg, const char *info,
gboolean text_body)
{
#if defined(PN_DEBUG)
GString *str;
size_t body_len;
const char *body;
GList *l;
g_return_if_fail(msg != NULL);
if (PECAN_LOG_LEVEL < PN_LOG_LEVEL_DEBUG)
return;
str = g_string_new(NULL);
/* Standard header. */
if (msg->charset == NULL)
{
g_string_append_printf(str,
"MIME-Version: 1.0\r\n"
"Content-Type: %s\r\n",
msg->content_type);
}
else
{
g_string_append_printf(str,
"MIME-Version: 1.0\r\n"
"Content-Type: %s; charset=%s\r\n",
msg->content_type, msg->charset);
}
for (l = msg->attr_list; l; l = l->next)
{
char *key;
const char *value;
key = l->data;
value = msn_message_get_attr(msg, key);
g_string_append_printf(str, "%s: %s\r\n", key, value);
}
g_string_append(str, "\r\n");
body = msn_message_get_bin_data(msg, &body_len);
if (msg->msnslp_message)
{
g_string_append_printf(str, "Session ID: %u\r\n", msg->msnslp_header.session_id);
g_string_append_printf(str, "ID: %u\r\n", msg->msnslp_header.id);
g_string_append_printf(str, "Offset: %" G_GUINT64_FORMAT "\r\n", msg->msnslp_header.offset);
g_string_append_printf(str, "Total size: %" G_GUINT64_FORMAT "\r\n", msg->msnslp_header.total_size);
g_string_append_printf(str, "Length: %u\r\n", msg->msnslp_header.length);
g_string_append_printf(str, "Flags: 0x%x\r\n", msg->msnslp_header.flags);
g_string_append_printf(str, "ACK ID: %u\r\n", msg->msnslp_header.ack_id);
g_string_append_printf(str, "SUB ID: %u\r\n", msg->msnslp_header.ack_sub_id);
g_string_append_printf(str, "ACK Size: %" G_GUINT64_FORMAT "\r\n", msg->msnslp_header.ack_size);
#ifdef PECAN_DEBUG_SLP_VERBOSE
if (body != NULL)
{
if (text_body)
{
g_string_append_len(str, body, body_len);
if (body[body_len - 1] == '\0')
{
str->len--;
g_string_append(str, " 0x00");
}
g_string_append(str, "\r\n");
}
else
{
gsize i;
for (i = 0; i < msg->body_len; i++)
{
g_string_append_printf(str, "%.2hhX ", body[i]);
if ((i % 16) == 15)
g_string_append(str, "\r\n");
}
g_string_append(str, "\r\n");
}
}
#endif
g_string_append_printf(str, "Footer: %u\r\n", msg->msnslp_footer.value);
}
else
{
if (body != NULL)
{
g_string_append_len(str, body, body_len);
g_string_append(str, "\r\n");
}
}
pn_debug ("info=[%s],str=[%s]", info, str->str);
g_string_free(str, TRUE);
#endif /* PN_DEBUG */
}
static void proxy_send_headers(liVRequest *vr, liChunkQueue *out) {
GString *head = g_string_sized_new(4095);
liHttpHeader *header;
GList *iter;
liHttpHeaderTokenizer header_tokenizer;
GString *tmp_str = vr->wrk->tmp_str;
g_string_append_len(head, GSTR_LEN(vr->request.http_method_str));
g_string_append_len(head, CONST_STR_LEN(" "));
g_string_append_len(head, GSTR_LEN(vr->request.uri.raw_path));
switch (vr->request.http_version) {
case LI_HTTP_VERSION_1_1:
/* g_string_append_len(head, CONST_STR_LEN(" HTTP/1.1\r\n")); */
g_string_append_len(head, CONST_STR_LEN(" HTTP/1.0\r\n"));
break;
case LI_HTTP_VERSION_1_0:
default:
g_string_append_len(head, CONST_STR_LEN(" HTTP/1.0\r\n"));
break;
}
li_http_header_tokenizer_start(&header_tokenizer, vr->request.headers, CONST_STR_LEN("Connection"));
while (li_http_header_tokenizer_next(&header_tokenizer, tmp_str)) {
if (0 == g_ascii_strcasecmp(tmp_str->str, "Upgrade")) {
g_string_append_len(head, CONST_STR_LEN("Connection: Upgrade\r\n"));
}
}
if (LI_HTTP_METHOD_GET != vr->request.http_method && LI_HTTP_METHOD_HEAD != vr->request.http_method) {
g_string_append_printf(head, "Content-Length: %" LI_GOFFSET_MODIFIER "i\r\n", vr->request.content_length);
}
for (iter = g_queue_peek_head_link(&vr->request.headers->entries); iter; iter = g_list_next(iter)) {
header = (liHttpHeader*) iter->data;
if (li_http_header_key_is(header, CONST_STR_LEN("Content-Length"))) continue;
if (li_http_header_key_is(header, CONST_STR_LEN("Transfer-Encoding"))) continue;
if (li_http_header_key_is(header, CONST_STR_LEN("TE"))) continue;
if (li_http_header_key_is(header, CONST_STR_LEN("Connection"))) continue;
if (li_http_header_key_is(header, CONST_STR_LEN("Proxy-Connection"))) continue;
if (li_http_header_key_is(header, CONST_STR_LEN("X-Forwarded-Proto"))) continue;
if (li_http_header_key_is(header, CONST_STR_LEN("X-Forwarded-For"))) continue;
g_string_append_len(head, GSTR_LEN(header->data));
g_string_append_len(head, CONST_STR_LEN("\r\n"));
}
g_string_append_len(head, CONST_STR_LEN("X-Forwarded-For: "));
g_string_append_len(head, GSTR_LEN(vr->coninfo->remote_addr_str));
g_string_append_len(head, CONST_STR_LEN("\r\n"));
if (vr->coninfo->is_ssl) {
g_string_append_len(head, CONST_STR_LEN("X-Forwarded-Proto: https\r\n"));
} else {
g_string_append_len(head, CONST_STR_LEN("X-Forwarded-Proto: http\r\n"));
}
/* terminate http header */
g_string_append_len(head, CONST_STR_LEN("\r\n"));
li_chunkqueue_append_string(out, head);
}
static void request_proppatch(DavServer *server, DavRequest *request) {
GString *buffer;
GString *physpath = g_string_sized_new(0);
struct stat st;
GPtrArray *proplist = NULL;
guint i, l;
guint status;
if (!dav_xml_parse_proppatch(server, request, &proplist)) goto cleanup;
dav_server_map_path(physpath, server, request->url_path);
if (-1 == stat(physpath->str, &st)) {
switch (errno) {
case EACCES:
dav_response_error(server, request, 403);
goto cleanup;
case ENOENT:
case ENOTDIR:
dav_response_error(server, request, 404);
goto cleanup;
default:
dav_response_error(server, request, 500);
/* TODO: log error */
goto cleanup;
}
}
if (S_ISDIR(st.st_mode) && '/' != request->url_path->str[request->url_path->len-1]) {
dav_append_trailing_slash(request->url_path);
dav_response_location(server, request, request->url_path);
}
if (S_ISDIR(st.st_mode) || S_ISREG(st.st_mode)) {
dav_response_error(server, request, 403);
goto cleanup;
}
if (!dav_server_set_properties_begin(server, request)) {
/* hard fail - internal server error. reason should be logged already */
dav_response_error(server, request, 500);
goto cleanup;
}
buffer = dav_response_prepare_buffer(server, request, 0);
request->response_status = 207;
g_string_append_len(buffer, GSTR_LEN(&XML_Start));
g_string_append_len(buffer, GSTR_LEN(&MultiStatus_Start));
g_string_append_len(buffer, CONST_STR_LEN("<D:response><D:href>"));
g_string_append_len(buffer, GSTR_LEN(request->http_base));
g_string_append_len(buffer, GSTR_LEN(request->url_path)); /* TODO: encode url */
g_string_append_len(buffer, CONST_STR_LEN("</D:href><D:propstat><D:prop>"));
for (i = 0, l = proplist->len; i < l; i += 3) {
GString *prop_ns = g_ptr_array_index(proplist, i);
GString *prop_name = g_ptr_array_index(proplist, i+1);
GString *value = g_ptr_array_index(proplist, i+2);
status = dav_server_set_property_check(server, request, physpath, prop_ns, prop_name, value);
if (200 != status) goto failed_check;
}
/* everything looks fine. now really set and commit */
for (i = 0, l = proplist->len; i < l; i += 3) {
GString *prop_ns = g_ptr_array_index(proplist, i);
GString *prop_name = g_ptr_array_index(proplist, i+1);
GString *value = g_ptr_array_index(proplist, i+2);
if (!dav_server_set_property(server, request, physpath, prop_ns, prop_name, value)) {
/* hard fail - internal server error. reason should be logged already */
dav_server_set_properties_rollback(server, request);
dav_response_error(server, request, 500);
goto cleanup;
}
if (GSTR_EQUAL(prop_ns, "DAV:")) {
g_string_append_printf(buffer, "<D:%s/>", prop_name->str);
} else {
g_string_append_printf(buffer, "<R:%s xmlns:R=\"%s\"/>", prop_name->str, prop_ns->str);
}
}
if (!dav_server_set_properties_commit(server, request)) {
/* hard fail - internal server error. reason should be logged already */
dav_response_error(server, request, 500);
goto cleanup;
}
g_string_append_len(buffer, CONST_STR_LEN("</D:prop><D:status>" STATUS_LINE_200 "</D:status></D:propstat>"));
g_string_append_len(buffer, CONST_STR_LEN("</D:response>\n"));
g_string_append_len(buffer, GSTR_LEN(&MultiStatus_End));
dav_response_xml_header(server, request);
goto cleanup;
failed_check:
{
guint failed_ndx = i;
{
GString *prop_ns = g_ptr_array_index(proplist, failed_ndx);
GString *prop_name = g_ptr_array_index(proplist, failed_ndx+1);
if (GSTR_EQUAL(prop_ns, "DAV:")) {
g_string_append_printf(buffer, "<D:%s/>", prop_name->str);
} else {
g_string_append_printf(buffer, "<R:%s xmlns:R=\"%s\"/>", prop_name->str, prop_ns->str);
}
g_string_append_printf(buffer, "</D:prop><D:status>HTTP/1.1 %i %s</D:status></D:propstat>", status, dav_response_status_str(status));
}
if (proplist->len > 3) {
for (i = 0, l = proplist->len; i < l; i += 3) {
GString *prop_ns = g_ptr_array_index(proplist, i);
GString *prop_name = g_ptr_array_index(proplist, i+1);
if (failed_ndx == i) continue;
if (GSTR_EQUAL(prop_ns, "DAV:")) {
g_string_append_printf(buffer, "<D:%s/>", prop_name->str);
} else {
g_string_append_printf(buffer, "<R:%s xmlns:R=\"%s\"/>", prop_name->str, prop_ns->str);
}
}
g_string_append_len(buffer, CONST_STR_LEN("</D:prop><D:status>" STATUS_LINE_424 "</D:status></D:propstat>"));
}
}
g_string_append_len(buffer, CONST_STR_LEN("</D:response>\n"));
g_string_append_len(buffer, GSTR_LEN(&MultiStatus_End));
dav_response_xml_header(server, request);
cleanup:
g_ptr_array_free(proplist, TRUE);
g_string_free(physpath, TRUE);
}
static gchar *
log_matcher_string_replace(LogMatcher *s, LogMessage *msg, gint value_handle, const gchar *value, gssize value_len, LogTemplate *replacement, gssize *new_length)
{
LogMatcherString *self = (LogMatcherString *) s;
GString *new_value = NULL;
gsize current_ofs = 0;
gboolean first_round = TRUE;
if (value_len < 0)
value_len = strlen(value);
const gchar *match;
do
{
if (current_ofs == value_len)
break;
match = log_matcher_string_match_string(self, value + current_ofs, value_len - current_ofs);
if (match != NULL)
{
/* start_ofs & end_ofs are relative to the original string */
gsize start_ofs = match - value;
gsize end_ofs = start_ofs + self->pattern_len;
if (start_ofs == end_ofs && !first_round)
{
start_ofs++;
end_ofs++;
}
if ((s->flags & LMF_STORE_MATCHES))
log_msg_clear_matches(msg);
if (!new_value)
new_value = g_string_sized_new(value_len);
g_string_append_len(new_value, value + current_ofs, start_ofs - current_ofs);
log_template_append_format(replacement, msg, NULL, LTZ_LOCAL, 0, NULL, new_value);
current_ofs = end_ofs;
if ((self->super.flags & LMF_GLOBAL) == 0)
{
g_string_append_len(new_value, value + current_ofs, value_len - current_ofs);
break;
}
}
else
{
if (new_value)
{
/* no more matches, append the end of the string */
g_string_append_len(new_value, value + current_ofs, value_len - current_ofs);
}
}
first_round = FALSE;
}
while (match && (self->super.flags & LMF_GLOBAL));
if (new_value)
{
if (new_length)
*new_length = new_value->len;
return g_string_free(new_value, FALSE);
}
return NULL;
}
static void
receive_message_loop(void)
{
XEvent e;
GString *msg = NULL;
char msg_temp[21];
size_t len;
skype_debug_info("skype_x11", "receive_message_loop started\n");
msg_temp[20] = '\0';
XSetErrorHandler(x11_error_handler);
while(run_loop)
{
if (!disp)
{
skype_debug_error("skype_x11", "display has disappeared\n");
g_thread_create((GThreadFunc)skype_message_received, g_strdup("CONNSTATUS LOGGEDOUT"), FALSE, NULL);
break;
}
Bool event_bool;
g_static_mutex_lock(&x11_mutex);
event_bool = XCheckTypedEvent(disp, ClientMessage, &e);
g_static_mutex_unlock(&x11_mutex);
if (!event_bool)
{
g_thread_yield();
usleep(1000);
//XPeekEvent(disp, &e);
//sleep(1);
continue;
}/*
XNextEvent(disp, &e);
printf("skype event: %d (clientmessage: %d)\n", e.type, ClientMessage);
if (e.type != ClientMessage)
continue;*/
strncpy(msg_temp, e.xclient.data.b, 20);
len = strlen(msg_temp);
if (e.xclient.message_type == message_start)
msg = g_string_new_len(msg_temp, len);
else if (e.xclient.message_type == message_continue)
msg = g_string_append_len(msg, msg_temp, len);
else
{
skype_debug_info("skype_x11", "unknown message type: %d\n", e.xclient.message_type);
if (disp)
{
g_static_mutex_lock(&x11_mutex);
XFlush(disp);
g_static_mutex_unlock(&x11_mutex);
}
continue;
}
if (len < 20)
{
g_thread_create((GThreadFunc)skype_message_received, (void *)g_string_free(msg, FALSE), FALSE, NULL);
if (disp)
{
g_static_mutex_lock(&x11_mutex);
XFlush(disp);
g_static_mutex_unlock(&x11_mutex);
}
}
}
}
static void
lua_tcp_handler (int fd, short what, gpointer ud)
{
struct lua_tcp_cbdata *cbd = ud;
gchar inbuf[BUFSIZ];
gssize r;
guint slen;
if (what == EV_READ) {
g_assert (cbd->partial || cbd->in != NULL);
r = read (cbd->fd, inbuf, sizeof (inbuf));
if (r <= 0) {
/*
* We actually can have connection reset here, so we just check if
* the cumulative buffer is not empty
*/
if (cbd->partial) {
if (r < 0) {
lua_tcp_push_error (cbd, strerror (errno));
}
}
else {
if (cbd->in->len > 0) {
lua_tcp_push_data (cbd, cbd->in->str, cbd->in->len);
}
else {
lua_tcp_push_error (cbd, "IO read error");
}
}
lua_tcp_maybe_free (cbd);
}
else {
if (cbd->partial) {
lua_tcp_push_data (cbd, inbuf, r);
}
else {
g_string_append_len (cbd->in, inbuf, r);
if (cbd->stop_pattern) {
slen = strlen (cbd->stop_pattern);
if (cbd->in->len >= slen) {
if (memcmp (cbd->stop_pattern, cbd->in->str +
(cbd->in->len - slen), slen) == 0) {
lua_tcp_push_data (cbd, cbd->in->str, cbd->in->len);
lua_tcp_maybe_free (cbd);
}
}
}
}
}
}
else if (what == EV_WRITE) {
lua_tcp_write_helper (cbd);
}
else {
lua_tcp_push_error (cbd, "IO timeout");
lua_tcp_maybe_free (cbd);
}
}
static void
cb_error_received (GCutProcess *process, const gchar *chunk, gsize size,
gpointer user_data)
{
g_string_append_len(error_string, chunk, size);
}
static void
text_handler (GMarkupParseContext *context,
const gchar *text,
gsize text_len,
gpointer user_data,
GError **error)
{
MarkupData *md = user_data;
if (md->accel_marker == 0)
{
/* Just append all the text */
md->index += text_len;
g_string_append_len (md->text, text, text_len);
}
else
{
/* Parse the accelerator */
const gchar *p;
const gchar *end;
const gchar *range_start;
const gchar *range_end;
gssize uline_index = -1;
gsize uline_len = 0; /* Quiet GCC */
range_end = NULL;
range_start = text;
p = text;
end = text + text_len;
while (p != end)
{
gunichar c;
c = g_utf8_get_char (p);
if (range_end)
{
if (c == md->accel_marker)
{
/* escaped accel marker; move range_end
* past the accel marker that came before,
* append the whole thing
*/
range_end = g_utf8_next_char (range_end);
g_string_append_len (md->text,
range_start,
range_end - range_start);
md->index += range_end - range_start;
/* set next range_start, skipping accel marker */
range_start = g_utf8_next_char (p);
}
else
{
/* Don't append the accel marker (leave range_end
* alone); set the accel char to c; record location for
* underline attribute
*/
if (md->accel_char == 0)
md->accel_char = c;
g_string_append_len (md->text,
range_start,
range_end - range_start);
md->index += range_end - range_start;
/* The underline should go underneath the char
* we're setting as the next range_start
*/
uline_index = md->index;
uline_len = g_utf8_next_char (p) - p;
/* set next range_start to include this char */
range_start = p;
}
/* reset range_end */
range_end = NULL;
}
else if (c == md->accel_marker)
{
range_end = p;
}
p = g_utf8_next_char (p);
}
if (range_end)
{
g_string_append_len (md->text,
range_start,
range_end - range_start);
md->index += range_end - range_start;
}
else
{
g_string_append_len (md->text,
range_start,
end - range_start);
md->index += end - range_start;
}
if (md->attr_list != NULL && uline_index >= 0)
{
/* Add the underline indicating the accelerator */
PangoAttribute *attr;
attr = pango_attr_underline_new (PANGO_UNDERLINE_LOW);
attr->start_index = uline_index;
attr->end_index = uline_index + uline_len;
pango_attr_list_change (md->attr_list, attr);
}
}
}
/* NOTE: Sticking to natural behavior of returning a list with the unchanged input_string, incase nothing can be substituted, however, this is expensive. A better way would be to return NULL incase of no changes, and let the caller handle the NULL case, which implies that there is no change in the input_string */
GPtrArray* substitute_parameters(gchar *input_string, FmFileInfoList *file_info_list)
{
//printf("Input string is %s\n", input_string);
GPtrArray *out_string_array = g_ptr_array_new();
if(strchr(input_string, '%') == NULL){
//printf("Found nothing to expand. Returning input_string.\n");
g_ptr_array_add(out_string_array, g_string_new(input_string));
return out_string_array;
}
gsize i, j;
gsize len_file_list = fm_list_get_length(file_info_list);
GString *out_string = g_string_new(NULL);
gsize first_pos = strcspn(input_string, "%");
gchar *pos = input_string + first_pos;
g_string_append_len(out_string, input_string, first_pos);
GString *g_string_i = NULL;
gchar *base_name = NULL, *base_dir = NULL, *file_name = NULL, *host_name = NULL, *user_name = NULL, *port = NULL, *scheme = NULL, *uri = NULL, *file_name_wo_ext = NULL, *ext_pos = NULL;
gboolean array_is_init = FALSE;
FmFileInfo *file_info_i = NULL, *file_info_j = NULL;
char temp[256];
gboolean curr_dir_flag;
while((pos = strchr(pos, '%')) != NULL){
switch(pos[1]){
case 'b':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
base_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
g_string_append(g_string_i, base_name);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
base_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, base_name);
g_string_append_c(g_string_i, ' ');
}
break;
case 'B':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
base_name = (gchar *)fm_file_info_get_disp_name(file_info_j);
g_string_append(g_string_i, base_name);
g_string_append_c(g_string_i, ' ');
}
}
break;
case 'c':
/* Works */
memset(temp, 256, 0);
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
sprintf(temp, "%u", len_file_list);
g_string_append(g_string_i, temp);
g_string_append_c(g_string_i, ' ');
}
break;
case 'd':
/* Works */
curr_dir_flag = FALSE;
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
if(fm_file_info_is_dir(file_info_i) == TRUE){
base_dir = fm_path_to_str(fm_file_info_get_path(file_info_i));
} else {
if(curr_dir_flag == FALSE){
base_dir = g_get_current_dir();
curr_dir_flag = TRUE;
} else {
continue;
}
}
g_string_append(g_string_i, base_dir);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_free(base_dir);
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
if(fm_file_info_is_dir(file_info_i) == TRUE){
base_dir = fm_path_to_str(fm_file_info_get_path(file_info_i));
} else {
if(curr_dir_flag == FALSE){
base_dir = g_get_current_dir();
curr_dir_flag = TRUE;
} else {
continue;
}
}
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, base_dir);
g_string_append_c(g_string_i, ' ');
}
g_free(base_dir);
break;
case 'D':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
curr_dir_flag = FALSE;
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
if(fm_file_info_is_dir(file_info_j) == TRUE){
base_dir = fm_path_to_str(fm_file_info_get_path(file_info_j));
} else {
if(curr_dir_flag == FALSE){
base_dir = g_get_current_dir();
curr_dir_flag = TRUE;
} else {
continue;
}
}
g_string_append(g_string_i, base_dir);
g_string_append_c(g_string_i, ' ');
g_free(base_dir);
}
}
break;
case 'f':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
file_name = (gchar *)fm_path_to_str(fm_file_info_get_path(file_info_i));
g_string_append(g_string_i, file_name);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_free(file_name);
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
file_name = (gchar *)fm_path_to_str(fm_file_info_get_path(file_info_i));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, file_name);
g_string_append_c(g_string_i, ' ');
}
g_free(file_name);
break;
case 'F':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
file_name = (gchar *)fm_path_to_str(fm_file_info_get_path(file_info_j));
g_string_append(g_string_i, file_name);
g_string_append_c(g_string_i, ' ');
g_free(file_name);
}
}
break;
case 'h':
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
file_info_i = fm_list_peek_nth(file_info_list, i);
host_name = get_host_name(file_info_i);
g_string_append(g_string_i, host_name);
g_string_append_c(g_string_i, ' ');
}
break;
case 'n':
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
file_info_i = fm_list_peek_nth(file_info_list, i);
user_name = get_user_name(file_info_i);
g_string_append(g_string_i, user_name);
g_string_append_c(g_string_i, ' ');
}
break;
case 'p':
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
file_info_i = fm_list_peek_nth(file_info_list, i);
port = get_port(file_info_i);
g_string_append(g_string_i, port);
g_string_append_c(g_string_i, ' ');
}
break;
case 's':
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
file_info_i = fm_list_peek_nth(file_info_list, i);
scheme = get_scheme(file_info_i);
g_string_append(g_string_i, scheme);
g_string_append_c(g_string_i, ' ');
}
break;
case 'u':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
uri = fm_path_to_uri(fm_file_info_get_path(file_info_i));
g_string_append(g_string_i, uri);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
uri = fm_path_to_uri(fm_file_info_get_path(file_info_i));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, uri);
g_string_append_c(g_string_i, ' ');
}
break;
case 'U':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
uri = fm_path_to_uri(fm_file_info_get_path(file_info_j));
g_string_append(g_string_i, uri);
g_string_append_c(g_string_i, ' ');
}
}
break;
case 'w':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
//printf("%s\n", file_name);
ext_pos = g_strrstr(fm_file_info_get_disp_name(fm_list_peek_nth(file_info_list, i)), ".");
if(ext_pos != NULL)
file_name_wo_ext = g_strndup(file_name, strlen(file_name) - strlen(ext_pos));
else
file_name_wo_ext = g_strdup(file_name);
g_string_append(g_string_i, file_name_wo_ext);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_free(file_name_wo_ext);
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos != NULL)
file_name_wo_ext = g_strndup(file_name, strlen(file_name) - strlen(ext_pos));
else
file_name_wo_ext = g_strdup(file_name);
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, file_name_wo_ext);
g_string_append_c(g_string_i, ' ');
}
g_free(file_name_wo_ext);
break;
case 'W':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_j);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos != NULL)
file_name_wo_ext = g_strndup(file_name, strlen(file_name) - strlen(ext_pos));
else
file_name_wo_ext = g_strdup(file_name);
g_string_append(g_string_i, file_name_wo_ext);
g_string_append_c(g_string_i, ' ');
g_free(file_name_wo_ext);
}
}
break;
case 'x':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
file_info_i = fm_list_peek_nth(file_info_list, i);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos != NULL){
g_string_i = g_string_new(out_string->str);
g_string_append(g_string_i, ext_pos);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_free(file_name_wo_ext);
g_string_free(g_string_i, TRUE);
}
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos == NULL)
break;
for(i=0; i<out_string_array->len;++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, ext_pos);
g_string_append_c(g_string_i, ' ');
}
break;
case 'X':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_j);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos != NULL){
g_string_append(g_string_i, ext_pos);
g_string_append_c(g_string_i, ' ');
}
}
}
break;
case '%':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, "% ");
}
break;
default:
return NULL;
}
pos += 2;
(array_is_init == FALSE)?array_is_init = TRUE:0;
}
return out_string_array;
}
static gboolean
fu_fuzzer_rom_create (GError **error)
{
GString *str;
guint8 *buffer;
g_autofree guint8 *blob_header = NULL;
g_autofree guint8 *blob_ifr = NULL;
g_autoptr(GHashTable) hash = NULL;
hash = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL,
(GDestroyNotify) _g_string_unref);
/* 24 byte header */
blob_header = g_malloc0 (0x200);
buffer = blob_header;
memcpy (buffer, "\x55\xaa", 2);
buffer[0x02] = 1; /* rom_len / 512 */
buffer[0x03] = 0x20; /* entry_point lo to blob just after header */
buffer[0x04] = 'K'; /* entry_point hi (NVIDIA) */
buffer[0x05] = '7'; /* entry_point higher (NVIDIA) */
memcpy (&buffer[0x6], "xxxxxxxxxxxxxxxxxx", 18); /* reserved */
buffer[0x18] = 0x20; /* cpi_ptr lo */
buffer[0x19] = 0x00; /* cpi_ptr hi */
memcpy (&blob_header[0x6], "hdr-no-data ", 18);
g_hash_table_insert (hash, (gpointer) "header-no-data.rom",
g_string_new_len ((gchar *) blob_header, 512));
/* data for header */
buffer = &blob_header[0x20];
memcpy (&buffer[0x00], "PCIR", 4); /* magic */
memcpy (&buffer[0x04], "\0\0", 2); /* vendor */
memcpy (&buffer[0x06], "\0\0", 2); /* device id */
memcpy (&buffer[0x08], "\0\0", 2); /* device_list_ptr */
buffer[0x0a] = 0x1c; /* data_len lo */
buffer[0x0b] = 0x00; /* data_len hi */
buffer[0x0c] = 0x0; /* data_rev */
memcpy (&buffer[0x0d], "\0\0\0", 3); /* class_code */
buffer[0x10] = 0x01; /* image_len lo / 512 */
buffer[0x11] = 0; /* image_len hi / 512 */
buffer[0x12] = 0; /* revision_level lo */
buffer[0x13] = 0; /* revision_level hi */
buffer[0x14] = 0x00; /* code_type, Intel x86 */
buffer[0x15] = 0x80; /* last_image */
buffer[0x16] = 0x0; /* max_runtime_len lo / 512 */
buffer[0x17] = 0x0; /* max_runtime_len hi / 512 */
buffer[0x18] = 0x00; /* config_header_ptr lo */
buffer[0x19] = 0x00; /* config_header_ptr hi */
buffer[0x1a] = 0x00; /* dmtf_clp_ptr lo (used for Intel FW) */
buffer[0x1b] = 0x00; /* dmtf_clp_ptr hi (used for Intel FW) */
blob_header[0x200-1] = 0x5c; /* checksum */
/* blob */
memcpy (&buffer[0x1c], "Version 1.0", 12);
memcpy (&blob_header[0x6], "hdr-data-payload ", 18);
g_hash_table_insert (hash, (gpointer) "header-data-payload.rom",
g_string_new_len ((gchar *) blob_header, 512));
/* optional IFR header on some NVIDIA blobs */
blob_ifr = g_malloc0 (0x80);
buffer = blob_ifr;
memcpy (buffer, "NVGI", 4);
fu_common_write_uint16 (&buffer[0x15], 0x80, G_BIG_ENDIAN);
g_hash_table_insert (hash, (gpointer) "naked-ifr.rom",
g_string_new_len ((const gchar *) blob_ifr, 0x80));
str = g_string_new_len ((gchar *) blob_ifr, 0x80);
memcpy (&blob_header[0x6], (gpointer) "ifr-hdr-data-payld", 18);
g_string_append_len (str, (gchar *) blob_header, 0x200);
g_hash_table_insert (hash, (gpointer) "ifr-header-data-payload.rom", str);
/* dump to files */
return fu_fuzzer_write_files (hash, error);
}
void test_mysqld_auth_with_pw(void) {
const char raw_packet[] =
":\0\0\1"
"\205\246\3\0"
"\0\0\0\1"
"\10"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"root\0"
"\24\241\304\260>\255\1:F,\256\337K\323\340\4\273\354I\256\204"
;
const char raw_challenge[] =
"%@R[SoWC" /* part 1 */
"+L|LG_+R={tV"; /* part 2 */
GString *packet, *challenge, *hashed_password;
network_mysqld_auth_response *auth;
auth = network_mysqld_auth_response_new();
g_string_assign(auth->username, "root");
auth->capabilities =
CLIENT_LONG_PASSWORD |
CLIENT_LONG_FLAG |
CLIENT_LOCAL_FILES |
CLIENT_PROTOCOL_41 |
CLIENT_INTERACTIVE |
CLIENT_TRANSACTIONS |
CLIENT_SECURE_CONNECTION |
CLIENT_MULTI_STATEMENTS |
CLIENT_MULTI_RESULTS;
auth->max_packet_size = 1 << 24;
auth->charset = 8;
challenge = g_string_new(NULL);
hashed_password = g_string_new(NULL);
g_string_append_len(challenge, raw_challenge, sizeof(raw_challenge) - 1);
network_mysqld_proto_password_hash(hashed_password, C("123"));
network_mysqld_proto_password_scramble(auth->response, S(challenge), S(hashed_password));
g_string_free(hashed_password, TRUE);
packet = g_string_new(NULL);
network_mysqld_proto_append_int8(packet, 58);
network_mysqld_proto_append_int8(packet, 0);
network_mysqld_proto_append_int8(packet, 0);
network_mysqld_proto_append_int8(packet, 1);
g_assert(0 == network_mysqld_proto_append_auth_response(packet, auth));
g_assert(packet->len == sizeof(raw_packet) - 1);
#if 0
for (i = 0; i < packet->len; i++) {
g_message("%s: [%d] %02x %c= %02x", G_STRLOC, i, packet->str[i], packet->str[i] == raw_packet[i] ? '=' : '!', raw_packet[i]);
}
#endif
g_assert(0 == memcmp(packet->str, raw_packet, sizeof(raw_packet) - 1));
network_mysqld_auth_response_free(auth);
g_string_free(packet, TRUE);
g_string_free(challenge, TRUE);
}
gchar *unmime_header(const gchar *encoded_str, gboolean addr_field)
{
const gchar *p = encoded_str;
const gchar *eword_begin_p, *encoding_begin_p, *text_begin_p,
*eword_end_p;
gchar charset[32];
gchar encoding;
gchar *conv_str;
GString *outbuf;
gchar *out_str;
gsize out_len;
int in_quote = FALSE;
outbuf = g_string_sized_new(strlen(encoded_str) * 2);
while (*p != '\0') {
gchar *decoded_text = NULL;
const gchar *quote_p;
gint len;
eword_begin_p = strstr(p, ENCODED_WORD_BEGIN);
if (!eword_begin_p) {
g_string_append(outbuf, p);
break;
}
quote_p = p;
while ((quote_p = strchr(quote_p, '"')) != NULL) {
if (quote_p && quote_p < eword_begin_p) {
/* Found a quote before the encoded word. */
in_quote = !in_quote;
quote_p++;
}
if (quote_p >= eword_begin_p)
break;
}
encoding_begin_p = strchr(eword_begin_p + 2, '?');
if (!encoding_begin_p) {
g_string_append(outbuf, p);
break;
}
text_begin_p = strchr(encoding_begin_p + 1, '?');
if (!text_begin_p) {
g_string_append(outbuf, p);
break;
}
eword_end_p = strstr(text_begin_p + 1, ENCODED_WORD_END);
if (!eword_end_p) {
g_string_append(outbuf, p);
break;
}
if (p == encoded_str) {
g_string_append_len(outbuf, p, eword_begin_p - p);
p = eword_begin_p;
} else {
/* ignore spaces between encoded words */
const gchar *sp;
for (sp = p; sp < eword_begin_p; sp++) {
if (!g_ascii_isspace(*sp)) {
g_string_append_len
(outbuf, p, eword_begin_p - p);
p = eword_begin_p;
break;
}
}
}
len = MIN(sizeof(charset) - 1,
encoding_begin_p - (eword_begin_p + 2));
memcpy(charset, eword_begin_p + 2, len);
charset[len] = '\0';
encoding = g_ascii_toupper(*(encoding_begin_p + 1));
if (encoding == 'B') {
decoded_text = g_malloc
(eword_end_p - (text_begin_p + 1) + 1);
len = base64_decode(decoded_text, text_begin_p + 1,
eword_end_p - (text_begin_p + 1));
decoded_text[len] = '\0';
} else if (encoding == 'Q') {
decoded_text = g_malloc
(eword_end_p - (text_begin_p + 1) + 1);
len = qp_decode_q_encoding
(decoded_text, text_begin_p + 1,
eword_end_p - (text_begin_p + 1));
} else {
g_string_append_len(outbuf, p, eword_end_p + 2 - p);
p = eword_end_p + 2;
continue;
}
/* An encoded word MUST not appear within a quoted string,
* so quoting that word after decoding should be safe.
* We check there are no quotes just to be sure. If there
* are, well, the comma won't pose a problem, probably.
*/
if (addr_field && strchr(decoded_text, ',') && !in_quote &&
!strchr(decoded_text, '"')) {
gchar *tmp = g_strdup_printf("\"%s\"", decoded_text);
g_free(decoded_text);
decoded_text = tmp;
}
/* convert to UTF-8 */
conv_str = conv_codeset_strdup(decoded_text, charset, NULL);
if (!conv_str || !g_utf8_validate(conv_str, -1, NULL)) {
g_free(conv_str);
conv_str = g_malloc(len + 1);
conv_utf8todisp(conv_str, len + 1, decoded_text);
}
g_string_append(outbuf, conv_str);
g_free(conv_str);
g_free(decoded_text);
p = eword_end_p + 2;
}
out_str = outbuf->str;
out_len = outbuf->len;
g_string_free(outbuf, FALSE);
return g_realloc(out_str, out_len + 1);
}
/*
* We are adding an idle handler - we do not need to hold the gdk lock
* for this.
*
* We can't just grab the GDK lock and call the real_error function
* since this runs a dialog, which has a nested g_main loop - glib
* doesn't like haveing main loops active in two threads at one
* time. When the idle handler gets run it is from the main thread.
*
*/
void
libbalsa_information_varg(GtkWindow *parent, LibBalsaInformationType type,
const char *fmt, va_list ap)
{
struct information_data *data;
g_return_if_fail(fmt != NULL);
g_assert(libbalsa_real_information_func != NULL);
#ifdef HAVE_NOTIFY
if (notify_is_initted()) {
gchar *msg, *p, *q;
GString *escaped;
NotifyNotification *note;
char *icon_str;
switch (type) {
case LIBBALSA_INFORMATION_MESSAGE:
icon_str = "dialog-information";
break;
case LIBBALSA_INFORMATION_WARNING:
icon_str = "dialog-warning";
break;
case LIBBALSA_INFORMATION_ERROR:
icon_str = "dialog-error";
break;
default:
icon_str = NULL;
break;
}
msg = g_strdup_vprintf(fmt, ap);
/* libnotify/DBUS uses HTML markup, so we must replace '<' and
* '&' with the corresponding entity in the message string. */
escaped = g_string_new(NULL);
for (p = msg; (q = strpbrk(p, "<>&\"")) != NULL; p = ++q) {
g_string_append_len(escaped, p, q - p);
switch (*q) {
case '<':
g_string_append(escaped, "<");
break;
case '>':
g_string_append(escaped, ">");
break;
case '&':
g_string_append(escaped, "&");
break;
case '"':
g_string_append(escaped, """);
break;
default:
break;
}
}
g_string_append(escaped, p);
g_free(msg);
#if HAVE_NOTIFY >= 7
note = notify_notification_new("Balsa", escaped->str, icon_str);
notify_notification_set_hint(note, "desktop-entry",
g_variant_new_string("balsa"));
#else
/* prior to 0.7.0 */
note = notify_notification_new("Balsa", escaped->str, icon_str, NULL);
#endif
g_string_free(escaped, TRUE);
notify_notification_set_timeout(note, 7000); /* 7 seconds */
notify_notification_show(note, NULL);
if (parent) {
/* Close with parent if earlier. */
g_object_weak_ref(G_OBJECT(parent),
lbi_notification_parent_weak_notify, note);
g_signal_connect(note, "closed",
G_CALLBACK(lbi_notification_closed_cb),
parent);
} else
g_object_unref(note);
return;
}
/* Fall through to the ordinary notification scheme */
#endif
data = g_new(struct information_data, 1);
data->parent = parent;
data->message_type = type;
/* We format the string here. It must be free()d in the idle
* handler We parse the args here because by the time the idle
* function runs we will no longer be in this stack frame.
*/
data->msg = g_strdup_vprintf(fmt, ap);
if (parent)
g_object_add_weak_pointer(G_OBJECT(parent),
(gpointer) & data->parent);
g_idle_add((GSourceFunc) libbalsa_information_idle_handler, data);
}
void
gdata_parser_string_append_escaped (GString *xml_string, const gchar *pre, const gchar *element_content, const gchar *post)
{
/* Allocate 10 extra bytes when reallocating the GString, to try and avoid having to reallocate again, by assuming
* there will be an increase in the length of element_content when escaped of less than 10 characters. */
/* #define SIZE_FUZZINESS 10*/
/* guint new_size;*/
const gchar *p;
/* Expand xml_string as necessary */
/* TODO: There is no way to expand the allocation of a GString if you know in advance how much room
* lots of append operations are going to require. */
/* new_size = xml_string->len + strlen (pre) + strlen (element_content) + strlen (post) + SIZE_FUZZINESS;
if (new_size > xml_string->allocated_len)
g_string_set_size (xml_string, new_size);*/
/* Append the pre content */
if (pre != NULL)
g_string_append (xml_string, pre);
/* Loop through the string to be escaped. Code adapted from GLib's g_markup_escape_text() function.
* Copyright 2000, 2003 Red Hat, Inc.
* Copyright 2007, 2008 Ryan Lortie <*****@*****.**> */
p = element_content;
while (p != NULL && *p != '\0') {
const gchar *next = g_utf8_next_char (p);
switch (*p) {
case '&':
g_string_append (xml_string, "&");
break;
case '<':
g_string_append (xml_string, "<");
break;
case '>':
g_string_append (xml_string, ">");
break;
case '\'':
g_string_append (xml_string, "'");
break;
case '"':
g_string_append (xml_string, """);
break;
default: {
gunichar c = g_utf8_get_char (p);
if ((0x1 <= c && c <= 0x8) ||
(0xb <= c && c <= 0xc) ||
(0xe <= c && c <= 0x1f) ||
(0x7f <= c && c <= 0x84) ||
(0x86 <= c && c <= 0x9f)) {
g_string_append_printf (xml_string, "&#x%x;", c);
} else {
g_string_append_len (xml_string, p, next - p);
break;
}
}
}
p = next;
}
/* Append the post content */
if (post != NULL)
g_string_append (xml_string, post);
}
gpointer read_data_thread(gboolean *stop)
{
/* This is mostly taken straight from alsa-utils-1.0.19 amidi/amidi.c
by Clemens Ladisch <*****@*****.**> */
int err;
int npfds;
struct pollfd *pfds;
GString *string = NULL;
npfds = snd_rawmidi_poll_descriptors_count(input);
pfds = alloca(npfds * sizeof(struct pollfd));
snd_rawmidi_poll_descriptors(input, pfds, npfds);
do {
unsigned char buf[256];
int i, length;
unsigned short revents;
/* SysEx messages can't contain bytes with 8th bit set.
memset our buffer to 0xFF, so if for some reason we'll
get out of reply bounds, we'll catch it */
memset(buf, '\0', sizeof(buf));
err = poll(pfds, npfds, 200);
if (err < 0 && errno == EINTR)
break;
if (err < 0) {
g_error("poll failed: %s", strerror(errno));
break;
}
if ((err = snd_rawmidi_poll_descriptors_revents(input, pfds, npfds, &revents)) < 0) {
g_error("cannot get poll events: %s", snd_strerror(errno));
break;
}
if (revents & (POLLERR | POLLHUP))
break;
if (!(revents & POLLIN))
continue;
err = snd_rawmidi_read(input, buf, sizeof(buf));
if (err == -EAGAIN)
continue;
if (err < 0) {
g_error("cannot read: %s", snd_strerror(err));
break;
}
length = 0;
for (i = 0; i < err; ++i)
if ((unsigned char)buf[i] != 0xFE) /* ignore active sensing */
buf[length++] = buf[i];
i = 0;
while (i < length) {
int pos;
int bytes;
if (string == NULL) {
while (buf[i] != 0xF0 && i < length)
i++;
}
pos = i;
for (bytes = 0; (bytes<length-i) && (buf[i+bytes] != 0xF7); bytes++);
if (buf[i+bytes] == 0xF7) bytes++;
i += bytes;
if (string == NULL)
string = g_string_new_len((gchar*)&buf[pos], bytes);
else
g_string_append_len(string, (gchar*)&buf[pos], bytes);
if ((unsigned char)string->str[string->len-1] == 0xF7) {
/* push message on stack */
push_message(string);
string = NULL;
}
}
} while (*stop == FALSE);
if (string) {
g_string_free(string, TRUE);
string = NULL;
}
return NULL;
}
char*
p_gpg_sign(const char *const str, const char *const fp)
{
gpgme_ctx_t ctx;
gpgme_error_t error = gpgme_new(&ctx);
if (error) {
log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error));
return NULL;
}
gpgme_set_passphrase_cb(ctx, (gpgme_passphrase_cb_t)_p_gpg_passphrase_cb, NULL);
gpgme_key_t key = NULL;
error = gpgme_get_key(ctx, fp, &key, 1);
if (error || key == NULL) {
log_error("GPG: Failed to get key. %s %s", gpgme_strsource(error), gpgme_strerror(error));
gpgme_release(ctx);
return NULL;
}
gpgme_signers_clear(ctx);
error = gpgme_signers_add(ctx, key);
gpgme_key_unref(key);
if (error) {
log_error("GPG: Failed to load signer. %s %s", gpgme_strsource(error), gpgme_strerror(error));
gpgme_release(ctx);
return NULL;
}
char *str_or_empty = NULL;
if (str) {
str_or_empty = strdup(str);
} else {
str_or_empty = strdup("");
}
gpgme_data_t str_data;
gpgme_data_new_from_mem(&str_data, str_or_empty, strlen(str_or_empty), 1);
free(str_or_empty);
gpgme_data_t signed_data;
gpgme_data_new(&signed_data);
gpgme_set_armor(ctx,1);
error = gpgme_op_sign(ctx, str_data, signed_data, GPGME_SIG_MODE_DETACH);
gpgme_data_release(str_data);
gpgme_release(ctx);
if (error) {
log_error("GPG: Failed to sign string. %s %s", gpgme_strsource(error), gpgme_strerror(error));
gpgme_data_release(signed_data);
return NULL;
}
char *result = NULL;
size_t len = 0;
char *signed_str = gpgme_data_release_and_get_mem(signed_data, &len);
if (signed_str) {
GString *signed_gstr = g_string_new("");
g_string_append_len(signed_gstr, signed_str, len);
result = _remove_header_footer(signed_gstr->str, PGP_SIGNATURE_FOOTER);
g_string_free(signed_gstr, TRUE);
gpgme_free(signed_str);
}
if (passphrase_attempt) {
passphrase = strdup(passphrase_attempt);
}
return result;
}
static gboolean
xmms_sid_init (xmms_xform_t *xform)
{
xmms_sid_data_t *data;
const char *subtune;
gint ret;
data = g_new0 (xmms_sid_data_t, 1);
data->wrapper = sidplay_wrapper_init ();
xmms_xform_private_data_set (xform, data);
data->buffer = g_string_new ("");
for (;;) {
xmms_error_t error;
gchar buf[4096];
gint ret;
ret = xmms_xform_read (xform, buf, sizeof (buf), &error);
if (ret == -1) {
XMMS_DBG ("Error reading sid file");
return FALSE;
}
if (ret == 0) {
break;
}
g_string_append_len (data->buffer, buf, ret);
}
ret = sidplay_wrapper_load (data->wrapper, data->buffer->str,
data->buffer->len);
if (ret < 0) {
XMMS_DBG ("Couldn't load sid file");
return FALSE;
}
if (xmms_xform_metadata_get_str (xform, "subtune", &subtune)) {
int num;
num = atoi (subtune);
if (num < 1 || num > sidplay_wrapper_subtunes (data->wrapper)) {
XMMS_DBG ("Invalid subtune index");
return FALSE;
}
sidplay_wrapper_set_subtune (data->wrapper, num);
}
xmms_sid_get_media_info (xform);
xmms_xform_outdata_type_add (xform,
XMMS_STREAM_TYPE_MIMETYPE,
"audio/pcm",
XMMS_STREAM_TYPE_FMT_FORMAT,
XMMS_SAMPLE_FORMAT_S16,
XMMS_STREAM_TYPE_FMT_CHANNELS,
2,
XMMS_STREAM_TYPE_FMT_SAMPLERATE,
44100,
XMMS_STREAM_TYPE_END);
return TRUE;
}
char*
p_gpg_encrypt(const char *const barejid, const char *const message, const char *const fp)
{
ProfPGPPubKeyId *pubkeyid = g_hash_table_lookup(pubkeys, barejid);
if (!pubkeyid) {
return NULL;
}
if (!pubkeyid->id) {
return NULL;
}
gpgme_key_t keys[3];
keys[0] = NULL;
keys[1] = NULL;
keys[2] = NULL;
gpgme_ctx_t ctx;
gpgme_error_t error = gpgme_new(&ctx);
if (error) {
log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error));
return NULL;
}
gpgme_key_t receiver_key;
error = gpgme_get_key(ctx, pubkeyid->id, &receiver_key, 0);
if (error || receiver_key == NULL) {
log_error("GPG: Failed to get receiver_key. %s %s", gpgme_strsource(error), gpgme_strerror(error));
gpgme_release(ctx);
return NULL;
}
keys[0] = receiver_key;
gpgme_key_t sender_key = NULL;
error = gpgme_get_key(ctx, fp, &sender_key, 0);
if (error || sender_key == NULL) {
log_error("GPG: Failed to get sender_key. %s %s", gpgme_strsource(error), gpgme_strerror(error));
gpgme_release(ctx);
return NULL;
}
keys[1] = sender_key;
gpgme_data_t plain;
gpgme_data_new_from_mem(&plain, message, strlen(message), 1);
gpgme_data_t cipher;
gpgme_data_new(&cipher);
gpgme_set_armor(ctx, 1);
error = gpgme_op_encrypt(ctx, keys, GPGME_ENCRYPT_ALWAYS_TRUST, plain, cipher);
gpgme_data_release(plain);
gpgme_release(ctx);
gpgme_key_unref(receiver_key);
gpgme_key_unref(sender_key);
if (error) {
log_error("GPG: Failed to encrypt message. %s %s", gpgme_strsource(error), gpgme_strerror(error));
return NULL;
}
size_t len;
char *cipher_str = gpgme_data_release_and_get_mem(cipher, &len);
char *result = NULL;
if (cipher_str) {
GString *cipher_gstr = g_string_new("");
g_string_append_len(cipher_gstr, cipher_str, len);
result = _remove_header_footer(cipher_gstr->str, PGP_MESSAGE_FOOTER);
g_string_free(cipher_gstr, TRUE);
gpgme_free(cipher_str);
}
return result;
}
gchar *
gsearchtool_strdup_strftime (const gchar * format,
struct tm * time_pieces)
{
/* This function is borrowed from eel's eel_strdup_strftime() */
GString * string;
const char * remainder, * percent;
char code[4], buffer[512];
char * piece, * result, * converted;
size_t string_length;
gboolean strip_leading_zeros, turn_leading_zeros_to_spaces;
char modifier;
int i;
/* Format could be translated, and contain UTF-8 chars,
* so convert to locale encoding which strftime uses */
converted = g_locale_from_utf8 (format, -1, NULL, NULL, NULL);
g_return_val_if_fail (converted != NULL, NULL);
string = g_string_new ("");
remainder = converted;
/* Walk from % character to % character. */
for (;;) {
percent = strchr (remainder, '%');
if (percent == NULL) {
g_string_append (string, remainder);
break;
}
g_string_append_len (string, remainder,
percent - remainder);
/* Handle the "%" character. */
remainder = percent + 1;
switch (*remainder) {
case '-':
strip_leading_zeros = TRUE;
turn_leading_zeros_to_spaces = FALSE;
remainder++;
break;
case '_':
strip_leading_zeros = FALSE;
turn_leading_zeros_to_spaces = TRUE;
remainder++;
break;
case '%':
g_string_append_c (string, '%');
remainder++;
continue;
case '\0':
g_warning ("Trailing %% passed to gsearchtool_strdup_strftime");
g_string_append_c (string, '%');
continue;
default:
strip_leading_zeros = FALSE;
turn_leading_zeros_to_spaces = FALSE;
break;
}
modifier = 0;
if (strchr (SUS_EXTENDED_STRFTIME_MODIFIERS, *remainder) != NULL) {
modifier = *remainder;
remainder++;
if (*remainder == 0) {
g_warning ("Unfinished %%%c modifier passed to gsearchtool_strdup_strftime", modifier);
break;
}
}
if (strchr (C_STANDARD_STRFTIME_CHARACTERS, *remainder) == NULL) {
g_warning ("gsearchtool_strdup_strftime does not support "
"non-standard escape code %%%c",
*remainder);
}
/* Convert code to strftime format. We have a fixed
* limit here that each code can expand to a maximum
* of 512 bytes, which is probably OK. There's no
* limit on the total size of the result string.
*/
i = 0;
code[i++] = '%';
if (modifier != 0) {
#ifdef HAVE_STRFTIME_EXTENSION
code[i++] = modifier;
#endif
}
code[i++] = *remainder;
code[i++] = '\0';
string_length = strftime (buffer, sizeof (buffer),
code, time_pieces);
if (string_length == 0) {
/* We could put a warning here, but there's no
* way to tell a successful conversion to
* empty string from a failure.
*/
buffer[0] = '\0';
}
/* Strip leading zeros if requested. */
piece = buffer;
if (strip_leading_zeros || turn_leading_zeros_to_spaces) {
if (strchr (C_STANDARD_NUMERIC_STRFTIME_CHARACTERS, *remainder) == NULL) {
g_warning ("gsearchtool_strdup_strftime does not support "
"modifier for non-numeric escape code %%%c%c",
remainder[-1],
*remainder);
}
if (*piece == '0') {
do {
piece++;
} while (*piece == '0');
if (!g_ascii_isdigit (*piece)) {
piece--;
}
}
if (turn_leading_zeros_to_spaces) {
memset (buffer, ' ', piece - buffer);
piece = buffer;
}
}
remainder++;
/* Add this piece. */
g_string_append (string, piece);
}
/* Convert the string back into utf-8. */
result = g_locale_to_utf8 (string->str, -1, NULL, NULL, NULL);
g_string_free (string, TRUE);
g_free (converted);
return result;
}
/* first space between words is treated as wildcard character;
* we are looking for s2 in s1, so s2 will be breaked into words
*/
static gboolean
contains_helper (const gchar *s1,
const gchar *s2,
const gchar *region)
{
gchar *s1uni;
gchar *s2uni;
GSList *words;
gchar *next;
gboolean have_nonspace;
gboolean have_space;
GString *last_word, *w;
gboolean res;
gunichar unich;
glong len1, len2;
if (!s2)
return FALSE;
/* the initial word contains an empty string for sure */
if (!*s2)
return TRUE;
s1uni = e_util_utf8_normalize (s1);
if (s1uni == NULL)
return FALSE;
s2uni = e_util_utf8_normalize (s2);
if (s2uni == NULL) {
g_free (s1uni);
return FALSE;
}
len1 = g_utf8_strlen (s1uni, -1);
len2 = g_utf8_strlen (s2uni, -1);
if (len1 == 0 || len2 == 0) {
g_free (s1uni);
g_free (s2uni);
/* both are empty strings */
if (len1 == len2)
return TRUE;
return FALSE;
}
/* breaking s2 into words */
words = NULL;
have_nonspace = FALSE;
have_space = FALSE;
last_word = NULL;
w = g_string_new ("");
for (next = e_util_unicode_get_utf8 (s2uni, &unich); next && unich; next = e_util_unicode_get_utf8 (next, &unich)) {
if (unich == ' ') {
if (have_nonspace && !have_space) {
/* treat only first space after nonspace character as wildcard,
* so we will start new word here
*/
have_space = TRUE;
words = g_slist_append (words, w);
last_word = w;
w = g_string_new ("");
} else {
g_string_append_unichar (w, unich);
}
} else {
have_nonspace = TRUE;
have_space = FALSE;
g_string_append_unichar (w, unich);
}
}
if (have_space) {
/* there was one or more spaces at the end of string,
* concat actual word with that last one
*/
g_string_append_len (last_word, w->str, w->len);
g_string_free (w, TRUE);
} else {
/* append actual word into words list */
words = g_slist_append (words, w);
}
res = try_contains_word (s1uni, words);
g_free (s1uni);
g_free (s2uni);
g_slist_foreach (words, contains_helper_free_word, NULL);
g_slist_free (words);
return res;
}
static gchar *
log_matcher_posix_re_replace(LogMatcher *s, LogMessage *msg, gint value_handle, const gchar *value, gssize value_len, LogTemplate *replacement, gssize *new_length)
{
LogMatcherPosixRe *self = (LogMatcherPosixRe *) s;
regmatch_t matches[RE_MAX_MATCHES];
gboolean rc;
GString *new_value = NULL;
gsize current_ofs = 0;
gboolean first_round = TRUE;
gchar *buf;
APPEND_ZERO(buf, value, value_len);
do
{
if (current_ofs == value_len)
break;
rc = !regexec(&self->pattern, buf + current_ofs, RE_MAX_MATCHES, matches, current_ofs > 0 ? REG_NOTBOL : 0);
if (rc)
{
/* start_ofs & end_ofs are relative to the original string */
gsize start_ofs = matches[0].rm_so + current_ofs;
gsize end_ofs = matches[0].rm_eo + current_ofs;
if (start_ofs == end_ofs && !first_round)
{
start_ofs++;
end_ofs++;
}
log_matcher_posix_re_feed_backrefs(s, msg, value_handle, matches, buf + current_ofs);
if (!new_value)
new_value = g_string_sized_new(value_len);
g_string_append_len(new_value, buf + current_ofs, start_ofs - current_ofs);
log_template_append_format(replacement, msg, NULL, LTZ_LOCAL, 0, NULL, new_value);
current_ofs = end_ofs;
if ((self->super.flags & LMF_GLOBAL) == 0)
{
g_string_append_len(new_value, buf + current_ofs, value_len - current_ofs);
break;
}
}
else
{
if (new_value)
{
/* no more matches, append the end of the string */
g_string_append_len(new_value, buf + current_ofs, value_len - current_ofs);
}
}
first_round = FALSE;
}
while (rc && (self->super.flags & LMF_GLOBAL));
if (new_value)
{
if (new_length)
*new_length = new_value->len;
return g_string_free(new_value, FALSE);
}
return NULL;
}
gboolean
log_macro_expand(GString *result, gint id, gboolean escape, const LogTemplateOptions *opts, gint tz, gint32 seq_num,
const gchar *context_id, const LogMessage *msg)
{
switch (id)
{
case M_FACILITY:
{
/* facility */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_FACMASK, sl_facilities);
if (n)
{
g_string_append(result, n);
}
else
{
format_uint32_padded(result, 0, 0, 16, (msg->pri & LOG_FACMASK) >> 3);
}
break;
}
case M_FACILITY_NUM:
{
format_uint32_padded(result, 0, 0, 10, (msg->pri & LOG_FACMASK) >> 3);
break;
}
case M_LEVEL:
{
/* level */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_PRIMASK, sl_levels);
if (n)
{
g_string_append(result, n);
}
else
{
format_uint32_padded(result, 0, 0, 10, msg->pri & LOG_PRIMASK);
}
break;
}
case M_LEVEL_NUM:
{
format_uint32_padded(result, 0, 0, 10, msg->pri & LOG_PRIMASK);
break;
}
case M_TAG:
{
format_uint32_padded(result, 2, '0', 16, msg->pri);
break;
}
case M_TAGS:
{
log_msg_print_tags(msg, result);
break;
}
case M_BSDTAG:
{
format_uint32_padded(result, 0, 0, 10, (msg->pri & LOG_PRIMASK));
g_string_append_c(result, (((msg->pri & LOG_FACMASK) >> 3) + 'A'));
break;
}
case M_PRI:
{
format_uint32_padded(result, 0, 0, 10, msg->pri);
break;
}
case M_HOST:
{
if (msg->flags & LF_CHAINED_HOSTNAME)
{
/* host */
const gchar *p1, *p2;
int remaining, length;
gssize host_len;
const gchar *host = log_msg_get_value(msg, LM_V_HOST, &host_len);
p1 = memchr(host, '@', host_len);
if (p1)
p1++;
else
p1 = host;
remaining = host_len - (p1 - host);
p2 = memchr(p1, '/', remaining);
length = p2 ? p2 - p1
: host_len - (p1 - host);
result_append(result, p1, length, escape);
}
else
{
_result_append_value(result, msg, LM_V_HOST, escape);
}
break;
}
case M_SDATA:
if (escape)
{
GString *sdstr = g_string_sized_new(0);
log_msg_append_format_sdata(msg, sdstr, seq_num);
result_append(result, sdstr->str, sdstr->len, TRUE);
g_string_free(sdstr, TRUE);
}
else
{
log_msg_append_format_sdata(msg, result, seq_num);
}
break;
case M_MSGHDR:
{
gssize len;
const gchar *p;
p = log_msg_get_value(msg, LM_V_LEGACY_MSGHDR, &len);
if (len > 0)
result_append(result, p, len, escape);
else
{
/* message, complete with program name and pid */
len = result->len;
_result_append_value(result, msg, LM_V_PROGRAM, escape);
if (len != result->len)
{
const gchar *pid = log_msg_get_value(msg, LM_V_PID, &len);
if (len > 0)
{
result_append(result, "[", 1, FALSE);
result_append(result, pid, len, escape);
result_append(result, "]", 1, FALSE);
}
result_append(result, ": ", 2, FALSE);
}
}
break;
}
case M_MESSAGE:
_result_append_value(result, msg, LM_V_MESSAGE, escape);
break;
case M_SOURCE_IP:
{
gchar *ip;
gchar buf[MAX_SOCKADDR_STRING];
if (_is_message_source_an_ip_address(msg))
{
g_sockaddr_format(msg->saddr, buf, sizeof(buf), GSA_ADDRESS_ONLY);
ip = buf;
}
else
{
ip = "127.0.0.1";
}
result_append(result, ip, strlen(ip), escape);
break;
}
case M_SEQNUM:
{
if (seq_num)
{
format_uint32_padded(result, 0, 0, 10, seq_num);
}
break;
}
case M_CONTEXT_ID:
{
if (context_id)
{
result_append(result, context_id, strlen(context_id), escape);
}
break;
}
case M_RCPTID:
{
rcptid_append_formatted_id(result, msg->rcptid);
break;
}
case M_RUNID:
{
run_id_append_formatted_id(result);
break;
}
case M_HOSTID:
{
host_id_append_formatted_id(result, msg->host_id);
break;
}
case M_UNIQID:
{
if (msg->rcptid)
{
host_id_append_formatted_id(result, msg->host_id);
g_string_append(result, "@");
format_uint64_padded(result, 16, '0', 16, msg->rcptid);
break;
}
break;
}
case M_LOGHOST:
{
const gchar *hname = get_local_hostname_fqdn();
result_append(result, hname, -1, escape);
break;
}
case M_SYSUPTIME:
{
GTimeVal ct;
g_get_current_time(&ct);
format_uint64_padded(result, 0, 0, 10, g_time_val_diff(&ct, &app_uptime) / 1000 / 10);
break;
}
default:
{
/* year, month, day */
struct tm *tm, tm_storage;
gchar buf[64];
gint length;
time_t t;
const LogStamp *stamp;
LogStamp sstamp;
glong zone_ofs;
guint tmp_hour;
if (id >= M_TIME_FIRST && id <= M_TIME_LAST)
{
stamp = &msg->timestamps[LM_TS_STAMP];
}
else if (id >= M_TIME_FIRST + M_RECVD_OFS && id <= M_TIME_LAST + M_RECVD_OFS)
{
id -= M_RECVD_OFS;
stamp = &msg->timestamps[LM_TS_RECVD];
}
else if (id >= M_TIME_FIRST + M_STAMP_OFS && id <= M_TIME_LAST + M_STAMP_OFS)
{
id -= M_STAMP_OFS;
stamp = &msg->timestamps[LM_TS_STAMP];
}
else if (id >= M_TIME_FIRST + M_CSTAMP_OFS && id <= M_TIME_LAST + M_CSTAMP_OFS)
{
GTimeVal tv;
id -= M_CSTAMP_OFS;
cached_g_current_time(&tv);
sstamp.tv_sec = tv.tv_sec;
sstamp.tv_usec = tv.tv_usec;
sstamp.zone_offset = -1;
stamp = &sstamp;
}
else
{
g_assert_not_reached();
break;
}
/* try to use the following zone values in order:
* destination specific timezone, if one is specified
* message specific timezone, if one is specified
* local timezone
*/
zone_ofs = (opts->time_zone_info[tz] != NULL ? time_zone_info_get_offset(opts->time_zone_info[tz],
stamp->tv_sec) : stamp->zone_offset);
if (zone_ofs == -1)
zone_ofs = stamp->zone_offset;
t = stamp->tv_sec + zone_ofs;
cached_gmtime(&t, &tm_storage);
tm = &tm_storage;
switch (id)
{
case M_WEEK_DAY_ABBREV:
g_string_append_len(result, weekday_names_abbrev[tm->tm_wday], 3);
break;
case M_WEEK_DAY_NAME:
g_string_append(result, weekday_names[tm->tm_wday]);
break;
case M_WEEK_DAY:
format_uint32_padded(result, 0, 0, 10, tm->tm_wday + 1);
break;
case M_WEEK:
format_uint32_padded(result, 2, '0', 10, (tm->tm_yday - (tm->tm_wday - 1 + 7) % 7 + 7) / 7);
break;
case M_YEAR:
format_uint32_padded(result, 4, '0', 10, tm->tm_year + 1900);
break;
case M_YEAR_DAY:
format_uint32_padded(result, 3, '0', 10, tm->tm_yday + 1);
break;
case M_MONTH:
format_uint32_padded(result, 2, '0', 10, tm->tm_mon + 1);
break;
case M_MONTH_WEEK:
format_uint32_padded(result, 0, 0, 10, ((tm->tm_mday / 7) + ((tm->tm_wday > 0) && ((tm->tm_mday % 7) >= tm->tm_wday))));
break;
case M_MONTH_ABBREV:
g_string_append_len(result, month_names_abbrev[tm->tm_mon], 3);
break;
case M_MONTH_NAME:
g_string_append(result, month_names[tm->tm_mon]);
break;
case M_DAY:
format_uint32_padded(result, 2, '0', 10, tm->tm_mday);
break;
case M_HOUR:
format_uint32_padded(result, 2, '0', 10, tm->tm_hour);
break;
case M_HOUR12:
if (tm->tm_hour < 12)
tmp_hour = tm->tm_hour;
else
tmp_hour = tm->tm_hour - 12;
if (tmp_hour == 0)
tmp_hour = 12;
format_uint32_padded(result, 2, '0', 10, tmp_hour);
break;
case M_MIN:
format_uint32_padded(result, 2, '0', 10, tm->tm_min);
break;
case M_SEC:
format_uint32_padded(result, 2, '0', 10, tm->tm_sec);
break;
case M_MSEC:
format_uint32_padded(result, 3, '0', 10, stamp->tv_usec/1000);
break;
case M_USEC:
format_uint32_padded(result, 6, '0', 10, stamp->tv_usec);
break;
case M_AMPM:
g_string_append(result, tm->tm_hour < 12 ? "AM" : "PM");
break;
case M_DATE:
case M_STAMP:
case M_ISODATE:
case M_FULLDATE:
case M_UNIXTIME:
{
gint format = id == M_DATE ? TS_FMT_BSD :
id == M_ISODATE ? TS_FMT_ISO :
id == M_FULLDATE ? TS_FMT_FULL :
id == M_UNIXTIME ? TS_FMT_UNIX :
opts->ts_format;
log_stamp_append_format(stamp, result, format, zone_ofs, opts->frac_digits);
break;
}
case M_TZ:
case M_TZOFFSET:
length = format_zone_info(buf, sizeof(buf), zone_ofs);
g_string_append_len(result, buf, length);
break;
default:
g_assert_not_reached();
break;
}
break;
}
}
return TRUE;
}
static gchar *
log_matcher_pcre_re_replace(LogMatcher *s, LogMessage *msg, gint value_handle, const gchar *value, gssize value_len, LogTemplate *replacement, gssize *new_length)
{
LogMatcherPcreRe *self = (LogMatcherPcreRe *) s;
GString *new_value = NULL;
gint *matches;
gsize matches_size;
gint num_matches;
gint rc;
gint start_offset, last_offset;
gint options;
gboolean last_match_was_empty;
if (pcre_fullinfo(self->pattern, self->extra, PCRE_INFO_CAPTURECOUNT, &num_matches) < 0)
g_assert_not_reached();
if (num_matches > RE_MAX_MATCHES)
num_matches = RE_MAX_MATCHES;
matches_size = 3 * (num_matches + 1);
matches = g_alloca(matches_size * sizeof(gint));
/* we need zero initialized offsets for the last match as the
* algorithm tries uses that as the base position */
matches[0] = matches[1] = matches[2] = 0;
if (value_len == -1)
value_len = strlen(value);
last_offset = start_offset = 0;
last_match_was_empty = FALSE;
do
{
/* loop over the string, replacing one occurence at a time. */
/* NOTE: zero length matches need special care, as we could spin
* forever otherwise (since the current position wouldn't be
* advanced).
*
* A zero-length match can be as simple as "a*" which will be
* returned unless PCRE_NOTEMPTY is specified.
*
* By supporting zero-length matches, we basically make it
* possible to insert replacement between each incoming
* character.
*
* For example:
* pattern: a*
* replacement: #
* input: message
* result: #m#e#s#s#a#g#e#
*
* This mimics Perl behaviour.
*/
if (last_match_was_empty)
{
/* Otherwise, arrange to run another match at the same point
* to see if a non-empty match can be found.
*/
options = PCRE_NOTEMPTY | PCRE_ANCHORED;
}
else
{
options = 0;
}
rc = pcre_exec(self->pattern, self->extra,
value, value_len,
start_offset, (self->match_options | options), matches, matches_size);
if (rc < 0 && rc != PCRE_ERROR_NOMATCH)
{
msg_error("Error while matching regexp",
evt_tag_int("error_code", rc),
NULL);
break;
}
else if (rc < 0)
{
if ((options & PCRE_NOTEMPTY) == 0)
{
/* we didn't match, even when we permitted to match the
* empty string. Nothing to find here, bail out */
break;
}
/* we didn't match, quite possibly because the empty match
* was not permitted. Skip one character in order to avoid
* infinite loop over the same zero-length match. */
start_offset = start_offset + 1;
/* FIXME: handle complex sequences like utf8 and newline characters */
last_match_was_empty = FALSE;
continue;
}
else
{
/* if the output array was too small, truncate the number of
captures to RE_MAX_MATCHES */
if (rc == 0)
rc = matches_size / 3;
log_matcher_pcre_re_feed_backrefs(s, msg, value_handle, matches, rc, value);
log_matcher_pcre_re_feed_named_substrings(s, msg, matches, value);
if (!new_value)
new_value = g_string_sized_new(value_len);
/* append non-matching portion */
g_string_append_len(new_value, &value[last_offset], matches[0] - last_offset);
/* replacement */
log_template_append_format(replacement, msg, NULL, LTZ_LOCAL, 0, NULL, new_value);
last_match_was_empty = (matches[0] == matches[1]);
start_offset = last_offset = matches[1];
}
}
while (self->super.flags & LMF_GLOBAL && start_offset < value_len);
if (new_value)
{
/* append the last literal */
g_string_append_len(new_value, &value[last_offset], value_len - last_offset);
if (new_length)
*new_length = new_value->len;
return g_string_free(new_value, FALSE);
}
return NULL;
}
void
restraint_append_message (SoupSession *session,
SoupMessage *msg,
gpointer msg_data,
MessageFinishCallback finish_callback,
GCancellable *cancellable,
gpointer user_data)
{
ClientData *client_data = (ClientData *) msg_data;
time_t result;
result = time(NULL);
static time_t transaction_id = 0;
// calculate the transaction id. base it off of epoch
// incase the host reboots we shouldn't collide
if (transaction_id == 0) {
transaction_id = result;
}
MessageData *message_data;
message_data = g_slice_new0 (MessageData);
message_data->msg = msg;
message_data->user_data = user_data;
message_data->finish_callback = finish_callback;
if (client_data != NULL) {
GString *body = g_string_new("");
SoupURI *uri = soup_message_get_uri (msg);
soup_message_headers_foreach (msg->request_headers, append_header,
body);
// if we are doing a POST transaction
// increment transaction_id and add it to headers
// populate Location header in msg->reponse_headers
const gchar *path = soup_uri_get_path (uri);
if (g_strcmp0 (msg->method, "POST") == 0) {
g_string_append_printf (body,
"transaction-id: %jd\n", (intmax_t) transaction_id);
gchar *location_url = g_strdup_printf ("%s%jd", path, (intmax_t) transaction_id);
soup_message_headers_append (msg->response_headers, "Location", location_url);
g_free (location_url);
transaction_id++;
}
soup_message_set_status (msg, SOUP_STATUS_OK);
g_string_append_printf (body,
"rstrnt-path: %s\n"
"rstrnt-method: %s\n"
"Content-Length: %d\r\n\r\n",
path,
msg->method,
(guint) msg->request_body->length);
SoupBuffer *request = soup_message_body_flatten (msg->request_body);
body = g_string_append_len (body, request->data,
request->length);
g_string_append_printf (body,
"\r\n--cut-here\n");
soup_buffer_free (request);
soup_message_body_append (client_data->client_msg->response_body,
SOUP_MEMORY_TAKE,
body->str, body->len);
g_string_free (body, FALSE);
soup_server_unpause_message (client_data->server, client_data->client_msg);
}
if (finish_callback) {
g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
message_finish,
message_data,
message_destroy);
} else {
g_object_unref (msg);
message_destroy (message_data);
}
}
static void powerword_markup_add_text(const gchar *text, gssize length, std::string *pango, std::string::size_type &cur_pos, LinksPosList *links_list)
{
const gchar *p;
const gchar *end;
p = text;
end = text + length;
GString *str;
str = g_string_sized_new (length);
const gchar *n;
bool find;
bool previous_islink = false;
std::string marktags;
guint currentmarktag = 0;
while (p != end) {
const gchar *next;
next = g_utf8_next_char (p);
switch (*p) {
case '}':
if (currentmarktag==0) {
g_string_append (str, "}");
previous_islink = false;
}
else {
currentmarktag--;
switch (marktags[currentmarktag]) {
case 'b':
case 'B':
g_string_append (str, "</b>");
previous_islink = false;
break;
case 'I':
g_string_append (str, "</i>");
previous_islink = false;
break;
case '+':
g_string_append (str, "</sup>");
previous_islink = false;
break;
case '-':
g_string_append (str, "</sub>");
previous_islink = false;
break;
case 'x':
g_string_append (str, "</span>");
previous_islink = false;
break;
case 'l':
case 'D':
case 'L':
case 'U':
g_string_append (str, "</span>");
previous_islink = true;
break;
default:
previous_islink = false;
break;
}
}
break;
case '&':
find = false;
if (next!=end) {
n = g_utf8_next_char(next);
if (n!=end && *n == '{') {
find=true;
currentmarktag++;
if (marktags.length()<currentmarktag)
marktags+=*next;
else
marktags[currentmarktag-1]=*next;
switch (*next) {
case 'b':
case 'B':
g_string_append (str, "<b>");
next = n+1;
break;
case 'I':
g_string_append (str, "<i>");
next = n+1;
break;
case '+':
g_string_append (str, "<sup>");
next = n+1;
break;
case '-':
g_string_append (str, "<sub>");
next = n+1;
break;
case 'x':
g_string_append (str, "<span foreground=\"blue\" underline=\"single\">");
next = n+1;
break;
case 'X':
case '2':
{
const gchar *tag_end = n+1;
while (tag_end!=end) {
if (*tag_end=='}')
break;
else
tag_end++;
}
g_string_append (str, "<span foreground=\"blue\">");
gchar *tag_str;
if (*next == 'X') {
tag_str = toUtfPhonetic(n+1, tag_end - (n+1));
} else {
tag_str = toUtfPhonetic2(n+1, tag_end - (n+1));
}
g_string_append (str, tag_str);
g_free(tag_str);
g_string_append (str, "</span>");
currentmarktag--;
if (tag_end!=end)
next = tag_end+1;
else
next = end;
previous_islink = false;
break;
}
case 'l':
case 'D':
case 'L':
case 'U':
if (previous_islink)
g_string_append (str, "\t");
if (*next == 'l' || *next == 'D')
g_string_append (str, "<span foreground=\"blue\" underline=\"single\">");
else
g_string_append (str, "<span foreground=\"#008080\" underline=\"single\">");
*pango += str->str;
cur_pos += xml_strlen(str->str);
g_string_erase(str, 0, -1);
{
const gchar *tag_end = n+1;
while (tag_end!=end) {
if (*tag_end=='}')
break;
else
tag_end++;
}
char *tmpstr = g_markup_escape_text(n+1, tag_end - (n+1));
size_t xml_len = xml_strlen(tmpstr);
std::string link("query://");
link.append(n+1, tag_end - (n+1));
links_list->push_back(LinkDesc(cur_pos, xml_len, link));
*pango += tmpstr;
cur_pos += xml_len;
g_free(tmpstr);
g_string_append (str, "</span>");
currentmarktag--;
if (tag_end!=end)
next = tag_end+1;
else
next = end;
previous_islink = true;
break;
}
/*case ' ':
case '9':
case 'S':*/
default:
next = n+1;
break;
}
}
}
if (!find) {
previous_islink = false;
g_string_append (str, "&");
}
break;
case '<':
previous_islink = false;
g_string_append (str, "<");
break;
case '>':
previous_islink = false;
g_string_append (str, ">");
break;
case '\'':
previous_islink = false;
g_string_append (str, "'");
break;
case '"':
previous_islink = false;
g_string_append (str, """);
break;
default:
previous_islink = false;
g_string_append_len (str, p, next - p);
break;
}
p = next;
}
if (currentmarktag>0) {
do {
currentmarktag--;
switch (marktags[currentmarktag]) {
case 'b':
case 'B':
g_string_append (str, "</b>");
break;
case 'I':
g_string_append (str, "</i>");
break;
case '+':
g_string_append (str, "</sup>");
break;
case '-':
g_string_append (str, "</sub>");
break;
case 'x':
case 'l':
case 'D':
case 'L':
case 'U':
g_string_append (str, "</span>");
break;
default:
break;
}
} while (currentmarktag>0);
}
*pango += str->str;
cur_pos += xml_strlen(str->str);
g_string_free (str, TRUE);
}
static gboolean
xmms_modplug_init (xmms_xform_t *xform)
{
xmms_modplug_data_t *data;
const gchar *metakey;
gint filesize;
xmms_config_property_t *cfgv;
gint i;
g_return_val_if_fail (xform, FALSE);
data = g_new0 (xmms_modplug_data_t, 1);
xmms_xform_private_data_set (xform, data);
for (i = 0; i < G_N_ELEMENTS (config_params); i++) {
cfgv = xmms_xform_config_lookup (xform, config_params[i].key);
xmms_config_property_callback_set (cfgv,
xmms_modplug_config_changed,
data);
xmms_modplug_config_changed (XMMS_OBJECT (cfgv), NULL, data);
}
/* mFrequency and mResamplingMode are set in config_changed */
data->settings.mChannels = 2;
data->settings.mBits = 16;
ModPlug_SetSettings (&data->settings);
xmms_xform_outdata_type_add (xform,
XMMS_STREAM_TYPE_MIMETYPE,
"audio/pcm",
XMMS_STREAM_TYPE_FMT_FORMAT,
XMMS_SAMPLE_FORMAT_S16,
XMMS_STREAM_TYPE_FMT_CHANNELS,
2,
XMMS_STREAM_TYPE_FMT_SAMPLERATE,
data->settings.mFrequency,
XMMS_STREAM_TYPE_END);
data->buffer = g_string_new ("");
for (;;) {
xmms_error_t error;
gchar buf[4096];
gint ret;
ret = xmms_xform_read (xform, buf, sizeof (buf), &error);
if (ret == -1) {
XMMS_DBG ("Error reading mod");
return FALSE;
}
if (ret == 0) {
break;
}
g_string_append_len (data->buffer, buf, ret);
}
data->mod = ModPlug_Load (data->buffer->str, data->buffer->len);
if (!data->mod) {
XMMS_DBG ("Error loading mod");
return FALSE;
}
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE;
if (xmms_xform_metadata_get_int (xform, metakey, &filesize)) {
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION;
xmms_xform_metadata_set_int (xform, metakey,
ModPlug_GetLength (data->mod));
}
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TITLE;
xmms_xform_metadata_set_str (xform, metakey, ModPlug_GetName (data->mod));
return TRUE;
}
/**
* thunar_dialogs_show_job_ask:
* @parent : the parent #GtkWindow or %NULL.
* @question : the question text.
* @choices : possible responses.
*
* Utility function to display a question dialog for the ThunarJob::ask
* signal.
*
* Return value: the #ThunarJobResponse.
**/
ThunarJobResponse
thunar_dialogs_show_job_ask (GtkWindow *parent,
const gchar *question,
ThunarJobResponse choices)
{
const gchar *separator;
const gchar *mnemonic;
GtkWidget *message;
GtkWidget *button;
GString *secondary = g_string_sized_new (256);
GString *primary = g_string_sized_new (256);
gint response;
gint n;
gboolean has_cancel = FALSE;
_thunar_return_val_if_fail (parent == NULL || GTK_IS_WINDOW (parent), THUNAR_JOB_RESPONSE_CANCEL);
_thunar_return_val_if_fail (g_utf8_validate (question, -1, NULL), THUNAR_JOB_RESPONSE_CANCEL);
/* try to separate the question into primary and secondary parts */
separator = strstr (question, ": ");
if (G_LIKELY (separator != NULL))
{
/* primary is everything before the colon, plus a dot */
g_string_append_len (primary, question, separator - question);
g_string_append_c (primary, '.');
/* secondary is everything after the colon (skipping whitespace) */
do
++separator;
while (g_ascii_isspace (*separator));
g_string_append (secondary, separator);
}
else
{
/* otherwise separate based on the \n\n */
separator = strstr (question, "\n\n");
if (G_LIKELY (separator != NULL))
{
/* primary is everything before the newlines */
g_string_append_len (primary, question, separator - question);
/* secondary is everything after the newlines (skipping whitespace) */
while (g_ascii_isspace (*separator))
++separator;
g_string_append (secondary, separator);
}
else
{
/* everything is primary */
g_string_append (primary, question);
}
}
/* allocate the question message dialog */
message = gtk_message_dialog_new (parent,
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"%s", primary->str);
if (G_LIKELY (*secondary->str != '\0'))
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message), "%s", secondary->str);
/* add the buttons based on the possible choices */
for (n = 6; n >= 0; --n)
{
/* check if the response is set */
response = choices & (1 << n);
if (response == 0)
continue;
switch (response)
{
case THUNAR_JOB_RESPONSE_YES:
mnemonic = _("_Yes");
break;
case THUNAR_JOB_RESPONSE_YES_ALL:
mnemonic = _("Yes to _all");
break;
case THUNAR_JOB_RESPONSE_NO:
mnemonic = _("_No");
break;
case THUNAR_JOB_RESPONSE_NO_ALL:
mnemonic = _("N_o to all");
break;
case THUNAR_JOB_RESPONSE_RETRY:
mnemonic = _("_Retry");
break;
case THUNAR_JOB_RESPONSE_FORCE:
mnemonic = _("Copy _Anyway");
break;
case THUNAR_JOB_RESPONSE_CANCEL:
/* cancel is always the last option */
has_cancel = TRUE;
continue;
default:
g_assert_not_reached ();
break;
}
button = gtk_button_new_with_mnemonic (mnemonic);
gtk_widget_set_can_default (button, TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (message), button, response);
gtk_widget_show (button);
gtk_dialog_set_default_response (GTK_DIALOG (message), response);
}
if (has_cancel)
{
button = gtk_button_new_with_mnemonic (_("_Cancel"));
gtk_widget_set_can_default (button, TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (message), button, GTK_RESPONSE_CANCEL);
gtk_widget_show (button);
gtk_dialog_set_default_response (GTK_DIALOG (message), GTK_RESPONSE_CANCEL);
}
/* run the question dialog */
response = gtk_dialog_run (GTK_DIALOG (message));
gtk_widget_destroy (message);
/* transform the result as required */
if (G_UNLIKELY (response <= 0))
response = THUNAR_JOB_RESPONSE_CANCEL;
/* cleanup */
g_string_free (secondary, TRUE);
g_string_free (primary, TRUE);
return response;
}
static liHandlerResult auth_basic(liVRequest *vr, gpointer param, gpointer *context) {
liHttpHeader *hdr;
gboolean auth_ok = FALSE;
AuthBasicData *bdata = param;
gboolean debug = _OPTION(vr, bdata->p, 0).boolean;
UNUSED(context);
if (li_vrequest_is_handled(vr)) {
if (debug || CORE_OPTION(LI_CORE_OPTION_DEBUG_REQUEST_HANDLING).boolean) {
VR_DEBUG(vr, "skipping auth.basic as request is already handled with current status %i", vr->response.http_status);
}
return LI_HANDLER_GO_ON;
}
/* check for Authorization header */
hdr = li_http_header_lookup(vr->request.headers, CONST_STR_LEN("Authorization"));
if (!hdr || !g_str_has_prefix(LI_HEADER_VALUE(hdr), "Basic ")) {
if (debug) {
VR_DEBUG(vr, "requesting authorization from client for realm \"%s\"", bdata->realm->str);
}
} else {
gchar *decoded, *username = NULL, *password;
size_t len;
/* auth_info contains username:password encoded in base64 */
if (NULL != (decoded = (gchar*)g_base64_decode(LI_HEADER_VALUE(hdr) + sizeof("Basic ") - 1, &len))) {
/* bogus data? */
if (NULL != (password = strchr(decoded, ':'))) {
*password = '******';
password++;
username = decoded;
} else {
g_free(decoded);
}
}
if (!username) {
if (debug) {
VR_DEBUG(vr, "couldn't parse authorization info from client for realm \"%s\"", bdata->realm->str);
}
} else {
GString user = li_const_gstring(username, password - username - 1);
GString pass = li_const_gstring(password, len - (password - username));
if (bdata->backend(vr, &user, &pass, bdata, debug)) {
auth_ok = TRUE;
li_environment_set(&vr->env, CONST_STR_LEN("REMOTE_USER"), username, password - username - 1);
li_environment_set(&vr->env, CONST_STR_LEN("AUTH_TYPE"), CONST_STR_LEN("Basic"));
} else {
if (debug) {
VR_DEBUG(vr, "wrong authorization info from client on realm \"%s\" (user: \"%s\")", bdata->realm->str, username);
}
}
g_free(decoded);
}
}
g_string_truncate(vr->wrk->tmp_str, 0);
g_string_append_len(vr->wrk->tmp_str, CONST_STR_LEN("Basic realm=\""));
g_string_append_len(vr->wrk->tmp_str, GSTR_LEN(bdata->realm));
g_string_append_c(vr->wrk->tmp_str, '"');
/* generate header always */
if (!auth_ok) {
li_http_header_overwrite(vr->response.headers, CONST_STR_LEN("WWW-Authenticate"), GSTR_LEN(vr->wrk->tmp_str));
/* we already checked for handled */
if (!li_vrequest_handle_direct(vr))
return LI_HANDLER_ERROR;
vr->response.http_status = 401;
return LI_HANDLER_GO_ON;
} else {
/* lets hope browser just ignore the header if status is not 401
* but this way it is easier to use a later "auth.deny;"
*/
li_http_header_overwrite(vr->response.headers, CONST_STR_LEN("WWW-Authenticate"), GSTR_LEN(vr->wrk->tmp_str));
}
if (debug) {
VR_DEBUG(vr, "client authorization successful for realm \"%s\"", bdata->realm->str);
}
return LI_HANDLER_GO_ON;
}
/*
* IO watcher for stdout, called whenever there is data to read from the backend.
* This is where most of the actual IO handling happens.
*/
static gboolean
io_watch_stdout (GIOChannel *source, GIOCondition condition, PasswdHandler *passwd_handler)
{
static GString *str = NULL; /* Persistent buffer */
gchar buf[BUFSIZE]; /* Temporary buffer */
gsize bytes_read;
GError *gio_error = NULL; /* Error returned by functions */
GError *error = NULL; /* Error sent to callbacks */
gboolean reinit = FALSE;
/* Initialize buffer */
if (str == NULL) {
str = g_string_new ("");
}
if (g_io_channel_read_chars (source, buf, BUFSIZE, &bytes_read, &gio_error)
!= G_IO_STATUS_NORMAL) {
g_warning ("IO Channel read error: %s", gio_error->message);
g_error_free (gio_error);
return TRUE;
}
str = g_string_append_len (str, buf, bytes_read);
/* In which state is the backend? */
switch (passwd_handler->backend_state) {
case PASSWD_STATE_AUTH:
/* Passwd is asking for our current password */
if (is_string_complete (str->str, "assword: ", "failure", "wrong", "error", NULL)) {
if (strstr (str->str, "assword: ") != NULL && strstr (str->str, "incorrect") == NULL) {
/* Authentication successful */
passwd_handler->backend_state = PASSWD_STATE_NEW;
/* Trigger callback to update authentication status */
if (passwd_handler->auth_cb)
passwd_handler->auth_cb (passwd_handler,
NULL,
passwd_handler->auth_cb_data);
} else {
/* Authentication failed */
error = g_error_new_literal (PASSWD_ERROR, PASSWD_ERROR_AUTH_FAILED,
_("Authentication failed"));
passwd_handler->changing_password = FALSE;
/* This error can happen both while authenticating or while changing password:
* if chpasswd_cb is set, this means we're already changing password */
if (passwd_handler->chpasswd_cb)
passwd_handler->chpasswd_cb (passwd_handler,
error,
passwd_handler->auth_cb_data);
else if (passwd_handler->auth_cb)
passwd_handler->auth_cb (passwd_handler,
error,
passwd_handler->auth_cb_data);
g_error_free (error);
}
reinit = TRUE;
}
break;
case PASSWD_STATE_NEW:
/* Passwd is asking for our new password */
if (is_string_complete (str->str, "assword: ", NULL)) {
/* Advance to next state */
passwd_handler->backend_state = PASSWD_STATE_RETYPE;
/* Pop retyped password from queue and into IO channel */
io_queue_pop (passwd_handler->backend_stdin_queue, passwd_handler->backend_stdin);
reinit = TRUE;
}
break;
case PASSWD_STATE_RETYPE:
/* Passwd is asking for our retyped new password */
if (is_string_complete (str->str,
"successfully",
"short",
"longer",
"palindrome",
"dictionary",
"simple",
"simplistic",
"similar",
"case",
"different",
"wrapped",
"recovered",
"recent",
"unchanged",
"match",
"1 numeric or special",
"failure",
"DIFFERENT",
"BAD PASSWORD",
NULL)) {
if (strstr (str->str, "successfully") != NULL) {
/* Hooray! */
passwd_handler->backend_state = PASSWD_STATE_DONE;
/* Trigger callback to update status */
if (passwd_handler->chpasswd_cb)
passwd_handler->chpasswd_cb (passwd_handler,
NULL,
passwd_handler->chpasswd_cb_data);
}
else {
/* Ohnoes! */
if (strstr (str->str, "recovered") != NULL) {
/* What does this indicate?
* "Authentication information cannot be recovered?" from libpam? */
error = g_error_new_literal (PASSWD_ERROR, PASSWD_ERROR_UNKNOWN,
str->str);
} else if (strstr (str->str, "short") != NULL ||
strstr (str->str, "longer") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password is too short"));
} else if (strstr (str->str, "palindrome") != NULL ||
strstr (str->str, "simple") != NULL ||
strstr (str->str, "simplistic") != NULL ||
strstr (str->str, "dictionary") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password is too simple"));
} else if (strstr (str->str, "similar") != NULL ||
strstr (str->str, "different") != NULL ||
strstr (str->str, "case") != NULL ||
strstr (str->str, "wrapped") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The old and new passwords are too similar"));
} else if (strstr (str->str, "recent") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password has already been used recently."));
} else if (strstr (str->str, "1 numeric or special") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password must contain numeric or special characters"));
} else if (strstr (str->str, "unchanged") != NULL ||
strstr (str->str, "match") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The old and new passwords are the same"));
} else if (strstr (str->str, "failure") != NULL) {
/* Authentication failure */
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_AUTH_FAILED,
_("Your password has been changed since you initially authenticated!"));
}
else if (strstr (str->str, "DIFFERENT")) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password does not contain enough different characters"));
}
else {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_UNKNOWN,
_("Unknown error"));
}
/* At this point, passwd might have exited, in which case
* child_watch_cb should clean up for us and remove this watcher.
* On some error conditions though, passwd just re-prompts us
* for our new password. */
passwd_handler->backend_state = PASSWD_STATE_ERR;
passwd_handler->changing_password = FALSE;
/* Trigger callback to update status */
if (passwd_handler->chpasswd_cb)
passwd_handler->chpasswd_cb (passwd_handler,
error,
passwd_handler->chpasswd_cb_data);
g_error_free (error);
}
reinit = TRUE;
/* child_watch_cb should clean up for us now */
}
break;
case PASSWD_STATE_NONE:
/* Passwd is not asking for anything yet */
if (is_string_complete (str->str, "assword: ", NULL)) {
/* If the user does not have a password set,
* passwd will immediately ask for the new password,
* so skip the AUTH phase */
if (is_string_complete (str->str, "new", "New", NULL)) {
gchar *pw;
passwd_handler->backend_state = PASSWD_STATE_NEW;
/* since passwd didn't ask for our old password
* in this case, simply remove it from the queue */
pw = g_queue_pop_head (passwd_handler->backend_stdin_queue);
g_free (pw);
/* Pop the IO queue, i.e. send new password */
io_queue_pop (passwd_handler->backend_stdin_queue, passwd_handler->backend_stdin);
} else {
passwd_handler->backend_state = PASSWD_STATE_AUTH;
/* Pop the IO queue, i.e. send current password */
io_queue_pop (passwd_handler->backend_stdin_queue, passwd_handler->backend_stdin);
}
reinit = TRUE;
}
break;
default:
/* Passwd has returned an error */
reinit = TRUE;
break;
}
if (reinit) {
g_string_free (str, TRUE);
str = NULL;
}
/* Continue calling us */
return TRUE;
}
gboolean
log_macro_expand(GString *result, gint id, guint32 flags, gint ts_format, TimeZoneInfo *zone_info, gint frac_digits, gint32 seq_num, LogMessage *msg)
{
switch (id)
{
case M_FACILITY:
{
/* facility */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_FACMASK, sl_facilities);
if (n)
{
g_string_append(result, n);
}
else
{
g_string_sprintfa(result, "%x", (msg->pri & LOG_FACMASK) >> 3);
}
break;
}
case M_FACILITY_NUM:
{
g_string_sprintfa(result, "%d", (msg->pri & LOG_FACMASK) >> 3);
break;
}
case M_LEVEL:
{
/* level */
const char *n;
n = syslog_name_lookup_name_by_value(msg->pri & LOG_PRIMASK, sl_levels);
if (n)
{
g_string_append(result, n);
}
else
{
g_string_sprintfa(result, "%d", msg->pri & LOG_PRIMASK);
}
break;
}
case M_LEVEL_NUM:
{
g_string_sprintfa(result, "%d", (msg->pri & LOG_PRIMASK));
break;
}
case M_TAG:
{
g_string_sprintfa(result, "%02x", msg->pri);
break;
}
case M_TAGS:
{
log_msg_print_tags(msg, result);
break;
}
case M_BSDTAG:
{
g_string_sprintfa(result, "%1d%c", (msg->pri & LOG_PRIMASK), (((msg->pri & LOG_FACMASK) >> 3) + 'A'));
break;
}
case M_PRI:
{
g_string_sprintfa(result, "%d", msg->pri);
break;
}
case M_HOST:
{
if (msg->flags & LF_CHAINED_HOSTNAME)
{
/* host */
const gchar *p1, *p2;
int remaining, length;
gssize host_len;
const gchar *host = log_msg_get_value(msg, LM_V_HOST, &host_len);
p1 = memchr(host, '@', host_len);
if (p1)
p1++;
else
p1 = host;
remaining = host_len - (p1 - host);
p2 = memchr(p1, '/', remaining);
length = p2 ? p2 - p1
: host_len - (p1 - host);
result_append(result, p1, length, !!(flags & LT_ESCAPE));
}
else
{
result_append_value(result, msg, LM_V_HOST, !!(flags & LT_ESCAPE));
}
break;
}
case M_SDATA:
if (flags & LT_ESCAPE)
{
GString *sdstr = g_string_sized_new(0);
log_msg_append_format_sdata(msg, sdstr);
result_append(result, sdstr->str, sdstr->len, TRUE);
g_string_free(sdstr, TRUE);
}
else
{
log_msg_append_format_sdata(msg, result);
}
break;
case M_MSGHDR:
if ((msg->flags & LF_LEGACY_MSGHDR))
{
/* fast path for now, as most messages come from legacy devices */
result_append_value(result, msg, LM_V_LEGACY_MSGHDR, !!(flags & LT_ESCAPE));
}
else
{
/* message, complete with program name and pid */
gssize len;
len = result->len;
result_append_value(result, msg, LM_V_PROGRAM, !!(flags & LT_ESCAPE));
if (len != result->len)
{
const gchar *pid = log_msg_get_value(msg, LM_V_PID, &len);
if (len > 0)
{
result_append(result, "[", 1, FALSE);
result_append(result, pid, len, !!(flags & LT_ESCAPE));
result_append(result, "]", 1, FALSE);
}
result_append(result, ": ", 2, FALSE);
}
}
break;
case M_MESSAGE:
if (!cfg_check_current_config_version(0x0300))
log_macro_expand(result, M_MSGHDR, flags, ts_format, zone_info, frac_digits, seq_num, msg);
result_append_value(result, msg, LM_V_MESSAGE, !!(flags & LT_ESCAPE));
break;
case M_SOURCE_IP:
{
gchar *ip;
if (msg->saddr && (g_sockaddr_inet_check(msg->saddr) ||
#if ENABLE_IPV6
g_sockaddr_inet6_check(msg->saddr))
#else
0)
#endif
)
{
gchar buf[MAX_SOCKADDR_STRING];
g_sockaddr_format(msg->saddr, buf, sizeof(buf), GSA_ADDRESS_ONLY);
ip = buf;
}
else
{
ip = "127.0.0.1";
}
result_append(result, ip, strlen(ip), !!(flags & LT_ESCAPE));
break;
}
case M_SEQNUM:
{
if (seq_num)
g_string_sprintfa(result, "%d", seq_num);
break;
}
default:
{
/* year, month, day */
struct tm *tm, tm_storage;
gchar buf[64];
gint length;
time_t t;
LogStamp *stamp;
glong zone_ofs;
if (id >= M_TIME_FIRST && id <= M_TIME_LAST)
{
if (flags & LT_STAMP_RECVD)
stamp = &msg->timestamps[LM_TS_RECVD];
else
stamp = &msg->timestamps[LM_TS_STAMP];
}
else if (id >= M_TIME_FIRST + M_RECVD_OFS && id <= M_TIME_LAST + M_RECVD_OFS)
{
id -= M_RECVD_OFS;
stamp = &msg->timestamps[LM_TS_RECVD];
}
else if (id >= M_TIME_FIRST + M_STAMP_OFS && id <= M_TIME_LAST + M_STAMP_OFS)
{
id -= M_STAMP_OFS;
stamp = &msg->timestamps[LM_TS_STAMP];
}
else
{
g_assert_not_reached();
break;
}
/* try to use the following zone values in order:
* destination specific timezone, if one is specified
* message specific timezone, if one is specified
* local timezone
*/
zone_ofs = (zone_info != NULL ? time_zone_info_get_offset(zone_info, stamp->time.tv_sec) : stamp->zone_offset);
if (zone_ofs == -1)
zone_ofs = stamp->zone_offset;
t = stamp->time.tv_sec + zone_ofs;
tm = gmtime_r(&t, &tm_storage);
switch (id)
{
case M_WEEK_DAY_ABBREV:
g_string_append_len(result, weekday_names_abbrev[tm->tm_wday], 3);
break;
case M_WEEK_DAY_NAME:
g_string_append(result, weekday_names[tm->tm_wday]);
break;
case M_WEEK_DAY:
g_string_sprintfa(result, "%d", tm->tm_wday + 1);
break;
case M_WEEK:
g_string_sprintfa(result, "%02d", (tm->tm_yday - (tm->tm_wday - 1 + 7) % 7 + 7) / 7);
break;
case M_YEAR:
g_string_sprintfa(result, "%04d", tm->tm_year + 1900);
break;
case M_YEAR_DAY:
g_string_sprintfa(result, "%03d", tm->tm_yday + 1);
break;
case M_MONTH:
g_string_sprintfa(result, "%02d", tm->tm_mon + 1);
break;
case M_MONTH_WEEK:
g_string_sprintfa(result, "%d", ((tm->tm_mday / 7) + ((tm->tm_wday > 0) && ((tm->tm_mday % 7) >= tm->tm_wday))));
break;
case M_MONTH_ABBREV:
g_string_append_len(result, month_names_abbrev[tm->tm_mon], 3);
break;
case M_MONTH_NAME:
g_string_append(result, month_names[tm->tm_mon]);
break;
case M_DAY:
g_string_sprintfa(result, "%02d", tm->tm_mday);
break;
case M_HOUR:
g_string_sprintfa(result, "%02d", tm->tm_hour);
break;
case M_MIN:
g_string_sprintfa(result, "%02d", tm->tm_min);
break;
case M_SEC:
g_string_sprintfa(result, "%02d", tm->tm_sec);
break;
case M_DATE:
case M_STAMP:
case M_ISODATE:
case M_FULLDATE:
case M_UNIXTIME:
{
GString *s = g_string_sized_new(0);
gint format = id == M_DATE ? TS_FMT_BSD :
id == M_ISODATE ? TS_FMT_ISO :
id == M_FULLDATE ? TS_FMT_FULL :
id == M_UNIXTIME ? TS_FMT_UNIX :
ts_format;
log_stamp_format(stamp, s, format, zone_ofs, frac_digits);
g_string_append_len(result, s->str, s->len);
g_string_free(s, TRUE);
break;
}
case M_TZ:
case M_TZOFFSET:
length = format_zone_info(buf, sizeof(buf), zone_ofs);
g_string_append_len(result, buf, length);
break;
}
break;
}
}