#include <haproxy/guid.h>

#include <import/cebis_tree.h>

#include <haproxy/listener-t.h>

#include <haproxy/obj_type.h>

#include <haproxy/proxy.h>

#include <haproxy/server-t.h>

#include <haproxy/tools.h>

#include <haproxy/thread.h>

/* GUID global tree */

struct ceb_root *guid_tree = NULL;

__decl_thread(HA_RWLOCK_T guid_lock);

/* note: touched under the guid_lock */

static int _guid_count = 0;

/* Initialize <guid> members. */

void guid_init(struct guid_node *guid)

{

  memset(guid, 0, sizeof(*guid));

}

/* Insert <objt> into GUID global tree with key <uid>. Must only be called on

 * thread isolation. On failure, <errmsg> will be allocated with an error

 * description. Caller is responsible to free it.

 *

 * Returns 0 on success else non-zero.

 */

int guid_insert(enum obj_type *objt, const char *uid, char **errmsg)

{

  struct guid_node *guid = NULL;

  struct guid_node *dup;

  char *dup_name = NULL;

  if (!guid_is_valid_fmt(uid, errmsg))

    goto err;

  switch (obj_type(objt)) {

  case OBJ_TYPE_PROXY:

    guid = &__objt_proxy(objt)->guid;

    break;

  case OBJ_TYPE_LISTENER:

    guid = &__objt_listener(objt)->guid;

    break;

  case OBJ_TYPE_SERVER:

    guid = &__objt_server(objt)->guid;

    break;

  default:

    /* No guid support for this objtype. */

    ABORT_NOW();

    return 0;

  }

  guid->key = strdup(uid);

  if (!guid->key) {

    memprintf(errmsg, "key alloc failure");

    goto err;

  }

  HA_RWLOCK_WRLOCK(GUID_LOCK, &guid_lock);

  dup = cebuis_item_insert(&guid_tree, node, key, guid);

  if (dup != guid) {

    HA_RWLOCK_WRUNLOCK(GUID_LOCK, &guid_lock);

    dup_name = guid_name(dup);

    memprintf(errmsg, "duplicate entry with %s", dup_name);

    goto err;

  }

  _guid_count += 1;

  HA_RWLOCK_WRUNLOCK(GUID_LOCK, &guid_lock);

  guid->obj_type = objt;

  return 0;

 err:

  if (guid)

    ha_free(&guid->key);

  ha_free(&dup_name);

  return 1;

}

/* Remove <guid> node from GUID global tree. Must only be called on thread

 * isolation. Safe to call even if node is not currently stored.

 */

void guid_remove(struct guid_node *guid)

{

  HA_RWLOCK_WRLOCK(GUID_LOCK, &guid_lock);

  if (guid->key)

    _guid_count--;

  cebuis_item_delete(&guid_tree, node, key, guid);

  ha_free(&guid->key);

  HA_RWLOCK_WRUNLOCK(GUID_LOCK, &guid_lock);

}

/* Retrieve an instance from GUID global tree with key <uid>.

 *

 * Returns the GUID instance or NULL if key not found.

 */

struct guid_node *guid_lookup(const char *uid)

{

  struct guid_node *guid = NULL;

  /* For now, guid_lookup() is only used during startup in single-thread

   * mode. If this is not the case anymore, GUID tree access must be

   * protected with the read-write lock.

   */

  BUG_ON(!(global.mode & MODE_STARTING));

  guid = cebuis_item_lookup(&guid_tree, node, key, uid, struct guid_node);

  return guid;

}

/* Returns a boolean checking if <uid> respects GUID format. If <errmsg> is not

 * NULL, it will be allocated with an error description in case of invalid

 * format.

 */

int guid_is_valid_fmt(const char *uid, char **errmsg)

{

  const size_t len = strlen(uid);

  const char *c;

  if (!len || len > GUID_MAX_LEN) {

    memprintf(errmsg, "invalid length");

    return 0;

  }

  c = invalid_char(uid);

  if (c) {

    memprintf(errmsg, "invalid character '%c'", c[0]);

    return 0;

  }

  return 1;

}

/* Generate a user-friendly description for the instance attached via <guid>

 * node. The string is dynamically allocated and the caller is responsible to

 * free it.

 *

 * Returns a pointer to the dynamically allocated message.

 */

char *guid_name(const struct guid_node *guid)

{

  char *msg = NULL;

  struct proxy *px;

  struct listener *l;

  struct server *srv;

  switch (obj_type(guid->obj_type)) {

  case OBJ_TYPE_PROXY:

    px = __objt_proxy(guid->obj_type);

    return memprintf(&msg, "%s %s", proxy_cap_str(px->cap), px->id);

  case OBJ_TYPE_LISTENER:

    l = __objt_listener(guid->obj_type);

    return memprintf(&msg, "listener %s (%s:%d)",

                     l->bind_conf->frontend->id,

                     l->bind_conf->file, l->bind_conf->line);

  case OBJ_TYPE_SERVER:

    srv = __objt_server(guid->obj_type);

    return memprintf(&msg, "server %s/%s", srv->proxy->id, srv->id);

  default:

    break;

  }

  return NULL;

}

/* returns the number of guid inserted in guid_tree */

int guid_count(void)

{

  int count;

  HA_RWLOCK_WRLOCK(GUID_LOCK, &guid_lock);

  count = _guid_count;

  HA_RWLOCK_WRUNLOCK(GUID_LOCK, &guid_lock);

  return count;

}