/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
*/
#include <auth_list.h>
#include <assert.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <libintl.h>
#include <libnwam.h>
#include "libnwam_impl.h"
/*
* Generic object manipulation functions. Given an object handle and
* etc. All object handles are "struct nwam_handle *" objects, sharing
* the same description based on the object type, name, original name
* (used in renaming) and associated data representing properties.
*/
struct nwam_handle **hpp)
{
return (NWAM_INVALID_ARG);
}
return (NWAM_NO_MEMORY);
return (NWAM_SUCCESS);
}
struct nwam_handle **hpp)
{
char *name;
/*
* Interface NCUs will have "_ifname" in the idlist instead of "name".
* Link NCUs will have "linkname" in the idlist instead of "name". If
* looking up "name" fails for an NCU, lookup "_ifname" and
* "linkname".
*/
(type == NWAM_OBJECT_TYPE_NCU &&
return (NWAM_INVALID_ARG);
return (err);
return (NWAM_SUCCESS);
}
/*
* Read object of specified type from dbname.
*/
{
return (err);
return (err);
return (netcfg_error_to_nwam_error(nerr));
/*
* For interface NCUs, the keyname is "_ifname" instead of "name".
* For link NCUs, the keyname is "linkname" instead of "name".
*/
if (type == NWAM_OBJECT_TYPE_NCU) {
sizeof (NWAM_IPADM_CONF_FILE_PRE)-1) == 0)
keyname = "_ifname";
else
keyname = "linkname";
} else {
keyname = "name";
}
!= NETCFG_SUCCESS) {
return (netcfg_error_to_nwam_error(nerr));
}
!= NETCFG_SUCCESS) {
return (netcfg_error_to_nwam_error(nerr));
}
/*
* The object name might need to be case-corrected; update the name in
* the handle with the name value from the returned idlist.
*/
}
done:
return (NWAM_SUCCESS);
}
/*
* Create simply creates the handle - the object-specific function must
* then fill in property values.
*/
struct nwam_handle **hpp)
{
return (NWAM_ENTITY_EXISTS);
}
/* Create handle */
return (err);
/* Create new object list */
}
{
return (NWAM_NO_MEMORY);
}
return (NWAM_SUCCESS);
}
{
if (hp->nwh_committed)
return (NWAM_ENTITY_READ_ONLY);
return (NWAM_INVALID_ARG);
return (NWAM_SUCCESS);
}
static void
{
}
/*
* Generic walk function takes the standard walk arguments, and in addition
* takes a selection callback that is object-specific. If this returns
* 0, the object is a valid selection for the walk and the callback is called.
* Otherwise, it is skipped.
*/
/* ARGSUSED */
{
return (netcfg_error_to_nwam_error(ncerr));
return (netcfg_error_to_nwam_error(ncerr));
}
void
{
}
}
/*
* Copy object represented by oldhp to an object newname, all in container
* dbname.
*/
struct nwam_handle **newhpp)
{
== NWAM_SUCCESS) {
return (NWAM_ENTITY_EXISTS);
}
!= NWAM_SUCCESS)
return (err);
return (err);
}
return (NWAM_SUCCESS);
}
/* ARGSUSED3 */
int (*cb)(const char *, nwam_value_t, void *),
{
int ret = 0;
return (err);
/* skip any object-id-list values */
continue;
}
if (ret != 0)
if (err != NWAM_SUCCESS)
break;
}
return (NWAM_SUCCESS);
return (err);
}
/*
* Note that prior to calling the generic commit function, object-specific
* validation should be carried out.
*/
{
char *keyname;
!= NWAM_SUCCESS)
return (err);
/*
* Does object already exist? If not, action is ADD, otherwise REFRESH.
*/
&testhp)) {
case NWAM_ENTITY_NOT_FOUND:
break;
case NWAM_SUCCESS:
/* FALLTHRU */
default:
break;
}
return (netcfg_error_to_nwam_error(nerr));
/*
* If this is an NCU, it must be a link NCU, as interface NCUs
* are written using libipadm function calls. dladm db entries
* use "linkname" for the object name key, rather than "name".
*/
!= NETCFG_SUCCESS) {
return (netcfg_error_to_nwam_error(nerr));
}
!= NETCFG_SUCCESS)
return (netcfg_error_to_nwam_error(nerr));
if (is_ncu) {
} else {
}
done:
return (NWAM_SUCCESS);
}
static boolean_t
{
state == NWAM_STATE_ONLINE));
}
{
return (err);
/* Check if object is active */
return (NWAM_ENTITY_IN_USE);
goto done;
/*
* Interface NCUs are not destroyed through nwam_destroy(). They are
* removed using libipadm function calls. Thus, there's no need for a
* special case to add "_ifname". Link NCUs have "linkname" for the
* key instead of "name".
*/
sizeof (NWAM_DATALINK_CONF_FILE_PRE)-1) == 0)
keyname = "linkname";
else
keyname = "name";
!= NETCFG_SUCCESS) {
return (netcfg_error_to_nwam_error(nerr));
}
/* remove the object */
if (is_ncu) {
} else {
}
done:
return (netcfg_error_to_nwam_error(nerr));
}
/*
* functions specifies the NCP for NCUs.
*/
{
}
{
}
{
}
{
}
{
}
struct nwam_prop_table_entry *
{
return (cur);
}
return (NULL);
}
const char **descriptionp)
{
*descriptionp = NULL;
return (NWAM_INVALID_ARG);
}
return (NWAM_SUCCESS);
}
{
return (NWAM_INVALID_ARG);
return (NWAM_SUCCESS);
}
{
return (NWAM_INVALID_ARG);
else
return (NWAM_SUCCESS);
}
{
return (NWAM_INVALID_ARG);
return (NWAM_SUCCESS);
}
/*
* Structure used to pass in prop table and errprop string pointer to internal
* validate function.
*/
struct validate_internal_arg {
const char **errpropp;
};
/*
* Callback used by nwam_walk_props() in nwam_validate(), and
* by nwam_validate_prop() to determine that the number, type and
* range of values are correct, and that validation function (if present)
* succeeds.
*/
static int
void *arg)
{
int i;
!= NWAM_SUCCESS ||
return (err);
}
/*
* Property not found in the property table. There's no way
* to validate this property; hence, return SUCCESS to
* continue walk and validation of other properties.
*/
return (NWAM_SUCCESS);
}
/* have we get expected number of values? */
if (numvalues < 1)
return (NWAM_ENTITY_NO_VALUE);
else
return (NWAM_ENTITY_INVALID_VALUE);
}
/* Ensure type matches */
if (numvalues > 0) {
for (i = 0; i < numvalues; i++) {
return (NWAM_ENTITY_TYPE_MISMATCH);
}
}
}
/* Call property-specific validation function */
return (err);
}
return (NWAM_SUCCESS);
}
{
}
const char **errpropp)
{
0, (int *)&err2);
if (err1 != NWAM_SUCCESS)
return (err2);
return (NWAM_SUCCESS);
}
/*
* Given the type and class flag representations, return the list of properties
* property list that includes both the required and the optional properties.
* The type and class flags are only used for NCU objects at present.
*
* Caller needs to free prop_list.
*/
{
int i = 0;
*numvalues = 0;
return (NWAM_NO_MEMORY);
}
continue;
}
*numvalues = i;
return (NWAM_SUCCESS);
}