/*      $NetBSD: iscsid_targets.c,v 1.7 2022/05/24 20:50:17 andvar Exp $        */

/*-
 * Copyright (c) 2005,2006,2011 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Wasabi Systems, Inc.
 *
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 "iscsid_globals.h"

#include <ctype.h>

/* counter for portal and target ID */
static uint32_t portarget_id = 0;

/* counter for send_targets ID */
static uint32_t send_target_id = 0;


/*
 * create_portal:
 *    Create a portal entry and link it into the appropriate lists.
 *    May also create the associated portal group entry if it does not exist.
 *    Will return the existing entry if the address matches a defined portal.
 *
 *    Parameter:
 *       target   the pointer to the target
 *       addr     the portal address (includes tag)
 *               dtype    portal discovery type
 *               did      discovery ID
 *
 *    Returns:    pointer to created portal
 */

static portal_t *
create_portal(target_t *target, iscsi_portal_address_t *addr,
                          iscsi_portal_types_t dtype, uint32_t did)
{
        portal_group_t *curr;
        portal_t *portal;
        u_short tag = addr->group_tag;

        DEB(9, ("Create Portal addr %s port %d group %d",
                        addr->address, addr->port, addr->group_tag));

        if ((portal = find_portal_by_addr(target, addr)) != NULL)
                return portal;

        portal = calloc(1, sizeof(*portal));
        if (!portal) {
                DEBOUT(("Out of memory in create_portal!"));
                return NULL;
        }
        portal->addr = *addr;
        portal->target = target;
        portal->portaltype = dtype;
        portal->discoveryid = did;
        if (!portal->addr.port) {
                portal->addr.port = ISCSI_DEFAULT_PORT;
        }
        for (portarget_id++; !portarget_id ||
             find_portal_id(portarget_id) != NULL ||
             find_target_id(TARGET_LIST, portarget_id) != NULL;) {
                portarget_id++;
        }
        portal->entry.sid.id = portarget_id;

        TAILQ_FOREACH(curr, &target->group_list, groups)
                if (curr->tag == tag)
                        break;

        if (!curr) {
                curr = calloc(1, sizeof(*curr));
                if (!curr) {
                        free(portal);
                        DEBOUT(("Out of memory in create_portal!"));
                        return NULL;
                }
                curr->tag = tag;
                TAILQ_INIT(&curr->portals);
                TAILQ_INSERT_TAIL(&target->group_list, curr, groups);
                target->num_groups++;
        }

        portal->group = curr;

        TAILQ_INSERT_TAIL(&curr->portals, portal, group_list);
        curr->num_portals++;
        target->num_portals++;

        TAILQ_INSERT_TAIL(&list[PORTAL_LIST].list, &portal->entry, link);
        list[PORTAL_LIST].num_entries++;

        DEB(9, ("create_portal returns %p", portal));
        return portal;
}


/*
 * delete_portal:
 *    Delete a portal entry after unlinking it from its lists.
 *    May also delete the associated portal group entry if the group is empty.
 *
 *    Parameter:
 *       portal                 the pointer to the portal
 *               delete_empty   delete empty target if true
 */

void
delete_portal(portal_t * portal, boolean_t delete_empty)
{
        portal_group_t *curr = portal->group;
        target_t *target = portal->target;

        TAILQ_REMOVE(&curr->portals, portal, group_list);
        TAILQ_REMOVE(&list[PORTAL_LIST].list, &portal->entry, link);
        curr->num_portals--;
        target->num_portals--;
        list[PORTAL_LIST].num_entries--;

        if (!curr->num_portals) {
                TAILQ_REMOVE(&target->group_list, curr, groups);
                free(curr);
                target->num_groups--;
        }
        free(portal);

        /* Optionally delete target if no portals left */
        if (delete_empty && !target->num_portals) {
                TAILQ_REMOVE(&list[TARGET_LIST].list, &target->entry, link);
                list[TARGET_LIST].num_entries--;
                free(target);
        }
}


/*
 * create_target:
 *    Create a target structure and initialize it.
 *
 *    Parameter:
 *          name        The target name
 *
 *    Returns:    Pointer to target structure, NULL if allocation failed.
 */

