int owl_zephyr_loadsubs_helper(ZSubscription_t subs[], int count) { int ret = 0; if (owl_global_is_havezephyr(&g)) { int i; /* sub without defaults */ if (ZSubscribeToSansDefaults(subs,count,0) != ZERR_NONE) { owl_function_error("Error subscribing to zephyr notifications."); ret=-2; } /* free stuff */ for (i=0; i<count; i++) { owl_free(subs[i].zsub_class); owl_free(subs[i].zsub_classinst); owl_free(subs[i].zsub_recipient); } owl_free(subs); } else { owl_sub_list *s = owl_malloc(sizeof(owl_sub_list)); s->subs = subs; s->nsubs = count; deferred_subs = g_list_append(deferred_subs, s); } return ret; }
int owl_zbuddylist_contains_user(const owl_zbuddylist *zb, const char *name) { int i, j; char *user; user=long_zuser(name); j=owl_list_get_size(&(zb->zusers)); for (i=0; i<j; i++) { if (!strcasecmp(user, owl_list_get_element(&(zb->zusers), i))) { owl_free(user); return(1); } } owl_free(user); return(0); }
int owl_variable_string_set_default(owl_variable *v, void *newval) { if (v->validate_fn) { if (!v->validate_fn(v, newval)) return(-1); } if (v->val) owl_free(v->val); v->val = owl_strdup(newval); return(0); }
/* Called on all new messages; receivemsg is only called on incoming ones */ void owl_perlconfig_newmsg(const owl_message *m, const char *subname) { char *ptr = NULL; if (owl_perlconfig_is_function("BarnOwl::Hooks::_new_msg")) { ptr = owl_perlconfig_call_with_message(subname?subname :"BarnOwl::Hooks::_new_msg", m); } if (ptr) owl_free(ptr); }
void owl_perlconfig_getmsg(const owl_message *m, const char *subname) { char *ptr = NULL; if (owl_perlconfig_is_function("BarnOwl::Hooks::_receive_msg")) { ptr = owl_perlconfig_call_with_message(subname?subname :"BarnOwl::_receive_msg_legacy_wrap", m); } if (ptr) owl_free(ptr); }
int owl_zbuddylist_deluser(owl_zbuddylist *zb, const char *name) { int i, j; char *user, *ptr; user=long_zuser(name); j=owl_list_get_size(&(zb->zusers)); for (i=0; i<j; i++) { ptr=owl_list_get_element(&(zb->zusers), i); if (!strcasecmp(user, ptr)) { owl_list_remove_element(&(zb->zusers), i); owl_free(ptr); owl_free(user); return(0); } } owl_free(user); return(-1); }
void owl_select_remove_timer(owl_timer *t) { GList **timers = owl_global_get_timerlist(&g); if (t && g_list_find(*timers, t)) { *timers = g_list_remove(*timers, t); if(t->destroy) { t->destroy(t); } owl_free(t); } }
SV *owl_new_sv(const char * str) { SV *ret = newSVpv(str, 0); if (is_utf8_string((const U8 *)str, strlen(str))) { SvUTF8_on(ret); } else { char *escape = owl_escape_highbit(str); owl_function_error("Internal error! Non-UTF-8 string encountered:\n%s", escape); owl_free(escape); } return ret; }
/* Append normal, uncolored text specified by format string to 'f' */ void owl_fmtext_appendf_normal(owl_fmtext *f, const char *fmt, ...) { va_list ap; char *buff; va_start(ap, fmt); buff = g_strdup_vprintf(fmt, ap); va_end(ap); if (!buff) return; owl_fmtext_append_attr(f, buff, OWL_FMTEXT_ATTR_NONE, OWL_COLOR_DEFAULT, OWL_COLOR_DEFAULT); owl_free(buff); }
void owl_variable_dict_newvar_string(owl_vardict * vd, char *name, char *summ, char * desc, char * initval) { owl_variable *old = owl_variable_get_var(vd, name, OWL_VARIABLE_STRING); if(old) { owl_variable_update(old, summ, desc); if(old->pval_default) owl_free(old->pval_default); old->pval_default = owl_strdup(initval); } else { owl_variable * var = owl_variable_newvar(name, summ, desc); var->type = OWL_VARIABLE_STRING; var->pval_default = owl_strdup(initval); var->set_fn = owl_variable_string_set_default; var->set_fromstring_fn = owl_variable_string_set_fromstring_default; var->get_fn = owl_variable_get_default; var->get_tostring_fn = owl_variable_string_get_tostring_default; var->free_fn = owl_variable_free_default; var->set_fn(var, initval); owl_variable_dict_add_variable(vd, var); } }
void owl_zephyr_finish_initialization(owl_dispatch *d) { Code_t code; owl_select_remove_dispatch(d->fd); ZClosePort(); if ((code = ZInitialize()) != ZERR_NONE) { owl_function_error("Initializing Zephyr: %s", error_message(code)); return; } if ((code = ZOpenPort(NULL)) != ZERR_NONE) { owl_function_error("Initializing Zephyr: %s", error_message(code)); return; } d = owl_malloc(sizeof(owl_dispatch)); d->fd = ZGetFD(); d->cfunc = &owl_zephyr_process_events; d->destroy = NULL; owl_select_add_dispatch(d); owl_global_set_havezephyr(&g); if(g.load_initial_subs) { owl_zephyr_load_initial_subs(); } while(deferred_subs != NULL) { owl_sub_list *subs = deferred_subs->data; owl_function_debugmsg("Loading %d deferred subs.", subs->nsubs); owl_zephyr_loadsubs_helper(subs->subs, subs->nsubs); deferred_subs = g_list_delete_link(deferred_subs, deferred_subs); owl_free(subs); } /* zlog in if we need to */ if (owl_global_is_startuplogin(&g)) { owl_function_debugmsg("startup: doing zlog in"); owl_zephyr_zlog_in(); } }
/* requires that the list values are strings or NULL. * joins the elements together with join_with. * If format_fn is specified, passes it the list element value * and it will return a string which this needs to free. */ void owl_fmtext_append_list(owl_fmtext *f, const owl_list *l, const char *join_with, char *(format_fn)(const char *)) { int i, size; const char *elem; char *text; size = owl_list_get_size(l); for (i=0; i<size; i++) { elem = owl_list_get_element(l,i); if (elem && format_fn) { text = format_fn(elem); if (text) { owl_fmtext_append_normal(f, text); owl_free(text); } } else if (elem) { owl_fmtext_append_normal(f, elem); } if ((i < size-1) && join_with) { owl_fmtext_append_normal(f, join_with); } } }
void owl_variable_delete(owl_variable *v) { if (v->delete_fn) v->delete_fn(v); owl_free(v); }
/* Free all memory allocated by the object */ void owl_fmtext_cleanup(owl_fmtext *f) { if (f->textbuff) owl_free(f->textbuff); }
/* Append the text 'text' to 'f' and interpret the zephyr style * formatting syntax to set appropriate attributes. */ void owl_fmtext_append_ztext(owl_fmtext *f, const char *text) { int stacksize, curattrs, curcolor; const char *ptr, *txtptr, *tmpptr; char *buff; int attrstack[32], chrstack[32], colorstack[32]; curattrs=OWL_FMTEXT_ATTR_NONE; curcolor=OWL_COLOR_DEFAULT; stacksize=0; txtptr=text; while (1) { ptr=strpbrk(txtptr, "@{[<()>]}"); if (!ptr) { /* add all the rest of the text and exit */ owl_fmtext_append_attr(f, txtptr, curattrs, curcolor, OWL_COLOR_DEFAULT); return; } else if (ptr[0]=='@') { /* add the text up to this point then deal with the stack */ buff=owl_malloc(ptr-txtptr+20); strncpy(buff, txtptr, ptr-txtptr); buff[ptr-txtptr]='\0'; owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT); owl_free(buff); /* update pointer to point at the @ */ txtptr=ptr; /* now the stack */ /* if we've hit our max stack depth, print the @ and move on */ if (stacksize==32) { owl_fmtext_append_attr(f, "@", curattrs, curcolor, OWL_COLOR_DEFAULT); txtptr++; continue; } /* if it's an @@, print an @ and continue */ if (txtptr[1]=='@') { owl_fmtext_append_attr(f, "@", curattrs, curcolor, OWL_COLOR_DEFAULT); txtptr+=2; continue; } /* if there's no opener, print the @ and continue */ tmpptr=strpbrk(txtptr, "(<[{ "); if (!tmpptr || tmpptr[0]==' ') { owl_fmtext_append_attr(f, "@", curattrs, curcolor, OWL_COLOR_DEFAULT); txtptr++; continue; } /* check what command we've got, push it on the stack, start using it, and continue ... unless it's a color command */ buff=owl_malloc(tmpptr-ptr+20); strncpy(buff, ptr, tmpptr-ptr); buff[tmpptr-ptr]='\0'; if (!strcasecmp(buff, "@bold")) { attrstack[stacksize]=OWL_FMTEXT_ATTR_BOLD; chrstack[stacksize]=tmpptr[0]; colorstack[stacksize]=curcolor; stacksize++; curattrs|=OWL_FMTEXT_ATTR_BOLD; txtptr+=6; owl_free(buff); continue; } else if (!strcasecmp(buff, "@b")) { attrstack[stacksize]=OWL_FMTEXT_ATTR_BOLD; chrstack[stacksize]=tmpptr[0]; colorstack[stacksize]=curcolor; stacksize++; curattrs|=OWL_FMTEXT_ATTR_BOLD; txtptr+=3; owl_free(buff); continue; } else if (!strcasecmp(buff, "@i")) { attrstack[stacksize]=OWL_FMTEXT_ATTR_UNDERLINE; chrstack[stacksize]=tmpptr[0]; colorstack[stacksize]=curcolor; stacksize++; curattrs|=OWL_FMTEXT_ATTR_UNDERLINE; txtptr+=3; owl_free(buff); continue; } else if (!strcasecmp(buff, "@italic")) { attrstack[stacksize]=OWL_FMTEXT_ATTR_UNDERLINE; chrstack[stacksize]=tmpptr[0]; colorstack[stacksize]=curcolor; stacksize++; curattrs|=OWL_FMTEXT_ATTR_UNDERLINE; txtptr+=8; owl_free(buff); continue; } else if (!strcasecmp(buff, "@")) { attrstack[stacksize]=OWL_FMTEXT_ATTR_NONE; chrstack[stacksize]=tmpptr[0]; colorstack[stacksize]=curcolor; stacksize++; txtptr+=2; owl_free(buff); continue; /* if it's a color read the color, set the current color and continue */ } else if (!strcasecmp(buff, "@color") && owl_global_get_hascolors(&g) && owl_global_is_colorztext(&g)) { owl_free(buff); txtptr+=7; tmpptr=strpbrk(txtptr, "@{[<()>]}"); if (tmpptr && ((txtptr[-1]=='(' && tmpptr[0]==')') || (txtptr[-1]=='<' && tmpptr[0]=='>') || (txtptr[-1]=='[' && tmpptr[0]==']') || (txtptr[-1]=='{' && tmpptr[0]=='}'))) { /* grab the color name */ buff=owl_malloc(tmpptr-txtptr+20); strncpy(buff, txtptr, tmpptr-txtptr); buff[tmpptr-txtptr]='\0'; /* set it as the current color */ curcolor=owl_util_string_to_color(buff); if (curcolor == OWL_COLOR_INVALID) curcolor = OWL_COLOR_DEFAULT; owl_free(buff); txtptr=tmpptr+1; continue; } else { } } else { /* if we didn't understand it, we'll print it. This is different from zwgc * but zwgc seems to be smarter about some screw cases than I am */ owl_fmtext_append_attr(f, "@", curattrs, curcolor, OWL_COLOR_DEFAULT); txtptr++; continue; } } else if (ptr[0]=='}' || ptr[0]==']' || ptr[0]==')' || ptr[0]=='>') { /* add the text up to this point first */ buff=owl_malloc(ptr-txtptr+20); strncpy(buff, txtptr, ptr-txtptr); buff[ptr-txtptr]='\0'; owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT); owl_free(buff); /* now deal with the closer */ txtptr=ptr; /* first, if the stack is empty we must bail (just print and go) */ if (stacksize==0) { buff=owl_malloc(5); buff[0]=ptr[0]; buff[1]='\0'; owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT); owl_free(buff); txtptr++; continue; } /* if the closing char is what's on the stack, turn off the attribue and pop the stack */ if ((ptr[0]==')' && chrstack[stacksize-1]=='(') || (ptr[0]=='>' && chrstack[stacksize-1]=='<') || (ptr[0]==']' && chrstack[stacksize-1]=='[') || (ptr[0]=='}' && chrstack[stacksize-1]=='{')) { int i; stacksize--; curattrs=OWL_FMTEXT_ATTR_NONE; curcolor = colorstack[stacksize]; for (i=0; i<stacksize; i++) { curattrs|=attrstack[i]; } txtptr+=1; continue; } else { /* otherwise print and continue */ buff=owl_malloc(5); buff[0]=ptr[0]; buff[1]='\0'; owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT); owl_free(buff); txtptr++; continue; } } else { /* we've found an unattached opener, print everything and move on */ buff=owl_malloc(ptr-txtptr+20); strncpy(buff, txtptr, ptr-txtptr+1); buff[ptr-txtptr+1]='\0'; owl_fmtext_append_attr(f, buff, curattrs, curcolor, OWL_COLOR_DEFAULT); owl_free(buff); txtptr=ptr+1; continue; } } }
char *owl_perlconfig_initperl(const char * file, int *Pargc, char ***Pargv, char *** Penv) { int ret; PerlInterpreter *p; char *err; const char *args[4] = {"", "-e", "0;", NULL}; AV *inc; char *path; /* create and initialize interpreter */ PERL_SYS_INIT3(Pargc, Pargv, Penv); p=perl_alloc(); owl_global_set_perlinterp(&g, p); perl_construct(p); PL_exit_flags |= PERL_EXIT_DESTRUCT_END; owl_global_set_no_have_config(&g); ret=perl_parse(p, owl_perl_xs_init, 2, (char **)args, NULL); if (ret || SvTRUE(ERRSV)) { err=owl_strdup(SvPV_nolen(ERRSV)); sv_setsv(ERRSV, &PL_sv_undef); /* and clear the error */ return(err); } ret=perl_run(p); if (ret || SvTRUE(ERRSV)) { err=owl_strdup(SvPV_nolen(ERRSV)); sv_setsv(ERRSV, &PL_sv_undef); /* and clear the error */ return(err); } owl_global_set_have_config(&g); /* create legacy variables */ get_sv("BarnOwl::id", TRUE); get_sv("BarnOwl::class", TRUE); get_sv("BarnOwl::instance", TRUE); get_sv("BarnOwl::recipient", TRUE); get_sv("BarnOwl::sender", TRUE); get_sv("BarnOwl::realm", TRUE); get_sv("BarnOwl::opcode", TRUE); get_sv("BarnOwl::zsig", TRUE); get_sv("BarnOwl::msg", TRUE); get_sv("BarnOwl::time", TRUE); get_sv("BarnOwl::host", TRUE); get_av("BarnOwl::fields", TRUE); if(file) { SV * cfg = get_sv("BarnOwl::configfile", TRUE); sv_setpv(cfg, file); } /* Add the system lib path to @INC */ inc = get_av("INC", 0); path = owl_sprintf("%s/lib", owl_get_datadir()); av_unshift(inc, 1); av_store(inc, 0, owl_new_sv(path)); owl_free(path); eval_pv("use BarnOwl;", FALSE); if (SvTRUE(ERRSV)) { err=owl_strdup(SvPV_nolen(ERRSV)); sv_setsv (ERRSV, &PL_sv_undef); /* and clear the error */ return(err); } /* check if we have the formatting function */ if (owl_perlconfig_is_function("BarnOwl::format_msg")) { owl_global_set_config_format(&g, 1); } return(NULL); }
void owl_variable_free_default(owl_variable *v) { if (v->val) owl_free(v->val); }
void owl_variable_free(owl_variable *v) { if (v->free_fn) v->free_fn(v); owl_free(v); }
void owl_variable_update(owl_variable *var, char *summary, char *desc) { if(var->summary) owl_free(var->summary); var->summary = owl_strdup(summary); if(var->description) owl_free(var->description); var->description = owl_strdup(desc); }
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; }
void owl_buddy_cleanup(owl_buddy *b) { if (b->name) owl_free(b->name); }
void owl_buddy_delete(owl_buddy *b) { owl_buddy_cleanup(b); owl_free(b); }
/* Free all memory allocated by the object */ void owl_fmtext_free(owl_fmtext *f) { if (f->textbuff) owl_free(f->textbuff); }
/* Load zephyr subscriptions from 'filename'. If 'filename' is NULL, * the default file $HOME/.zephyr.subs will be used. * * Returns 0 on success. If the file does not exist, return -1 if * 'error_on_nofile' is 1, otherwise return 0. Return -1 if the file * exists but can not be read. Return -2 if there is a failure from * zephyr to load the subscriptions. */ int owl_zephyr_loadsubs(char *filename, int error_on_nofile) { #ifdef HAVE_LIBZEPHYR FILE *file; char *tmp, *start; char buffer[1024], subsfile[1024]; ZSubscription_t *subs; int subSize = 1024; int count, ret; struct stat statbuff; subs = owl_malloc(sizeof(ZSubscription_t) * subSize); if (filename==NULL) { sprintf(subsfile, "%s/%s", owl_global_get_homedir(&g), ".zephyr.subs"); } else { strcpy(subsfile, filename); } ret=stat(subsfile, &statbuff); if (ret) { if (error_on_nofile==1) return(-1); return(0); } ZResetAuthentication(); count=0; file=fopen(subsfile, "r"); if (!file) return(-1); while ( fgets(buffer, 1024, file)!=NULL ) { if (buffer[0]=='#' || buffer[0]=='\n' || buffer[0]=='\n') continue; if (buffer[0]=='-') { start=buffer+1; } else { start=buffer; } if (count >= subSize) { subSize *= 2; subs = owl_realloc(subs, sizeof(ZSubscription_t) * subSize); } /* add it to the list of subs */ if ((tmp=(char *) strtok(start, ",\n\r"))==NULL) continue; subs[count].zsub_class=owl_strdup(tmp); if ((tmp=(char *) strtok(NULL, ",\n\r"))==NULL) continue; subs[count].zsub_classinst=owl_strdup(tmp); if ((tmp=(char *) strtok(NULL, " \t\n\r"))==NULL) continue; subs[count].zsub_recipient=owl_strdup(tmp); /* if it started with '-' then add it to the global punt list, and * remove it from the list of subs. */ if (buffer[0]=='-') { owl_function_zpunt(subs[count].zsub_class, subs[count].zsub_classinst, subs[count].zsub_recipient, 0); owl_free(subs[count].zsub_class); owl_free(subs[count].zsub_classinst); owl_free(subs[count].zsub_recipient); } else { count++; } } fclose(file); ret = owl_zephyr_loadsubs_helper(subs, count); return(ret); #else return(0); #endif }