static RouteEntry *
route_sv2c(SV *h, RouteEntry *ref)
{
if (ref && h && SvROK(h)) {
HV *hv = (HV *)SvRV(h);
memset(ref, 0, sizeof(RouteEntry));
if (hv_exists(hv, "route_dst", 9)) {
SV **r = hv_fetch(hv, "route_dst", 9, 0);
if (SvOK(*r)) {
struct addr a;
if (addr_aton(SvPV(*r, PL_na), &a) == 0) {
memcpy(&(ref->route_dst), &a, sizeof(struct addr));
}
}
}
if (hv_exists(hv, "route_gw", 8)) {
SV **r = hv_fetch(hv, "route_gw", 8, 0);
if (SvOK(*r)) {
struct addr a;
if (addr_aton(SvPV(*r, PL_na), &a) == 0) {
memcpy(&(ref->route_gw), &a, sizeof(struct addr));
}
}
}
}
else {
ref = NULL;
}
return ref;
}
/*
* Parse a configuration section, and populate a HV.
* This function is recursively called (allows to have nested hashes.)
*/
static void perl_parse_config(CONF_SECTION *cs, int lvl, HV *rad_hv)
{
if (!cs || !rad_hv) return;
int indent_section = (lvl + 1) * 4;
int indent_item = (lvl + 2) * 4;
DEBUG("%*s%s {", indent_section, " ", cf_section_name1(cs));
CONF_ITEM *ci = NULL;
while ((ci = cf_item_next(cs, ci))) {
/*
* This is a section.
* Create a new HV, store it as a reference in current HV,
* Then recursively call perl_parse_config with this section and the new HV.
*/
if (cf_item_is_section(ci)) {
CONF_SECTION *sub_cs = cf_item_to_section(ci);
char const *key = cf_section_name1(sub_cs); /* hash key */
HV *sub_hv;
SV *ref;
if (!key) continue;
if (hv_exists(rad_hv, key, strlen(key))) {
WARN("Ignoring duplicate config section '%s'", key);
continue;
}
sub_hv = newHV();
ref = newRV_inc((SV*) sub_hv);
(void)hv_store(rad_hv, key, strlen(key), ref, 0);
perl_parse_config(sub_cs, lvl + 1, sub_hv);
} else if (cf_item_is_pair(ci)){
CONF_PAIR *cp = cf_item_to_pair(ci);
char const *key = cf_pair_attr(cp); /* hash key */
char const *value = cf_pair_value(cp); /* hash value */
if (!key || !value) continue;
/*
* This is an item.
* Store item attr / value in current HV.
*/
if (hv_exists(rad_hv, key, strlen(key))) {
WARN("Ignoring duplicate config item '%s'", key);
continue;
}
(void)hv_store(rad_hv, key, strlen(key), newSVpvn(value, strlen(value)), 0);
DEBUG("%*s%s = %s", indent_item, " ", key, value);
}
}
DEBUG("%*s}", indent_section, " ");
}
SV *modperl_pnotes(pTHX_ HV **pnotes, SV *key, SV *val,
request_rec *r, conn_rec *c) {
SV *retval = (SV *)NULL;
if (!*pnotes) {
apr_pool_t *pool = r ? r->pool : c->pool;
void *cleanup_data;
*pnotes = newHV();
cleanup_data = modperl_pnotes_cleanup_data(aTHX_ pnotes, pool);
apr_pool_cleanup_register(pool, cleanup_data,
modperl_cleanup_pnotes,
apr_pool_cleanup_null);
}
if (key) {
STRLEN len;
char *k = SvPV(key, len);
if (val) {
retval = *hv_store(*pnotes, k, len, SvREFCNT_inc(val), 0);
}
else if (hv_exists(*pnotes, k, len)) {
retval = *hv_fetch(*pnotes, k, len, FALSE);
}
return retval ? SvREFCNT_inc(retval) : &PL_sv_undef;
}
return newRV_inc((SV *)*pnotes);
}
bool Embperl::SubExists(const char *package, const char *sub) {
HV *stash = gv_stashpv(package, false);
if(!stash)
return(false);
int len = strlen(sub);
return(hv_exists(stash, sub, len));
}
/* Deletes name from all the isarev entries listed in isa */
STATIC void
S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name,
const STRLEN len, HV * const exceptions, U32 hash,
U32 flags)
{
HE* iter;
PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV;
/* Delete our name from our former parents' isarevs. */
if(HvARRAY(isa) && hv_iterinit(isa)) {
SV **svp;
while((iter = hv_iternext(isa))) {
I32 klen;
const char * const key = hv_iterkey(iter, &klen);
if(exceptions && hv_exists(exceptions, key, HeKUTF8(iter) ? -klen : klen))
continue;
svp = hv_fetch(PL_isarev, key, HeKUTF8(iter) ? -klen : klen, 0);
if(svp) {
HV * const isarev = (HV *)*svp;
(void)hv_common(isarev, NULL, name, len, flags,
G_DISCARD|HV_DELETE, NULL, hash);
if(!HvARRAY(isarev) || !HvUSEDKEYS(isarev))
(void)hv_delete(PL_isarev, key,
HeKUTF8(iter) ? -klen : klen, G_DISCARD);
}
}
}
}
nv_item *perl_store_namedvars(nv_list *nv, HV *values) {
int i, j;
nv_item *item;
SV **value;
i = 0;
j = 0;
item = nv_new_item(nv);
while (nv->format[i].fldname != NULL) {
if (hv_exists(values, nv->format[i].fldname, strlen(nv->format[i].fldname))) {
value = hv_fetch(values, nv->format[i].fldname, strlen(nv->format[i].fldname), FALSE);
} else {
i++;
continue;
}
switch (nv->format[i].type) {
case NV_PSTR:
case NV_STR:
nv_sf_string(item, nv->format[i].fldname, SvPV_nolen(*value));
break;
case NV_INT:
nv_sf_int(item, nv->format[i].fldname, SvIV(*value));
break;
case NV_LONG:
nv_sf_long(item, nv->format[i].fldname, SvIV(*value));
break;
case NV_VOID:
default:
printf("Value: Unhandled!\n");
break;
}
i++;
}
return item;
}
bool Embperl::VarExists(const char *package, const char *var) {
HV *stash = gv_stashpv(package, false);
if(!stash)
return(false);
int len = strlen(var);
return(hv_exists(stash, var, len));
}
static const char*pl_find_func(const char* func) {
if (hv_exists(PL_defstash, func, strlen(func))) {
ices_log_debug("Found method: %s", func);
return func;
}
return NULL;
}
int perl_ht_add_str(HV *ht, char *key, char *val) {
// warn & ignore if key exists
if (hv_exists(ht, key, strlen(key))) {
fprintf(stderr, "perl ht key '%s' exists, ignoring", key);
return 0;
}
hv_store(ht, key, strlen(key), sv_2mortal(newSVpv(val, 0)), 0);
return 1;
}
/*
=for apidoc mro_method_changed_in
Invalidates method caching on any child classes
of the given stash, so that they might notice
the changes in this one.
Ideally, all instances of C<PL_sub_generation++> in
perl source outside of F<mro.c> should be
replaced by calls to this.
Perl automatically handles most of the common
ways a method might be redefined. However, there
are a few ways you could change a method in a stash
without the cache code noticing, in which case you
need to call this method afterwards:
1) Directly manipulating the stash HV entries from
XS code.
2) Assigning a reference to a readonly scalar
constant into a stash entry in order to create
a constant subroutine (like F<constant.pm>
does).
This same method is available from pure perl
via, C<mro::method_changed_in(classname)>.
=cut
*/
void
Perl_mro_method_changed_in(pTHX_ HV *stash)
{
const char * const stashname = HvENAME_get(stash);
const STRLEN stashname_len = HvENAMELEN_get(stash);
SV ** const svp = hv_fetchhek(PL_isarev, HvENAME_HEK(stash), 0);
HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
if(!stashname)
Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
/* Inc the package generation, since a local method changed */
HvMROMETA(stash)->pkg_gen++;
/* DESTROY can be cached in SvSTASH. */
if (!SvOBJECT(stash)) SvSTASH(stash) = NULL;
/* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
invalidate all method caches globally */
if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
|| (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
PL_sub_generation++;
return;
}
/* else, invalidate the method caches of all child classes,
but not itself */
if(isarev) {
HE* iter;
hv_iterinit(isarev);
while((iter = hv_iternext(isarev))) {
HV* const revstash = gv_stashsv(hv_iterkeysv(iter), 0);
struct mro_meta* mrometa;
if(!revstash) continue;
mrometa = HvMROMETA(revstash);
mrometa->cache_gen++;
if(mrometa->mro_nextmethod)
hv_clear(mrometa->mro_nextmethod);
if (!SvOBJECT(revstash)) SvSTASH(revstash) = NULL;
}
}
/* The method change may be due to *{$package . "::()"} = \&nil; in
overload.pm. */
HvAMAGIC_on(stash);
/* pessimise derefs for now. Will get recalculated by Gv_AMupdate() */
HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_NO_DEREF;
}
/*
=for apidoc mro_method_changed_in
Invalidates method caching on any child classes
of the given stash, so that they might notice
the changes in this one.
Ideally, all instances of C<PL_sub_generation++> in
perl source outside of C<mro.c> should be
replaced by calls to this.
Perl automatically handles most of the common
ways a method might be redefined. However, there
are a few ways you could change a method in a stash
without the cache code noticing, in which case you
need to call this method afterwards:
1) Directly manipulating the stash HV entries from
XS code.
2) Assigning a reference to a readonly scalar
constant into a stash entry in order to create
a constant subroutine (like constant.pm
does).
This same method is available from pure perl
via, C<mro::method_changed_in(classname)>.
=cut
*/
void
Perl_mro_method_changed_in(pTHX_ HV *stash)
{
const char * const stashname = HvNAME_get(stash);
const STRLEN stashname_len = HvNAMELEN_get(stash);
SV ** const svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
if(!stashname)
Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
/* Inc the package generation, since a local method changed */
HvMROMETA(stash)->pkg_gen++;
/* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
invalidate all method caches globally */
if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
|| (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
PL_sub_generation++;
return;
}
/* else, invalidate the method caches of all child classes,
but not itself */
if(isarev) {
HE* iter;
hv_iterinit(isarev);
while((iter = hv_iternext(isarev))) {
I32 len;
const char* const revkey = hv_iterkey(iter, &len);
HV* const revstash = gv_stashpvn(revkey, len, 0);
struct mro_meta* mrometa;
if(!revstash) continue;
mrometa = HvMROMETA(revstash);
mrometa->cache_gen++;
if(mrometa->mro_nextmethod)
hv_clear(mrometa->mro_nextmethod);
}
}
}
void ht_to_perl_ht(HV *perl_ht, struct hashtable *params) {
if (!hashtable_count(params)) return;
struct hashtable_itr *itr;
itr = hashtable_iterator(params);
do {
char *param = hashtable_iterator_key(itr);
char *value = hashtable_iterator_value(itr);
// check if key already exists
if (hv_exists(perl_ht, param, strlen(param))) {
fprintf(stderr, "Parameter '%s' is already defined. Ignoring.\n", param);
continue;
}
hv_store(perl_ht, param, strlen(param),
sv_2mortal(newSVpv(value, 0)), 0);
} while (hashtable_iterator_advance(itr));
free(itr);
}
static void unroll_tree(pTHX_ struct sljit_compiler* compiler, HV* seenops,
OP* op, OP* end)
{
// XXX: This basically is the algorithm from walk_exec in B::Concise, but I
// think it could be done better. (Maybe core will get something like
// codegen?).
while (op && op != end) {
const char* op_hex = format_hex(op);
// Have we visited this op already?
if (hv_exists(seenops, op_hex, strlen(op_hex))) {
DEBUGf((" ;; Already seen %s [0x%s]\n", OP_NAME(op), op_hex));
// Insert jump to it
emit_jump(compiler, op);
// We know we have followed all the next pointers for this chain,
// so:
break;
}
// Seen op
hv_store(seenops, op_hex, 0, &PL_sv_yes, strlen(op_hex));
if (op->op_type == OP_CUSTOM) {
// All bets are off
sljit_emit_return(compiler, SLJIT_MEM, (sljit_w) &PL_op);
}
else if (OP_CLASS(op) == OA_LOGOP) {
unroll_branching_op(compiler, seenops, op, op->op_next,
cLOGOPx(op)->op_other);
}
else if (op->op_type == OP_SUBST
&& cPMOPx(op)->op_pmstashstartu.op_pmreplstart) {
unroll_branching_op(compiler, seenops, op, op->op_next,
cPMOPx(op)->op_pmstashstartu.op_pmreplstart);
}
else if (op->op_type == OP_GREPSTART || op->op_type == OP_MAPSTART) {
unroll_branching_op(compiler, seenops, op, op->op_next->op_next,
cLOGOPx(op->op_next)->op_other);
}
else if (op->op_type == OP_NEXT || op->op_type == OP_LAST
|| op->op_type == OP_REDO) {
sljit_emit_return(compiler, SLJIT_MEM, (sljit_w) &PL_op);
//need_patch = 1; XXX
}
else if (op->op_type == OP_FLIP || op->op_type == OP_GOTO) {
sljit_emit_return(compiler, SLJIT_MEM, (sljit_w) &PL_op);
//need_patch = 1; XXX
}
else if (op->op_type == OP_ENTERSUB) {
sljit_emit_return(compiler, SLJIT_MEM, (sljit_w) &PL_op);
//need_patch = 1; XXX
}
else if (op->op_type == OP_RETURN || op->op_type == OP_LEAVESUB
|| op->op_type == OP_REQUIRE) {
// XXX: leavesublv?
unroll_op(compiler, op);
sljit_emit_return(compiler, SLJIT_MEM, (sljit_w) &PL_op);
}
else {
unroll_op(compiler, op);
#ifdef DEBUG
// Ensure returned OP is actually the one we expect
struct sljit_jump *jump1 = sljit_emit_cmp(compiler, SLJIT_C_EQUAL,
SLJIT_RETURN_REG, 0, SLJIT_IMM, (sljit_w) op->op_next);
sljit_emit_op0(compiler, SLJIT_BREAKPOINT);
sljit_set_label(jump1, sljit_emit_label(compiler));
#endif
}
op = op->op_next;
}
}
static FwRule *
fw_sv2c(SV *h, FwRule *ref)
{
if (ref && h && SvROK(h)) {
HV *hv = (HV *)SvRV(h);
memset(ref, 0, sizeof(FwRule));
if (hv_exists(hv, "fw_device", 9)) {
SV **r = hv_fetch(hv, "fw_device", 9, 0);
if (SvOK(*r)) {
memcpy(&(ref->fw_device), SvPV(*r, PL_na), sizeof(ref->fw_device));
}
}
if (hv_exists(hv, "fw_op", 5)) {
SV **r = hv_fetch(hv, "fw_op", 5, 0);
ref->fw_op = (SvOK(*r) ? SvIV(*r) : 0);
}
if (hv_exists(hv, "fw_dir", 6)) {
SV **r = hv_fetch(hv, "fw_dir", 6, 0);
ref->fw_dir = (SvOK(*r) ? SvIV(*r) : 0);
}
if (hv_exists(hv, "fw_proto", 8)) {
SV **r = hv_fetch(hv, "fw_proto", 8, 0);
ref->fw_proto = (SvOK(*r) ? SvIV(*r) : 0);
}
if (hv_exists(hv, "fw_src", 6)) {
SV **r = hv_fetch(hv, "fw_src", 6, 0);
if (SvOK(*r)) {
struct addr a;
if (addr_aton(SvPV(*r, PL_na), &a) == 0) {
memcpy(&(ref->fw_src), &a, sizeof(struct addr));
}
}
}
if (hv_exists(hv, "fw_dst", 6)) {
SV **r = hv_fetch(hv, "fw_dst", 6, 0);
if (SvOK(*r)) {
struct addr a;
if (addr_aton(SvPV(*r, PL_na), &a) == 0) {
memcpy(&(ref->fw_dst), &a, sizeof(struct addr));
}
}
}
if (hv_exists(hv, "fw_sport", 8)) {
SV **r = hv_fetch(hv, "fw_sport", 8, 0);
if (SvOK(*r)) {
AV *a = (AV *)SvRV(*r);
SV *p1 = av_shift(a);
SV *p2 = av_shift(a);
ref->fw_sport[0] = (SvOK(p1) ? SvIV(p1) : 0);
ref->fw_sport[1] = (SvOK(p2) ? SvIV(p2) : 0);
}
}
if (hv_exists(hv, "fw_dport", 8)) {
SV **r = hv_fetch(hv, "fw_dport", 8, 0);
if (SvOK(*r)) {
AV *a = (AV *)SvRV(*r);
SV *p1 = av_shift(a);
SV *p2 = av_shift(a);
ref->fw_dport[0] = (SvOK(p1) ? SvIV(p1) : 0);
ref->fw_dport[1] = (SvOK(p2) ? SvIV(p2) : 0);
}
}
}
else {
ref = NULL;
}
return ref;
}
static gboolean
probe_perl_plugin(PurplePlugin *plugin)
{
/* XXX This would be much faster if I didn't create a new
* PerlInterpreter every time I probed a plugin */
PerlInterpreter *prober = perl_alloc();
char *argv[] = {"", plugin->path };
gboolean status = TRUE;
HV *plugin_info;
PERL_SET_CONTEXT(prober);
PL_perl_destruct_level = 1;
perl_construct(prober);
perl_parse(prober, xs_init, 2, argv, NULL);
perl_run(prober);
plugin_info = perl_get_hv("PLUGIN_INFO", FALSE);
if (plugin_info == NULL)
status = FALSE;
else if (!hv_exists(plugin_info, "perl_api_version",
strlen("perl_api_version")) ||
!hv_exists(plugin_info, "name", strlen("name")) ||
!hv_exists(plugin_info, "load", strlen("load"))) {
/* Not a valid plugin. */
status = FALSE;
} else {
SV **key;
int perl_api_ver;
key = hv_fetch(plugin_info, "perl_api_version",
strlen("perl_api_version"), 0);
perl_api_ver = SvIV(*key);
if (perl_api_ver != 2)
status = FALSE;
else {
PurplePluginInfo *info;
PurplePerlScript *gps;
char *basename;
STRLEN len;
info = g_new0(PurplePluginInfo, 1);
gps = g_new0(PurplePerlScript, 1);
info->magic = PURPLE_PLUGIN_MAGIC;
info->major_version = PURPLE_MAJOR_VERSION;
info->minor_version = PURPLE_MINOR_VERSION;
info->type = PURPLE_PLUGIN_STANDARD;
info->dependencies = g_list_append(info->dependencies,
PERL_PLUGIN_ID);
gps->plugin = plugin;
basename = g_path_get_basename(plugin->path);
purple_perl_normalize_script_name(basename);
gps->package = g_strdup_printf("Purple::Script::%s",
basename);
g_free(basename);
/* We know this one exists. */
key = hv_fetch(plugin_info, "name", strlen("name"), 0);
info->name = g_strdup(SvPV(*key, len));
/* Set id here in case we don't find one later. */
info->id = g_strdup(SvPV(*key, len));
#ifdef PURPLE_GTKPERL
if ((key = hv_fetch(plugin_info, "GTK_UI",
strlen("GTK_UI"), 0)))
info->ui_requirement = PURPLE_GTK_PLUGIN_TYPE;
#endif
if ((key = hv_fetch(plugin_info, "url",
strlen("url"), 0)))
info->homepage = g_strdup(SvPV(*key, len));
if ((key = hv_fetch(plugin_info, "author",
strlen("author"), 0)))
info->author = g_strdup(SvPV(*key, len));
if ((key = hv_fetch(plugin_info, "summary",
strlen("summary"), 0)))
info->summary = g_strdup(SvPV(*key, len));
if ((key = hv_fetch(plugin_info, "description",
strlen("description"), 0)))
info->description = g_strdup(SvPV(*key, len));
if ((key = hv_fetch(plugin_info, "version",
strlen("version"), 0)))
info->version = g_strdup(SvPV(*key, len));
/* We know this one exists. */
key = hv_fetch(plugin_info, "load", strlen("load"), 0);
gps->load_sub = g_strdup_printf("%s::%s", gps->package,
SvPV(*key, len));
if ((key = hv_fetch(plugin_info, "unload",
strlen("unload"), 0)))
gps->unload_sub = g_strdup_printf("%s::%s",
gps->package,
SvPV(*key, len));
if ((key = hv_fetch(plugin_info, "id",
strlen("id"), 0))) {
g_free(info->id);
info->id = g_strdup_printf("perl-%s",
SvPV(*key, len));
}
/********************************************************/
/* Only one of the next two options should be present */
/* */
/* prefs_info - Uses non-GUI (read GTK) purple API calls */
/* and creates a PurplePluginPrefInfo type. */
/* */
/* gtk_prefs_info - Requires gtk2-perl be installed by */
/* the user and he must create a */
/* GtkWidget the user and he must */
/* create a GtkWidget representing the */
/* plugin preferences page. */
/********************************************************/
if ((key = hv_fetch(plugin_info, "prefs_info",
strlen("prefs_info"), 0))) {
/* key now is the name of the Perl sub that
* will create a frame for us */
gps->prefs_sub = g_strdup_printf("%s::%s",
gps->package,
SvPV(*key, len));
info->prefs_info = &ui_info;
}
#ifdef PURPLE_GTKPERL
if ((key = hv_fetch(plugin_info, "gtk_prefs_info",
strlen("gtk_prefs_info"), 0))) {
/* key now is the name of the Perl sub that
* will create a frame for us */
gps->gtk_prefs_sub = g_strdup_printf("%s::%s",
gps->package,
SvPV(*key, len));
info->ui_info = >k_ui_info;
}
#endif
if ((key = hv_fetch(plugin_info, "plugin_action_sub",
strlen("plugin_action_sub"), 0))) {
gps->plugin_action_sub = g_strdup_printf("%s::%s",
gps->package,
SvPV(*key, len));
info->actions = purple_perl_plugin_actions;
}
plugin->info = info;
info->extra_info = gps;
status = purple_plugin_register(plugin);
}
}
PL_perl_destruct_level = 1;
PERL_SET_CONTEXT(prober);
perl_destruct(prober);
perl_free(prober);
return status;
}
void
Perl_mro_isa_changed_in(pTHX_ HV* stash)
{
HV* isarev;
AV* linear_mro;
HE* iter;
SV** svp;
I32 items;
bool is_universal;
struct mro_meta * meta;
HV *isa = NULL;
const HEK * const stashhek = HvENAME_HEK(stash);
const char * const stashname = HvENAME_get(stash);
const STRLEN stashname_len = HvENAMELEN_get(stash);
PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN;
if(!stashname)
Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
/* wipe out the cached linearizations for this stash */
meta = HvMROMETA(stash);
CLEAR_LINEAR(meta);
if (meta->isa) {
/* Steal it for our own purposes. */
isa = (HV *)sv_2mortal((SV *)meta->isa);
meta->isa = NULL;
}
/* Inc the package generation, since our @ISA changed */
meta->pkg_gen++;
/* Wipe the global method cache if this package
is UNIVERSAL or one of its parents */
svp = hv_fetchhek(PL_isarev, stashhek, 0);
isarev = svp ? MUTABLE_HV(*svp) : NULL;
if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
|| (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
PL_sub_generation++;
is_universal = TRUE;
}
else { /* Wipe the local method cache otherwise */
meta->cache_gen++;
is_universal = FALSE;
}
/* wipe next::method cache too */
if(meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
/* Changes to @ISA might turn overloading on */
HvAMAGIC_on(stash);
/* pessimise derefs for now. Will get recalculated by Gv_AMupdate() */
HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_NO_DEREF;
/* DESTROY can be cached in SvSTASH. */
if (!SvOBJECT(stash)) SvSTASH(stash) = NULL;
/* Iterate the isarev (classes that are our children),
wiping out their linearization, method and isa caches
and upating PL_isarev. */
if(isarev) {
HV *isa_hashes = NULL;
/* We have to iterate through isarev twice to avoid a chicken and
* egg problem: if A inherits from B and both are in isarev, A might
* be processed before B and use B's previous linearisation.
*/
/* First iteration: Wipe everything, but stash away the isa hashes
* since we still need them for updating PL_isarev.
*/
if(hv_iterinit(isarev)) {
/* Only create the hash if we need it; i.e., if isarev has
any elements. */
isa_hashes = (HV *)sv_2mortal((SV *)newHV());
}
while((iter = hv_iternext(isarev))) {
HV* revstash = gv_stashsv(hv_iterkeysv(iter), 0);
struct mro_meta* revmeta;
if(!revstash) continue;
revmeta = HvMROMETA(revstash);
CLEAR_LINEAR(revmeta);
if(!is_universal)
revmeta->cache_gen++;
if(revmeta->mro_nextmethod)
hv_clear(revmeta->mro_nextmethod);
if (!SvOBJECT(revstash)) SvSTASH(revstash) = NULL;
(void)
hv_store(
isa_hashes, (const char*)&revstash, sizeof(HV *),
revmeta->isa ? (SV *)revmeta->isa : &PL_sv_undef, 0
);
revmeta->isa = NULL;
}
/* Second pass: Update PL_isarev. We can just use isa_hashes to
* avoid another round of stash lookups. */
/* isarev might be deleted from PL_isarev during this loop, so hang
* on to it. */
SvREFCNT_inc_simple_void_NN(sv_2mortal((SV *)isarev));
if(isa_hashes) {
hv_iterinit(isa_hashes);
while((iter = hv_iternext(isa_hashes))) {
HV* const revstash = *(HV **)HEK_KEY(HeKEY_hek(iter));
HV * const isa = (HV *)HeVAL(iter);
const HEK *namehek;
/* We're starting at the 2nd element, skipping revstash */
linear_mro = mro_get_linear_isa(revstash);
svp = AvARRAY(linear_mro) + 1;
items = AvFILLp(linear_mro);
namehek = HvENAME_HEK(revstash);
if (!namehek) namehek = HvNAME_HEK(revstash);
while (items--) {
SV* const sv = *svp++;
HV* mroisarev;
HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
/* That fetch should not fail. But if it had to create
a new SV for us, then will need to upgrade it to an
HV (which sv_upgrade() can now do for us). */
mroisarev = MUTABLE_HV(HeVAL(he));
SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
/* This hash only ever contains PL_sv_yes. Storing it
over itself is almost as cheap as calling hv_exists,
so on aggregate we expect to save time by not making
two calls to the common HV code for the case where
it doesn't exist. */
(void)
hv_storehek(mroisarev, namehek, &PL_sv_yes);
}
if ((SV *)isa != &PL_sv_undef) {
assert(namehek);
mro_clean_isarev(
isa, HEK_KEY(namehek), HEK_LEN(namehek),
HvMROMETA(revstash)->isa, HEK_HASH(namehek),
HEK_UTF8(namehek)
);
}
}
}
}
/* Now iterate our MRO (parents), adding ourselves and everything from
our isarev to their isarev.
*/
/* We're starting at the 2nd element, skipping ourselves here */
linear_mro = mro_get_linear_isa(stash);
svp = AvARRAY(linear_mro) + 1;
items = AvFILLp(linear_mro);
while (items--) {
SV* const sv = *svp++;
HV* mroisarev;
HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
/* That fetch should not fail. But if it had to create a new SV for
us, then will need to upgrade it to an HV (which sv_upgrade() can
now do for us. */
mroisarev = MUTABLE_HV(HeVAL(he));
SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
/* This hash only ever contains PL_sv_yes. Storing it over itself is
almost as cheap as calling hv_exists, so on aggregate we expect to
save time by not making two calls to the common HV code for the
case where it doesn't exist. */
(void)hv_storehek(mroisarev, stashhek, &PL_sv_yes);
}
/* Delete our name from our former parents' isarevs. */
if(isa && HvARRAY(isa))
mro_clean_isarev(isa, stashname, stashname_len, meta->isa,
HEK_HASH(stashhek), HEK_UTF8(stashhek));
}
STATIC void
S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes,
HV *stash, HV *oldstash, SV *namesv)
{
XPVHV* xhv;
HE *entry;
I32 riter = -1;
I32 items = 0;
const bool stash_had_name = stash && HvENAME(stash);
bool fetched_isarev = FALSE;
HV *seen = NULL;
HV *isarev = NULL;
SV **svp = NULL;
PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME;
/* We use the seen_stashes hash to keep track of which packages have
been encountered so far. This must be separate from the main list of
stashes, as we need to distinguish between stashes being assigned
and stashes being replaced/deleted. (A nested stash can be on both
sides of an assignment. We cannot simply skip iterating through a
stash on the right if we have seen it on the left, as it will not
get its ename assigned to it.)
To avoid allocating extra SVs, instead of a bitfield we can make
bizarre use of immortals:
&PL_sv_undef: seen on the left (oldstash)
&PL_sv_no : seen on the right (stash)
&PL_sv_yes : seen on both sides
*/
if(oldstash) {
/* Add to the big list. */
struct mro_meta * meta;
HE * const entry
= (HE *)
hv_common(
seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
);
if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) {
oldstash = NULL;
goto check_stash;
}
HeVAL(entry)
= HeVAL(entry) == &PL_sv_no ? &PL_sv_yes : &PL_sv_undef;
meta = HvMROMETA(oldstash);
(void)
hv_store(
stashes, (const char *)&oldstash, sizeof(HV *),
meta->isa
? SvREFCNT_inc_simple_NN((SV *)meta->isa)
: &PL_sv_yes,
0
);
CLEAR_LINEAR(meta);
/* Update the effective name. */
if(HvENAME_get(oldstash)) {
const HEK * const enamehek = HvENAME_HEK(oldstash);
if(SvTYPE(namesv) == SVt_PVAV) {
items = AvFILLp((AV *)namesv) + 1;
svp = AvARRAY((AV *)namesv);
}
else {
items = 1;
svp = &namesv;
}
while (items--) {
const U32 name_utf8 = SvUTF8(*svp);
STRLEN len;
const char *name = SvPVx_const(*svp, len);
if(PL_stashcache) {
DEBUG_o(Perl_deb(aTHX_ "mro_gather_and_rename clearing PL_stashcache for '%"SVf"'\n",
SVfARG(*svp)));
(void)hv_delete(PL_stashcache, name, name_utf8 ? -(I32)len : (I32)len, G_DISCARD);
}
++svp;
hv_ename_delete(oldstash, name, len, name_utf8);
if (!fetched_isarev) {
/* If the name deletion caused a name change, then we
* are not going to call mro_isa_changed_in with this
* name (and not at all if it has become anonymous) so
* we need to delete old isarev entries here, both
* those in the superclasses and this class's own list
* of subclasses. We simply delete the latter from
* PL_isarev, since we still need it. hv_delete morti-
* fies it for us, so sv_2mortal is not necessary. */
if(HvENAME_HEK(oldstash) != enamehek) {
if(meta->isa && HvARRAY(meta->isa))
mro_clean_isarev(meta->isa, name, len, 0, 0,
name_utf8 ? HVhek_UTF8 : 0);
isarev = (HV *)hv_delete(PL_isarev, name,
name_utf8 ? -(I32)len : (I32)len, 0);
fetched_isarev=TRUE;
}
}
}
}
}
check_stash:
if(stash) {
if(SvTYPE(namesv) == SVt_PVAV) {
items = AvFILLp((AV *)namesv) + 1;
svp = AvARRAY((AV *)namesv);
}
else {
items = 1;
svp = &namesv;
}
while (items--) {
const U32 name_utf8 = SvUTF8(*svp);
STRLEN len;
const char *name = SvPVx_const(*svp++, len);
hv_ename_add(stash, name, len, name_utf8);
}
/* Add it to the big list if it needs
* mro_isa_changed_in called on it. That happens if it was
* detached from the symbol table (so it had no HvENAME) before
* being assigned to the spot named by the 'name' variable, because
* its cached isa linearisation is now stale (the effective name
* having changed), and subclasses will then use that cache when
* mro_package_moved calls mro_isa_changed_in. (See
* [perl #77358].)
*
* If it did have a name, then its previous name is still
* used in isa caches, and there is no need for
* mro_package_moved to call mro_isa_changed_in.
*/
entry
= (HE *)
hv_common(
seen_stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
);
if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no)
stash = NULL;
else {
HeVAL(entry)
= HeVAL(entry) == &PL_sv_undef ? &PL_sv_yes : &PL_sv_no;
if(!stash_had_name)
{
struct mro_meta * const meta = HvMROMETA(stash);
(void)
hv_store(
stashes, (const char *)&stash, sizeof(HV *),
meta->isa
? SvREFCNT_inc_simple_NN((SV *)meta->isa)
: &PL_sv_yes,
0
);
CLEAR_LINEAR(meta);
}
}
}
if(!stash && !oldstash)
/* Both stashes have been encountered already. */
return;
/* Add all the subclasses to the big list. */
if(!fetched_isarev) {
/* If oldstash is not null, then we can use its HvENAME to look up
the isarev hash, since all its subclasses will be listed there.
It will always have an HvENAME. It the HvENAME was removed
above, then fetch_isarev will be true, and this code will not be
reached.
If oldstash is null, then this is an empty spot with no stash in
it, so subclasses could be listed in isarev hashes belonging to
any of the names, so we have to check all of them.
*/
assert(!oldstash || HvENAME(oldstash));
if (oldstash) {
/* Extra variable to avoid a compiler warning */
const HEK * const hvename = HvENAME_HEK(oldstash);
fetched_isarev = TRUE;
svp = hv_fetchhek(PL_isarev, hvename, 0);
if (svp) isarev = MUTABLE_HV(*svp);
}
else if(SvTYPE(namesv) == SVt_PVAV) {
items = AvFILLp((AV *)namesv) + 1;
svp = AvARRAY((AV *)namesv);
}
else {
items = 1;
svp = &namesv;
}
}
if(
isarev || !fetched_isarev
) {
while (fetched_isarev || items--) {
HE *iter;
if (!fetched_isarev) {
HE * const he = hv_fetch_ent(PL_isarev, *svp++, 0, 0);
if (!he || !(isarev = MUTABLE_HV(HeVAL(he)))) continue;
}
hv_iterinit(isarev);
while((iter = hv_iternext(isarev))) {
HV* revstash = gv_stashsv(hv_iterkeysv(iter), 0);
struct mro_meta * meta;
if(!revstash) continue;
meta = HvMROMETA(revstash);
(void)
hv_store(
stashes, (const char *)&revstash, sizeof(HV *),
meta->isa
? SvREFCNT_inc_simple_NN((SV *)meta->isa)
: &PL_sv_yes,
0
);
CLEAR_LINEAR(meta);
}
if (fetched_isarev) break;
}
}
/* This is partly based on code in hv_iternext_flags. We are not call-
ing that here, as we want to avoid resetting the hash iterator. */
/* Skip the entire loop if the hash is empty. */
if(oldstash && HvUSEDKEYS(oldstash)) {
xhv = (XPVHV*)SvANY(oldstash);
seen = (HV *) sv_2mortal((SV *)newHV());
/* Iterate through entries in the oldstash, adding them to the
list, meanwhile doing the equivalent of $seen{$key} = 1.
*/
while (++riter <= (I32)xhv->xhv_max) {
entry = (HvARRAY(oldstash))[riter];
/* Iterate through the entries in this list */
for(; entry; entry = HeNEXT(entry)) {
const char* key;
I32 len;
/* If this entry is not a glob, ignore it.
Try the next. */
if (!isGV(HeVAL(entry))) continue;
key = hv_iterkey(entry, &len);
if ((len > 1 && key[len-2] == ':' && key[len-1] == ':')
|| (len == 1 && key[0] == ':')) {
HV * const oldsubstash = GvHV(HeVAL(entry));
SV ** const stashentry
= stash ? hv_fetch(stash, key, HeUTF8(entry) ? -(I32)len : (I32)len, 0) : NULL;
HV *substash = NULL;
/* Avoid main::main::main::... */
if(oldsubstash == oldstash) continue;
if(
(
stashentry && *stashentry && isGV(*stashentry)
&& (substash = GvHV(*stashentry))
)
|| (oldsubstash && HvENAME_get(oldsubstash))
)
{
/* Add :: and the key (minus the trailing ::)
to each name. */
SV *subname;
if(SvTYPE(namesv) == SVt_PVAV) {
SV *aname;
items = AvFILLp((AV *)namesv) + 1;
svp = AvARRAY((AV *)namesv);
subname = sv_2mortal((SV *)newAV());
while (items--) {
aname = newSVsv(*svp++);
if (len == 1)
sv_catpvs(aname, ":");
else {
sv_catpvs(aname, "::");
sv_catpvn_flags(
aname, key, len-2,
HeUTF8(entry)
? SV_CATUTF8 : SV_CATBYTES
);
}
av_push((AV *)subname, aname);
}
}
else {
subname = sv_2mortal(newSVsv(namesv));
if (len == 1) sv_catpvs(subname, ":");
else {
sv_catpvs(subname, "::");
sv_catpvn_flags(
subname, key, len-2,
HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES
);
}
}
mro_gather_and_rename(
stashes, seen_stashes,
substash, oldsubstash, subname
);
}
(void)hv_store(seen, key, HeUTF8(entry) ? -(I32)len : (I32)len, &PL_sv_yes, 0);
}
}
}
}
/* Skip the entire loop if the hash is empty. */
if (stash && HvUSEDKEYS(stash)) {
xhv = (XPVHV*)SvANY(stash);
riter = -1;
/* Iterate through the new stash, skipping $seen{$key} items,
calling mro_gather_and_rename(stashes,seen,entry,NULL, ...). */
while (++riter <= (I32)xhv->xhv_max) {
entry = (HvARRAY(stash))[riter];
/* Iterate through the entries in this list */
for(; entry; entry = HeNEXT(entry)) {
const char* key;
I32 len;
/* If this entry is not a glob, ignore it.
Try the next. */
if (!isGV(HeVAL(entry))) continue;
key = hv_iterkey(entry, &len);
if ((len > 1 && key[len-2] == ':' && key[len-1] == ':')
|| (len == 1 && key[0] == ':')) {
HV *substash;
/* If this entry was seen when we iterated through the
oldstash, skip it. */
if(seen && hv_exists(seen, key, HeUTF8(entry) ? -(I32)len : (I32)len)) continue;
/* We get here only if this stash has no corresponding
entry in the stash being replaced. */
substash = GvHV(HeVAL(entry));
if(substash) {
SV *subname;
/* Avoid checking main::main::main::... */
if(substash == stash) continue;
/* Add :: and the key (minus the trailing ::)
to each name. */
if(SvTYPE(namesv) == SVt_PVAV) {
SV *aname;
items = AvFILLp((AV *)namesv) + 1;
svp = AvARRAY((AV *)namesv);
subname = sv_2mortal((SV *)newAV());
while (items--) {
aname = newSVsv(*svp++);
if (len == 1)
sv_catpvs(aname, ":");
else {
sv_catpvs(aname, "::");
sv_catpvn_flags(
aname, key, len-2,
HeUTF8(entry)
? SV_CATUTF8 : SV_CATBYTES
);
}
av_push((AV *)subname, aname);
}
}
else {
subname = sv_2mortal(newSVsv(namesv));
if (len == 1) sv_catpvs(subname, ":");
else {
sv_catpvs(subname, "::");
sv_catpvn_flags(
subname, key, len-2,
HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES
);
}
}
mro_gather_and_rename(
stashes, seen_stashes,
substash, NULL, subname
);
}
}
}
}
}
}
/*
=for apidoc mro_isa_changed_in
Takes the necessary steps (cache invalidations, mostly)
when the @ISA of the given package has changed. Invoked
by the C<setisa> magic, should not need to invoke directly.
=cut
*/
void
Perl_mro_isa_changed_in(pTHX_ HV* stash)
{
dVAR;
HV* isarev;
AV* linear_mro;
HE* iter;
SV** svp;
I32 items;
bool is_universal;
struct mro_meta * meta;
const char * const stashname = HvNAME_get(stash);
const STRLEN stashname_len = HvNAMELEN_get(stash);
PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN;
if(!stashname)
Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
/* wipe out the cached linearizations for this stash */
meta = HvMROMETA(stash);
if (meta->mro_linear_dfs) {
SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_dfs));
meta->mro_linear_dfs = NULL;
/* This is just acting as a shortcut pointer. */
meta->mro_linear_c3 = NULL;
} else if (meta->mro_linear_c3) {
/* Only the current MRO is stored, so this owns the data. */
SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_c3));
meta->mro_linear_c3 = NULL;
}
if (meta->isa) {
SvREFCNT_dec(meta->isa);
meta->isa = NULL;
}
/* Inc the package generation, since our @ISA changed */
meta->pkg_gen++;
/* Wipe the global method cache if this package
is UNIVERSAL or one of its parents */
svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
isarev = svp ? MUTABLE_HV(*svp) : NULL;
if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
|| (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
PL_sub_generation++;
is_universal = TRUE;
}
else { /* Wipe the local method cache otherwise */
meta->cache_gen++;
is_universal = FALSE;
}
/* wipe next::method cache too */
if(meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
/* Iterate the isarev (classes that are our children),
wiping out their linearization, method and isa caches */
if(isarev) {
hv_iterinit(isarev);
while((iter = hv_iternext(isarev))) {
I32 len;
const char* const revkey = hv_iterkey(iter, &len);
HV* revstash = gv_stashpvn(revkey, len, 0);
struct mro_meta* revmeta;
if(!revstash) continue;
revmeta = HvMROMETA(revstash);
if (revmeta->mro_linear_dfs) {
SvREFCNT_dec(MUTABLE_SV(revmeta->mro_linear_dfs));
revmeta->mro_linear_dfs = NULL;
/* This is just acting as a shortcut pointer. */
revmeta->mro_linear_c3 = NULL;
} else if (revmeta->mro_linear_c3) {
/* Only the current MRO is stored, so this owns the data. */
SvREFCNT_dec(MUTABLE_SV(revmeta->mro_linear_c3));
revmeta->mro_linear_c3 = NULL;
}
if(!is_universal)
revmeta->cache_gen++;
if(revmeta->mro_nextmethod)
hv_clear(revmeta->mro_nextmethod);
if (revmeta->isa) {
SvREFCNT_dec(revmeta->isa);
revmeta->isa = NULL;
}
}
}
/* Now iterate our MRO (parents), and do a few things:
1) instantiate with the "fake" flag if they don't exist
2) flag them as universal if we are universal
3) Add everything from our isarev to their isarev
*/
/* We're starting at the 2nd element, skipping ourselves here */
linear_mro = mro_get_linear_isa(stash);
svp = AvARRAY(linear_mro) + 1;
items = AvFILLp(linear_mro);
while (items--) {
SV* const sv = *svp++;
HV* mroisarev;
HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
/* That fetch should not fail. But if it had to create a new SV for
us, then we can detect it, because it will not be the correct type.
Probably faster and cleaner for us to free that scalar [very little
code actually executed to free it] and create a new HV than to
copy&paste [SIN!] the code from newHV() to allow us to upgrade the
new SV from SVt_NULL. */
mroisarev = MUTABLE_HV(HeVAL(he));
if(SvTYPE(mroisarev) != SVt_PVHV) {
SvREFCNT_dec(mroisarev);
mroisarev = newHV();
HeVAL(he) = MUTABLE_SV(mroisarev);
}
/* This hash only ever contains PL_sv_yes. Storing it over itself is
almost as cheap as calling hv_exists, so on aggregate we expect to
save time by not making two calls to the common HV code for the
case where it doesn't exist. */
(void)hv_store(mroisarev, stashname, stashname_len, &PL_sv_yes, 0);
if(isarev) {
hv_iterinit(isarev);
while((iter = hv_iternext(isarev))) {
I32 revkeylen;
char* const revkey = hv_iterkey(iter, &revkeylen);
(void)hv_store(mroisarev, revkey, revkeylen, &PL_sv_yes, 0);
}
}
}
}
int perlresult2dbres(SV *perlres, db_res_t **r) {
HV * result = NULL;
SV *colarrayref = NULL;
AV *colarray = NULL;
SV *acol = NULL;
int colcount = 0;
SV *rowarrayref = NULL;
AV *rowarray = NULL;
int rowcount = 0;
SV *arowref = NULL;
AV *arow = NULL;
int arowlen = 0;
SV *aelement = NULL;
SV *atypesv = 0;
int atype = 0;
SV *aval = NULL;
char *charbuf;
char *currentstring;
int i, j;
int retval = 0;
STRLEN len;
SV *d1; /* helper variables */
/*db_val_t cur_val;*/ /* Abbreviation in "switch" below. The currently
modified db result value. */
if (!(SvROK(perlres) &&
(sv_derived_from(perlres, "OpenSIPS::VDB::Result")))) {
goto error;
}
result = (HV*)SvRV(perlres);
/* Memory allocation for C side result structure */
*r = db_new_result();
/* Fetch column definitions */
colarrayref = *hv_fetchs(result, PERL_VDB_COLDEFSMETHOD, 0);
/* colarrayref = perlvdb_perlmethod(perlres, PERL_VDB_COLDEFSMETHOD,
NULL, NULL, NULL, NULL); */
if (!(SvROK(colarrayref))) goto error;
colarray = (AV *)SvRV(colarrayref);
/* SvREFCNT_dec(colarray); */
if (!(SvTYPE(colarray) == SVt_PVAV)) goto error;
colcount = av_len(colarray) + 1;
RES_COL_N(*r) = colcount;
db_allocate_columns(*r, colcount);
/* reverse direction, as elements are removed by "SvREFCNT_dec" */
for (i = colcount-1; i >= 0; i--) {
acol = *av_fetch(colarray, i, 0);
d1 = perlvdb_perlmethod(acol, PERL_VDB_TYPEMETHOD,
NULL, NULL, NULL, NULL);
if (!SvIOK(d1)) goto error;
(*r)->col.types[i] = SvIV(d1);
SvREFCNT_dec(d1);
d1 = perlvdb_perlmethod(acol, PERL_VDB_NAMEMETHOD,
NULL, NULL, NULL, NULL);
if (!SvPOK(d1)) goto error;
currentstring = SvPV(d1, len);
charbuf = pkg_malloc(len+1);
/* Column names buffers are freed in the perlvdb free function */
strncpy(charbuf, currentstring, len+1);
(*r)->col.names[i]->s = charbuf;
(*r)->col.names[i]->len = strlen(charbuf);
SvREFCNT_dec(d1);
}
if(hv_exists(result, "rows", 4)){
rowarrayref =(SV*) hv_fetchs(result, "rows", 0);
}else{
(*r)->n = 0;
(*r)->res_rows = 0;
(*r)->last_row = 0;
goto end;
}
if(rowarrayref){
rowarrayref = *((SV**)rowarrayref);
}else{
(*r)->n = 0;
(*r)->res_rows = 0;
(*r)->last_row = 0;
goto end;
}
if (!(SvROK(rowarrayref))) { /* Empty result set */
(*r)->n = 0;
(*r)->res_rows = 0;
(*r)->last_row = 0;
goto end;
}
rowarray = (AV *)SvRV(rowarrayref);
if (!(SvTYPE(rowarray) == SVt_PVAV)) goto error;
rowcount = av_len(rowarray) + 1;
(*r)->n = rowcount;
(*r)->res_rows = rowcount;
(*r)->last_row = rowcount;
db_allocate_rows(*r, rowcount);
/* (rows * (sizeof(db_row_t) + sizeof(db_val_t) * RES_COL_N(_res)) */
/* LM_DBG("We got %d rows each row requres %d bytes because the row struct is %d and"
"the values in that row take up %d. That is %d values each size is %d\n",
rowcount, sizeof(db_row_t) + sizeof(db_val_t) * RES_COL_N(*r), sizeof(db_row_t), sizeof(db_val_t) * RES_COL_N(*r), RES_COL_N(*r), sizeof(db_val_t));
*/
for (i = 0; i < rowcount; i++) {
arowref = *av_fetch(rowarray, i, 0);
if (!SvROK(arowref)) goto error;
arow = (AV *)SvRV(arowref);
if (!(SvTYPE(colarray) == SVt_PVAV)) goto error;
arowlen = av_len(arow) + 1;
(*r)->rows[i].n = arowlen;
for (j = 0; j < arowlen; j++) {
aelement = *av_fetch(arow, j, 0);
#define cur_val (((*r)->rows)[i].values)[j]
/*cur_val = (((*r)->rows)[i].values)[j];*/
/* cur_val is just an "abbreviation" */
if (!(sv_isobject(aelement) &&
sv_derived_from(aelement, PERL_CLASS_VALUE))) {
cur_val.nul = 1;
continue;
}
atypesv = *hv_fetchs((HV*)SvRV(aelement),PERL_VDB_TYPEMETHOD,0); /*aelement->{type} */
atype = SvIV(atypesv);
/*atypesv = perlvdb_perlmethod(aelement,
PERL_VDB_TYPEMETHOD,
NULL, NULL, NULL, NULL);*/
aval = perlvdb_perlmethod(aelement, PERL_VDB_DATAMETHOD,
NULL, NULL, NULL, NULL);
(*r)->rows[i].values[j].type = atype;
/* SvREFCNT_dec(atypesv); */
if (!SvOK(aval)) {
cur_val.nul = 1;
} else {
switch (atype) {
case DB_INT:
cur_val.val.int_val =
SvIV(aval);
cur_val.nul = 0;
break;
case DB_DOUBLE:
cur_val.val.double_val =
SvNV(aval);
cur_val.nul = 0;
break;
case DB_STRING:
case DB_STR:
/* We dont support DB_STR for now.
* Set DB_STRING instead */
cur_val.type = DB_STRING;
currentstring = SvPV(aval, len);
charbuf = pkg_malloc(len+1);
strncpy(charbuf, currentstring,
len+1);
cur_val.val.string_val =
charbuf;
cur_val.nul = 0;
break;
case DB_DATETIME:
cur_val.val.time_val =
(time_t)SvIV(aval);
cur_val.nul = 0;
break;
case DB_BLOB:
currentstring = SvPV(aval, len);
charbuf = pkg_malloc(len+1);
strncpy(charbuf, currentstring,
len+1);
cur_val.val.blob_val.s =
charbuf;
cur_val.val.blob_val.len = len;
cur_val.nul = 0;
break;
case DB_BITMAP:
cur_val.val.bitmap_val =
SvIV(aval);
cur_val.nul = 0;
break;
default:
LM_CRIT("cannot handle this data type.\n");
return -1;
break;
}
}
SvREFCNT_dec(aval);
}
}
end:
return retval;
error:
LM_CRIT("broken result set. Exiting, leaving OpenSIPS in unknown state.\n");
return -1;
}
int p5_hv_exists(PerlInterpreter *my_perl, HV *hv, STRLEN len, const char *key) {
PERL_SET_CONTEXT(my_perl);
return hv_exists(hv, key, len);
}
static IntfEntry *
intf_sv2c(SV *h, IntfEntry *ref)
{
if (ref && h && SvROK(h)) {
HV *hv = (HV *)SvRV(h);
memset(ref, 0, sizeof(IntfEntry));
if (hv_exists(hv, "intf_len", 8)) {
SV **len = hv_fetch((HV *)SvRV(h), "intf_len", 8, 0);
ref->intf_len = (SvOK(*len) ? SvIV(*len) : 0);
}
if (hv_exists(hv, "intf_name", 9)) {
SV **name = hv_fetch((HV *)SvRV(h), "intf_name", 9, 0);
if (SvOK(*name)) {
memcpy(&(ref->intf_name), SvPV(*name, PL_na),
sizeof(ref->intf_name));
}
}
if (hv_exists(hv, "intf_type", 9)) {
SV **type = hv_fetch((HV *)SvRV(h), "intf_type", 9, 0);
ref->intf_type = (SvOK(*type) ? SvIV(*type) : 0);
}
if (hv_exists(hv, "intf_flags", 10)) {
SV **flags = hv_fetch((HV *)SvRV(h), "intf_flags", 10, 0);
ref->intf_flags = (SvOK(*flags) ? SvIV(*flags) : 0);
}
if (hv_exists(hv, "intf_mtu", 8)) {
SV **mtu = hv_fetch((HV *)SvRV(h), "intf_mtu", 8, 0);
ref->intf_mtu = (SvOK(*mtu) ? SvIV(*mtu) : 0);
}
if (hv_exists(hv, "intf_addr", 9)) {
SV **addr = hv_fetch((HV *)SvRV(h), "intf_addr", 9, 0);
if (SvOK(*addr)) {
struct addr a;
if (addr_aton(SvPV(*addr, PL_na), &a) == 0) {
memcpy(&(ref->intf_addr), &a, sizeof(struct addr));
}
}
}
if (hv_exists(hv, "intf_dst_addr", 13)) {
SV **dstAddr = hv_fetch((HV *)SvRV(h), "intf_dst_addr", 13, 0);
if (SvOK(*dstAddr)) {
struct addr a;
if (addr_aton(SvPV(*dstAddr, PL_na), &a) == 0) {
memcpy(&(ref->intf_dst_addr), &a, sizeof(struct addr));
}
}
}
if (hv_exists(hv, "intf_link_addr", 14)) {
SV **lnkAddr = hv_fetch((HV *)SvRV(h), "intf_link_addr", 14, 0);
if (SvOK(*lnkAddr)) {
struct addr a;
if (addr_aton(SvPV(*lnkAddr, PL_na), &a) == 0) {
memcpy(&(ref->intf_link_addr), &a, sizeof(struct addr));
}
}
}
}
else {
ref = NULL;
}
// XXX: put aliases also
return ref;
}