static target_t *
create_target(uint8_t * name)
{
        target_t *target;

        DEB(9, ("Create Target %s", name));

        if ((target = calloc(1, sizeof(*target))) == NULL) {
                DEBOUT(("Out of memory in create_target!"));
                return NULL;
        }

        TAILQ_INIT(&target->group_list);

        for (portarget_id++;
             !portarget_id ||
             find_portal_id(portarget_id) != NULL ||
             find_target_id(TARGET_LIST, portarget_id) != NULL;
             portarget_id++) {
        }

        target->entry.sid.id = portarget_id;
        strlcpy((char *)target->TargetName, (char *)name, sizeof(target->TargetName));

        return target;
}


/*
 * delete_target:
 *    Delete a target entry after unlinking it from its lists.
 *    Also deletes all portals associated with the target.
 *
 *    Parameter:
 *       target   the pointer to the target
 */

static void
delete_target(target_t * target)
{
        portal_group_t *cgroup;
        portal_t *curr = NULL;

        /* First delete all portals in all portal groups. */
        /* (this will also delete the groups) */
        while (target->num_groups) {
                cgroup = TAILQ_FIRST(&target->group_list);
                while (cgroup && cgroup->num_portals) {
                        curr = TAILQ_FIRST(&cgroup->portals);
                        if (curr)
                                delete_portal(curr, FALSE);
                }
        }

        /*Now delete the target itself */
        TAILQ_REMOVE(&list[TARGET_LIST].list, &target->entry, link);
        list[TARGET_LIST].num_entries--;
        free(target);
}


/*
 * create_send_target:
 *    Create a send_target structure and initialize it.
 *
 *    Parameter:
 *          name        The target name
 *          addr        The portal address
 *
 *    Returns:    Pointer to structure, NULL if allocation failed.
 */

static target_t *
create_send_target(uint8_t * name, iscsi_portal_address_t * addr)
{
        send_target_t *target;

        DEB(9, ("Create Send Target %s", name));

        if ((target = calloc(1, sizeof(*target))) == NULL)
                return NULL;

        for (send_target_id++;
                 !send_target_id
                 || find_target_id(SEND_TARGETS_LIST, send_target_id) != NULL;)
                send_target_id++;

        target->entry.sid.id = send_target_id;
        strlcpy((char *)target->TargetName, (char *)name, sizeof(target->TargetName));
        target->addr = *addr;
        target->num_groups = 1;
        target->num_portals = 1;

        return (target_t *)(void *)target;
}

/*
 * delete_send_target:
 *    Delete a send_target entry after unlinking it from its lists.
 *
 *    Parameter:
 *       send_target   the pointer to the send_target
 */

static void
delete_send_target(send_target_t * send_target)
{
        generic_entry_t *curr;
        uint32_t id;

        id = send_target->entry.sid.id;

        TAILQ_FOREACH(curr, &list[PORTAL_LIST].list, link) {
                portal_t *p = (void *)curr;
                if (p->portaltype == PORTAL_TYPE_SENDTARGET &&
                        p->discoveryid == id)
                        p->discoveryid = 0; /* mark deleted */
        }

        TAILQ_REMOVE(&list[SEND_TARGETS_LIST].list, &send_target->entry, link);
        list[SEND_TARGETS_LIST].num_entries--;
        free(send_target);
}



/*
 * add_target:
 *    Handle ADD_TARGET request: Create a target or send_target and its
 *    associated portals.
 *    This routine allows the same target to be defined more than once,
 *    adding any missing data (for example additional portals).
 *
 *    Parameter:
 *          par         The request parameters.
 *          prsp        Pointer to address of response buffer.
 *          prsp_temp   Will be set to TRUE if buffer was allocated, FALSE
 *                      for static buffer.
 */


