/* Return 1 if we should log the given message, otherwise return 0 */
int owl_log_shouldlog_message(const owl_message *m) {
const owl_filter *f;
/* If there's a logfilter and this message matches it, log */
f=owl_global_get_filter(&g, owl_global_get_logfilter(&g));
if (f && owl_filter_message_match(f, m)) return(1);
/* otherwise we do things based on the logging variables */
/* skip login/logout messages if appropriate */
if (!owl_global_is_loglogins(&g) && owl_message_is_loginout(m)) return(0);
/* check direction */
if ((owl_global_get_loggingdirection(&g)==OWL_LOGGING_DIRECTION_IN) && owl_message_is_direction_out(m)) {
return(0);
}
if ((owl_global_get_loggingdirection(&g)==OWL_LOGGING_DIRECTION_OUT) && owl_message_is_direction_in(m)) {
return(0);
}
if (owl_message_is_type_zephyr(m)) {
if (owl_message_is_personal(m) && !owl_global_is_logging(&g)) return(0);
if (!owl_message_is_personal(m) && !owl_global_is_classlogging(&g)) return(0);
} else {
if (owl_message_is_private(m) || owl_message_is_loginout(m)) {
if (!owl_global_is_logging(&g)) return(0);
} else {
if (!owl_global_is_classlogging(&g)) return(0);
}
}
return(1);
}
void owl_log_outgoing(const owl_message *m)
{
char *filename, *logpath;
char *to, *temp;
GList *cc;
/* expand ~ in path names */
logpath = owl_util_makepath(owl_global_get_logpath(&g));
/* Figure out what path to log to */
if (owl_message_is_type_zephyr(m)) {
/* If this has CC's, do all but the "recipient" which we'll do below */
cc = owl_message_get_cc_without_recipient(m);
while (cc != NULL) {
temp = short_zuser(cc->data);
filename = g_strdup_printf("%s/%s", logpath, temp);
owl_log_append(m, filename);
g_free(filename);
g_free(temp);
g_free(cc->data);
cc = g_list_delete_link(cc, cc);
}
to = short_zuser(owl_message_get_recipient(m));
} else if (owl_message_is_type_jabber(m)) {
to = g_strdup_printf("jabber:%s", owl_message_get_recipient(m));
owl_text_tr(to, '/', '_');
} else if (owl_message_is_type_aim(m)) {
char *temp2;
temp = owl_aim_normalize_screenname(owl_message_get_recipient(m));
temp2 = g_utf8_strdown(temp,-1);
to = g_strdup_printf("aim:%s", temp2);
g_free(temp2);
g_free(temp);
} else {
to = g_strdup("loopback");
}
filename = g_strdup_printf("%s/%s", logpath, to);
owl_log_append(m, filename);
g_free(to);
g_free(filename);
filename = g_strdup_printf("%s/all", logpath);
owl_log_append(m, filename);
g_free(logpath);
g_free(filename);
}
void owl_log_append(const owl_message *m, const char *filename) {
FILE *file;
file=fopen(filename, "a");
if (!file) {
owl_function_error("Unable to open file for logging");
return;
}
if (owl_message_is_type_zephyr(m)) {
owl_log_zephyr(m, file);
} else if (owl_message_is_type_jabber(m)) {
owl_log_jabber(m, file);
} else if (owl_message_is_type_aim(m)) {
owl_log_aim(m, file);
} else {
owl_log_generic(m, file);
}
fclose(file);
}
void owl_log_incoming(const owl_message *m)
{
char *filename, *allfilename, *logpath;
const char *from=NULL;
char *frombuff=NULL;
int len, ch, i, personal;
/* figure out if it's a "personal" message or not */
if (owl_message_is_type_zephyr(m)) {
if (owl_message_is_personal(m)) {
personal = 1;
} else {
personal = 0;
}
} else if (owl_message_is_type_jabber(m)) {
/* This needs to be fixed to handle groupchat */
const char* msgtype = owl_message_get_attribute_value(m,"jtype");
if (msgtype && !strcmp(msgtype,"groupchat")) {
personal = 0;
} else {
personal = 1;
}
} else {
if (owl_message_is_private(m) || owl_message_is_loginout(m)) {
personal = 1;
} else {
personal = 0;
}
}
if (owl_message_is_type_zephyr(m)) {
if (personal) {
from=frombuff=short_zuser(owl_message_get_sender(m));
} else {
from=frombuff=g_strdup(owl_message_get_class(m));
}
} else if (owl_message_is_type_aim(m)) {
/* we do not yet handle chat rooms */
char *normalto, *temp;
temp = owl_aim_normalize_screenname(owl_message_get_sender(m));
normalto = g_utf8_strdown(temp, -1);
from=frombuff=g_strdup_printf("aim:%s", normalto);
g_free(normalto);
g_free(temp);
} else if (owl_message_is_type_loopback(m)) {
from=frombuff=g_strdup("loopback");
} else if (owl_message_is_type_jabber(m)) {
if (personal) {
from=frombuff=g_strdup_printf("jabber:%s",owl_message_get_sender(m));
} else {
from=frombuff=g_strdup_printf("jabber:%s",owl_message_get_recipient(m));
}
} else {
from=frombuff=g_strdup("unknown");
}
/* check for malicious sender formats */
len=strlen(frombuff);
if (len<1 || len>35) from="weird";
if (strchr(frombuff, '/')) from="weird";
ch=frombuff[0];
if (!g_ascii_isalnum(ch)) from="weird";
for (i=0; i<len; i++) {
if (frombuff[i]<'!' || frombuff[i]>='~') from="weird";
}
if (!strcmp(frombuff, ".") || !strcasecmp(frombuff, "..")) from="weird";
if (!personal) {
if (strcmp(from, "weird")) {
char* temp = g_utf8_strdown(frombuff, -1);
if (temp) {
g_free(frombuff);
from = frombuff = temp;
}
}
}
/* create the filename (expanding ~ in path names) */
if (personal) {
logpath = owl_util_makepath(owl_global_get_logpath(&g));
filename = g_strdup_printf("%s/%s", logpath, from);
allfilename = g_strdup_printf("%s/all", logpath);
owl_log_append(m, allfilename);
g_free(allfilename);
} else {
logpath = owl_util_makepath(owl_global_get_classlogpath(&g));
filename = g_strdup_printf("%s/%s", logpath, from);
}
owl_log_append(m, filename);
g_free(filename);
if (personal && owl_message_is_type_zephyr(m)) {
/* We want to log to all of the CC'd people who were not us, or
* the sender, as well.
*/
char *temp;
GList *cc;
cc = owl_message_get_cc_without_recipient(m);
while (cc != NULL) {
temp = short_zuser(cc->data);
if (strcasecmp(temp, frombuff) != 0) {
filename = g_strdup_printf("%s/%s", logpath, temp);
owl_log_append(m, filename);
g_free(filename);
}
g_free(temp);
g_free(cc->data);
cc = g_list_delete_link(cc, cc);
}
}
g_free(frombuff);
g_free(logpath);
}
CALLER_OWN SV *owl_perlconfig_message2hashref(const owl_message *m)
{
HV *h, *stash;
SV *hr;
const char *type;
char *ptr, *utype, *blessas;
const char *f;
int i;
const owl_pair *pair;
const owl_filter *wrap;
if (!m) return &PL_sv_undef;
wrap = owl_global_get_filter(&g, "wordwrap");
if(!wrap) {
owl_function_error("wrap filter is not defined");
return &PL_sv_undef;
}
h = newHV();
#define MSG2H(h,field) (void)hv_store(h, #field, strlen(#field), \
owl_new_sv(owl_message_get_##field(m)), 0)
if (owl_message_is_type_zephyr(m) && owl_message_is_direction_in(m)) {
/* Handle zephyr-specific fields... */
AV *av_zfields = newAV();
if (owl_message_get_notice(m)) {
for (f = owl_zephyr_first_raw_field(owl_message_get_notice(m)); f != NULL;
f = owl_zephyr_next_raw_field(owl_message_get_notice(m), f)) {
ptr = owl_zephyr_field_as_utf8(owl_message_get_notice(m), f);
av_push(av_zfields, owl_new_sv(ptr));
g_free(ptr);
}
(void)hv_store(h, "auth", strlen("auth"),
owl_new_sv(owl_zephyr_get_authstr(owl_message_get_notice(m))), 0);
} else {
/* Incoming zephyrs without a ZNotice_t are pseudo-logins. To appease
* existing styles, put in bogus 'auth' and 'fields' keys. */
(void)hv_store(h, "auth", strlen("auth"), owl_new_sv("NO"), 0);
}
(void)hv_store(h, "fields", strlen("fields"), newRV_noinc((SV*)av_zfields), 0);
}
for (i = 0; i < m->attributes->len; i++) {
pair = m->attributes->pdata[i];
(void)hv_store(h, owl_pair_get_key(pair), strlen(owl_pair_get_key(pair)),
owl_new_sv(owl_pair_get_value(pair)),0);
}
MSG2H(h, type);
MSG2H(h, direction);
MSG2H(h, class);
MSG2H(h, instance);
MSG2H(h, sender);
MSG2H(h, realm);
MSG2H(h, recipient);
MSG2H(h, opcode);
MSG2H(h, hostname);
MSG2H(h, body);
MSG2H(h, login);
MSG2H(h, zsig);
MSG2H(h, zwriteline);
if (owl_message_get_header(m)) {
MSG2H(h, header);
}
(void)hv_store(h, "time", strlen("time"), owl_new_sv(owl_message_get_timestr(m)),0);
(void)hv_store(h, "unix_time", strlen("unix_time"), newSViv(m->time), 0);
(void)hv_store(h, "id", strlen("id"), newSViv(owl_message_get_id(m)),0);
(void)hv_store(h, "deleted", strlen("deleted"), newSViv(owl_message_is_delete(m)),0);
(void)hv_store(h, "private", strlen("private"), newSViv(owl_message_is_private(m)),0);
(void)hv_store(h, "should_wordwrap",
strlen("should_wordwrap"), newSViv(
owl_filter_message_match(wrap, m)),0);
type = owl_message_get_type(m);
if(!type || !*type) type = "generic";
utype = g_strdup(type);
utype[0] = toupper(type[0]);
blessas = g_strdup_printf("BarnOwl::Message::%s", utype);
hr = newRV_noinc((SV*)h);
stash = gv_stashpv(blessas,0);
if(!stash) {
owl_function_error("No such class: %s for message type %s", blessas, owl_message_get_type(m));
stash = gv_stashpv("BarnOwl::Message", 1);
}
hr = sv_bless(hr,stash);
g_free(utype);
g_free(blessas);
return hr;
}
/*
* Process a new message passed to us on the message queue from some
* protocol. This includes adding it to the message list, updating the
* view and scrolling if appropriate, logging it, and so on.
*
* Either a pointer is kept to the message internally, or it is freed
* if unneeded. The caller no longer ``owns'' the message's memory.
*
* Returns 1 if the message was added to the message list, and 0 if it
* was ignored due to user settings or otherwise.
*/
static int owl_process_message(owl_message *m) {
const owl_filter *f;
/* if this message it on the puntlist, nuke it and continue */
if (owl_global_message_is_puntable(&g, m)) {
owl_message_delete(m);
return 0;
}
/* login or logout that should be ignored? */
if (owl_global_is_ignorelogins(&g)
&& owl_message_is_loginout(m)) {
owl_message_delete(m);
return 0;
}
if (!owl_global_is_displayoutgoing(&g)
&& owl_message_is_direction_out(m)) {
owl_message_delete(m);
return 0;
}
/* add it to the global list */
owl_messagelist_append_element(owl_global_get_msglist(&g), m);
/* add it to any necessary views; right now there's only the current view */
owl_view_consider_message(owl_global_get_current_view(&g), m);
if(owl_message_is_direction_in(m)) {
/* let perl know about it*/
owl_perlconfig_getmsg(m, NULL);
/* do we need to autoreply? */
if (owl_global_is_zaway(&g) && !owl_message_get_attribute_value(m, "isauto")) {
if (owl_message_is_type_zephyr(m)) {
owl_zephyr_zaway(m);
} else if (owl_message_is_type_aim(m)) {
if (owl_message_is_private(m)) {
owl_function_send_aimawymsg(owl_message_get_sender(m), owl_global_get_zaway_msg(&g));
}
}
}
/* ring the bell if it's a personal */
if (!strcmp(owl_global_get_personalbell(&g), "on")) {
if (!owl_message_is_loginout(m) &&
!owl_message_is_mail(m) &&
owl_message_is_personal(m)) {
owl_function_beep();
}
} else if (!strcmp(owl_global_get_personalbell(&g), "off")) {
/* do nothing */
} else {
f=owl_global_get_filter(&g, owl_global_get_personalbell(&g));
if (f && owl_filter_message_match(f, m)) {
owl_function_beep();
}
}
/* if it matches the alert filter, do the alert action */
f=owl_global_get_filter(&g, owl_global_get_alert_filter(&g));
if (f && owl_filter_message_match(f, m)) {
owl_function_command_norv(owl_global_get_alert_action(&g));
}
/* if it's a zephyr login or logout, update the zbuddylist */
if (owl_message_is_type_zephyr(m) && owl_message_is_loginout(m)) {
if (owl_message_is_login(m)) {
owl_zbuddylist_adduser(owl_global_get_zephyr_buddylist(&g), owl_message_get_sender(m));
} else if (owl_message_is_logout(m)) {
owl_zbuddylist_deluser(owl_global_get_zephyr_buddylist(&g), owl_message_get_sender(m));
} else {
owl_function_error("Internal error: received login notice that is neither login nor logout");
}
}
}
/* let perl know about it */
owl_perlconfig_newmsg(m, NULL);
/* log the message if we need to */
owl_log_message(m);
/* redraw the sepbar; TODO: don't violate layering */
owl_global_sepbar_dirty(&g);
return 1;
}
SV *owl_perlconfig_message2hashref(const owl_message *m)
{
HV *h, *stash;
SV *hr;
const char *type;
char *ptr, *utype, *blessas;
int i, j;
const owl_pair *pair;
const owl_filter *wrap;
if (!m) return &PL_sv_undef;
wrap = owl_global_get_filter(&g, "wordwrap");
if(!wrap) {
owl_function_error("wrap filter is not defined");
return &PL_sv_undef;
}
h = newHV();
#define MSG2H(h,field) (void)hv_store(h, #field, strlen(#field), \
owl_new_sv(owl_message_get_##field(m)), 0)
if (owl_message_is_type_zephyr(m)
&& owl_message_is_direction_in(m)) {
/* Handle zephyr-specific fields... */
AV *av_zfields;
av_zfields = newAV();
j=owl_zephyr_get_num_fields(owl_message_get_notice(m));
for (i=0; i<j; i++) {
ptr=owl_zephyr_get_field_as_utf8(owl_message_get_notice(m), i+1);
av_push(av_zfields, owl_new_sv(ptr));
owl_free(ptr);
}
(void)hv_store(h, "fields", strlen("fields"), newRV_noinc((SV*)av_zfields), 0);
(void)hv_store(h, "auth", strlen("auth"),
owl_new_sv(owl_zephyr_get_authstr(owl_message_get_notice(m))),0);
}
j=owl_list_get_size(&(m->attributes));
for(i=0; i<j; i++) {
pair=owl_list_get_element(&(m->attributes), i);
(void)hv_store(h, owl_pair_get_key(pair), strlen(owl_pair_get_key(pair)),
owl_new_sv(owl_pair_get_value(pair)),0);
}
MSG2H(h, type);
MSG2H(h, direction);
MSG2H(h, class);
MSG2H(h, instance);
MSG2H(h, sender);
MSG2H(h, realm);
MSG2H(h, recipient);
MSG2H(h, opcode);
MSG2H(h, hostname);
MSG2H(h, body);
MSG2H(h, login);
MSG2H(h, zsig);
MSG2H(h, zwriteline);
if (owl_message_get_header(m)) {
MSG2H(h, header);
}
(void)hv_store(h, "time", strlen("time"), owl_new_sv(owl_message_get_timestr(m)),0);
(void)hv_store(h, "unix_time", strlen("unix_time"), newSViv(m->time), 0);
(void)hv_store(h, "id", strlen("id"), newSViv(owl_message_get_id(m)),0);
(void)hv_store(h, "deleted", strlen("deleted"), newSViv(owl_message_is_delete(m)),0);
(void)hv_store(h, "private", strlen("private"), newSViv(owl_message_is_private(m)),0);
(void)hv_store(h, "should_wordwrap",
strlen("should_wordwrap"), newSViv(
owl_filter_message_match(wrap, m)),0);
type = owl_message_get_type(m);
if(!type || !*type) type = "generic";
utype = owl_strdup(type);
utype[0] = toupper(type[0]);
blessas = owl_sprintf("BarnOwl::Message::%s", utype);
hr = newRV_noinc((SV*)h);
stash = gv_stashpv(blessas,0);
if(!stash) {
owl_function_error("No such class: %s for message type %s", blessas, owl_message_get_type(m));
stash = gv_stashpv("BarnOwl::Message", 1);
}
hr = sv_bless(hr,stash);
owl_free(utype);
owl_free(blessas);
return hr;
}
/* XXX TODO: Messages should round-trip properly between
message2hashref and hashref2message. Currently we lose
zephyr-specific properties stored in the ZNotice_t
This has been somewhat addressed, but is still not lossless.
*/
owl_message * owl_perlconfig_hashref2message(SV *msg)
{
owl_message * m;
HE * ent;
I32 count, len;
const char *key,*val;
HV * hash;
struct tm tm;
hash = (HV*)SvRV(msg);
m = owl_malloc(sizeof(owl_message));
owl_message_init(m);
count = hv_iterinit(hash);
while((ent = hv_iternext(hash))) {
key = hv_iterkey(ent, &len);
val = SvPV_nolen(hv_iterval(hash, ent));
if(!strcmp(key, "type")) {
owl_message_set_type(m, val);
} else if(!strcmp(key, "direction")) {
owl_message_set_direction(m, owl_message_parse_direction(val));
} else if(!strcmp(key, "private")) {
SV * v = hv_iterval(hash, ent);
if(SvTRUE(v)) {
owl_message_set_isprivate(m);
}
} else if (!strcmp(key, "hostname")) {
owl_message_set_hostname(m, val);
} else if (!strcmp(key, "zwriteline")) {
owl_message_set_zwriteline(m, val);
} else if (!strcmp(key, "time")) {
m->timestr = owl_strdup(val);
strptime(val, "%a %b %d %T %Y", &tm);
m->time = mktime(&tm);
} else {
owl_message_set_attribute(m, key, val);
}
}
if(owl_message_is_type_admin(m)) {
if(!owl_message_get_attribute_value(m, "adminheader"))
owl_message_set_attribute(m, "adminheader", "");
}
#ifdef HAVE_LIBZEPHYR
if (owl_message_is_type_zephyr(m)) {
ZNotice_t *n = &(m->notice);
n->z_kind = ACKED;
n->z_port = 0;
n->z_auth = ZAUTH_NO;
n->z_checked_auth = 0;
n->z_class = zstr(owl_message_get_class(m));
n->z_class_inst = zstr(owl_message_get_instance(m));
n->z_opcode = zstr(owl_message_get_opcode(m));
n->z_sender = zstr(owl_message_get_sender(m));
n->z_recipient = zstr(owl_message_get_recipient(m));
n->z_default_format = zstr("[zephyr created from perl]");
n->z_multinotice = zstr("[zephyr created from perl]");
n->z_num_other_fields = 0;
n->z_message = owl_sprintf("%s%c%s", owl_message_get_zsig(m), '\0', owl_message_get_body(m));
n->z_message_len = strlen(owl_message_get_zsig(m)) + strlen(owl_message_get_body(m)) + 1;
}
#endif
return m;
}
