#include <sys_defs.h>
#include <unistd.h>
#include <stddef.h>
#include <string.h>
#include <msg.h>
#include <ring.h>
#include <htable.h>
#include <vstring.h>
#include <mymalloc.h>
#include <events.h>
#include <scache.h>
typedef struct {
SCACHE scache[1];
HTABLE *dest_cache;
HTABLE *endp_cache;
int sess_count;
} SCACHE_MULTI;
typedef struct {
RING ring[1];
char *parent_key;
SCACHE_MULTI *cache;
} SCACHE_MULTI_HEAD;
#define RING_TO_MULTI_HEAD(p) RING_TO_APPL((p), SCACHE_MULTI_HEAD, ring)
typedef struct {
RING ring[1];
SCACHE_MULTI_HEAD *head;
char *endp_label;
char *dest_prop;
} SCACHE_MULTI_DEST;
#define RING_TO_MULTI_DEST(p) RING_TO_APPL((p), SCACHE_MULTI_DEST, ring)
static void scache_multi_expire_dest(int, void *);
typedef struct {
RING ring[1];
SCACHE_MULTI_HEAD *head;
int fd;
char *endp_prop;
} SCACHE_MULTI_ENDP;
#define RING_TO_MULTI_ENDP(p) RING_TO_APPL((p), SCACHE_MULTI_ENDP, ring)
static void scache_multi_expire_endp(int, void *);
#define BOTTOM_UP 1
#define TOP_DOWN 2
static void scache_multi_drop_endp(SCACHE_MULTI_ENDP *endp, int direction)
{
const char *myname = "scache_multi_drop_endp";
SCACHE_MULTI_HEAD *head;
if (msg_verbose)
msg_info("%s: endp_prop=%s fd=%d", myname,
endp->endp_prop, endp->fd);
event_cancel_timer(scache_multi_expire_endp, (void *) endp);
ring_detach(endp->ring);
head = endp->head;
head->cache->sess_count--;
if (direction == BOTTOM_UP && ring_pred(head->ring) == head->ring)
htable_delete(head->cache->endp_cache, head->parent_key, myfree);
if (endp->fd >= 0 && close(endp->fd) != 0)
msg_warn("%s: close(%d): %m", myname, endp->fd);
myfree(endp->endp_prop);
myfree((void *) endp);
}
static void scache_multi_expire_endp(int unused_event, void *context)
{
SCACHE_MULTI_ENDP *endp = (SCACHE_MULTI_ENDP *) context;
scache_multi_drop_endp(endp, BOTTOM_UP);
}
static void scache_multi_free_endp(void *ptr)
{
SCACHE_MULTI_HEAD *head = (SCACHE_MULTI_HEAD *) ptr;
SCACHE_MULTI_ENDP *endp;
RING *ring;
while ((ring = ring_succ(head->ring)) != head->ring) {
endp = RING_TO_MULTI_ENDP(ring);
scache_multi_drop_endp(endp, TOP_DOWN);
}
myfree((void *) head);
}
static void scache_multi_save_endp(SCACHE *scache, int ttl,
const char *endp_label,
const char *endp_prop, int fd)
{
const char *myname = "scache_multi_save_endp";
SCACHE_MULTI *sp = (SCACHE_MULTI *) scache;
SCACHE_MULTI_HEAD *head;
SCACHE_MULTI_ENDP *endp;
if (ttl < 0)
msg_panic("%s: bad ttl: %d", myname, ttl);
if ((head = (SCACHE_MULTI_HEAD *)
htable_find(sp->endp_cache, endp_label)) == 0) {
head = (SCACHE_MULTI_HEAD *) mymalloc(sizeof(*head));
ring_init(head->ring);
head->parent_key =
htable_enter(sp->endp_cache, endp_label, (void *) head)->key;
head->cache = sp;
}
endp = (SCACHE_MULTI_ENDP *) mymalloc(sizeof(*endp));
endp->head = head;
endp->fd = fd;
endp->endp_prop = mystrdup(endp_prop);
ring_prepend(head->ring, endp->ring);
sp->sess_count++;
event_request_timer(scache_multi_expire_endp, (void *) endp, ttl);
if (msg_verbose)
msg_info("%s: endp_label=%s -> endp_prop=%s fd=%d",
myname, endp_label, endp_prop, fd);
}
static int scache_multi_find_endp(SCACHE *scache, const char *endp_label,
VSTRING *endp_prop)
{
const char *myname = "scache_multi_find_endp";
SCACHE_MULTI *sp = (SCACHE_MULTI *) scache;
SCACHE_MULTI_HEAD *head;
SCACHE_MULTI_ENDP *endp;
RING *ring;
int fd;
if ((head = (SCACHE_MULTI_HEAD *)
htable_find(sp->endp_cache, endp_label)) == 0) {
if (msg_verbose)
msg_info("%s: no endpoint cache: endp_label=%s",
myname, endp_label);
return (-1);
}
if ((ring = ring_succ(head->ring)) != head->ring) {
endp = RING_TO_MULTI_ENDP(ring);
fd = endp->fd;
endp->fd = -1;
vstring_strcpy(endp_prop, endp->endp_prop);
if (msg_verbose)
msg_info("%s: found: endp_label=%s -> endp_prop=%s fd=%d",
myname, endp_label, endp->endp_prop, fd);
scache_multi_drop_endp(endp, BOTTOM_UP);
return (fd);
}
if (msg_verbose)
msg_info("%s: not found: endp_label=%s", myname, endp_label);
return (-1);
}
static void scache_multi_drop_dest(SCACHE_MULTI_DEST *dest, int direction)
{
const char *myname = "scache_multi_drop_dest";
SCACHE_MULTI_HEAD *head;
if (msg_verbose)
msg_info("%s: dest_prop=%s endp_label=%s",
myname, dest->dest_prop, dest->endp_label);
event_cancel_timer(scache_multi_expire_dest, (void *) dest);
ring_detach(dest->ring);
head = dest->head;
if (direction == BOTTOM_UP && ring_pred(head->ring) == head->ring)
htable_delete(head->cache->dest_cache, head->parent_key, myfree);
myfree(dest->dest_prop);
myfree(dest->endp_label);
myfree((void *) dest);
}
static void scache_multi_expire_dest(int unused_event, void *context)
{
SCACHE_MULTI_DEST *dest = (SCACHE_MULTI_DEST *) context;
scache_multi_drop_dest(dest, BOTTOM_UP);
}
static void scache_multi_free_dest(void *ptr)
{
SCACHE_MULTI_HEAD *head = (SCACHE_MULTI_HEAD *) ptr;
SCACHE_MULTI_DEST *dest;
RING *ring;
while ((ring = ring_succ(head->ring)) != head->ring) {
dest = RING_TO_MULTI_DEST(ring);
scache_multi_drop_dest(dest, TOP_DOWN);
}
myfree((void *) head);
}
static void scache_multi_save_dest(SCACHE *scache, int ttl,
const char *dest_label,
const char *dest_prop,
const char *endp_label)
{
const char *myname = "scache_multi_save_dest";
SCACHE_MULTI *sp = (SCACHE_MULTI *) scache;
SCACHE_MULTI_HEAD *head;
SCACHE_MULTI_DEST *dest;
RING *ring;
int refresh = 0;
if (ttl < 0)
msg_panic("%s: bad ttl: %d", myname, ttl);
if ((head = (SCACHE_MULTI_HEAD *)
htable_find(sp->dest_cache, dest_label)) == 0) {
head = (SCACHE_MULTI_HEAD *) mymalloc(sizeof(*head));
ring_init(head->ring);
head->parent_key =
htable_enter(sp->dest_cache, dest_label, (void *) head)->key;
head->cache = sp;
}
RING_FOREACH(ring, head->ring) {
dest = RING_TO_MULTI_DEST(ring);
if (strcmp(dest->endp_label, endp_label) == 0
&& strcmp(dest->dest_prop, dest_prop) == 0) {
refresh = 1;
break;
}
}
if (refresh == 0) {
dest = (SCACHE_MULTI_DEST *) mymalloc(sizeof(*dest));
dest->head = head;
dest->endp_label = mystrdup(endp_label);
dest->dest_prop = mystrdup(dest_prop);
ring_prepend(head->ring, dest->ring);
}
event_request_timer(scache_multi_expire_dest, (void *) dest, ttl);
if (msg_verbose)
msg_info("%s: dest_label=%s -> dest_prop=%s endp_label=%s%s",
myname, dest_label, dest_prop, endp_label,
refresh ? " (refreshed)" : "");
}
static int scache_multi_find_dest(SCACHE *scache, const char *dest_label,
VSTRING *dest_prop,
VSTRING *endp_prop)
{
const char *myname = "scache_multi_find_dest";
SCACHE_MULTI *sp = (SCACHE_MULTI *) scache;
SCACHE_MULTI_HEAD *head;
SCACHE_MULTI_DEST *dest;
RING *ring;
int fd;
if ((head = (SCACHE_MULTI_HEAD *)
htable_find(sp->dest_cache, dest_label)) == 0) {
if (msg_verbose)
msg_info("%s: no destination cache: dest_label=%s",
myname, dest_label);
return (-1);
}
RING_FOREACH(ring, head->ring) {
dest = RING_TO_MULTI_DEST(ring);
fd = scache_multi_find_endp(scache, dest->endp_label, endp_prop);
if (fd >= 0) {
vstring_strcpy(dest_prop, dest->dest_prop);
return (fd);
}
}
if (msg_verbose)
msg_info("%s: not found: dest_label=%s", myname, dest_label);
return (-1);
}
static void scache_multi_size(SCACHE *scache, SCACHE_SIZE *size)
{
SCACHE_MULTI *sp = (SCACHE_MULTI *) scache;
size->dest_count = sp->dest_cache->used;
size->endp_count = sp->endp_cache->used;
size->sess_count = sp->sess_count;
}
static void scache_multi_free(SCACHE *scache)
{
SCACHE_MULTI *sp = (SCACHE_MULTI *) scache;
htable_free(sp->dest_cache, scache_multi_free_dest);
htable_free(sp->endp_cache, scache_multi_free_endp);
myfree((void *) sp);
}
SCACHE *scache_multi_create(void)
{
SCACHE_MULTI *sp = (SCACHE_MULTI *) mymalloc(sizeof(*sp));
sp->scache->save_endp = scache_multi_save_endp;
sp->scache->find_endp = scache_multi_find_endp;
sp->scache->save_dest = scache_multi_save_dest;
sp->scache->find_dest = scache_multi_find_dest;
sp->scache->size = scache_multi_size;
sp->scache->free = scache_multi_free;
sp->dest_cache = htable_create(1);
sp->endp_cache = htable_create(1);
sp->sess_count = 0;
return (sp->scache);
}