void
add_target(iscsid_add_target_req_t *par, iscsid_response_t **prsp,
                        int *prsp_temp)
{
        iscsid_add_target_rsp_t *res;
        iscsid_response_t *rsp = *prsp;
        target_t *target, *tn;
        portal_t *portal;
        int i, num;

        DEB(9, ("Add Target, name %s, num_portals %d",
                        par->TargetName, par->num_portals));

        if (par->list_kind == SEND_TARGETS_LIST && par->num_portals != 1) {
                rsp->status = ISCSID_STATUS_PARAMETER_INVALID;
                return;
        }
        /* check to see if the target already exists */
        if ((par->TargetName[0] &&
             (target = find_TargetName(par->list_kind, par->TargetName)) != NULL) ||
            (par->list_kind == SEND_TARGETS_LIST &&
             (target = (target_t *)(void *)
                        find_send_target_by_addr(&par->portal[0])) != NULL)) {
                num = target->num_portals;

                /* symbolic name? */
                if (par->sym_name[0]) {
                        /* already named? rename if OK */
                        tn = find_target_symname(par->list_kind, par->sym_name);
                        if (tn && tn != target) {
                                rsp->status = ISCSID_STATUS_DUPLICATE_NAME;
                                return;
                        }
                        strlcpy((char *)target->entry.sid.name, (char *)par->sym_name, sizeof(target->entry.sid.name));
                }
        } else {
                if (par->sym_name[0] &&
                        (find_target_symname(par->list_kind, par->sym_name) ||
                         find_portal_name(par->sym_name))) {
                        rsp->status = ISCSID_STATUS_DUPLICATE_NAME;
                        return;
                }

                if (par->list_kind == SEND_TARGETS_LIST)
                        target = create_send_target(par->TargetName, &par->portal[0]);
                else
                        target = create_target(par->TargetName);

                if (target == NULL) {
                        rsp->status = ISCSID_STATUS_NO_RESOURCES;
                        return;
                }
                num = 0;
                strlcpy((char *)target->entry.sid.name, (char *)par->sym_name,
                        sizeof(target->entry.sid.name));
        }

        rsp = make_rsp(sizeof(*res) + (par->num_portals * sizeof(uint32_t)),
                        prsp, prsp_temp);
        if (rsp == NULL)
                return;

        res = (iscsid_add_target_rsp_t *)(void *)rsp->parameter;
        res->target_id = target->entry.sid.id;

        /* link into target list */
        if (!num) {
                TAILQ_INSERT_TAIL(&list[par->list_kind].list, &target->entry,
                        link);
                list[par->list_kind].num_entries++;
        }

        /*
           Add the given portals. Note that create_portal also checks for
           duplicate entries, and returns the pointer to the existing entry
           if the request is a duplicate.
         */

        if (par->list_kind == SEND_TARGETS_LIST) {
                res->portal_id[0] = target->entry.sid.id;
                res->num_portals = 1;
        } else {
                for (i = 0; i < (int)par->num_portals; i++) {
                        portal = create_portal(target, &par->portal[i],
                                        PORTAL_TYPE_STATIC,
                                        target->entry.sid.id);
                        if (portal == NULL) {
                                rsp->status = ISCSID_STATUS_NO_RESOURCES;
                                break;
                        }
                        res->portal_id[i] = portal->entry.sid.id;
                }
                res->num_portals = i;
        }

        DEB(9, ("AddTarget returns"));
}


/*
 * add_discovered_target:
 *    Check whether the given target and portal already exist.
 *    If not, add them.
 *
 *    Parameter:
 *          TargetName
 *          portal
 *          dtype = type of portal added: PORTAL_TYPE_SENDTARGET or
 *                                      PORTAL_TYPE_ISNS
 *          did = ID of SendTargets or iSNS for which portal was discovered
 *
 *    Returns: Pointer to created target, NULL on error (out of memory)
 *    Always sets portaltype to dtype even if portal already exists
 *      (used for refreshing to mark portals that we find)
 */

target_t *
add_discovered_target(uint8_t * TargetName, iscsi_portal_address_t * addr,
                                iscsi_portal_types_t dtype, uint32_t did)
{
        target_t *target;
        portal_t *portal;

        DEB(9, ("Add Discovered Target, name %s, addr %s",
                        TargetName, addr->address));

        if ((target = find_TargetName(TARGET_LIST, TargetName)) == NULL) {
                if ((target = create_target(TargetName)) == NULL) {
                        return NULL;
                }
                portal = create_portal(target, addr, dtype, did);
                if (portal == NULL) {
                        free(target);
                        return NULL;
                }
                TAILQ_INSERT_TAIL(&list[TARGET_LIST].list, &target->entry, link);
                list[TARGET_LIST].num_entries++;
        } else if ((portal = create_portal(target, addr, dtype, did)) == NULL) {
                return NULL;
        }
        portal->portaltype = dtype;

        return target;
}


/*
 * set_target_options:
 *    Handle SET_TARGET_OPTIONS request: Copy the given options into the
 *    target structure.
 *
 *    Parameter:
 *          par         The request parameters.
 *
 *    Returns:     status
 */

