MODULE = MIME::Fast PACKAGE = MIME::Fast::Hash::Header PREFIX=hash_
MIME::Fast::Hash::Header
hash_TIEHASH(Class, objptr)
char * Class
MIME::Fast::Message objptr
PREINIT:
hash_header * hash;
CODE:
hash = g_malloc(sizeof(hash_header));
hash->keyindex = 0;
hash->objptr = objptr;
hash->fetchvalue = NULL;
if (gmime_debug)
warn("function hash_TIEHASH(%s, 0x%x) returns 0x%x\n", Class, objptr, hash);
RETVAL = hash;
OUTPUT:
RETVAL
void
hash_DESTROY(obj)
MIME::Fast::Hash::Header obj
CODE:
if (gmime_debug)
warn("function hash_DESTROY(0x%x)\n", obj);
obj->objptr = NULL;
g_free(obj);
void
hash_FETCH(obj, key)
MIME::Fast::Hash::Header obj
const char * key
PREINIT:
MIME__Fast__Message msg;
GList *gret = NULL, *item;
AV * retav;
I32 gimme = GIMME_V;
PPCODE:
msg = obj->objptr;
/* THE HACK - FETCH method would get value indirectly from NEXTKEY */
if (obj->keyindex != -1 && obj->fetchvalue != NULL) {
XPUSHs(sv_2mortal(newSVpv(obj->fetchvalue,0)));
obj->fetchvalue == NULL;
XSRETURN(1);
}
obj->fetchvalue = NULL;
gret = message_get_header(msg, key);
if (gmime_debug)
warn("hash_FETCH(0x%x, '%s', items=%d)", obj, key ? key : "NULL", items);
if (!gret || gret->data == NULL) {
if (gmime_debug)
warn("fetch returns undef\n");
if (gret)
g_list_free(gret);
XSRETURN(0);
} else {
if (gret->next == NULL) { // one value
XPUSHs(sv_2mortal(newSVpv((char *)(gret->data),0)));
} else {
if (gimme == G_ARRAY) {
item = gret;
while (item && item->data) {
XPUSHs(sv_2mortal(newSVpv((char *)(item->data),0)));
item = item->next;
}
} else if (gimme == G_SCALAR) {
retav = newAV();
item = gret;
while (item && item->data) {
av_push(retav, newSVpv((char *)g_strdup((item->data)), 0));
item = item->next;
}
XPUSHs(newRV_noinc((SV *)retav));
}
}
}
if (gret) {
item = gret;
while (item) {
if (item->data)
g_free((char *)(item->data));
item = item->next;
}
g_list_free(gret);
}
void
hash_STORE(obj, key, svmixed)
MIME::Fast::Hash::Header obj
const char * key
SV * svmixed
PREINIT:
MIME__Fast__Message msg;
char * value;
SV * svvalue;
svtype svvaltype;
STRLEN vallen;
CODE:
/* only one value can be stored - no arrays allowed by perl */
msg = obj->objptr;
svvalue = svmixed;
if (SvROK(svmixed)) {
svvalue = SvRV(svmixed);
}
svvaltype = SvTYPE(svvalue);
if (SvGMAGICAL(svvalue)) {
if (gmime_debug)
warn("hash_STORE: mg_get sv magical");
mg_get(svvalue);
}
// TEST: display sv value
if (gmime_debug)
warn_type(svvalue, "hash_STORE");
/* delete header for the first array item */
g_mime_object_remove_header (GMIME_OBJECT(msg), key);
if (svvaltype == SVt_PVAV) {
AV * avvalue;
I32 i, avlen;
SV * svtmp;
/* set header */
avvalue = (AV *)svvalue;
avlen = av_len(avvalue);
for (i=avlen; i>=0; --i) {
svtmp = (SV *)(*(av_fetch(avvalue, i, 0)));
if (SvGMAGICAL(svtmp)) {
if (gmime_debug)
warn("hash_STORE(AV): mg_get sv magical");
mg_get(svtmp);
}
if (svtmp && SvPOKp(svtmp)) {
value = (char *)SvPV(svtmp, vallen);
message_set_header(msg, key, value);
}
}
} else if (SvPOK(svvalue) || SvIOK(svvalue) || SvNOK(svvalue)) {
value = (char *)SvPV(svvalue, vallen);
message_set_header(msg, key, value);
} else { /* assume scalar value */
/* undefined value -> remove header */
if (!(SvOK(svvalue)))
g_mime_object_remove_header (GMIME_OBJECT(msg), key);
else if (!(SvPOKp(svvalue)))
croak("hash_STORE: Unknown sv type: %d for field %s 0x%x/0x%x/0x%x",
SvTYPE(svvalue), key, &svvalue, &PL_sv_undef, svvalue);
}
if (gmime_debug)
warn("hash_STORE: %s(0x%x) = %s\n", key, svvalue, SvPV(svvalue, vallen));
gboolean
hash_EXISTS(obj, key)
MIME::Fast::Hash::Header obj
const char * key
PREINIT:
MIME__Fast__Message msg;
GList *gret, *item;
CODE:
msg = obj->objptr;
if (gmime_debug)
warn("hash_EXISTS(%s)\n", key);
gret = message_get_header(msg, key);
RETVAL = (gret != NULL && gret->data != NULL);
if (gret) {
item = gret;
while (item) {
if (item->data)
g_free((char *)(item->data));
item = item->next;
}
g_list_free(gret);
}
OUTPUT:
RETVAL
void
hash_DELETE(obj, key)
MIME::Fast::Hash::Header obj
const char * key
CODE:
if (gmime_debug)
warn("hash_DELETE %s\n", key);
g_mime_object_remove_header (GMIME_OBJECT(obj->objptr), key);
void
hash_NEXTKEY(obj, lastkey = NULL)
MIME::Fast::Hash::Header obj
const char * lastkey
ALIAS:
MIME::Fast::Hash::Header::FIRSTKEY = 1
PREINIT:
char * key = NULL;
char * value = NULL;
MIME__Fast__Message msg;
I32 gimme = GIMME_V;
gint i, j, found;
local_GMimeHeader * header;
struct raw_header *h;
INIT:
if (ix == 1) {
obj->keyindex = -1;
}
PPCODE:
msg = obj->objptr;
++obj->keyindex;
if (gmime_debug)
warn("hash_NEXTKEY");
i = obj->keyindex;
header = GMIME_OBJECT(msg)->headers;
h = header->headers;
j = 0;
found = 0;
while (h) {
if (j >= i) {
key = h->name;
value = h->value;
found = 1;
break;
}
j++;
h = h->next;
}
if (!found && key == NULL) {
obj->keyindex = -1;
}
if (gimme != G_SCALAR && !value) {
// TODO: does each, keys, retrieves the value?
// retrieve the value
warn("Error in hash_NEXTKEY: NEED TO RETRIEVE THE VALUE, contact the author\n");
}
/* THE HACK - FETCH method would get value indirectly */
obj->fetchvalue = NULL;
if (key) {
XPUSHs(sv_2mortal(newSVpv(key,0)));
if (gimme != G_SCALAR && value)
XPUSHs(sv_2mortal(newSVpv(value,0)));
/* THE HACK - FETCH method would get value indirectly */
obj->fetchvalue = value;
}
if (gmime_debug)
warn("hash_%s(0x%x, %s) = (\"%s\",\"%s\") key no. %d%s",
(ix == 1) ? "FIRSTKEY" : "NEXTKEY",
obj, lastkey ? lastkey : "NULL",
key ? key : "NULL",
value ? value : "NULL",
i, obj->keyindex == -1 ? " (last)" : "");
void
hash_CLEAR(obj)
MIME::Fast::Hash::Header obj
PREINIT:
MIME__Fast__Message message;
local_GMimeHeader *header;
CODE:
message = obj->objptr;
if (gmime_debug)
warn("function hash_CLEAR(0x%x)\n", obj);
g_free (message->from);
message->from = NULL;
g_free (message->reply_to);
message->reply_to = NULL;
/* destroy all recipients */
g_hash_table_foreach_remove (message->recipients, recipients_destroy, NULL);
//g_hash_table_destroy (message->header->recipients);
//message->header->recipients = g_hash_table_new (g_str_hash, g_str_equal);
g_free (message->subject);
message->subject = NULL;
g_free (message->message_id);
message->message_id = NULL;
/* free all the headers */
header = GMIME_OBJECT(message)->headers;
g_mime_header_destroy(header);
GMIME_OBJECT(message)->headers = g_mime_header_new ();