/*

 * Copyright (c) 2004-2006 Maxim Sobolev <sobomax@FreeBSD.org>

 * Copyright (c) 2006-2016 Sippy Software, Inc., http://www.sippysoft.com

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 */

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <errno.h>

#include <netdb.h>

#include <pthread.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include "config.h"

#include "rtpp_types.h"

#include "rtpp_defines.h"

#include "rtpp_cfg.h"

#include "rtpp_log.h"

#include "rtpp_log_obj.h"

#include "rtpp_network.h"

#include "rtpp_mallocs.h"

#include "rtpp_codeptr.h"

#include "rtpp_refcnt.h"

#include "rtpp_str.h"

#include "rtpp_bindaddr.h"

#include "rtpp_bindaddrs.h"

struct bindaddr_list {

    struct rtpp_bindaddr bindaddr;

    struct bindaddr_list *next;

};

struct rtpp_bindaddrs_pvt {

    struct rtpp_bindaddrs pub;

    struct bindaddr_list *bindaddr_list;

    pthread_mutex_t bindaddr_lock;

};

static void rtpp_bindaddrs_dtor(struct rtpp_bindaddrs_pvt *);

static const struct rtpp_bindaddr *

addr2bindaddr_i(struct rtpp_bindaddrs *pub, const struct sockaddr *ia,

  const char **ep, const struct rtpp_bindaddr_params *params)

{

    struct bindaddr_list *bl;

    struct rtpp_bindaddrs_pvt *cf;

    struct sockaddr_storage *ap;

    PUB2PVT(pub, cf);

    pthread_mutex_lock(&cf->bindaddr_lock);

    for (bl = cf->bindaddr_list; bl != NULL; bl = bl->next) {

        const struct rtpp_bindaddr *ba = &bl->bindaddr;

        if (ishostseq(ba->addr, ia) != 0) {

            const rtpp_str_const_t *bll = &ba->params.label;

            if (params != NULL && !rtpp_str_match(&params->label, bll))

                continue;

            pthread_mutex_unlock(&cf->bindaddr_lock);

            return (ba);

        }

    }

    bl = rtpp_zmalloc(sizeof(*bl) + sizeof(struct sockaddr_storage));

    if (bl == NULL) {

        pthread_mutex_unlock(&cf->bindaddr_lock);

        *ep = strerror(errno);

        return (NULL);

    }

    ap = (struct sockaddr_storage *)((char *)bl + sizeof(*bl));

    memcpy(ap, ia, SA_LEN(ia));

    bl->bindaddr.addr = sstosa(ap);

    if (params != NULL) {

        bl->bindaddr.params = *params;

    }

    bl->next = cf->bindaddr_list;

    cf->bindaddr_list = bl;

    pthread_mutex_unlock(&cf->bindaddr_lock);

    return (&bl->bindaddr);

}

static const struct rtpp_bindaddr *

addr2bindaddr(struct rtpp_bindaddrs *pub, const struct sockaddr *ia,

  const char **ep)

{

    return addr2bindaddr_i(pub, ia, ep, NULL);

}

static const struct rtpp_bindaddr *

label2bindaddr(struct rtpp_bindaddrs *pub, const rtpp_str_const_t *label)

{

    struct bindaddr_list *bl;

    struct rtpp_bindaddrs_pvt *cf;

    PUB2PVT(pub, cf);

    pthread_mutex_lock(&cf->bindaddr_lock);

    for (bl = cf->bindaddr_list; bl != NULL; bl = bl->next) {

  const rtpp_str_const_t *blabel = &bl->bindaddr.params.label;

  if (blabel->s != NULL && rtpp_str_match(blabel, label))

      break;

    }

    pthread_mutex_unlock(&cf->bindaddr_lock);

    return (bl == NULL ? NULL : &bl->bindaddr);

}

static const struct rtpp_bindaddr *

host2bindaddr(struct rtpp_bindaddrs *pub, const char *host, int pf,

  int ai_flags, const char **ep, const struct rtpp_bindaddr_params *params)