uint32_t
set_target_options(iscsid_get_set_target_options_t * par)
{
        target_t *target;

        if ((target = find_target(par->list_kind, &par->target_id)) == NULL)
                return ISCSID_STATUS_INVALID_TARGET_ID;

        target->options = *par;

        return ISCSID_STATUS_SUCCESS;
}


/*
 * set_target_auth:
 *    Handle SET_TARGET_AUTHENTICATION request: Copy the given options into the
 *    target structure.
 *
 *    Parameter:
 *          par         The request parameters.
 *
 *    Returns:     status
 */

uint32_t
set_target_auth(iscsid_set_target_authentication_req_t * par)
{
        target_t *target;

        if ((target = find_target(par->list_kind, &par->target_id)) == NULL) {
                return ISCSID_STATUS_INVALID_TARGET_ID;
        }
        target->auth = *par;

        return ISCSID_STATUS_SUCCESS;
}


/*
 * get_target_info:
 *    Handle GET_TARGET_INFO request: Return information about the given
 *    target and its portals. If a portal ID is given, returns only the
 *    target info and the ID of this portal.
 *
 *    Parameter:
 *          par         The request parameters.
 *          prsp        Pointer to address of response buffer.
 *          prsp_temp   Will be set to TRUE if buffer was allocated, FALSE
 *                      for static buffer.
 */

void
get_target_info(iscsid_list_id_t *par, iscsid_response_t **prsp, int *prsp_temp)
{
        iscsid_get_target_rsp_t *res;
        iscsid_response_t *rsp = *prsp;
        uint32_t *idp;
        target_t *target;
        portal_group_t *cgroup;
        portal_t *curr = NULL;
        int num = 1;

        DEB(10, ("get_target_info, id %d", par->id.id));

        if ((target = find_target(par->list_kind, &par->id)) == NULL) {
                if (par->list_kind == SEND_TARGETS_LIST ||
                    (curr = find_portal(&par->id)) == NULL) {
                        rsp->status = ISCSID_STATUS_INVALID_TARGET_ID;
                        return;
                }
                target = curr->target;
        } else if (par->list_kind != SEND_TARGETS_LIST) {
                num = target->num_portals;
        }
        rsp = make_rsp(sizeof(*res) + (num - 1) * sizeof(uint32_t),
                        prsp, prsp_temp);
        if (rsp == NULL)
                return;

        res = (iscsid_get_target_rsp_t *)(void *)rsp->parameter;
        res->target_id = target->entry.sid;
        strlcpy((char *)res->TargetName, (char *)target->TargetName,
                        sizeof(res->TargetName));
        strlcpy((char *)res->TargetAlias, (char *)target->TargetAlias,
                        sizeof(res->TargetAlias));

        res->num_portals = num;
        idp = res->portal;

        if (curr) {
                *idp = curr->entry.sid.id;
        } else if (par->list_kind != SEND_TARGETS_LIST) {
                TAILQ_FOREACH(cgroup, &target->group_list, groups)
                        TAILQ_FOREACH(curr, &cgroup->portals, group_list)
                        * idp++ = curr->entry.sid.id;
        } else
                *idp = target->entry.sid.id;
}


/*
 * add_portal:
 *    Handle ADD_PORTAL request: Add a portal to an existing target.
 *
 *    Parameter:
 *          par         The request parameters.
 *          prsp        Pointer to address of response buffer.
 *          prsp_temp   Will be set to TRUE if buffer was allocated, FALSE
 *                      for static buffer.
 */


void
add_portal(iscsid_add_portal_req_t *par, iscsid_response_t **prsp,
                        int *prsp_temp)
{
        iscsid_add_portal_rsp_t *res;
        iscsid_response_t *rsp = *prsp;
        target_t *target;
        portal_t *portal;

        DEB(9, ("Add portal: target %d (%s), symname %s, addr %s",
                        par->target_id.id, par->target_id.name,
                        par->sym_name, par->portal.address));

        if ((target = find_target(TARGET_LIST, &par->target_id)) == NULL) {
                rsp->status = ISCSID_STATUS_INVALID_TARGET_ID;
                return;
        }

        if (par->sym_name[0] &&
                (find_target_symname(TARGET_LIST, par->sym_name) ||
                 find_portal_name(par->sym_name))) {
                rsp->status = ISCSID_STATUS_DUPLICATE_NAME;
                return;
        }

        portal = create_portal(target, &par->portal, PORTAL_TYPE_STATIC,
                                                        target->entry.sid.id);
        if (portal == NULL) {
                rsp->status = ISCSID_STATUS_NO_RESOURCES;
                return;
        }

        if (par->sym_name[0]) {
                strlcpy((char *)portal->entry.sid.name, (char *)par->sym_name,
                        sizeof(portal->entry.sid.name));
        }
        portal->options = par->options;

        rsp = make_rsp(sizeof(*res), prsp, prsp_temp);
        if (rsp == NULL)
                return;
#if 0 /*XXX: christos res is uninitialized here?? */
        res->target_id = target->entry.sid;
        res->portal_id = portal->entry.sid;
#endif

        DEB(9, ("AddPortal success (id %d)", portal->entry.sid.id));
}


