Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sbin/iscsid/iscsid_targets.c

1030 lines
26 KiB
C
Raw Blame History

/* $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;
}
Reference in New Issue View Git Blame Copy Permalink