{

    int n;

    struct sockaddr_storage ia;

    const struct rtpp_bindaddr *rval;

    if (params != NULL && params->label.s != NULL && label2bindaddr(pub, &params->label) != NULL) {

  *ep = "duplicate label";

  return (NULL);

    }

    /*

     * If user specified * then change it to NULL,

     * that will make getaddrinfo to return addr_any socket

     */

    if (host != NULL && is_wildcard(host, pf))

        host = NULL;

    if (host != NULL) {

        ai_flags |= is_numhost(host, pf) ? AI_NUMERICHOST : 0;

    } else {

        ai_flags &= ~AI_ADDRCONFIG;

    }

    if ((n = resolve(sstosa(&ia), pf, host, SERVICE, ai_flags)) != 0) {

        *ep = gai_strerror(n);

        return (NULL);

    }

    rval = addr2bindaddr_i(pub, sstosa(&ia), ep, params);

    return (rval);

}

static const struct rtpp_bindaddr *

bindaddr4af(struct rtpp_bindaddrs *pub, int af)

{

    struct bindaddr_list *bl;

    struct rtpp_bindaddrs_pvt *cf;

    PUB2PVT(pub, cf);

    pthread_mutex_lock(&cf->bindaddr_lock);

    for (bl = cf->bindaddr_list; bl != NULL; bl = bl->next) {

        if (bl->bindaddr.addr->sa_family == af) {

            pthread_mutex_unlock(&cf->bindaddr_lock);

            return (&bl->bindaddr);

        }

    }

    pthread_mutex_unlock(&cf->bindaddr_lock);

    return (NULL);

}

static void

rtpp_bindaddrs_dtor(struct rtpp_bindaddrs_pvt *cf)

{

    struct bindaddr_list *bl, *bl_next;

    for (bl = cf->bindaddr_list; bl != NULL; bl = bl_next) {

        bl_next = bl->next;

        free(bl);

    }

    pthread_mutex_destroy(&cf->bindaddr_lock);

}

static const struct rtpp_bindaddr *

rtpp_bindaddrs_local4remote(struct rtpp_bindaddrs *pub, const struct rtpp_cfg *cfsp,

  struct rtpp_log *log, int pf, const char *host, const char *port)

{

    struct sockaddr_storage local_addr;

    const struct rtpp_bindaddr *rval;

    const char *errmsg;

    int ai_flags = cfsp->no_resolve ? AI_NUMERICHOST : 0;

    int n = resolve(sstosa(&local_addr), pf, host, port, ai_flags);

    if (n != 0) {

        RTPP_LOG(log, RTPP_LOG_ERR, "invalid remote address: %s: %s", host,

          gai_strerror(n));

        return (NULL);

    }

    if (local4remote(sstosa(&local_addr), &local_addr) == -1) {

        RTPP_LOG(log, RTPP_LOG_ERR, "can't find local address for remote address: %s",

          host);

        return (NULL);

    }

    rval = addr2bindaddr(pub, sstosa(&local_addr), &errmsg);

    if (rval == NULL) {

        RTPP_LOG(log, RTPP_LOG_ERR, "invalid local address: %s", errmsg);

        return (NULL);

    }

    return (rval);

}

DEFINE_SMETHODS(rtpp_bindaddrs,

    .addr2 = &addr2bindaddr,

    .label2 = &label2bindaddr,

    .host2 = &host2bindaddr,

    .foraf = &bindaddr4af,

    .local4remote = &rtpp_bindaddrs_local4remote,

);

struct rtpp_bindaddrs *

rtpp_bindaddrs_ctor(void)

{

    struct rtpp_bindaddrs_pvt *cf;

    cf = rtpp_rzmalloc(sizeof(*cf), PVT_RCOFFS(cf));

    if (cf == NULL)

        goto e0;

    if (pthread_mutex_init(&cf->bindaddr_lock, NULL) != 0)

        goto e1;

    PUBINST_FININIT(&cf->pub, cf, rtpp_bindaddrs_dtor);

    return (&(cf->pub));

e1:

    RTPP_OBJ_DECREF(&(cf->pub));

e0:

    return (NULL);

}