/*
 * get_portal_info:
 *    Handle GET_PORTAL_INFO request: Return information about the given
 *    portal.
 *
 *    Parameter:
 *          par         The request parameters.
 *          prsp        Pointer to address of response buffer.
 *          prsp_temp   Will be set to TRUE if buffer was allocated, FALSE
 *                      for static buffer.
 */

void
get_portal_info(iscsid_list_id_t *par, iscsid_response_t **prsp, int *prsp_temp)
{
        iscsid_get_portal_rsp_t *res;
        iscsid_response_t *rsp = *prsp;
        portal_t *portal = NULL;
        send_target_t *starg = NULL;
        int err;

        DEB(10, ("get_portal_info, id %d", par->id.id));

        if (par->list_kind == SEND_TARGETS_LIST)
                err = ((starg = (send_target_t *)(void *)find_target(par->list_kind,
                                                        &par->id)) == NULL);
        else
                err = ((portal = find_portal(&par->id)) == NULL);

        if (err) {
                rsp->status = ISCSID_STATUS_INVALID_PORTAL_ID;
                return;
        }

        rsp = make_rsp(sizeof(*res), prsp, prsp_temp);
        if (rsp == NULL)
                return;

        res = (iscsid_get_portal_rsp_t *)(void *)rsp->parameter;
        if (par->list_kind == SEND_TARGETS_LIST) {
                res->target_id = starg->entry.sid;
                res->portal_id = starg->entry.sid;
                res->portal = starg->addr;
        } else {
                res->target_id = portal->target->entry.sid;
                res->portal_id = portal->entry.sid;
                res->portal = portal->addr;
        }
}

/*
 * remove_target:
 *    Handle REMOVE_TARGET request: Removes a target, target portal,
 *              or Send-Targets portal from its respective list.
 *      Removing a target will remove all associated portals.
 *
 *    Parameter:
 *          par         The request parameters = iscsid_list_id_t
 *                                              containing the target ID.
 *
 *    Returns:     status
 */

uint32_t
remove_target(iscsid_list_id_t * par)
{
        target_t *target = NULL;
        portal_t *portal = NULL;
        send_target_t *starg = NULL;
        int err;

        DEB(9, ("remove_target, id %d", par->id.id));

        if (par->list_kind == SEND_TARGETS_LIST) {
                err = ((starg = (send_target_t *)(void *)find_target(par->list_kind,
                                                        &par->id)) == NULL);
                if (!err) {
                        delete_send_target(starg);
                }
        } else if (par->list_kind == PORTAL_LIST) {
                err = ((portal = find_portal(&par->id)) == NULL);
                if (!err) {
                        delete_portal(portal, FALSE);
                }
        } else {
                target = find_target(par->list_kind, &par->id);
                err = (target == NULL);
                if (!err) {
                        delete_target(target);
                }
        }

        return err ? ISCSID_STATUS_INVALID_PORTAL_ID : ISCSID_STATUS_SUCCESS;
}



/*
 * cl_get_address:
 *    Get an address specification that may include port and group tag.
 *
 *    Parameter:
 *          portal   The portal address
 *          str      The parameter string to scan
 *
 *    Returns:    0 on error, 1 if OK.
 */

static int
cl_get_address(iscsi_portal_address_t * portal, char *str)
{
        char *sp, *sp2;
        int val;

        /* is there a port? don't check inside square brackets (IPv6 addr) */
        for (sp = str + 1, val = 0; *sp && (*sp != ':' || val); sp++) {
                if (*sp == '[')
                        val = 1;
                else if (*sp == ']')
                        val = 0;
        }

        /* */
        if (*sp) {
                for (sp2 = sp + 1; *sp2 && *sp2 != ':'; sp2++);
                /* if there's a second colon, assume it's an unbracketed IPv6
                 * address */
                if (!*sp2) {
                        /* truncate source, that's the address */
                        *sp++ = '\0';
                        if (sscanf(sp, "%d", &val) != 1)
                                return 0;
                        if (val < 0 || val > 0xffff)
                                return 0;
                        portal->port = (uint16_t) val;
                }
                /* is there a group tag? */
                for (; isdigit((unsigned char)*sp); sp++) {
                }
                if (*sp && *sp != ',')
                        return 0;
        } else
                for (sp = str + 1; *sp && *sp != ','; sp++);

        if (*sp) {
                if (sscanf(sp + 1, "%d", &val) != 1)
                        return 0;
                if (val < 0 || val > 0xffff)
                        return 0;
                portal->group_tag = (uint16_t) val;
                /* truncate source, that's the address */
                *sp = '\0';
        }
        /* only check length, don't verify correct format (too many
         * possibilities) */
        if (strlen(str) >= sizeof(portal->address))
                return 0;

        strlcpy((char *)portal->address, str, sizeof(portal->address));

        return 1;
}

/*
 * refresh_send_target:
 *    Handle REFRESH_TARGETS request for a Send Target
 *
 *    Parameter:
 *          id    The send target ID.
 *
 *    Returns:     status
 */


static uint32_t
refresh_send_target(uint32_t id)
{
        uint8_t *response_buffer = NULL;
        uint32_t response_size;
        uint32_t ret;
        uint8_t *TargetName;
        iscsi_portal_address_t addr;
        uint8_t *tp, *sp;
        generic_entry_t *curr;
        generic_entry_t *next;
        send_target_t *sendtarg;
        int rc;

        /*
         * Go through our list of portals and mark each one
         * belonging to the current sendtargets group to refreshing
         * This mark is used afterwards to remove any portals that
         * were not refreshed (because the mark gets reset for portals
         * that are refreshed).
         */

        TAILQ_FOREACH(curr, &list[PORTAL_LIST].list, link) {
                portal_t *p = (void *)curr;
                if (p->portaltype == PORTAL_TYPE_SENDTARGET &&
                    p->discoveryid == id) {
                        p->portaltype = PORTAL_TYPE_REFRESHING;
                }
        }

        if ((ret = send_targets(id, &response_buffer, &response_size)) == 0) {
                /*
                 * Parse the response target list
                 * The SendTargets response in response_buffer is a list of
                 * target strings. Each target string consists of a TargetName
                 * string, followed by 0 or more TargetAddress strings:
                 *
                 *      TargetName=<target-name>
                 *      TargetAddress=<hostname-or-ip>[:<tcp-port>],
                 *                              <portal-group-tag>
                 * The entire list is terminated by a null (after
                 * response_size bytes) (this terminating NULL was placed
                 * there by send_targets routine.)
                 */

                tp = response_buffer;
                while (*tp) {
                        if (strncmp((char *)tp, "TargetName=", 11) != 0) {
                                DEBOUT(("Response not TargetName <%s>", tp));
                                break;
                        }
                        tp += 11;
                        TargetName = tp; /*Point to target name */
                        while (*tp++) {
                        }
                        rc = -1; /* Mark no address found yet */

                        /*Now process any "TargetAddress" entries following */
                        while (*tp && strncmp((char *)tp, "TargetAddress=", 14) == 0) {
                                tp += 14;
                                sp = tp; /* save start of address */
                                while (*tp++) {
                                }
                                /*Get the target address */
                                rc = cl_get_address(&addr, (char *)sp);
                                if (rc) {
                                        add_discovered_target(TargetName,
                                                &addr, PORTAL_TYPE_SENDTARGET,
                                                id);
                                } else {
                                        DEBOUT(("Syntax error in returned target address <%s>", sp));
                                        break;
                                }
                        }

                        if (rc == -1) {
                                /* There are no TargetAddress entries
                                 * associated with TargetName. This means the
                                 * sendtarget address is used. */
                                sendtarg = find_send_target_id(id);
                                if (sendtarg != NULL) {
                                        add_discovered_target(TargetName,
                                                &sendtarg->addr,
                                                PORTAL_TYPE_SENDTARGET, id);
                                }
                        }
                } /* end of while */
        }
        /*
         * Go through our list of portals and look for ones
         * that are still marked for refreshing.
         * These are ones that are no longer there and should be removed.
         */

        for (curr = TAILQ_FIRST(&list[PORTAL_LIST].list); curr != NULL;
                 curr = next) {
                portal_t *p = (void *)curr;
                next = TAILQ_NEXT(curr, link);
                if (p->portaltype == PORTAL_TYPE_REFRESHING)
                        delete_portal(p, TRUE);
        }

        /*
         * Clean up
         */

        if (response_buffer != NULL)
                free(response_buffer);

        return ret;
}


/*
 * cleanup_send_target_orphans:
 *    Delete portals that were discovered through a now deleted send target.
 */


static void
cleanup_orphans(iscsi_portal_types_t type)
{
        generic_entry_t *curr;
        generic_entry_t *next;

        /*
         * Go through the list of portals and look for ones marked with a zero
         * discovery ID, those are associated with send targets that no
         * longer exist.
         */

        for (curr = TAILQ_FIRST(&list[PORTAL_LIST].list); curr != NULL;
                 curr = next) {
                portal_t *p = (void *)curr;
                next = TAILQ_NEXT(curr, link);
                if (p->portaltype == type && p->discoveryid == 0) {
                        delete_portal(p, TRUE);
                }
        }
}


/*
 * refresh_targets:
 *    Handle REFRESH_TARGETS request:
 *    Refreshes the list of targets discovered via SendTargets or iSNS
 *
 *    Parameter:
 *          The request parameter = iscsid_refresh_targets_req_t containing:
 *             iscsid_list_kind_t   kind;       Kind: 
 *                                                  SEND_TARGETS_LIST
 *                                                  ISNS_LIST
 *             uint32_t                num_ids;    # of targets in list 
 *             uint32_t            id [1];     List of targets 
 *
 *    Returns:     status
 */

uint32_t
refresh_targets(iscsid_refresh_req_t * par)
{
        uint32_t t;
        uint32_t rc, retval;
        generic_entry_t *curr;

        retval = ISCSID_STATUS_NO_TARGETS_FOUND;

        switch (par->kind) {
        case TARGET_LIST:
                /*
                 * Refreshing for a specific target makes no sense if it's
                 * static. Maybe implement it for dynamically discovered
                 * targets? But then it's best done through the discovering
                 * instance, or we'll refresh much more than just the given
                 * target. And refreshing the whole list is iffy as well. So
                 * refuse this op on the target list for now.
                 */
                break;

        case SEND_TARGETS_LIST:
                DEB(9, ("Refresh Send Targets List - num_ids = %d",
                                par->num_ids));
                if (par->num_ids) {
                        /* Target ids are specified */
                        for (t = 0; t < par->num_ids; t++) {
                                rc = refresh_send_target(par->id[t]);
                                if (rc == 0) {
                                        retval = ISCSID_STATUS_SUCCESS;
                                }
                        }
                } else {
                        cleanup_orphans(PORTAL_TYPE_SENDTARGET);

                        /* No target ids specified - refresh all. */
                        TAILQ_FOREACH(curr, &list[SEND_TARGETS_LIST].list, link)
                                if ((rc = refresh_send_target(curr->sid.id)) == 0)
                                        retval = ISCSID_STATUS_SUCCESS;
                }
                return retval;

#ifndef ISCSI_MINIMAL
        case ISNS_LIST:
                DEB(9, ("Refresh iSNS List - num_ids = %d", par->num_ids));
                if (par->num_ids) {
                        /*Target ids are specified */
                        for (t = 0; t < par->num_ids; t++)
                                if ((rc = refresh_isns_server(par->id[t])) == 0)
                                        retval = ISCSI_STATUS_SUCCESS;
                } else {
                        cleanup_orphans(PORTAL_TYPE_ISNS);

                        /*No target ids specified - refresh all. */
                        TAILQ_FOREACH(curr, &list[ISNS_LIST].list, link)
                                if ((rc = refresh_isns_server(curr->sid.id)) == 0)
                                        retval = ISCSI_STATUS_SUCCESS;
                }
                return retval;
#endif

        default:
                break;
        }

        return ISCSID_STATUS_PARAMETER_INVALID;
}