add the association of Net_SettingSDefineState. Signed-off-by: Wayne Xia <xiawenc(a)linux.vnet.ibm.com&gt; --- schema/SettingsDefineState.mof | 9 +- schema/SettingsDefineState.registration | 3 +- src/Virt_SettingsDefineState.c | 256 +++++++++++++++++++++++++++++++ 3 files changed, 266 insertions(+), 2 deletions(-) diff --git a/schema/SettingsDefineState.mof b/schema/SettingsDefineState.mof index 7664ae2..1ee6698 100644 --- a/schema/SettingsDefineState.mof +++ b/schema/SettingsDefineState.mof @@ -1,4 +1,4 @@ -// Copyright IBM Corp. 2007 +// Copyright IBM Corp. 2011 [Association, Provider("cmpi::Virt_SettingsDefineState") @@ -20,3 +20,10 @@ class KVM_SettingsDefineState : CIM_SettingsDefineState class LXC_SettingsDefineState : CIM_SettingsDefineState { }; + +[Association, + Provider("cmpi::Virt_SettingsDefineState") +] +class Net_SettingsDefineState : CIM_SettingsDefineState +{ +}; diff --git a/schema/SettingsDefineState.registration b/schema/SettingsDefineState.registration index 0563491..b5e03ba 100644 --- a/schema/SettingsDefineState.registration +++ b/schema/SettingsDefineState.registration @@ -1,5 +1,6 @@ -# Copyright IBM Corp. 2007 +# Copyright IBM Corp. 2011 # Classname Namespace ProviderName ProviderModule ProviderTypes Xen_SettingsDefineState root/virt Virt_SettingsDefineState Virt_SettingsDefineState association KVM_SettingsDefineState root/virt Virt_SettingsDefineState Virt_SettingsDefineState association LXC_SettingsDefineState root/virt Virt_SettingsDefineState Virt_SettingsDefineState association +Net_SettingsDefineState root/virt Virt_SettingsDefineState Virt_SettingsDefineState association diff --git a/src/Virt_SettingsDefineState.c b/src/Virt_SettingsDefineState.c index b4e4b80..ae7054f 100644 --- a/src/Virt_SettingsDefineState.c +++ b/src/Virt_SettingsDefineState.c @@ -4,6 +4,9 @@ * Authors: * Dan Smith <danms(a)us.ibm.com&gt; * + * Modified by: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either @@ -36,6 +39,11 @@ #include "Virt_ComputerSystem.h" #include "Virt_VSSD.h" #include "svpc_types.h" +#include "Virt_VESSSD.h" +#include "Virt_VirtualEthernetSwitchSystem.h" +#include "Virt_EASD.h" +#include "Virt_EthernetPort.h" +#include "network_model.h" const static CMPIBroker *_BROKER; @@ -319,6 +327,172 @@ static CMPIStatus vssd_to_vs(const CMPIObjectPath *ref, return s; } +static CMPIStatus vess_to_vesssd(const CMPIObjectPath *ref, + struct std_assoc_info *info, + struct inst_list *list) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIInstance *inst; + const char *name = NULL; + + if (!match_hypervisor_prefix(ref, info)) { + return s; + } + /* the step of creating a vess instance is skipped to make it fast */ + if (cu_get_str_path(ref, "Name", &name) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Missing Name property"); + goto out; + } + + CU_DEBUG("vess to vesssd , name %s", name); + s = get_vesssd_by_name(_BROKER, name, ref, &inst); + if (s.rc != CMPI_RC_OK) { + goto out; + } + + inst_list_add(list, inst); + + out: + return s; +} + +static CMPIStatus vesssd_to_vess(const CMPIObjectPath *ref, + struct std_assoc_info *info, + struct inst_list *list) +{ + const char *id = NULL; + char *pfx = NULL; + char *name = NULL; + int ret; + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIInstance *inst = NULL; + + if (!match_hypervisor_prefix(ref, info)) { + return s; + } + + /* the step of creating a vesssd instance is skipped to make it fast */ + if (cu_get_str_path(ref, "InstanceID", &id) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Missing InstanceID"); + goto out; + } + + ret = sscanf(id, "%a[^:]:%as", &pfx, &name); + if (ret != 2) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Invalid InstanceID"); + goto out; + } + + CU_DEBUG("vesssd to vess , name %s", name); + s = get_switch_by_name(_BROKER, name, ref, &inst); + if (s.rc != CMPI_RC_OK) { + goto out; + } + + inst_list_add(list, inst); + + out: + free(name); + free(pfx); + + return s; +} + +/* according to DSP 1050.1.0.0_0 page 41, SDS only associate EP with EASD_EA */ +static CMPIStatus ep_to_easd(const CMPIObjectPath *ref, + struct std_assoc_info *info, + struct inst_list *list) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIInstance *inst = NULL; + char *newid = NULL; + const char *name; + + if (!match_hypervisor_prefix(ref, info)) { + return s; + } + + /* the step of creating a ep instance is skipped to make it fast */ + if (cu_get_str_path(ref, "DeviceID", &name) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "No DeviceID specified"); + goto out; + } + + newid = ep_id_to_easdea_id(name); + if (newid == NULL) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_NOT_FOUND, + "Invalid DeviceID set."); + goto out; + } + + s = get_easd_by_id(_BROKER, + newid, + ref, + NULL, + &inst); + if (s.rc != CMPI_RC_OK) { + goto out; + } + + inst_list_add(list, inst); + + out: + free(newid); + return s; +} + +static CMPIStatus easd_to_ep(const CMPIObjectPath *ref, + struct std_assoc_info *info, + struct inst_list *list) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIInstance *inst = NULL; + const char *name = NULL; + char *newid = NULL; + + if (!match_hypervisor_prefix(ref, info)) { + return s; + } + + /* the step of creating a easd instance is skipped to make it fast */ + + if (cu_get_str_path(ref, "InstanceID", &name) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Missing InstanceID"); + goto out; + } + newid = easdea_id_to_ep_id(name); + + if (newid == NULL) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_NOT_FOUND, + "Invalid InstanceID set."); + goto out; + } + + s = get_ep_by_id(_BROKER, newid, ref, NULL, &inst); + if (s.rc != CMPI_RC_OK) { + goto out; + } + + inst_list_add(list, inst); + + + out: + free(newid); + return s; +} + LIBVIRT_CIM_DEFAULT_MAKEREF() static char* logical_device[] = { @@ -386,6 +560,32 @@ static char* assoc_classname[] = { NULL }; + +static char *vess_name[] = { + "Net_VirtualEthernetSwitchSystem", + NULL +}; + +static char *vesssd_name[] = { + "Net_VirtualEthernetSwitchSystemSettingData", + NULL +}; + +static char *ep_name[] = { + "Net_EthernetPort", + NULL +}; + +static char *easd_name[] = { + "Net_EthernetPortAllocationSettingData", + NULL +}; + +static char *vess_assoc_name[] = { + "Net_SettingsDefineState", + NULL +}; + static struct std_assoc _dev_to_rasd = { .source_class = (char**)&logical_device, .source_prop = "ManagedElement", @@ -438,11 +638,67 @@ static struct std_assoc _vssd_to_vs = { .make_ref = make_ref }; +static struct std_assoc _vess_to_vesssd = { + .source_class = (char **)&vess_name, + .source_prop = "ManagedElement", + + .target_class = (char **)&vesssd_name, + .target_prop = "SettingData", + + .assoc_class = (char **)&vess_assoc_name, + + .handler = vess_to_vesssd, + .make_ref = make_ref +}; + +static struct std_assoc _vesssd_to_vess = { + .source_class = (char **)&vesssd_name, + .source_prop = "SettingData", + + .target_class = (char **)&vess_name, + .target_prop = "ManagedElement", + + .assoc_class = (char **)&vess_assoc_name, + + .handler = vesssd_to_vess, + .make_ref = make_ref +}; + +static struct std_assoc _ep_to_easd = { + .source_class = (char **)&ep_name, + .source_prop = "ManagedElement", + + .target_class = (char **)&easd_name, + .target_prop = "SettingData", + + .assoc_class = (char **)&vess_assoc_name, + + .handler = ep_to_easd, + .make_ref = make_ref +}; + +static struct std_assoc _easd_to_ep = { + .source_class = (char **)&easd_name, + .source_prop = "SettingData", + + .target_class = (char **)&ep_name, + .target_prop = "ManagedElement", + + .assoc_class = (char **)&vess_assoc_name, + + .handler = easd_to_ep, + .make_ref = make_ref +}; + static struct std_assoc *handlers[] = { &_dev_to_rasd, &_rasd_to_dev, &_vs_to_vssd, &_vssd_to_vs, + &_vess_to_vesssd, + &_vesssd_to_vess, + &_ep_to_easd, + &_easd_to_ep, NULL }; -- 1.7.6

add the class Net_VirtualEthernetSwitchSystemSettingDataComponent. Signed-off-by: Wayne Xia <xiawenc(a)linux.vnet.ibm.com&gt; --- schema/VESSSDComponent.mof | 8 ++ schema/VESSSDComponent.registration | 3 + src/Virt_VESSSDComponent.c | 181 +++++++++++++++++++++++++++++++++++ 3 files changed, 192 insertions(+), 0 deletions(-) create mode 100644 schema/VESSSDComponent.mof create mode 100644 schema/VESSSDComponent.registration create mode 100644 src/Virt_VESSSDComponent.c diff --git a/schema/VESSSDComponent.mof b/schema/VESSSDComponent.mof new file mode 100644 index 0000000..a96d837 --- /dev/null +++ b/schema/VESSSDComponent.mof @@ -0,0 +1,8 @@ +// Copyright IBM Corp. 2011 + +[Association, + Provider("cmpi::Virt_VESSSDComponent") +] +class Net_VirtualEthernetSwitchSystemSettingDataComponent : CIM_VirtualSystemSettingDataComponent +{ +}; diff --git a/schema/VESSSDComponent.registration b/schema/VESSSDComponent.registration new file mode 100644 index 0000000..0416881 --- /dev/null +++ b/schema/VESSSDComponent.registration @@ -0,0 +1,3 @@ +# Copyright IBM Corp. 2011 +# Classname Namespace ProviderName ProviderModule ProviderTypes +Net_VirtualEthernetSwitchSystemSettingDataComponent root/virt Virt_VESSSDComponent Virt_VESSSDComponent association diff --git a/src/Virt_VESSSDComponent.c b/src/Virt_VESSSDComponent.c new file mode 100644 index 0000000..34f2cbc --- /dev/null +++ b/src/Virt_VESSSDComponent.c @@ -0,0 +1,181 @@ +/* + * Copyright IBM Corp. 2011 + * + * Authors: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include <stdio.h> +#include <stdlib.h> + +#include "cmpidt.h" +#include "cmpift.h" +#include "cmpimacs.h" + +#include <libcmpiutil/libcmpiutil.h> +#include <libcmpiutil/std_association.h> +#include "misc_util.h" +#include "device_parsing.h" + +#include "Virt_VESSSD.h" +#include "Virt_EASD.h" +#include "svpc_types.h" +#include "misc_util.h" + +static const CMPIBroker *_BROKER; + +static CMPIStatus vesssd_to_easd(const CMPIObjectPath *ref, + struct std_assoc_info *info, + struct inst_list *list) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + char *name = NULL; + + if (!match_hypervisor_prefix(ref, info)) { + CU_DEBUG("Requested a unexpectted assoc."); + goto out; + } + + /* the step of creating a vesssd instance is skipped to make it fast */ + if (!parse_instanceid(ref, NULL, &name)) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Unable to get system name"); + goto out; + } + + s = enum_easds(_BROKER, + name, + ref, + info->properties, + list); + + free(name); + + out: + return s; +} + +static CMPIStatus easd_to_vesssd(const CMPIObjectPath *ref, + struct std_assoc_info *info, + struct inst_list *list) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIInstance *inst = NULL; + const char *id = NULL; + char *host = NULL; + char *devid = NULL; + int ret; + + if (!match_hypervisor_prefix(ref, info)) { + CU_DEBUG("Requested a unexpectted assoc."); + goto out; + } + + /* the step of creating a easd instance is skipped to make it fast */ + if (cu_get_str_path(ref, "InstanceID", &id) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Missing InstanceID"); + goto out; + } + + ret = parse_fq_devid(id, &host, &devid); + if (!ret) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Invalid InstanceID"); + goto out; + } + + s = get_vesssd_by_name(_BROKER, host, ref, &inst); + if (s.rc != CMPI_RC_OK) { + goto out; + } + + inst_list_add(list, inst); + + out: + free(host); + free(devid); + + return s; +} + +LIBVIRT_CIM_DEFAULT_MAKEREF() + +static char *group_component[] = { + "Net_VirtualEthernetSwitchSystemSettingData", + NULL +}; + +static char *part_component[] = { + "Net_EthernetPortAllocationSettingData", + NULL +}; + +static char *assoc_classname[] = { + "Net_VirtualEthernetSwitchSystemSettingDataComponent", + NULL +}; + +static struct std_assoc forward = { + .source_class = (char **)&group_component, + .source_prop = "GroupComponent", + + .target_class = (char **)&part_component, + .target_prop = "PartComponent", + + .assoc_class = (char **)&assoc_classname, + + .handler = vesssd_to_easd, + .make_ref = make_ref +}; + +static struct std_assoc backward = { + .source_class = (char **)&part_component, + .source_prop = "PartComponent", + + .target_class = (char **)&group_component, + .target_prop = "GroupComponent", + + .assoc_class = (char **)&assoc_classname, + + .handler = easd_to_vesssd, + .make_ref = make_ref +}; + +static struct std_assoc *handlers[] = { + &forward, + &backward, + NULL +}; + +STDA_AssocMIStub(, + Virt_VESSSDComponent, + _BROKER, + libvirt_cim_init(), + handlers); + +/* + * Local Variables: + * mode: C + * c-set-style: "K&R" + * tab-width: 8 + * c-basic-offset: 8 + * indent-tabs-mode: nil + * End: + */ -- 1.7.6

This patch add the core functions in CIM model, which provided the capabilities to configure the bridge and vlan child ports. It is based on DSP1050. Signed-off-by: Wayne Xia <xiawenc(a)linux.vnet.ibm.com&gt; --- ...irtualEthernetSwitchSystemManagementService.mof | 14 + ...ernetSwitchSystemManagementService.registration | 3 + ..._VirtualEthernetSwitchSystemManagementService.c | 1342 ++++++++++++++++++++ ..._VirtualEthernetSwitchSystemManagementService.h | 31 + 4 files changed, 1390 insertions(+), 0 deletions(-) create mode 100644 schema/VirtualEthernetSwitchSystemManagementService.mof create mode 100644 schema/VirtualEthernetSwitchSystemManagementService.registration create mode 100644 src/Virt_VirtualEthernetSwitchSystemManagementService.c create mode 100644 src/Virt_VirtualEthernetSwitchSystemManagementService.h diff --git a/schema/VirtualEthernetSwitchSystemManagementService.mof b/schema/VirtualEthernetSwitchSystemManagementService.mof new file mode 100644 index 0000000..5317305 --- /dev/null +++ b/schema/VirtualEthernetSwitchSystemManagementService.mof @@ -0,0 +1,14 @@ +// Copyright IBM Corp. 2011 + +[Provider("cmpi::Virt_VirtualEthernetSwitchSystemManagementService")] +class Net_VirtualEthernetSwitchSystemManagementService : CIM_VirtualSystemManagementService +{ + [Description("HG changeset id of the providers")] + string Changeset; + + [Description("HG revision number of the providers")] + string Revision; + + [Description("Package Version")] + string Release; +}; diff --git a/schema/VirtualEthernetSwitchSystemManagementService.registration b/schema/VirtualEthernetSwitchSystemManagementService.registration new file mode 100644 index 0000000..ef2b4b1 --- /dev/null +++ b/schema/VirtualEthernetSwitchSystemManagementService.registration @@ -0,0 +1,3 @@ +# Copyright IBM Corp. 2011 +# Classname Namespace ProviderName ProviderModule ProviderTypes +Net_VirtualEthernetSwitchSystemManagementService root/virt Virt_VirtualEthernetSwitchSystemManagementService Virt_VirtualEthernetSwitchSystemManagementService method instance diff --git a/src/Virt_VirtualEthernetSwitchSystemManagementService.c b/src/Virt_VirtualEthernetSwitchSystemManagementService.c new file mode 100644 index 0000000..c60068c --- /dev/null +++ b/src/Virt_VirtualEthernetSwitchSystemManagementService.c @@ -0,0 +1,1342 @@ +/* + * Copyright IBM Corp. 2011 + * + * Authors: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <stdbool.h> +#include <inttypes.h> +#include <time.h> +#include <sys/time.h> +#include <libvirt/libvirt.h> + +#include "cmpidt.h" +#include "cmpift.h" +#include "cmpimacs.h" + +#include "cs_util.h" +#include "misc_util.h" +#include "device_parsing.h" +#include "xmlgen.h" + +#include <libcmpiutil/libcmpiutil.h> +#include <libcmpiutil/std_invokemethod.h> +#include <libcmpiutil/std_indication.h> +#include <libcmpiutil/std_instance.h> + +#include "misc_util.h" +#include "infostore.h" + +#include "Virt_VirtualSystemManagementService.h" +#include "Virt_VirtualEthernetSwitchSystemManagementService.h" +#include "Virt_VirtualEthernetSwitchSystem.h" +#include "Virt_HostSystem.h" +#include "Virt_EASD.h" +#include "network_model.h" +#include "svpc_types.h" + +#include "config.h" + + +static const CMPIBroker *_BROKER; + +typedef enum ResourceAction { + RESOURCE_ADD, + RESOURCE_DEL, + RESOURCE_MOD, +} ResourceAction; + +static CMPIArray *set_result_res_vessms(struct inst_list *list, + const char *ns) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIObjectPath *op = NULL; + CMPIArray *res = NULL; + int i = 0; + + if (list->cur == 0) { + CU_DEBUG("No resources were added or modified"); + return res; + } + + res = CMNewArray(_BROKER, list->cur, CMPI_ref, &s); + if ((s.rc != CMPI_RC_OK) || (res == NULL)) { + CU_DEBUG("Unable to create results array"); + goto out; + } + + for (i = 0; list->list[i] != NULL; i++) { + op = CMGetObjectPath(list->list[i], NULL); + if (op == NULL) { + CU_DEBUG("Unable to EASD reference"); + goto out; + } + CMSetNameSpace(op, ns); + + s = CMSetArrayElementAt(res, i, (CMPIValue *)&op, CMPI_ref); + if (s.rc != CMPI_RC_OK) { + CU_DEBUG("Error setting results array element"); + goto out; + } + } + + out: + if (s.rc != CMPI_RC_OK) { + res = NULL; + } + + return res; +} + +static CMPIStatus check_piface_for_easd_ea(const CMPIBroker *broker, + EthIface *piface) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + VLAN_Prop_8021q *pvlan_8021q; + if ((piface->eth_type != ETH_TYPE_VLAN) || + (piface->pvlan_prop->vlan_type != VLAN_TYPE_802_1_Q)) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "now only support opertaion for IEEE 802.1.q."); + CU_DEBUG("only support IEEE 802.1.q."); + eth_iface_print(piface); + goto out; + } + + pvlan_8021q = &(piface->pvlan_prop->props.prop_8021q); + if ((pvlan_8021q->vlan_id < 0) || (pvlan_8021q->vlan_id > 4095)) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "invalid vlan id set."); + CU_DEBUG("invalid vlan id %d set.", pvlan_8021q->vlan_id); + goto out; + } + + out: + return s; +} + +static CMPIStatus check_piface_for_easd_ec(const CMPIBroker *broker, + EthIface *piface_src, + EthIface *piface_dest) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + if ((piface_dest->eth_type != ETH_TYPE_BRIDGE) || + (piface_dest->name == NULL)) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "now only support connection between bridge and " + "port, but the dest is not a bridge or " + "dest name not got."); + CU_DEBUG("requested connectting device %s is not a bridge.", + piface_dest->name); + goto out; + } + + if (piface_src->name == NULL) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "connection src port was not got."); + CU_DEBUG("connection src port was not got."); + goto out; + } + + out: + return s; +} + +/* piface need to be created before calling the funtion */ +static CMPIStatus instance_to_vesssd(const CMPIBroker *broker, + EthIface *piface, + CMPIInstance *inst) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIObjectPath *opathp = NULL; + const char *brname = NULL; + const char *cn; + char *pfx = NULL; + uint16_t stp; + int ret; + + opathp = CMGetObjectPath(inst, NULL); + if (opathp == NULL) { + cu_statusf(broker, &s, + CMPI_RC_ERR_NOT_FOUND, + "failed to get object path."); + goto out; + } + + cn = CLASSNAME(opathp); + pfx = class_prefix_name(cn); + if (pfx == NULL) { + cu_statusf(broker, &s, + CMPI_RC_ERR_NOT_FOUND, + "Unknown prefix for the class."); + goto out; + } + + ret = cu_get_str_prop(inst, "VirtualSystemIdentifier", &brname); + if (ret != CMPI_RC_OK) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "property VirtualSystemIdentifier not set."); + CU_DEBUG("failed to get property VirtualSystemIdentifier."); + goto out; + } + piface->name = get_iface_name_from_switch(brname); + if (piface->name == NULL) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "failed to convert switch_name"); + CU_DEBUG("switch name %s failed to convert.", brname); + goto out; + } + + ret = cu_get_u16_prop(inst, "STP", &stp); + if (ret == CMPI_RC_OK) { + piface->pbr_prop->STP = stp; + } + + out: + free(pfx); + return s; +} + +static CMPIStatus instance_to_easd_ea(const CMPIBroker *broker, + EthIface *piface, + CMPIInstance *inst) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIStatus s_tmp; + int ret, temp; + uint16_t vlan_type = 0; + uint16_t hdr = 0; + char *charpvalues[8]; + int charpcount = 0; + VLAN_Prop_8021q *pvlan_8021q = NULL; + VLAN_Qos_8021q qos; + const char *ingress; + const char *egress; + + ret = cu_get_u16_prop(inst, "VLANType", &vlan_type); + if (ret == CMPI_RC_OK) { + if (vlan_type == 1) { + piface->eth_type = ETH_TYPE_VLAN; + piface->pvlan_prop->vlan_type = VLAN_TYPE_802_1_Q; + pvlan_8021q = &(piface->pvlan_prop->props.prop_8021q); + } else { + CU_DEBUG("unsupported VLANType " + "%d requested", vlan_type); + } + } else { + CU_DEBUG("VLANType is missing"); + } + + if ((pvlan_8021q == NULL) || + (piface->pvlan_prop->vlan_type != VLAN_TYPE_802_1_Q)) { + goto end_of_8021q; + } + + pvlan_8021q->parent = SAFE_STRDUP(piface->dep_ifname); + + s_tmp = get_array_string_from_instance(broker, inst, "Connection", + charpvalues, &charpcount, 8); + if ((s_tmp.rc == CMPI_RC_OK) && (charpcount == 1)) { + temp = vlanid_from_connection_name(charpvalues[0]); + if ((temp >= 0) && (temp < 4096)) { + pvlan_8021q->vlan_id = temp; + } + } else { + CU_DEBUG("Connnection property have %d settings.", charpcount); + } + + /* optional settings */ + ret = cu_get_u16_prop(inst, "ReorderHdr", &hdr); + if (ret == CMPI_RC_OK) { + pvlan_8021q->reorder_hdr = hdr; + } + + ret = cu_get_str_prop(inst, "VLANQosIngress", &ingress); + if (ret == CMPI_RC_OK) { + CU_DEBUG("vlan qos ingress was got."); + if (1 == vlan_8021q_qos_str_to_num(&qos, ingress)) { + pvlan_8021q->ingress = qos; + } else { + CU_DEBUG("invalid ingress string.") + } + } + + ret = cu_get_str_prop(inst, "VLANQosEgress", &egress); + if (ret == CMPI_RC_OK) { + CU_DEBUG("vlan qos egress was got."); + if (1 == vlan_8021q_qos_str_to_num(&qos, egress)) { + pvlan_8021q->egress = qos; + } else { + CU_DEBUG("invalid ingress string.") + } + } + + end_of_8021q: + return s; +} + +static CMPIStatus instance_to_easd_ec(const CMPIBroker *broker, + EthIface *piface_src, + EthIface *piface_dest, + CMPIInstance *inst) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}, s_tmp; + int ret, i; + char *charpvalues[8]; + int charpcount = 0; + char *prefix = NULL, *portname = NULL; + const char *tmp; + + s_tmp = get_array_string_from_instance(broker, inst, "HostResource", + charpvalues, &charpcount, 8); + if ((s_tmp.rc == CMPI_RC_OK) && (charpcount == 1)) { + piface_dest->name = get_iface_name_from_switch(charpvalues[0]); + if (piface_dest->name != NULL) { + piface_dest->eth_type = ETH_TYPE_BRIDGE; + } + } else { + CU_DEBUG("HostResource have %d settings.", charpcount); + } + i = 0; + while (i < charpcount) { + SAFE_FREE(charpvalues[i]); + i++; + } + + ret = cu_get_str_prop(inst, "Parent", &tmp); + if (ret == CMPI_RC_OK) { + if (1 == parse_fq_devid(tmp, &prefix, &portname)) { + SAFE_FREE(piface_src->name); + piface_src->name = get_iface_name_from_ethportsd(portname, + NULL); + } + } + + SAFE_FREE(prefix); + SAFE_FREE(portname); + return s; +} + +/* pifaces need to be created before calling the funtion */ +static CMPIStatus instance_to_easd(const CMPIBroker *broker, + const char *preset_parent, + EthIface *piface_src, + EthIface *piface_dest, + CMPIInstance *inst, + int *type) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + char *prefix = NULL; + char *name = NULL; + char *port_name = NULL; + char *switch_name = NULL; + const char *tmp; + int request_type = 0; + int ret; + + CU_DEBUG("enter inst to easd, preset_parent is %s.", preset_parent); + /* If a preset_parent is set by the user, then the code use it as + parent device. This parameter was used when user call the method + with parameter AffectedSystem was set. */ + if (preset_parent == NULL) { + s = get_instanceid(inst, &prefix, &name); + if ((s.rc != CMPI_RC_OK) || + (prefix == NULL) || (name == NULL)) { + cu_statusf(broker, &s, + CMPI_RC_ERR_NOT_FOUND, + "failed to translate InstanceId"); + CU_DEBUG("failed to translate InstanceId, " + "prefix %s, name %s.", prefix, name); + goto out; + } + } else { + /*fix me, use value from Parent if ElementName was not set */ + ret = cu_get_str_prop(inst, "ElementName", &tmp); + if (ret == CMPI_RC_OK) { + name = SAFE_STRDUP(tmp); + prefix = SAFE_STRDUP(preset_parent); + } else { + s = get_instanceid(inst, &prefix, &name); + if ((s.rc != CMPI_RC_OK) || (name == NULL)) { + cu_statusf(broker, &s, + CMPI_RC_ERR_NOT_FOUND, + "failed to get port name, " + "InstanceID or ElementName " + "need to be set correctly."); + CU_DEBUG("failed to geto port name, " + "prefix %s, name %s.", prefix, name); + goto out; + } + } + } + + if (name == NULL) { + s = get_instanceid(inst, &prefix, &name); + if ((s.rc != CMPI_RC_OK) || + (prefix == NULL) || (name == NULL)) { + cu_statusf(broker, &s, + CMPI_RC_ERR_NOT_FOUND, + "failed to translate InstanceId"); + CU_DEBUG("failed to translate InstanceId, " + "prefix %s, name %s.", prefix, name); + goto out; + } + } + + switch_name = get_iface_name_from_switch(prefix); + if (switch_name == NULL) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "failed to convert instance prefix name"); + CU_DEBUG("switch name %s failed to convert.", prefix); + goto out; + } + port_name = get_iface_name_from_ethportsd(name, &request_type); + if (port_name == NULL) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "failed to convert instance suffix name"); + CU_DEBUG("ethport name %s failed to convert.", name); + goto out; + } + + if (request_type == EASD_TYPE_EA) { + piface_src->name = port_name; + piface_src->dep_ifname = switch_name; + port_name = NULL; + switch_name = NULL; + s = instance_to_easd_ea(broker, piface_src, inst); + } else { + piface_src->name = port_name; + port_name = NULL; + s = instance_to_easd_ec(broker, piface_src, piface_dest, inst); + } + + out: + *type = request_type; + SAFE_FREE(prefix); + SAFE_FREE(name); + SAFE_FREE(port_name); + SAFE_FREE(switch_name); + return s; +} + +static CMPIStatus find_merge_existing_easd(const CMPIBroker *broker, + EthIface *piface) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + EthIface iface_ref; + EthIfacesList ifaces_list; + int ret; + + eth_ifaceslist_init(&ifaces_list); + eth_iface_init(&iface_ref); + if (piface->name == NULL) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "switch name not set."); + goto out; + } + iface_ref.name = SAFE_STRDUP(piface->name); + iface_ref.eth_type = piface->eth_type; + ret = get_host_ifaces(&ifaces_list, + eth_iface_filter_by_ref, &iface_ref); + if ((ret != 1) || (ifaces_list.count != 1)) { + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "failed to get original easd settings," + " maybe it do not exist."); + goto out; + } + eth_iface_merge(piface, ifaces_list.pifaces[0], 1); + out: + eth_ifaceslist_uninit(&ifaces_list); + eth_iface_uninit(&iface_ref); + return s; +} + +static CMPIStatus _update_easd_for(const CMPIBroker *broker, + const CMPIContext *context, + const CMPIObjectPath *ref, + const char *preset_parent, + CMPIInstance *rasd, + ResourceAction action) +{ + CMPIStatus s; + int type; + EthIface iface_src, iface_dest; + int ret; + char *errstr; + + eth_iface_init(&iface_src); + eth_iface_init(&iface_dest); + eth_iface_add_br_prop(&iface_src); + eth_iface_add_vlan_prop(&iface_src, VLAN_TYPE_802_1_Q); + eth_iface_add_br_prop(&iface_dest); + eth_iface_add_vlan_prop(&iface_dest, VLAN_TYPE_802_1_Q); + + + CU_DEBUG("Enter _update_easd_for"); + s = instance_to_easd(broker, preset_parent, + &iface_src, &iface_dest, rasd, &type); + if (s.rc != CMPI_RC_OK) { + goto out; + } + + if (type == EASD_TYPE_EA) { + s = check_piface_for_easd_ea(broker, &iface_src); + if (s.rc != CMPI_RC_OK) { + goto out; + } + CU_DEBUG("easd-EA operation with request type %d," + "iface settings is :", action); + eth_iface_print(&iface_src); + if (action == RESOURCE_ADD) { + ret = add_host_iface(&iface_src, 1); + } else if (action == RESOURCE_MOD) { + s = find_merge_existing_easd(broker, &iface_src); + if (s.rc != CMPI_RC_OK) { + goto out; + } + ret = mod_host_iface(&iface_src, 1); + } else if (action == RESOURCE_DEL) { + ret = del_host_iface(&iface_src, 1); + } else { + errstr = "requested an unsupported operation."; + CU_DEBUG("%s", errstr); + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + errstr); + goto out; + } + } else { + s = check_piface_for_easd_ec(broker, &iface_src, &iface_dest); + if (s.rc != CMPI_RC_OK) { + goto out; + } + CU_DEBUG("easd-EC operation with request type %d," + "iface settings are :", action); + eth_iface_print(&iface_src); + eth_iface_print(&iface_dest); + if (action == RESOURCE_ADD) { + ret = connect_two_ifaces(&iface_src, &iface_dest, 1); + } else if (action == RESOURCE_DEL) { + ret = disconnect_two_ifaces(&iface_src, &iface_dest, 1); + } else { + errstr = "requested an unsupported operation."; + CU_DEBUG("%s", errstr); + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + errstr); + goto out; + } + } + + if (ret != 1) { + errstr = get_host_iface_error_reason(ret); + CU_DEBUG("error num %d returned, reason %s.", ret, errstr); + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + errstr); + goto out; + } + + out: + eth_iface_uninit(&iface_src); + eth_iface_uninit(&iface_dest); + return s; +} + +static CMPIStatus _update_easd_settings(const CMPIContext *context, + const CMPIObjectPath *ref, + const char *bridge, + CMPIArray *resources, + const CMPIResult *results, + ResourceAction action, + struct inst_list *list) +{ + int i; + CMPIStatus s = {CMPI_RC_OK, NULL}; + int count = 0; + uint32_t rc = CIM_SVPC_RETURN_FAILED; + + CU_DEBUG("Enter _update_easd_settings"); + if (resources == NULL) { + CU_DEBUG("No easd settings."); + goto out; + } + + count = CMGetArrayCount(resources, &s); + if (s.rc != CMPI_RC_OK) { + CU_DEBUG("failed to get array size."); + goto out; + } + + i = 0; + CU_DEBUG("Trying update %d easds.", count); + while (i < count) { + CMPIData item; + CMPIInstance *inst; + item = CMGetArrayElementAt(resources, i, NULL); + inst = item.value.inst; + + s = _update_easd_for(_BROKER, + context, + ref, + bridge, + inst, + action); + if (s.rc != CMPI_RC_OK) { + break; + } + inst_list_add(list, inst); + i++; + } + + out: + if (s.rc == CMPI_RC_OK) { + rc = CIM_SVPC_RETURN_COMPLETED; + } + if ((results != NULL) && (resources != NULL)) { + CMReturnData(results, &rc, CMPI_uint32); + } + + return s; +} + +static CMPIStatus easd_refs_to_insts(const CMPIBroker *broker, + const CMPIContext *ctx, + const CMPIObjectPath *reference, + CMPIArray *arr, + CMPIArray **ret_arr) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIArray *tmp_arr; + int i; + int c; + + c = CMGetArrayCount(arr, &s); + if (s.rc != CMPI_RC_OK) { + return s; + } + + tmp_arr = CMNewArray(broker, + c, + CMPI_instance, + &s); + + for (i = 0; i < c; i++) { + CMPIData d; + CMPIObjectPath *ref; + CMPIInstance *inst = NULL; + const char *id; + + d = CMGetArrayElementAt(arr, i, &s); + ref = d.value.ref; + if (s.rc != CMPI_RC_OK) { + CU_DEBUG("Unable to get ResourceSettings[%i]", i); + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "Unable to get ResourceSettings"); + goto out; + } + + if (cu_get_str_path(ref, "InstanceID", &id) != CMPI_RC_OK) { + CU_DEBUG("Unable to get InstanceID of `%s'", + REF2STR(ref)); + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "Unable to get InstanceID"); + goto out; + } + + s = get_easd_by_id(broker, id, reference, NULL, &inst); + if (s.rc != CMPI_RC_OK) { + goto out; + } + + CMSetArrayElementAt(tmp_arr, i, + &inst, + CMPI_instance); + + } + + *ret_arr = tmp_arr; + + out: + return s; +} + +static CMPIInstance *create_switch_system(const CMPIContext *context, + CMPIInstance *vsssd, + CMPIArray *resources, + const CMPIObjectPath *ref, + const CMPIObjectPath *refconf, + CMPIStatus *s) +{ + CMPIInstance *inst = NULL; + EthIface iface_br; + int ret; + char *errstr; + char *br_name = NULL; + struct inst_list list; + + inst_list_init(&list); + eth_iface_init(&iface_br); + eth_iface_add_br_prop(&iface_br); + + CU_DEBUG("Enter create_switch_system"); + if (refconf != NULL) { + cu_statusf(_BROKER, s, + CMPI_RC_ERR_FAILED, + "creating switch system with" + " reference is not supported now."); + goto out; + } + + *s = instance_to_vesssd(_BROKER, &iface_br, vsssd); + if (s->rc != CMPI_RC_OK) { + cu_statusf(_BROKER, s, + CMPI_RC_ERR_FAILED, + "failed to translate settings."); + goto out; + } + iface_br.eth_type = ETH_TYPE_BRIDGE; + CU_DEBUG("Creating Switch System as follow:"); + eth_iface_print(&iface_br); + + ret = add_host_iface(&iface_br, 1); + if (ret != 1) { + errstr = get_host_iface_error_reason(ret); + CU_DEBUG("error num %d returned, reason %s.", ret, errstr); + cu_statusf(_BROKER, s, + CMPI_RC_ERR_FAILED, + errstr); + goto out; + } + + br_name = get_switch_name_from_iface(iface_br.name); + *s = _update_easd_settings(context, + ref, + br_name, + resources, + NULL, + RESOURCE_ADD, + &list); + + + *s = get_switch_by_name(_BROKER, + br_name, + ref, + &inst); + + out: + inst_list_free(&list); + eth_iface_uninit(&iface_br); + free(br_name); + + return inst; +} + +static CMPIStatus update_switchsystem_settings(const CMPIContext *context, + const CMPIObjectPath *ref, + CMPIInstance *vsssd) +{ + CMPIStatus s; + EthIface iface_br, iface_ref; + EthIfacesList ifaces_list; + int ret; + char *errstr; + + eth_ifaceslist_init(&ifaces_list); + eth_iface_init(&iface_br); + eth_iface_init(&iface_ref); + eth_iface_add_br_prop(&iface_br); + + s = instance_to_vesssd(_BROKER, &iface_br, vsssd); + if (s.rc != CMPI_RC_OK || (iface_br.name == NULL)) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "failed to translate settings."); + goto out; + + } + + iface_ref.name = SAFE_STRDUP(iface_br.name); + iface_ref.eth_type = iface_br.eth_type; + ret = get_host_ifaces(&ifaces_list, + eth_iface_filter_by_ref, &iface_ref); + if ((ret != 1) || (ifaces_list.count != 1)) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "failed to get original vs settings," + " maybe it do not exist."); + goto out; + } + eth_iface_merge(&iface_br, ifaces_list.pifaces[0], 1); + CU_DEBUG("update switch settings as following settings:"); + eth_iface_print(&iface_br); + ret = mod_host_iface(&iface_br, 1); + if (ret != 1) { + errstr = get_host_iface_error_reason(ret); + CU_DEBUG("error num %d returned, reason %s.", ret, errstr); + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + errstr); + goto out; + } + + out: + eth_ifaceslist_uninit(&ifaces_list); + eth_iface_uninit(&iface_ref); + eth_iface_uninit(&iface_br); + return s; +} + +static CMPIStatus define_switch_system_parse_args(const CMPIArgs *argsin, + CMPIInstance **sys, + const char *ns, + CMPIArray **res, + CMPIObjectPath **refconf) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + + if (cu_get_inst_arg(argsin, "SystemSettings", sys) != CMPI_RC_OK) { + CU_DEBUG("No SystemSettings string argument"); + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_INVALID_PARAMETER, + "Missing argument `SystemSettings'"); + goto out; + } + + if (cu_get_array_arg(argsin, "ResourceSettings", res) != + CMPI_RC_OK) { + CU_DEBUG("Did not get ResourceSettings arg"); + *res = NULL; + } + + if (cu_get_ref_arg(argsin, "ReferenceConfiguration", refconf) != + CMPI_RC_OK) { + CU_DEBUG("Did not get ReferenceConfiguration arg"); + *refconf = NULL; + } + out: + return s; +} + +static CMPIStatus define_system(CMPIMethodMI *self, + const CMPIContext *context, + const CMPIResult *results, + const CMPIObjectPath *reference, + const CMPIArgs *argsin, + CMPIArgs *argsout) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIInstance *vsssd; + CMPIArray *res; + CMPIObjectPath *refconf; + CMPIInstance *sys = NULL; + CMPIObjectPath *result; + uint32_t rc = CIM_SVPC_RETURN_FAILED; + + CU_DEBUG("DefineSystem"); + + s = define_switch_system_parse_args(argsin, + &vsssd, + NAMESPACE(reference), + &res, + &refconf); + if (s.rc != CMPI_RC_OK) { + goto out; + } + + sys = create_switch_system(context, vsssd, res, reference, refconf, &s); + if (sys == NULL) { + goto out; + } + + result = CMGetObjectPath(sys, &s); + if ((result != NULL) && (s.rc == CMPI_RC_OK)) { + CMSetNameSpace(result, NAMESPACE(reference)); + CMAddArg(argsout, "ResultingSystem", &result, CMPI_ref); + } + + + out: + if (s.rc == CMPI_RC_OK) { + rc = CIM_SVPC_RETURN_COMPLETED; + } + CMReturnData(results, &rc, CMPI_uint32); + + return s; +} + +static CMPIStatus destroy_system(CMPIMethodMI *self, + const CMPIContext *context, + const CMPIResult *results, + const CMPIObjectPath *reference, + const CMPIArgs *argsin, + CMPIArgs *argsout) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + const char *br_name = NULL; + EthIface iface_br; + uint32_t rc = IM_RC_FAILED; + CMPIObjectPath *sys; + int ret; + char *errstr; + + eth_iface_init(&iface_br); + CU_DEBUG("entering destroy switch system."); + + if (cu_get_ref_arg(argsin, "AffectedSystem", &sys) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "AffectedSystem not set"); + goto out; + } + + br_name = get_key_from_ref_arg(argsin, "AffectedSystem", "Name"); + if (br_name == NULL) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Failed get Name of AffectedSystem"); + goto out; + } + + iface_br.name = get_iface_name_from_switch(br_name); + if (iface_br.name == NULL) { + CU_DEBUG("failed to get iface name from %s.", br_name); + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Failed to translate Name of AffectedSystem"); + goto out; + } + + iface_br.eth_type = ETH_TYPE_BRIDGE; + CU_DEBUG("Deleting Switch System as follow:"); + eth_iface_print(&iface_br); + + ret = del_host_iface(&iface_br, 1); + if (ret != 1) { + errstr = get_host_iface_error_reason(ret); + CU_DEBUG("error num %d returned, reason %s.", ret, errstr); + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + errstr); + goto out; + } + + rc = IM_RC_OK; + + out: + eth_iface_uninit(&iface_br); + CMReturnData(results, &rc, CMPI_uint32); + return s; +} + + +static CMPIStatus mod_system_settings(CMPIMethodMI *self, + const CMPIContext *context, + const CMPIResult *results, + const CMPIObjectPath *reference, + const CMPIArgs *argsin, + CMPIArgs *argsout) +{ + CMPIInstance *inst; + CMPIStatus s; + uint32_t rc; + + if (cu_get_inst_arg(argsin, "SystemSettings", &inst) != CMPI_RC_OK) { + + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Missing SystemSettings"); + goto out; + } + + s = update_switchsystem_settings(context, reference, inst); + out: + if (s.rc == CMPI_RC_OK) { + rc = CIM_SVPC_RETURN_COMPLETED; + } else { + rc = CIM_SVPC_RETURN_FAILED; + } + + CMReturnData(results, &rc, CMPI_uint32); + + return s; +} + +static CMPIStatus add_resource_settings(CMPIMethodMI *self, + const CMPIContext *context, + const CMPIResult *results, + const CMPIObjectPath *reference, + const CMPIArgs *argsin, + CMPIArgs *argsout) +{ + CMPIArray *arr; + CMPIStatus s; + CMPIObjectPath *sys; + char *bridge = NULL; + CMPIArray *res = NULL; + struct inst_list list; + + inst_list_init(&list); + + if (cu_get_array_arg(argsin, "ResourceSettings", &arr) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Missing ResourceSettings"); + return s; + } + + if (cu_get_ref_arg(argsin, + "AffectedConfiguration", + &sys) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_INVALID_PARAMETER, + "Missing AffectedConfiguration parameter"); + return s; + } + + if (!parse_instanceid(sys, NULL, &bridge)) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_INVALID_PARAMETER, + "AffectedConfiguration has invalid InstanceID"); + return s; + } + + s = _update_easd_settings(context, + reference, + bridge, + arr, + results, + RESOURCE_ADD, + &list); + + free(bridge); + + res = set_result_res_vessms(&list, NAMESPACE(reference)); + inst_list_free(&list); + CMAddArg(argsout, "ResultingResourceSettings", &res, CMPI_refA); + + + return s; +} + +static CMPIStatus mod_resource_settings(CMPIMethodMI *self, + const CMPIContext *context, + const CMPIResult *results, + const CMPIObjectPath *reference, + const CMPIArgs *argsin, + CMPIArgs *argsout) +{ + CMPIArray *arr; + CMPIStatus s; + CMPIArray *res = NULL; + struct inst_list list; + + CU_DEBUG("Enter mod_resource_settings"); + inst_list_init(&list); + + if (cu_get_array_arg(argsin, "ResourceSettings", &arr) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Missing ResourceSettings"); + return s; + } + + s = _update_easd_settings(context, + reference, + NULL, + arr, + results, + RESOURCE_MOD, + &list); + + res = set_result_res_vessms(&list, NAMESPACE(reference)); + CMAddArg(argsout, "ResultingResourceSettings", &res, CMPI_refA); + inst_list_free(&list); + + return s; +} + +static CMPIStatus rm_resource_settings(CMPIMethodMI *self, + const CMPIContext *context, + const CMPIResult *results, + const CMPIObjectPath *reference, + const CMPIArgs *argsin, + CMPIArgs *argsout) +{ + /* The RemoveResources case is different from either Add or + * Modify, because it takes references instead of instances + */ + + CMPIArray *arr; + CMPIArray *resource_arr = NULL; + CMPIStatus s; + struct inst_list list; + + inst_list_init(&list); + + if (cu_get_array_arg(argsin, "ResourceSettings", &arr) != CMPI_RC_OK) { + cu_statusf(_BROKER, &s, + CMPI_RC_ERR_FAILED, + "Missing ResourceSettings"); + goto out; + } + + /* delete is simple, just specify the names */ + s = easd_refs_to_insts(_BROKER, context, reference, arr, + &resource_arr); + if (s.rc != CMPI_RC_OK) { + goto out; + } + + s = _update_easd_settings(context, + reference, + NULL, + resource_arr, + results, + RESOURCE_DEL, + &list); + out: + inst_list_free(&list); + + return s; +} + +static struct method_handler DefineSystem = { + .name = "DefineSystem", + .handler = define_system, + .args = {{"SystemSettings", CMPI_instance, false}, + {"ResourceSettings", CMPI_instanceA, true}, + {"ReferenceConfiguration", CMPI_ref, true}, + ARG_END + } +}; + +static struct method_handler DestroySystem = { + .name = "DestroySystem", + .handler = destroy_system, + .args = {{"AffectedSystem", CMPI_ref, false}, + ARG_END + } +}; + +static struct method_handler AddResourceSettings = { + .name = "AddResourceSettings", + .handler = add_resource_settings, + .args = {{"AffectedConfiguration", CMPI_ref, false}, + {"ResourceSettings", CMPI_instanceA, false}, + ARG_END + } +}; + +static struct method_handler ModifyResourceSettings = { + .name = "ModifyResourceSettings", + .handler = mod_resource_settings, + .args = {{"ResourceSettings", CMPI_instanceA, false}, + ARG_END + } +}; + +static struct method_handler ModifySystemSettings = { + .name = "ModifySystemSettings", + .handler = mod_system_settings, + .args = {{"SystemSettings", CMPI_instance, false}, + ARG_END + } +}; + +static struct method_handler RemoveResourceSettings = { + .name = "RemoveResourceSettings", + .handler = rm_resource_settings, + .args = {{"ResourceSettings", CMPI_refA, false}, + ARG_END + } +}; + +static struct method_handler *my_handlers[] = { + &DefineSystem, + &DestroySystem, + &AddResourceSettings, + &ModifyResourceSettings, + &ModifySystemSettings, + &RemoveResourceSettings, + NULL, +}; + +STDIM_MethodMIStub(, Virt_VirtualEthernetSwitchSystemManagementService, + _BROKER, libvirt_cim_init(), my_handlers); + + +CMPIStatus get_vessms(const CMPIObjectPath *reference, + CMPIInstance **_inst, + const CMPIBroker *broker, + const CMPIContext *context, + bool is_get_inst) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIInstance *inst = NULL; + char host_name[256]; + CMPIArray *array; + uint16_t op_status; + + *_inst = NULL; + + inst = get_typed_instance(broker, + NETWORK_CLASS_PREFIX, + "VirtualEthernetSwitchSystemManagementService", + NAMESPACE(reference)); + + if (inst == NULL) { + CU_DEBUG("Failed to get typed instance"); + cu_statusf(broker, &s, + CMPI_RC_ERR_FAILED, + "Failed to create instance"); + goto out; + } + + CMSetProperty(inst, "Caption", + (CMPIValue *)"VLAN and VBridge services", CMPI_chars); + + CMSetProperty(inst, "Name", + (CMPIValue *)"Management Service", CMPI_chars); + + if (0 == get_fqdn(host_name, sizeof(host_name))) { + CMSetProperty(inst, "SystemName", + (CMPIValue *)host_name, CMPI_chars); + } + + CMSetProperty(inst, "SystemCreationClassName", + (CMPIValue *)"KVM_HostSystem", CMPI_chars); + + + CMSetProperty(inst, "Revision", + (CMPIValue *)LIBVIRT_CIM_RV, CMPI_chars); + + CMSetProperty(inst, "Release", + (CMPIValue *)PACKAGE_VERSION, CMPI_chars); + + array = CMNewArray(broker, 1, CMPI_uint16, &s); + if ((s.rc != CMPI_RC_OK) || (CMIsNullObject(array))) { + goto out; + } + + op_status = CIM_OPERATIONAL_STATUS; + CMSetArrayElementAt(array, 0, &op_status, CMPI_uint16); + + CMSetProperty(inst, "OperationalStatus", + (CMPIValue *)&array, CMPI_uint16A); + + if (is_get_inst) { + s = cu_validate_ref(broker, reference, inst); + if (s.rc != CMPI_RC_OK) { + goto out; + } + } + + cu_statusf(broker, &s, + CMPI_RC_OK, + ""); + out: + *_inst = inst; + + return s; +} + +static CMPIStatus return_vessms(const CMPIContext *context, + const CMPIObjectPath *reference, + const CMPIResult *results, + bool name_only, + bool is_get_inst) +{ + CMPIStatus s = {CMPI_RC_OK, NULL}; + CMPIInstance *inst; + + s = get_vessms(reference, &inst, _BROKER, context, is_get_inst); + if ((s.rc != CMPI_RC_OK) || (inst == NULL)) { + goto out; + } + + if (name_only) { + cu_return_instance_name(results, inst); + } else { + CMReturnInstance(results, inst); + } + out: + return s; +} + +static CMPIStatus EnumInstanceNames(CMPIInstanceMI *self, + const CMPIContext *context, + const CMPIResult *results, + const CMPIObjectPath *reference) +{ + return return_vessms(context, reference, results, true, false); +} + +static CMPIStatus EnumInstances(CMPIInstanceMI *self, + const CMPIContext *context, + const CMPIResult *results, + const CMPIObjectPath *reference, + const char **properties) +{ + + return return_vessms(context, reference, results, false, false); +} + +static CMPIStatus GetInstance(CMPIInstanceMI *self, + const CMPIContext *context, + const CMPIResult *results, + const CMPIObjectPath *ref, + const char **properties) +{ + return return_vessms(context, ref, results, false, true); +} + +DEFAULT_CI(); +DEFAULT_MI(); +DEFAULT_DI(); +DEFAULT_EQ(); +DEFAULT_INST_CLEANUP(); + +STD_InstanceMIStub(, + Virt_VirtualEthernetSwitchSystemManagementService, + _BROKER, + libvirt_cim_init()); + + +/* + * Local Variables: + * mode: C + * c-set-style: "K&R" + * tab-width: 8 + * c-basic-offset: 8 + * indent-tabs-mode: nil + * End: + */ diff --git a/src/Virt_VirtualEthernetSwitchSystemManagementService.h b/src/Virt_VirtualEthernetSwitchSystemManagementService.h new file mode 100644 index 0000000..07c0f4e --- /dev/null +++ b/src/Virt_VirtualEthernetSwitchSystemManagementService.h @@ -0,0 +1,31 @@ +/* + * Copyright IBM Corp. 2011 + * + * Authors: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef VESSMS_H +#define VESSMS_H + +CMPIStatus get_vessms(const CMPIObjectPath *reference, + CMPIInstance **_inst, + const CMPIBroker *broker, + const CMPIContext *context, + bool is_get_inst); + +#endif -- 1.7.6

this is the API layer let the libvirt-cim call. Signed-off-by: Wayne Xia <xiawenc(a)linux.vnet.ibm.com&gt; --- libxkutil/host_network_API.c | 150 ++++++++++++++++++++++++++++++++++++++++++ libxkutil/host_network_API.h | 32 +++++++++ 2 files changed, 182 insertions(+), 0 deletions(-) create mode 100644 libxkutil/host_network_API.c create mode 100644 libxkutil/host_network_API.h diff --git a/libxkutil/host_network_API.c b/libxkutil/host_network_API.c new file mode 100644 index 0000000..89a9879 --- /dev/null +++ b/libxkutil/host_network_API.c @@ -0,0 +1,150 @@ +/* + * Copyright IBM Corp. 2011 + * + * Authors: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + */ + + +#include "host_network_API.h" +#include "host_network_implement_cmdline.h" +#include "host_network_error.h" + +/* this layer is added to devide the abstraction and implemention, so that + different implemention could be used and switched */ + +int get_host_ifaces(EthIfacesList *plist, + eth_iface_filter_func filter_func, void *filter_opaque) +{ + return get_host_eth_ifaces_cmd_all(plist, filter_func, filter_opaque); +} + +int add_host_iface(EthIface *piface, int persist_flag) +{ + int ret = 0; + if (piface->eth_type == ETH_TYPE_BRIDGE) { + ret = add_host_br_cmd(piface, persist_flag); + } else if (piface->eth_type == ETH_TYPE_VLAN) { + + if (piface->pvlan_prop == NULL) { + CU_DEBUG("requested an unsupported operation."); + ret = ERR_REQUEST_NOT_SUPPORT; + } else { + if (piface->pvlan_prop->vlan_type == VLAN_TYPE_802_1_Q) { + ret = add_host_vlan_8021q_cmd(piface, persist_flag); + } else { + CU_DEBUG("requested an unsupported operation."); + ret = ERR_REQUEST_NOT_SUPPORT; + } + } + + } else { + CU_DEBUG("requested an unsupported operation."); + ret = ERR_REQUEST_NOT_SUPPORT; + } + + return ret; +} + +int del_host_iface(EthIface *piface, int persist_flag) +{ + int ret = 0; + if (piface->eth_type == ETH_TYPE_BRIDGE) { + ret = del_host_br_cmd(piface, persist_flag); + } else if (piface->eth_type == ETH_TYPE_VLAN) { + + if (piface->pvlan_prop == NULL) { + CU_DEBUG("requested an unsupported operation."); + ret = ERR_REQUEST_NOT_SUPPORT; + } else { + if (piface->pvlan_prop->vlan_type == VLAN_TYPE_802_1_Q) { + ret = del_host_vlan_8021q_cmd(piface, persist_flag); + } else { + CU_DEBUG("requested an unsupported operation."); + ret = ERR_REQUEST_NOT_SUPPORT; + } + } + + } else { + CU_DEBUG("requested an unsupported operation."); + ret = ERR_REQUEST_NOT_SUPPORT; + } + + return ret; +} + +int mod_host_iface(EthIface *piface, int persist_flag) +{ + int ret = 0; + if (piface->eth_type == ETH_TYPE_BRIDGE) { + ret = mod_host_br_cmd(piface, persist_flag); + } else if (piface->eth_type == ETH_TYPE_VLAN) { + + if (piface->pvlan_prop == NULL) { + CU_DEBUG("requested an unsupported operation."); + ret = ERR_REQUEST_NOT_SUPPORT; + } else { + if (piface->pvlan_prop->vlan_type == VLAN_TYPE_802_1_Q) { + ret = mod_host_vlan_8021q_cmd(piface, persist_flag); + } else { + CU_DEBUG("requested an unsupported operation."); + ret = ERR_REQUEST_NOT_SUPPORT; + } + } + + } else { + CU_DEBUG("requested an unsupported operation."); + ret = ERR_REQUEST_NOT_SUPPORT; + } + + return ret; +} + +int change_state_host_iface(EthIface *piface, int state) +{ + return change_state_host_iface_cmd(piface, state); +} + +int connect_two_ifaces(EthIface *p1, EthIface *p2, int persist_flag) +{ + if ((p1 == NULL) || (p2 == NULL)) { + return 0; + } + if ((p1->eth_type == ETH_TYPE_BRIDGE) && + (p2->eth_type != ETH_TYPE_BRIDGE)) { + return add_host_iface_to_br_cmd(p2, p1, persist_flag); + } else if ((p1->eth_type != ETH_TYPE_BRIDGE) && + (p2->eth_type == ETH_TYPE_BRIDGE)) { + return add_host_iface_to_br_cmd(p1, p2, persist_flag); + } else { + CU_DEBUG("requested an unsupported operation."); + return ERR_REQUEST_NOT_SUPPORT; + } +} + +int disconnect_two_ifaces(EthIface *p1, EthIface *p2, int persist_flag) +{ + if ((p1 == NULL) || (p2 == NULL)) { + return 0; + } + if ((p1->eth_type == ETH_TYPE_BRIDGE) && + (p2->eth_type != ETH_TYPE_BRIDGE)) { + return remove_host_iface_from_br_cmd(p2, p1, persist_flag); + } else if ((p1->eth_type != ETH_TYPE_BRIDGE) && + (p2->eth_type == ETH_TYPE_BRIDGE)) { + return remove_host_iface_from_br_cmd(p1, p2, persist_flag); + } else { + CU_DEBUG("requested an unsupported operation."); + return ERR_REQUEST_NOT_SUPPORT; + } +} + +char *get_host_iface_error_reason(int errno) +{ + return translate_error_no(errno); +} diff --git a/libxkutil/host_network_API.h b/libxkutil/host_network_API.h new file mode 100644 index 0000000..b821d58 --- /dev/null +++ b/libxkutil/host_network_API.h @@ -0,0 +1,32 @@ +/* + * Copyright IBM Corp. 2011 + * + * Authors: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + */ + +#ifndef HOST_NETWORK_API +#define HOST_NETWORK_API + +#include "host_network_basic.h" +#include "host_network_helper.h" + +int get_host_ifaces(EthIfacesList *plist, + eth_iface_filter_func filter_func, void *filter_opaque); + +int add_host_iface(EthIface *piface, int persist_flag); +int del_host_iface(EthIface *piface, int persist_flag); +int mod_host_iface(EthIface *piface, int persist_flag); +int change_state_host_iface(EthIface *piface, int state); + +int connect_two_ifaces(EthIface *p1, EthIface *p2, int persist_flag); +int disconnect_two_ifaces(EthIface *p1, EthIface *p2, int persist_flag); + +char *get_host_iface_error_reason(int errno); + +#endif -- 1.7.6

于 2011-12-24 4:01, Chip Vincent 写道: OK. A pure C project which would include only the function code and C testing cases was sent before. Running that would be easy to view what it does. Sorry I did not catch your idea. Do you mean that this file should be merged to another host_network files? There is a member in struct iface recording the active state, so this function would retrieve all ifaces information. What I intended to do is that errno was returned when CIM model code call the "API" functions, and CIM model code could use the errno to call this function to get a string, which was used to tell the user like wbemcli what was happening. Do you mean that this details should be hidden inside libvirt-cim? -- Best Regards Wayne Xia mail:xiawenc@linux.vnet.ibm.com tel:86-010-82450803

On 12/07/2011 04:25 AM, Wayne Xia wrote: Are these debug functions always needed? Perhaps they should be wrapped in a #ifdef DEBUG to keep the code and runtime minimal. I have not yet looked up the definition of EthIface but assume it's a struct. I'd prefer to see 'struct EthIface' so that's clear. In general, we should avoid using #defines and #typedefs to obscure the actual type of something. These macro names are not obvious. Consider clarifying. Why not name 'NUM_NOT_GOT' to something like 'NONE' or 'NOT_DEFINED'? What about IPv6? -- Chip Vincent Open Virtualization IBM Linux Technology Center cvincent(a)linux.vnet.ibm.com

this is the helper function for the lib. Signed-off-by: Wayne Xia <xiawenc(a)linux.vnet.ibm.com&gt; --- libxkutil/host_network_error.h | 28 ++ libxkutil/host_network_helper.c | 659 +++++++++++++++++++++++++++++++++++++++ libxkutil/host_network_helper.h | 192 ++++++++++++ 3 files changed, 879 insertions(+), 0 deletions(-) create mode 100644 libxkutil/host_network_error.h create mode 100644 libxkutil/host_network_helper.c create mode 100644 libxkutil/host_network_helper.h diff --git a/libxkutil/host_network_error.h b/libxkutil/host_network_error.h new file mode 100644 index 0000000..d809033 --- /dev/null +++ b/libxkutil/host_network_error.h @@ -0,0 +1,28 @@ +#ifndef HOST_NETWORK_ERROR_H +#define HOST_NETWORK_ERROR_H + +#define ERR_REQUEST_NOT_SUPPORT -1 + +#define ERR_COMMAND_NOT_SET -11 +#define ERR_COMMAND_PIPE_ERR -12 +#define ERR_COMMAND_NOT_SUPPORT -13 +#define ERR_COMMAND_NO_PERMISSION -14 +#define ERR_COMMAND_NO_READY -15 +#define ERR_COMMAND_PARAMETER_WRONG -16 +#define ERR_COMMAND_EXECUTION -17 + +#define ERR_DEVICE_EXCEED_MAXNUM -100 +#define ERR_DEVICE_EXIST -101 +#define ERR_DEVICE_NOT_EXIST -102 +#define ERR_DEVICE_ALREADY_DONE -103 +#define ERR_DEVICE_CONNECT_OTHER -104 + +#define ERR_FILE_OP_FAIL -125 +#define ERR_FILE_EMPTY -126 +#define ERR_FILE_TOO_LARGE -127 +#define ERR_FILE_CONT_TOO_LARGE -128 +#define ERR_FILE_LOCK_FAIL -129 + +#define ERR_PERSIST_NOT_REDHAT -200 + +#endif diff --git a/libxkutil/host_network_helper.c b/libxkutil/host_network_helper.c new file mode 100644 index 0000000..dc9f775 --- /dev/null +++ b/libxkutil/host_network_helper.c @@ -0,0 +1,659 @@ +/* + * Copyright IBM Corp. 2011 + * + * Authors: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + */ + + + +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> +#include <fcntl.h> + +#include "host_network_helper.h" +#include "host_network_error.h" + +#define CONFIGURE_FILE_MAX_SIZE 2048 + +#define PIPE_CMD_SUFFIX " 2>&1" + +static int g_linux_version = LINUX_UNKNOWN; + +static int compare_qos_8021q(const void *p1, const void *p2) +{ + const VLAN_Qos_8021q_elem *qos1 = (VLAN_Qos_8021q_elem *)p1; + const VLAN_Qos_8021q_elem *qos2 = (VLAN_Qos_8021q_elem *)p2; + int ret = 0; + if ((qos1->from) > (qos2->from)) { + ret = 1; + } + return ret; +} + +/* it need to be checked see whether these are the conditions */ +int vlan_8021q_qos_check_valid(VLAN_Qos_8021q *pqos) +{ + int ret = 1; + int i = 0; + int last_num = -1; + if ((pqos->count < 0) || (pqos->count > 8)) { + ret = 0; + goto out; + } else if (pqos->count == 0) { + goto out; + } + qsort((void *)pqos->values, pqos->count, sizeof(VLAN_Qos_8021q_elem), + compare_qos_8021q); + + while (i < pqos->count) { + if (pqos->values[i].from == last_num) { + CU_DEBUG("error: vlan 802.1.q qos setting have same <from> values: " + "last is %d, new is %d", last_num, pqos->values[i].from); + ret = 0; + goto out; + } + last_num = pqos->values[i].from; + if ((pqos->values[i].from < 0) || (pqos->values[i].from >= 8)) { + CU_DEBUG("error: vlan 802.1.q qos setting have outbound value: " + "from is %d.", pqos->values[i].from); + ret = 0; + goto out; + } + if ((pqos->values[i].to < 0) || (pqos->values[i].to >= 8)) { + CU_DEBUG("error: vlan 802.1.q qos setting have outbound value: " + "to is %d.", pqos->values[i].to); + ret = 0; + goto out; + } + i++; + } + + out: + return ret; +} + +int vlan_8021q_qos_str_to_num(VLAN_Qos_8021q *pqos, const char* str) +{ + int ret = 1; + char *str_line = NULL; + char *temp; + char *saveptr = NULL; + char *invalptr1, *invalptr2; + int qos_num1, qos_num2; + VLAN_Qos_8021q qos; + + if (str == NULL) { + ret = 0; + goto out; + } + if (str[0] == '\0') { + ret = 1; + pqos->count = 0; + CU_DEBUG("empty vlan 802.1.q qos string found."); + goto out; + } + str_line = SAFE_STRDUP(str); + qos.count = 0; + + temp = strtok_r(str_line, " ", &saveptr); + while (temp != NULL) { + qos_num1 = strtol(temp, &invalptr1, 10); + if (temp == invalptr1) { + ret = 0; + goto out; + } + if (*invalptr1 != ':') { + ret = 0; + goto out; + } + invalptr1++; + qos_num2 = strtol(invalptr1, &invalptr2, 10); + if (invalptr1 == invalptr2) { + ret = 0; + goto out; + } + if (*invalptr2 != '\0') { + ret = 0; + goto out; + } + if (qos.count >= 8) { + ret = 0; + CU_DEBUG("too many settings found in vlan 802.1.q qos string [%s]", + str); + goto out; + } + qos.values[qos.count].from = qos_num1; + qos.values[qos.count].to = qos_num2; + qos.count++; + temp = strtok_r(NULL, " ", &saveptr); + } + ret = vlan_8021q_qos_check_valid(&qos); + if (ret == 1) { + *pqos = qos; + } + + out: + if (ret != 1) { + CU_DEBUG("vlan 802.1.q qos string [%s] is invalid.", str); + } + SAFE_FREE(str_line); + return ret; +} + +int vlan_8021q_qos_num_to_str(char **str, const VLAN_Qos_8021q *pqos) +{ + char temp[16]; + int i; + VLAN_Qos_8021q qos = *pqos; + int ret = vlan_8021q_qos_check_valid(&qos); + if (ret != 1) { + goto out; + } + SAFE_MALLOC(*str, 64); + *str[0] = '\0'; + if (qos.count == 0) { + goto out; + } + i = 0; + snprintf(temp, sizeof(temp), "%d:%d", + qos.values[i].from, qos.values[i].to); + strcat(*str, temp); + i++; + while (i < qos.count) { + strcat(*str, " "); + snprintf(temp, sizeof(temp), "%d:%d", + qos.values[i].from, qos.values[i].to); + strcat(*str, temp); + i++; + } + + out: + return ret; +} + +int netmask_easy_to_inaddr(struct in_addr *paddr, const char* pmask) +{ + long mask_one_num = -1; + unsigned char *p; + int bitnum; + + mask_one_num = strtol(pmask, NULL, 10); + if ((mask_one_num < 0) || (mask_one_num > 32)) { + return 0; + } + + /* use network byte order */ + p = (unsigned char *)&paddr->s_addr; + memset(p, 0, 4); + while (mask_one_num > 8) { + *(p++) = 255; + mask_one_num -= 8; + } + bitnum = 7; + while (mask_one_num > 0) { + *p = *p + (1<<bitnum); + mask_one_num--; + bitnum--; + } + return 1; +} + +char *strtok_onetime(const char *str, const char *delim) +{ + char *t = strstr(str, delim); + char *ret_char; + int len; + if (t == NULL) { + return NULL; + } + len = t - str; + if (len <= 0) { + return NULL; + } + SAFE_MALLOC(ret_char, len+1); + strncpy(ret_char, str, len); + ret_char[len] = '\0'; + + return ret_char; +} + +char *combine_file_name(const char *prefix, const char *name) +{ + char *ret = NULL; + int size; + size = strlen(prefix) + strlen(name) + 1; + SAFE_CALLOC(ret, size, sizeof(char)); + snprintf(ret, size, "%s%s", prefix, name); + return ret; +} + +/* return the whole content length that need update. The data length keep + unchanged in the head part is returned in *unchanged_len which could be + used to avoid write whole data later. + requriement: cont must contain end character, prefix must be not NULL */ +static int replace_prop_str(char *cont, const int maxsize, const char *prefix, + const char *prop, int *unchanged_len) +{ + int target_len, origin_len; + int cont_len; + int valid_len = 0; + int prefix_len, prop_len = 0; + char *endchar1 = "\n"; + char *pprop_start, *pprop_end; + int head_len; + + cont_len = strlen(cont); + head_len = cont_len; + prefix_len = strlen(prefix); + if ((prop == NULL) || (*prop == '\0')) { + /* want the property removed */ + target_len = 0; + } else { + /* want the property changed */ + prop_len = strlen(prop); + target_len = prefix_len + prop_len; + } + + pprop_start = strstr(cont, prefix); + if (pprop_start == NULL) { + /* the content do not exist in original contents */ + if (target_len > 0) { + /* add the property */ + if ((cont_len + target_len) >= maxsize) { + CU_DEBUG("buffer is too small for the operation."); + valid_len = -1; + goto out; + } + strcat(cont, prefix); + strcat(cont, prop); + valid_len = cont_len + target_len; + } else { + /* remove the property, but it do not exist, so skip */ + } + } else { + /* the content exist in original contents */ + /* locate the end of the property */ + pprop_end = strstr(pprop_start, endchar1); + if (pprop_end == NULL) { + /* last line */ + origin_len = strlen(pprop_start); + pprop_end = cont+cont_len; + } else { + origin_len = pprop_end - pprop_start; + } + if (target_len > 0) { + /* change the property */ + /* check the bound */ + if ((cont_len + target_len - origin_len) >= maxsize) { + CU_DEBUG("buffer is too small for the operation."); + valid_len = -1; + goto out; + } + /* move contents in the tail */ + memmove(pprop_end+target_len-origin_len, pprop_end, + cont+cont_len+1-pprop_end); + /* copy the content of the new string */ + memcpy(pprop_start+prefix_len, prop, prop_len); + head_len = pprop_start - cont + prefix_len; + } else { + /* remove the property */ + /* move contents in the tail to replace original string*/ + memmove(pprop_end+target_len-origin_len, pprop_end, + cont+cont_len+1-pprop_end); + head_len = pprop_start - cont; + } + valid_len = cont_len + target_len - origin_len; + } + + out: + if (unchanged_len != NULL) { + *unchanged_len = head_len; + } + return valid_len; +} + +int configure_file_replace_attr(const char *path, const char *prefix, + const char *prop) +{ + int fd = -1; + int fop_ret; + struct stat s; + struct flock lock; + int lock_state = -1; + char *cont = NULL; + char *pbuff; + int write_len; + int cont_len_update; + int cont_len_unchanged; + int ret = 0; + + if ((prefix == NULL) || (*prefix == '\0')) { + CU_DEBUG("no prefix for property set, could not replace the content."); + goto out; + } + + fd = open(path, O_RDWR, 0644); + if (fd < 0) { + CU_DEBUG("Unable to open [%s], it does not exist.", path); + ret = ERR_FILE_OP_FAIL; + goto out; + } + + lock.l_type = F_WRLCK; + lock.l_start = 0; + lock.l_whence = SEEK_SET; + lock.l_len = 0; + lock_state = fcntl(fd, F_SETLK, &lock); + if (lock_state < 0) { + CU_DEBUG("Failed to lock file [%s], it may be locked by other.", path); + ret = ERR_FILE_LOCK_FAIL; + goto out; + } + + fstat(fd, &s); + if (s.st_size == 0) { + CU_DEBUG("file [%s] is empty, will not replace attr for it.", path); + ret = ERR_FILE_EMPTY; + goto out; + } else if (s.st_size >= CONFIGURE_FILE_MAX_SIZE) { + CU_DEBUG("file [%s] is too large, " + "it have %lld bytes, will not read it.", + path, (long long)s.st_size); + ret = ERR_FILE_TOO_LARGE; + goto out; + } + + SAFE_MALLOC(cont, CONFIGURE_FILE_MAX_SIZE); + lseek(fd, 0, SEEK_SET); + fop_ret = read(fd, cont, s.st_size); + cont[s.st_size] = '\0'; + cont_len_update = replace_prop_str(cont, CONFIGURE_FILE_MAX_SIZE, + prefix, prop, &cont_len_unchanged); + if (cont_len_update < 0) { + CU_DEBUG("file [%s] is too big to expand it with [%s%s].", + path, prefix, prop); + ret = ERR_FILE_TOO_LARGE; + goto out; + } else if (cont_len_update == 0) { + CU_DEBUG("the contents was not changed, do not need update it"); + ret = 1; + goto out; + } else { + if (ftruncate(fd, cont_len_unchanged) != 0) { + CU_DEBUG("file [%s] Unable to truncate it", path); + ret = ERR_FILE_OP_FAIL; + goto out; + } + write_len = cont_len_update-cont_len_unchanged; + if (write_len > 0) { + lseek(fd, cont_len_unchanged, SEEK_SET); + CU_DEBUG("writing file [%s] for %d bytes with offset %d," + " cont is :\n%s\n", + path, write_len, cont_len_unchanged, cont); + pbuff = cont+cont_len_unchanged; + fop_ret = write(fd, pbuff, write_len); + } + } + ret = 1; + + out: + if (fd >= 0) { + if (lock_state >= 0) { + lock.l_type = F_UNLCK; + fcntl(fd, F_SETLK, &lock); + } + close(fd); + } + SAFE_FREE(cont); + return ret; +} + +int configure_file_update(const char *path, const char *cont) +{ + int fd = -1; + int fop_ret; + struct flock lock; + int lock_state = -1; + int write_len; + int ret = 0; + + fd = open(path, O_RDWR|O_CREAT, 0644); + if (fd < 0) { + CU_DEBUG("Unable to open [%s], it does not exist.", path); + ret = ERR_FILE_OP_FAIL; + goto out; + } + + lock.l_type = F_WRLCK; + lock.l_start = 0; + lock.l_whence = SEEK_SET; + lock.l_len = 0; + lock_state = fcntl(fd, F_SETLK, &lock); + if (lock_state < 0) { + CU_DEBUG("Failed to lock file [%s], it may be locked by other.", path); + ret = ERR_FILE_LOCK_FAIL; + goto out; + } + + if (ftruncate(fd, 0) != 0) { + CU_DEBUG("file [%s] Unable to truncate it", path); + ret = ERR_FILE_OP_FAIL; + goto out; + } + + write_len = strlen(cont); + if (write_len > 0) { + lseek(fd, 0, SEEK_SET); + CU_DEBUG("writing file [%s] for %d bytes with offset 0," + " cont is :\n%s\n", + path, write_len, cont); + fop_ret = write(fd, cont, write_len); + } + ret = 1; + + out: + if (fd >= 0) { + if (lock_state >= 0) { + lock.l_type = F_UNLCK; + fcntl(fd, F_SETLK, &lock); + } + close(fd); + } + return ret; +} + +int configure_file_remove(const char *path) +{ + int fd_ret; + int ret = 0; + if (access(path, F_OK) == 0) { + CU_DEBUG("Deleting %s.", path); + fd_ret = remove(path); + if (fd_ret != 0) { + CU_DEBUG("failed to remove %s.", path); + ret = ERR_FILE_OP_FAIL; + goto out; + } + } + + ret = 1; + out: + return ret; +} + +FILE *pipe_excute_command_type_read(char *cmd, const int buf_size, + const char *type, int *errno) +{ + FILE *stream = NULL; + char *suffix = PIPE_CMD_SUFFIX; + if ((strlen(cmd) + strlen(suffix)) >= buf_size) { + CU_DEBUG("cmd [%s] is too long to append the suffix", cmd); + *errno = ERR_COMMAND_NO_READY; + goto out; + } + strcat(cmd, suffix); + CU_DEBUG("excuting readonly cmd [%s].", cmd); + stream = popen(cmd, type); + if (stream == NULL) { + CU_DEBUG("Failed to open pipe to run command"); + *errno = ERR_COMMAND_PIPE_ERR; + } + +out: + return stream; +} + +FILE *pipe_excute_command_type_write(char *cmd, const int buf_size, + const char *type, int *errno) +{ + FILE *stream = NULL; + char *suffix = PIPE_CMD_SUFFIX; + if ((strlen(cmd) + strlen(suffix)) >= buf_size) { + CU_DEBUG("cmd [%s] is too long to append the suffix", cmd); + *errno = ERR_COMMAND_NO_READY; + goto out; + } + strcat(cmd, suffix); + CU_DEBUG("excuting system modification cmd [%s].", cmd); + stream = popen(cmd, type); + if (stream == NULL) { + CU_DEBUG("Failed to open pipe to run command"); + *errno = ERR_COMMAND_PIPE_ERR; + } + usleep(10000); + +out: + return stream; +} + +int get_host_linux_version(void) +{ + FILE *stream = NULL; + char cmd[64]; + char buff[256]; + int linenum; + int errno; + + if (g_linux_version != LINUX_UNKNOWN) { + goto out; + } + + cmd[0] = '\0'; + strcat(cmd, "lsb_release -a"); + stream = pipe_excute_command_type_read(cmd, sizeof(cmd), "r", &errno); + if (stream == NULL) { + goto out; + } + + linenum = -1; + g_linux_version = LINUX_OTHER; + while (fgets(buff, 256, stream) != NULL) { + linenum++; + if (linenum == 0) { + if (NULL == strstr(buff, "LSB")) { + CU_DEBUG("ERR: unable to get linux distribution version."); + g_linux_version = LINUX_FAIL_TO_GET; + } + } + if ((NULL != strstr(buff, "Red Hat")) || + (NULL != strstr(buff, "RedHat"))) { + g_linux_version = LINUX_REDHAT; + break; + } + } + + out: + if (stream != NULL) { + pclose(stream); + } + return g_linux_version; +} + +char *translate_error_no(int errno) +{ + char *ret = NULL; + switch (errno) { + case ERR_REQUEST_NOT_SUPPORT: + ret = "request is not supported now"; + break; + + case ERR_COMMAND_NOT_SET: + ret = "command is not set."; + break; + case ERR_COMMAND_PIPE_ERR: + ret = "failed in creating pipe to execute the command."; + break; + case ERR_COMMAND_NOT_SUPPORT: + ret = "command is not found, check u environment."; + break; + case ERR_COMMAND_NO_PERMISSION: + ret = "not enough authority to execute the command."; + break; + case ERR_COMMAND_NO_READY: + ret = "failed to build up the command line, check your input, " + "maybe it is too long."; + break; + case ERR_COMMAND_PARAMETER_WRONG: + ret = "got invalid paramenter, check your input."; + break; + case ERR_COMMAND_EXECUTION: + ret = "error happened in the excution of command."; + break; + + case ERR_DEVICE_EXCEED_MAXNUM: + ret = "too many devices found or set, check the environment."; + break; + case ERR_DEVICE_EXIST: + ret = "device already exist, can not execute the command."; + break; + case ERR_DEVICE_NOT_EXIST: + ret = "device do not exist, can not execute the command."; + break; + case ERR_DEVICE_ALREADY_DONE: + ret = "the operation you want have been done before, " + "will not do it again."; + break; + case ERR_DEVICE_CONNECT_OTHER: + ret = "the device you want to connect have been connect to another" + " device, can't change it directly."; + break; + + case ERR_FILE_OP_FAIL: + ret = "failed in accessing the file."; + break; + case ERR_FILE_EMPTY: + ret = "the file it want is empty."; + break; + case ERR_FILE_TOO_LARGE: + ret = "the file it want is too large."; + break; + case ERR_FILE_CONT_TOO_LARGE: + ret = "the content it want to combine to file is too large."; + break; + case ERR_FILE_LOCK_FAIL: + ret = "failed in locking the file, " + "check if other process is using it."; + break; + + case ERR_PERSIST_NOT_REDHAT: + ret = "host is not a RedHat distribution, can't persist the " + "configuration, it would not take effect after host is " + "rebooted. Other version would be supported in the future. " + "If you are sure host is RedHat, make sure command " + "<lsb_release -a> could work."; + break; + + default: + ret = "internal error."; + break; + } + return ret; +} diff --git a/libxkutil/host_network_helper.h b/libxkutil/host_network_helper.h new file mode 100644 index 0000000..a232221 --- /dev/null +++ b/libxkutil/host_network_helper.h @@ -0,0 +1,192 @@ +/* + * Copyright IBM Corp. 2011 + * + * Authors: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + */ + + +#ifndef HOST_NETWORK_HELPER_H +#define HOST_NETWORK_HELPER_H + +#include <stdio.h> +#include <stdlib.h> +#include <arpa/inet.h> + +#include "host_network_basic.h" + +#ifdef TESTLIB +#include "TestDefines.h" +#else +#include <libcmpiutil/libcmpiutil.h> +#endif + +#define LINUX_FAIL_TO_GET -2 +#define LINUX_UNKNOWN -1 +#define LINUX_OTHER 0 +#define LINUX_REDHAT 1 + +#define CMD_DEBUG_LEVEL 2 + +/* macro functions */ +#define CMD_DEBUG(lvl, fmt, args...) do { \ + if (CMD_DEBUG_LEVEL && (lvl) <= CMD_DEBUG_LEVEL) { \ + debug_print(fmt, ##args); \ + } \ +} while (0) + +#define SAFE_MALLOC(p, size) \ +{ \ + (p) = malloc((size)); \ + if ((p) == NULL) { \ + CU_DEBUG("malloc failed."); \ + } \ +} + +#define SAFE_CALLOC(p, nmen, size) \ +{ \ + (p) = calloc((nmen), (size)); \ + if ((p) == NULL) { \ + CU_DEBUG("calloc failed."); \ + } \ +} + +#define SAFE_FREE(p) {free(p); (p) = NULL; } + + +/* Macro used to compare two char*, it would skip if ref is NULL. It would + only set the result when src != ref, user need to set the result to 1 by + default before use the macro. If not set, the it could be used to do + check multi times in "one fail all die" mode. Empty lines is the place + where result should be set to 1. */ +#define CHARS_COMPARE_BY_REF(src, ref, result) do { \ + if ((ref) == NULL) { \ + ; \ + } else { \ + if ((src) == NULL) { \ + (result) = 0; \ + } else { \ + if (0 == strcmp((src), (ref))) { \ + ; \ + } else { \ + (result) = 0; \ + } \ + } \ + } \ +} while (0) + +#define CHARS_COMPARE_CASE_BY_REF(src, ref, result) do { \ + if ((ref) == NULL) { \ + ; \ + } else { \ + if ((src) == NULL) { \ + (result) = 0; \ + } else { \ + if (0 == strcasecmp((src), (ref))) { \ + ; \ + } else { \ + (result) = 0; \ + } \ + } \ + } \ +} while (0) + +#define NUM_COMPARE_BY_REF(src, ref, result, default) do { \ + if ((ref) == (default)) { \ + ; \ + } else { \ + if ((src) == (ref)) { \ + ; \ + } else { \ + result = 0; \ + } \ + } \ +} while (0) + +#define CHARS_MERGE_NORMAL(dest, src) do { \ + if (((dest) == NULL) && ((src) != NULL)) { \ + (dest) = strdup((src)); \ + } \ +} while (0) + +#define CHARS_MERGE_MOVE(dest, src) do { \ + if (((dest) == NULL) && ((src) != NULL)) { \ + (dest) = (src); \ + (src) = NULL; \ + } \ +} while (0) + +#define NUM_MERGE(dest, src, default) do { \ + if ((dest) == (default)) { \ + (dest) = (src); \ + } \ +} while (0) + +/* this macro may cause "p" to be excuted twice if it is a function */ +#define SAFE_STRDUP(p) (p) == NULL ? NULL : strdup(p); + +/* this macro make sure "src" to be excuted once if it is function, so it is + safe for functions that have state logged, such as "strtok" */ +#define SAFE_STRDUP_WITH_FUNC(dest, src, iter) do { \ + (iter) = (src); \ + if ((iter) == NULL) { \ + (dest) = NULL; \ + } else { \ + (dest) = strdup((iter)); \ + } \ +} while (0) + +#define SAFE_PSTR_ARRAY_DUP(ppdest, dest_num, ppsrc, src_num, iter) do { \ + (dest_num) = (src_num); \ + (ppdest) = NULL; \ + if (((ppsrc) != NULL) && ((src_num) > 0)) { \ + SAFE_CALLOC((ppdest), (src_num), sizeof(char *)); \ + (iter) = 0; \ + while ((iter) < (src_num)) { \ + *((ppdest)+(iter)) = SAFE_STRDUP(*((ppsrc)+(iter))); \ + (iter)++; \ + } \ + } \ +} while (0) + +/* functions */ +/* this function convert ip mask "24" in "192.1.0.9/24" to real mask num as + 255.255.255.0 */ +int netmask_easy_to_inaddr(struct in_addr *paddr, const char *pmask); + +/* this function would sort the pqos and check its values. */ +int vlan_8021q_qos_check_valid(VLAN_Qos_8021q *pqos); + +/* converting qos string of 802.1.Q, it should be as "0:0 1:0 2:0" */ +int vlan_8021q_qos_str_to_num(VLAN_Qos_8021q *pqos, const char *str); +int vlan_8021q_qos_num_to_str(char **str, const VLAN_Qos_8021q *pqos); + +/* following functions would return FILE popened, so it need pclose later, + cmd would be appended so it must be writable. */ +FILE *pipe_excute_command_type_read(char *cmd, const int buf_size, + const char *type, int *errno); +FILE *pipe_excute_command_type_write(char *cmd, const int buf_size, + const char *type, int *errno); + +/* following functions would return string by malloc, so it need free later */ +char *strtok_onetime(const char *str, const char *delim); +char *combine_file_name(const char *prefix, const char *name); + +/* write the configuration file */ +int configure_file_update(const char *path, const char *cont); +/* remove the configuration file */ +int configure_file_remove(const char *path); +/* replace one attribute, the file have format with one line for one propety */ +int configure_file_replace_attr(const char *path, const char *prefix, + const char *prop); + +int get_host_linux_version(void); + +char *translate_error_no(int errno); + +#endif -- 1.7.6

于 2011-12-24 4:18, Chip Vincent 写道: No, just a custom to use negative number indicating errors. Is that bad? Tried some version, it seems the output was almost the same, but persisting of configuration was linux distribution depending. -- Best Regards Wayne Xia mail:xiawenc@linux.vnet.ibm.com tel:86-010-82450803

this file use tools ip, brctl, ifconfig to provide the functionalities. Signed-off-by: Wayne Xia <xiawenc(a)linux.vnet.ibm.com&gt; --- libxkutil/host_network_implement_cmdline.c | 2002 ++++++++++++++++++++++++++++ libxkutil/host_network_implement_cmdline.h | 55 + 2 files changed, 2057 insertions(+), 0 deletions(-) create mode 100644 libxkutil/host_network_implement_cmdline.c create mode 100644 libxkutil/host_network_implement_cmdline.h diff --git a/libxkutil/host_network_implement_cmdline.c b/libxkutil/host_network_implement_cmdline.c new file mode 100644 index 0000000..fc9226b --- /dev/null +++ b/libxkutil/host_network_implement_cmdline.c @@ -0,0 +1,2002 @@ +/* + * Copyright IBM Corp. 2011 + * + * Authors: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * Note: + * the string example used below is all reformed to avoid code format check + * errors, so it just says the command output format as a reference. + * char "tab" is changed to "space", tailing space is removed, lines over 80 + * characters was foldered. + */ + +#include <string.h> +#include <stdlib.h> +#include <unistd.h> + +#include "host_network_implement_cmdline.h" +#include "host_network_helper.h" +#include "host_network_error.h" + +/* macro defines */ +#define COMMAND_NOTFOUND_STRING "command not found" +#define COMMAND_NOPERMISSION_STRING "Permission denied" +#define BRCTL_EXPECT_STRING "bridge name" +#define VLAN8021Q_CAT_ETH_EXPECT_STRING "REORDER_HDR:" +#define VLAN8021Q_CONFIG_EXPECT_STRING "VLAN Dev name" + +#define IFACE_CONFIG_FILE_PREFIX_RH "/etc/sysconfig/network-scripts/ifcfg-" + +#define CONT_BUFF_SIZE 256 + +/* the bridge seems have 0 value when it is up , so adjust the value, + and found out which are physical cards */ +static int host_iface_adjust(EthIface *piface) +{ + if (piface->eth_type == ETH_TYPE_BRIDGE) { + if (piface->run_prop.state == ETH_TYPE_UNKNOWN) { + piface->run_prop.state = ETH_STATE_UP; + } + } + if (1 == eth_iface_filter_peths(piface, NULL)) { + piface->eth_type = ETH_TYPE_PHYSICAL; + } + return 1; +} + +int host_ifacelist_is_present_cmd(EthIfacesList *plist, int *retvalues, + int compare_name_only) +{ + EthIfacesList ifaces_list; + int retvalue; + int i, j; + eth_iface_filter_func func; + + eth_ifaceslist_init(&ifaces_list); + retvalue = get_host_eth_ifaces_ip_addr(ifaces_list.pifaces, + &ifaces_list.count, MAX_IFACE_NUM, NULL, NULL); + if (retvalue != 1) { + goto out; + } + + if (compare_name_only == 0) { + func = eth_iface_filter_by_refname; + } else { + func = eth_iface_filter_by_ref; + } + i = 0; + while (i < plist->count) { + retvalues[i] = 0; + j = 0; + while (j < ifaces_list.count) { + if (1 == func(ifaces_list.pifaces[j], plist->pifaces[i])) { + retvalues[i] = 1; + break; + } + j++; + } + i++; + } + + out: + eth_ifaceslist_uninit(&ifaces_list); + return retvalue; +} + +static int host_iface_is_present_cmd(EthIface *piface) +{ + EthIface *pifaces[1]; + int retvalue; + int ifaces_num; + int exist_flag = 0; + EthIface ref; + eth_iface_init(&ref); + ref.name = SAFE_STRDUP(piface->name); + + retvalue = get_host_eth_ifaces_ip_addr(pifaces, &ifaces_num, + 1, eth_iface_filter_by_ref, &ref); + + if ((retvalue == 1) && (ifaces_num == 1)) { + exist_flag = 1; + } + eth_ifaces_clear(pifaces, ifaces_num); + eth_iface_uninit(&ref); + return exist_flag; +} + +static int host_br_is_present_cmd(EthIface *piface) +{ + EthIface *pifaces[1]; + int retvalue; + int ifaces_num; + int exist_flag = 0; + EthIface ref; + eth_iface_init(&ref); + ref.name = SAFE_STRDUP(piface->name); + + retvalue = get_host_eth_ifaces_brctl(pifaces, &ifaces_num, + 1, eth_iface_filter_by_ref, &ref); + + if ((retvalue == 1) && (ifaces_num == 1)) { + exist_flag = 1; + } + eth_ifaces_clear(pifaces, ifaces_num); + eth_iface_uninit(&ref); + return exist_flag; +} + +/* 1: the bridge have the iface attached + 2: the iface is attached to other bridge + other: not found */ +int host_br_have_iface_attached_cmd(EthIface *pbr, EthIface *piface, + EthIface **ppbr_result) +{ + int ret = 0; + BR_Prop *pbr_prop; + EthIface **pifaces = NULL; + int retvalue; + int ifaces_num = 0; + int i, j; + + if (0 == host_iface_is_present_cmd(piface)) { + return -1; + } + + SAFE_CALLOC(pifaces, MAX_IFACE_NUM, sizeof(EthIface *)); + + retvalue = get_host_eth_ifaces_brctl(pifaces, &ifaces_num, + MAX_IFACE_NUM, NULL, NULL); + + if ((retvalue == 1) && (ifaces_num > 0)) { + i = 0; + while (i < ifaces_num) { + if (0 == strcmp(pbr->name, pifaces[i]->name)) { + /* found the bridge */ + pbr_prop = pifaces[i]->pbr_prop; + j = 0; + while (j < pbr_prop->port_num) { + if (0 == strcmp(piface->name, pbr_prop->port_names[j])) { + ret = 1; + break; + } + j++; + } + if (ppbr_result != NULL) { + *ppbr_result = pifaces[i]; + pifaces[i] = NULL; + } + goto out; + } else { + /* not the bridge */ + pbr_prop = pifaces[i]->pbr_prop; + j = 0; + while (j < pbr_prop->port_num) { + if (0 == strcmp(piface->name, pbr_prop->port_names[j])) { + ret = 2; + goto out; + } + j++; + } + } + i++; + } + } else { + ret = -2; + } + + out: + if (pifaces != NULL) { + eth_ifaces_clear(pifaces, ifaces_num); + SAFE_FREE(pifaces); + } + return ret; +} + +static int host_vlan_is_present_8021q_cmd(EthIface *piface) +{ + EthIface *pifaces[1]; + int retvalue; + int ifaces_num; + int exist_flag = 0; + EthIface ref; + eth_iface_init(&ref); + ref.name = SAFE_STRDUP(piface->name); + + retvalue = get_host_eth_ifaces_cat_vlan_config(pifaces, &ifaces_num, + 1, eth_iface_filter_by_ref, &ref); + + if ((retvalue == 1) && (ifaces_num == 1)) { + exist_flag = 1; + } + eth_ifaces_clear(pifaces, ifaces_num); + eth_iface_uninit(&ref); + return exist_flag; +} + +int get_host_eth_ifaces_ip_addr(EthIface **ppifaces, int *retnum, int maxnum, + eth_iface_filter_func filter_func, void *filter_opaque) +{ + FILE *stream = NULL; + char cmd[64]; + char *buff = NULL; + int ret = 0; + EthIface tcard, **ppdest; + char *temp, *temp2, *temp3; + char *search_str; + int count = 0; + int filter_ret; + int line_count = 0; + struct in_addr addr; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + cmd[0] = '\0'; + strcat(cmd, "ip addr"); + stream = pipe_excute_command_type_read(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + eth_iface_init(&tcard); + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CMD_DEBUG(3, "%s", buff); + if (line_count == 0) { + if (NULL != strstr(buff, COMMAND_NOTFOUND_STRING)) { + CU_DEBUG("Got [%s] with command [%s], check u environment.\n", + COMMAND_NOTFOUND_STRING, cmd); + ret = ERR_COMMAND_NOT_SUPPORT; + goto out; + } + if (NULL != strstr(buff, COMMAND_NOPERMISSION_STRING)) { + CU_DEBUG("Got [%s] with command [%s], check u environment.\n", + COMMAND_NOPERMISSION_STRING, cmd); + ret = ERR_COMMAND_NO_PERMISSION; + goto out; + } + } + line_count++; + /*analysis the output, example is something like following: + +3: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc \ +pfifo_fast run_prop.state UP qlen 1000 + link/ether 08:00:27:e3:13:f8 brd ff:ff:ff:ff:ff:ff + inet 10.0.3.15/24 brd 10.0.3.255 scope global eth1 + inet6 fe80::a00:27ff:fee3:13f8/64 scope link + valid_lft forever preferred_lft forever +4: eth1.5@eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc \ +noqueue run_prop.state UP + link/ether 08:00:27:e3:13:f8 brd ff:ff:ff:ff:ff:ff + inet6 fe80::a00:27ff:fee3:13f8/64 scope link + valid_lft forever preferred_lft forever + + */ + /* for line that divide two devices */ + if ((0 != strncmp(buff, " ", 1)) && (0 != strncmp(buff, "\t", 1))) { + if (tcard.name != NULL) { + /* device found, copy the content */ + filter_ret = 1; + if (filter_func != NULL) { + filter_ret = filter_func(&tcard, filter_opaque); + } + /* found a device match the requirement, put it to the list */ + if (filter_ret == 1) { + if (count >= maxnum) { + ret = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + ppdest = ppifaces + count; + SAFE_MALLOC(*ppdest, sizeof(EthIface)); + eth_iface_dup(*ppdest, &tcard); + count++; + } + eth_iface_uninit(&tcard); + eth_iface_init(&tcard); + } + /* discovery names */ + search_str = ": "; + temp = strstr(buff, search_str); + if (temp != NULL) { + temp += strlen(search_str); + temp2 = strstr(temp, search_str); + if (temp2 != NULL) { + /* found string that contains names, + start point is temp, end point is temp2 */ + search_str = "@"; + temp3 = strstr(temp, search_str); + if ((temp3 != NULL) && (temp3 < temp2)) { + /* have parent dev, temp3 holds the division */ + SAFE_FREE(tcard.dep_ifname); + tcard.dep_ifname = strndup(temp3+1, temp2-temp3-1); + SAFE_FREE(tcard.name); + tcard.name = strndup(temp, temp3-temp); + } else { + SAFE_FREE(tcard.name); + tcard.name = strndup(temp, temp2-temp); + } + } + } + /* discovery run_prop.state */ + search_str = "state "; + temp = strstr(buff, search_str); + if (temp != NULL) { + temp += strlen(search_str); + if (0 == strncmp(temp, "UP", 2)) { + tcard.run_prop.state = ETH_STATE_UP; + } else if (0 == strncmp(temp, "DOWN", 4)) { + tcard.run_prop.state = ETH_STATE_DOWN; + } else if (0 == strncmp(temp, "UNKNOWN", 7)) { + tcard.run_prop.state = ETH_STATE_UNKNOWN; + } + } + continue; + } + /* for lines that saying other properties */ + /* dicovering mac */ + search_str = "ether "; + temp = strstr(buff, search_str); + if (temp != NULL) { + temp += strlen(search_str); + SAFE_FREE(tcard.mac); + tcard.mac = strtok_onetime(temp, " "); + } + /* dicovering ip and ip_mask for ipv4 */ + search_str = "inet "; + temp = strstr(buff, search_str); + if (temp != NULL) { + temp += strlen(search_str); + temp2 = strstr(temp, "/"); + if (temp2 != NULL) { + /* found the ip and mask, temp2 holds the division */ + SAFE_FREE(tcard.ipv4_prop.ip); + tcard.ipv4_prop.ip = strndup(temp, temp2-temp); + if (1 == netmask_easy_to_inaddr(&addr, temp2+1)) { + SAFE_FREE(tcard.ipv4_prop.ip_mask); + SAFE_MALLOC(tcard.ipv4_prop.ip_mask, INET_ADDRSTRLEN); + tcard.ipv4_prop.ip_mask[INET_ADDRSTRLEN-1] = '\0'; + if (NULL == inet_ntop(AF_INET, &addr, + tcard.ipv4_prop.ip_mask, INET_ADDRSTRLEN)) { + SAFE_FREE(tcard.ipv4_prop.ip_mask); + } + } + } + } + } + + /* because the output have no indication about end, so need to try add + the latest device found to the list */ + if (tcard.name != NULL) { + /* device found, copy the content */ + filter_ret = 1; + if (filter_func != NULL) { + filter_ret = filter_func(&tcard, filter_opaque); + } + /* found a device match the requirement, put it to the list */ + if (filter_ret == 1) { + if (count >= maxnum) { + ret = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + ppdest = ppifaces + count; + SAFE_MALLOC(*ppdest, sizeof(EthIface)); + eth_iface_dup(*ppdest, &tcard); + count++; + } + } + + ret = 1; + + out: + if (stream != NULL) { + pclose(stream); + } + eth_iface_uninit(&tcard); + SAFE_FREE(buff); + *retnum = count; + + return ret; +} + +int get_host_eth_ifaces_ifconfig(EthIface **ppifaces, int *retnum, int maxnum, + eth_iface_filter_func filter_func, void *filter_opaque) +{ + FILE *stream = NULL; + char cmd[64]; + char *buff = NULL; + int ret = 0; + EthIface tcard, **ppdest; + char *temp, *temp2; + char *search_str; + int count = 0; + int filter_ret; + int line_count = 0; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + cmd[0] = '\0'; + strcat(cmd, "ifconfig"); + stream = pipe_excute_command_type_read(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + eth_iface_init(&tcard); + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CMD_DEBUG(3, "%s", buff); + if (line_count == 0) { + if (NULL != strstr(buff, COMMAND_NOTFOUND_STRING)) { + CU_DEBUG("Got [%s] with command [%s], check u environment.\n", + COMMAND_NOTFOUND_STRING, cmd); + ret = ERR_COMMAND_NOT_SUPPORT; + goto out; + } + if (NULL != strstr(buff, COMMAND_NOPERMISSION_STRING)) { + CU_DEBUG("Got [%s] with command [%s], check u environment.\n", + COMMAND_NOPERMISSION_STRING, cmd); + ret = ERR_COMMAND_NO_PERMISSION; + goto out; + } + } + line_count++; + /*analysis the output, example is something like following: + +eth1 Link encap:Ethernet HWaddr 08:00:27:E3:13:F8 + inet addr:10.0.3.15 Bcast:10.0.3.255 Mask:255.255.255.0 + inet6 addr: fe80::a00:27ff:fee3:13f8/64 Scope:Link + UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 + RX packets:236 errors:0 dropped:0 overruns:0 frame:0 + TX packets:346 errors:0 dropped:0 overruns:0 carrier:0 + collisions:0 txqueuelen:1000 + RX bytes:100464 (98.1 KiB) TX bytes:30721 (30.0 KiB) + +eth1.5 Link encap:Ethernet HWaddr 08:00:27:E3:13:F8 + ... + + */ + /* for line that divide two devices */ + if (0 == strncmp(buff, "\n", 1)) { + /* device found, copy the content */ + filter_ret = 1; + if (filter_func != NULL) { + filter_ret = filter_func(&tcard, filter_opaque); + } + /* found a device match the requirement, put it to the list */ + if (filter_ret == 1) { + if (count >= maxnum) { + ret = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + ppdest = ppifaces + count; + SAFE_MALLOC(*ppdest, sizeof(EthIface)); + eth_iface_dup(*ppdest, &tcard); + count++; + } + eth_iface_uninit(&tcard); + eth_iface_init(&tcard); + continue; + } + /* for line that saying other properties */ + if (0 == strncmp(buff, " ", 1)) { + /* discovery ip for ip v4 */ + search_str = "inet addr:"; + temp = strstr(buff, search_str); + if (temp != NULL) { + temp += strlen(search_str); + SAFE_FREE(tcard.ipv4_prop.ip); + tcard.ipv4_prop.ip = strtok_onetime(temp, " "); + /* discovery ip mask*/ + search_str = "Mask"; + temp = strstr(buff, search_str); + if (temp != NULL) { + temp += strlen(search_str); + SAFE_FREE(tcard.ipv4_prop.ip_mask); + tcard.ipv4_prop.ip_mask = strtok_onetime(temp, " "); + if (tcard.ipv4_prop.ip_mask == NULL) { + tcard.ipv4_prop.ip_mask = strtok_onetime(temp, "\n"); + } + } + } + + /* discovery RX and TX bytes */ + search_str = "RX bytes:"; + temp = strstr(buff, search_str); + if (temp != NULL) { + temp += strlen(search_str); + tcard.run_prop.rx_bytes = strtoll(temp, &temp2, 10); + if (temp == temp2) { + /*failed to get the value, restore it to default */ + tcard.run_prop.rx_bytes = NUM_NOT_GOT; + } + search_str = "TX bytes:"; + temp = strstr(buff, search_str); + if (temp != NULL) { + temp += strlen(search_str); + tcard.run_prop.tx_bytes = strtoll(temp, &temp2, 10); + if (temp == temp2) { + /*failed to get the value, restore it to default */ + tcard.run_prop.tx_bytes = NUM_NOT_GOT; + } + } + } + continue; + } + /* for lines that saying the device with title */ + /* discovery name */ + SAFE_FREE(tcard.name); + tcard.name = strtok_onetime(buff, " "); + /* discovery mac */ + search_str = "HWaddr "; + temp = strstr(buff, search_str); + if (temp != NULL) { + temp += strlen(search_str); + SAFE_FREE(tcard.mac); + tcard.mac = strtok_onetime(temp, " "); + if (tcard.mac == NULL) { + tcard.mac = strtok_onetime(temp, "\n"); + } + } + /* discovery type */ + search_str = "Local Loopback"; + temp = strstr(buff, search_str); + if (temp != NULL) { + tcard.eth_type = ETH_TYPE_LOOPBACK; + } + continue; + } + + ret = 1; + + out: + if (stream != NULL) { + pclose(stream); + } + eth_iface_uninit(&tcard); + SAFE_FREE(buff); + *retnum = count; + + return ret; +} + +int get_host_eth_ifaces_brctl(EthIface **ppifaces, int *retnum, int maxnum, + eth_iface_filter_func filter_func, void *filter_opaque) +{ + FILE *stream = NULL; + char cmd[64]; + char *buff = NULL; + int ret = 0; + EthIface tcard, **ppdest; + BR_Prop tbr; + char *last = NULL, *iter; + char *char_stp = NULL; + char *port_name = NULL; + int count = 0; + int filter_ret; + int line_count = 0; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + cmd[0] = '\0'; + strcat(cmd, "brctl show"); + stream = pipe_excute_command_type_read(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + eth_iface_init(&tcard); + br_prop_init(&tbr); + tbr.port_num = 0; + port_name = NULL; + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CMD_DEBUG(3, "%s", buff); +/* output string should be something like following + +bridge name bridge id STP enabled interfaces +testbr 8000.000000000000 no +virbr0 8000.5254004ac14c yes virbr0-nic + vnet0 +virbr3 8000.5254004ac16c yes virbr3-nic +... +*/ + if (line_count == 0) { + if (NULL == strstr(buff, BRCTL_EXPECT_STRING)) { + CU_DEBUG("[%s] not found with command [%s]," + "check u environment.\n", + BRCTL_EXPECT_STRING, cmd); + ret = ERR_COMMAND_NOT_SUPPORT; + goto out; + } + line_count++; + continue; + } + if ((buff[0] == ' ') || (buff[0] == '\t')) { + /* the line saying ifaces it attached */ + port_name = strtok_r(buff, "\n", &last); + if (port_name == NULL) { + CU_DEBUG("command [%s] did not output as expected.", cmd); + continue; + } + port_name = strtok_r(buff, "\t", &last); + if (port_name == NULL) { + CU_DEBUG("command [%s] did not output as expected.", cmd); + continue; + } + /* adding the port */ + if (tbr.port_names == NULL) { + SAFE_CALLOC(tbr.port_names, MAX_IFACE_NUM, sizeof(char *)); + tbr.port_num = 0; + } + if (tbr.port_num >= MAX_IFACE_NUM) { + CU_DEBUG("bridge [%s] have too much eth attached!", + tcard.name); + ret = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + tbr.port_names[tbr.port_num] = SAFE_STRDUP(port_name); + tbr.port_num++; + } else { + /* the line saying a new bridge */ + if (tcard.name != NULL) { + /* have a valid iface, so add it to the list */ + tcard.pbr_prop = &tbr; + tcard.eth_type = ETH_TYPE_BRIDGE; + filter_ret = 1; + if (filter_func != NULL) { + filter_ret = filter_func(&tcard, filter_opaque); + } + /* found a device match the requirement, put it to the list */ + if (filter_ret == 1) { + if (count >= maxnum) { + CU_DEBUG("too much bridge found, max is %d", + maxnum); + ret = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + ppdest = ppifaces + count; + SAFE_MALLOC(*ppdest, sizeof(EthIface)); + eth_iface_dup(*ppdest, &tcard); + count++; + } + tcard.pbr_prop = NULL; + eth_iface_uninit(&tcard); + eth_iface_init(&tcard); + br_prop_uninit(&tbr); + br_prop_init(&tbr); + tbr.port_num = 0; + } + SAFE_STRDUP_WITH_FUNC(tcard.name, + strtok_r(buff, "\t", &last), iter); + SAFE_STRDUP_WITH_FUNC(tbr.bridge_id, + strtok_r(NULL, "\t", &last), iter); + char_stp = strtok_r(NULL, "\t", &last); + if (char_stp != NULL) { + if (0 == strcmp(char_stp, "yes")) { + tbr.STP = 1; + } else if (0 == strcmp(char_stp, "no")) { + tbr.STP = 0; + } + } + if (last != NULL) { + if ((*last == '\0') || (*(last+1) == '\0')) { + CU_DEBUG("command [%s] did not output as expected," + "string left [%s].", cmd, last); + continue; + } + last++; + } + if (*last == '\t') { + port_name = NULL; + } else { + port_name = strtok_r(NULL, "\n", &last); + if (port_name != NULL) { + /* adding the port */ + if (tbr.port_names == NULL) { + SAFE_CALLOC(tbr.port_names, + MAX_IFACE_NUM, sizeof(char *)); + tbr.port_num = 0; + } + if (tbr.port_num >= MAX_IFACE_NUM) { + CU_DEBUG("bridge [%s] have too much eth attached!", + tcard.name); + ret = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + tbr.port_names[tbr.port_num] = SAFE_STRDUP(port_name); + tbr.port_num++; + } + } + } + line_count++; + } + + if (tcard.name != NULL) { + /* have a valid iface, so add it to the list */ + tcard.pbr_prop = &tbr; + tcard.eth_type = ETH_TYPE_BRIDGE; + filter_ret = 1; + if (filter_func != NULL) { + filter_ret = filter_func(&tcard, filter_opaque); + } + /* found a device match the requirement, put it to the list */ + if (filter_ret == 1) { + if (count >= maxnum) { + CU_DEBUG("too much bridge found, max is %d", + maxnum); + ret = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + ppdest = ppifaces + count; + SAFE_MALLOC(*ppdest, sizeof(EthIface)); + eth_iface_dup(*ppdest, &tcard); + count++; + } + tcard.pbr_prop = NULL; + } + + ret = 1; + + out: + if (stream != NULL) { + pclose(stream); + } + br_prop_uninit(&tbr); + eth_iface_uninit(&tcard); + SAFE_FREE(buff); + *retnum = count; + + return ret; +} + +static int get_iface_cat_vlan_one_eth_8021q(EthIface *piface) +{ + FILE *stream = NULL; + char cmd[64]; + char *cmd_prefix = "cat /proc/net/vlan/"; + char *buff = NULL; + VLAN_Prop_8021q *pprop_8021q; + char *last = NULL; + char *char_temp = NULL; + char *search_str, *iter, *temp1, *temp2, *temp3, *qos; + int ret = 0; + int line_count = -1; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + if ((piface->name == NULL) || + ((strlen(piface->name)+strlen(cmd_prefix)) > (sizeof(cmd)-1))) { + CU_DEBUG("error in building up cmd line, name is %s.", piface->name); + ret = ERR_COMMAND_NO_READY; + goto out; + } + memcpy(cmd, cmd_prefix, strlen(cmd_prefix)+1); + strcat(cmd, piface->name); + + stream = pipe_excute_command_type_read(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + if (piface->pvlan_prop == NULL) { + SAFE_MALLOC(piface->pvlan_prop, sizeof(VLAN_Prop)); + vlan_prop_init(piface->pvlan_prop, VLAN_TYPE_802_1_Q); + } + if (piface->pvlan_prop->vlan_type != VLAN_TYPE_802_1_Q) { + ret = 0; + goto out; + } + pprop_8021q = &(piface->pvlan_prop->props.prop_8021q); + + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + line_count++; + CMD_DEBUG(3, "%s", buff); +/* output is expected some thing like following +eth1.7.7 VID: 7 REORDER_HDR: 1 dev->priv_flags: 1 + total frames received 0 + total bytes received 0 + Broadcast/Multicast Rcvd 0 + + total frames transmitted 0 + total bytes transmitted 0 + total headroom inc 0 + total encap on xmit 0 +Device: eth1.7 +INGRESS priority mappings: 0:0 1:0 2:0 3:0 4:0 5:0 6:0 7:0 + EGRESS priority mappings: +*/ + if (line_count == 0) { + if (NULL == strstr(buff, VLAN8021Q_CAT_ETH_EXPECT_STRING)) { + CU_DEBUG("[%s] not found with command [%s]," + "check u environment.\n", + VLAN8021Q_CAT_ETH_EXPECT_STRING, cmd); + ret = ERR_COMMAND_NOT_SUPPORT; + goto out; + } + } + search_str = "VID: "; + temp1 = strstr(buff, search_str); + if (temp1 != NULL) { + /* first line */ + temp1 += strlen(search_str); + search_str = "REORDER_HDR: "; + temp2 = strstr(buff, search_str); + if (temp2 != NULL) { + temp2 += strlen(search_str); + } + search_str = "priv_flags: "; + temp3 = strstr(buff, search_str); + if (temp3 != NULL) { + temp3 += strlen(search_str); + } + if ((temp2 != NULL) && (temp3 != NULL)) { + char_temp = strtok_r(temp1, " ", &last); + if (char_temp != NULL) { + pprop_8021q->vlan_id = strtol(char_temp, &iter, 10); + } + char_temp = strtok_r(temp2, " ", &last); + if (char_temp != NULL) { + pprop_8021q->reorder_hdr = strtol(char_temp, &iter, 10); + } + char_temp = strtok_r(temp3, " ", &last); + if (char_temp != NULL) { + pprop_8021q->priv_flag = strtol(char_temp, &iter, 10); + } + } + continue; + } + search_str = "total bytes received"; + temp1 = strstr(buff, search_str); + if (temp1 != NULL) { + temp1 += strlen(search_str); + char_temp = strtok_r(temp1, " ", &last); + if (char_temp != NULL) { + piface->run_prop.rx_bytes = strtoll(char_temp, &iter, 10); + } + continue; + } + search_str = "total bytes transmitted"; + temp1 = strstr(buff, search_str); + if (temp1 != NULL) { + temp1 += strlen(search_str); + char_temp = strtok_r(temp1, " ", &last); + if (char_temp != NULL) { + piface->run_prop.tx_bytes = strtoll(char_temp, &iter, 10); + } + continue; + } + search_str = "Device: "; + temp1 = strstr(buff, search_str); + if (temp1 != NULL) { + temp1 += strlen(search_str); + pprop_8021q->parent = strtok_onetime(temp1, " "); + if (pprop_8021q->parent == NULL) { + pprop_8021q->parent = strtok_onetime(temp1, "\n"); + } + continue; + } + search_str = "INGRESS priority mappings: "; + temp1 = strstr(buff, search_str); + if (temp1 != NULL) { + temp1 += strlen(search_str); + if (NULL != strstr(temp1, ":")) { + qos = strtok_onetime(temp1, "\n"); + if (qos != NULL) { + vlan_8021q_qos_str_to_num(&(pprop_8021q->ingress), qos); + SAFE_FREE(qos); + } + } + continue; + } + search_str = "EGRESS priority mappings: "; + temp1 = strstr(buff, search_str); + if (temp1 != NULL) { + temp1 += strlen(search_str); + if (NULL != strstr(temp1, ":")) { + qos = strtok_onetime(temp1, "\n"); + if (qos != NULL) { + vlan_8021q_qos_str_to_num(&(pprop_8021q->egress), qos); + SAFE_FREE(qos); + } + } + continue; + } + } + piface->eth_type = ETH_TYPE_VLAN; + ret = 1; + + out: + if (stream != NULL) { + pclose(stream); + } + SAFE_FREE(buff); + + return ret; +} + +int get_host_eth_ifaces_cat_vlan_config(EthIface **ppifaces, int *retnum, + int maxnum, eth_iface_filter_func filter_func, void *filter_opaque) +{ + FILE *stream = NULL; + char cmd[64]; + char *buff = NULL; + int ret = 0; + EthIface tcard, **ppdest; + VLAN_Prop tvlan; + int count = 0; + int filter_ret; + int line_count = -1; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + cmd[0] = '\0'; + strcat(cmd, "cat /proc/net/vlan/config"); + stream = pipe_excute_command_type_read(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + eth_iface_init(&tcard); + vlan_prop_init(&tvlan, VLAN_TYPE_802_1_Q); + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + line_count++; + CMD_DEBUG(3, "%s", buff); +/* output string should be something like following + +VLAN Dev name | VLAN ID +Name-Type: VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD +eth1.5 | 5 | eth1 +... +*/ + if (line_count == 0) { + if (NULL == strstr(buff, VLAN8021Q_CONFIG_EXPECT_STRING)) { + CU_DEBUG("[%s] not found with command [%s]," + "check u environment.\n", + VLAN8021Q_CONFIG_EXPECT_STRING, cmd); + ret = ERR_COMMAND_NOT_SUPPORT; + goto out; + } + continue; + } + if (line_count < 2) { + continue; + } + + /* the line saying a new bridge */ + if (tcard.name != NULL) { + /* have a valid iface, so add it to the list */ + tcard.pvlan_prop = &tvlan; + /* get additional information for this vlan */ + get_iface_cat_vlan_one_eth_8021q(&tcard); + /* filt it */ + filter_ret = 1; + if (filter_func != NULL) { + filter_ret = filter_func(&tcard, filter_opaque); + } + /* found a device match the requirement, put it to the list */ + if (filter_ret == 1) { + if (count >= maxnum) { + CU_DEBUG("too much vlan found, max is %d", + maxnum); + ret = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + ppdest = ppifaces + count; + SAFE_MALLOC(*ppdest, sizeof(EthIface)); + eth_iface_dup(*ppdest, &tcard); + count++; + } + tcard.pvlan_prop = NULL; + eth_iface_uninit(&tcard); + eth_iface_init(&tcard); + vlan_prop_uninit(&tvlan); + vlan_prop_init(&tvlan, VLAN_TYPE_802_1_Q); + } + /* get the name, other properties would be got in special file */ + tcard.name = strtok_onetime(buff, " "); + } + + if (tcard.name != NULL) { + /* have a valid iface, so add it to the list */ + tcard.pvlan_prop = &tvlan; + /* get additional information for this vlan */ + get_iface_cat_vlan_one_eth_8021q(&tcard); + /* filt it */ + filter_ret = 1; + if (filter_func != NULL) { + filter_ret = filter_func(&tcard, filter_opaque); + } + /* found a device match the requirement, put it to the list */ + if (filter_ret == 1) { + if (count >= maxnum) { + CU_DEBUG("too much vlan found, max is %d", + maxnum); + ret = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + ppdest = ppifaces + count; + SAFE_MALLOC(*ppdest, sizeof(EthIface)); + eth_iface_dup(*ppdest, &tcard); + count++; + } + tcard.pvlan_prop = NULL; + } + + ret = 1; + + out: + if (stream != NULL) { + pclose(stream); + } + vlan_prop_uninit(&tvlan); + eth_iface_uninit(&tcard); + SAFE_FREE(buff); + *retnum = count; + + return ret; +} + +int change_state_host_iface_cmd(EthIface *piface, int state) +{ + FILE *stream = NULL; + char cmd[64]; + char *cmd_prefix = "ifconfig "; + char *cmd_suffix = NULL; + char *buff = NULL; + int ret = 0; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + if (state == ETH_STATE_UP) { + cmd_suffix = " up"; + } else if (state == ETH_STATE_DOWN) { + cmd_suffix = " down"; + } + + if (cmd_suffix == NULL) { + CU_DEBUG("state change have not target state set."); + goto out; + } + + if (piface->name == NULL) { + ret = ERR_COMMAND_PARAMETER_WRONG; + CU_DEBUG("bridge name not set, direct goto out."); + goto out; + } + + if (0 == host_iface_is_present_cmd(piface)) { + CU_DEBUG("iface %s do not exist, can't change state.", piface->name); + ret = ERR_DEVICE_NOT_EXIST; + goto out; + } + + if ((strlen(cmd_prefix)+strlen(piface->name)+strlen(cmd_suffix)) + > (sizeof(cmd)-1)) { + CU_DEBUG("error in building up cmd line, name is %s.", piface->name); + ret = ERR_COMMAND_NO_READY; + goto out; + } + snprintf(cmd, sizeof(cmd), "%s%s%s", cmd_prefix, piface->name, cmd_suffix); + + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_NOT_SUPPORT; + goto out; + } + + ret = 1; + +out: + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + SAFE_FREE(buff); + + return ret; +} + +int add_host_br_cmd(EthIface *piface, int persist_flag) +{ + FILE *stream = NULL; + char cmd[64]; + char *cmd_prefix = "brctl addbr "; + char *path; + char *path_prefix = IFACE_CONFIG_FILE_PREFIX_RH; + char *cont, *c_stp; + char *buff = NULL; + int ret = 0; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + if (piface->name == NULL) { + ret = ERR_COMMAND_PARAMETER_WRONG; + CU_DEBUG("bridge name not set, direct goto out."); + goto out; + } + + if (1 == host_iface_is_present_cmd(piface)) { + CU_DEBUG("%s already exist, cann't create it as bridge.", piface->name); + ret = ERR_DEVICE_EXIST; + goto out; + } + + if ((strlen(cmd_prefix)+strlen(piface->name)) > (sizeof(cmd)-1)) { + CU_DEBUG("error in building up cmd line, name is %s.", piface->name); + ret = ERR_COMMAND_NO_READY; + goto out; + } + snprintf(cmd, sizeof(cmd), "%s%s", cmd_prefix, piface->name); + + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_EXECUTION; + goto out; + } + + if ((piface->pbr_prop != NULL) && + (piface->pbr_prop->STP == 1)) { + c_stp = "on"; + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + cmd_prefix = "brctl stp "; + if ((strlen(cmd_prefix)+strlen(piface->name) + +strlen(c_stp)) > (sizeof(cmd)-2)) { + CU_DEBUG("error in building up cmd line, name is %s.", + piface->name); + ret = ERR_COMMAND_NO_READY; + goto out; + } + snprintf(cmd, sizeof(cmd), "%s%s %s", cmd_prefix, piface->name, c_stp); + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_EXECUTION; + goto out; + } + } else { + c_stp = "off"; + } + + if (persist_flag == 1) { + if (LINUX_REDHAT != get_host_linux_version()) { + ret = ERR_PERSIST_NOT_REDHAT; + CU_DEBUG("Host is not a RedHat version, return is %d", + get_host_linux_version()); + goto out; + } + path = combine_file_name(path_prefix, piface->name); + SAFE_CALLOC(cont, 1024, sizeof(char)); + cont[1023] = 1; + snprintf(cont, 1024, + "DEVICE=%s\nTYPE=Bridge\nBOOTPROTO=dhcp\n" + "ONBOOT=yes\nDELAY=0\nSTP=%s\n", + piface->name, c_stp); + if (cont[1023] == '\0') { + CU_DEBUG("failed to build up contents, check the parameter."); + ret = ERR_FILE_CONT_TOO_LARGE; + SAFE_FREE(path); + SAFE_FREE(cont); + goto out; + } + ret = configure_file_update(path, cont); + SAFE_FREE(path); + SAFE_FREE(cont); + if (ret != 1) { + goto out; + } + + } + ret = 1; + +out: + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + SAFE_FREE(buff); + + return ret; +} + +int del_host_br_cmd(EthIface *piface, int persist_flag) +{ + FILE *stream = NULL; + char cmd[64]; + char *cmd_prefix = "brctl delbr "; + char *path; + char *path_prefix = IFACE_CONFIG_FILE_PREFIX_RH; + char *buff = NULL; + int ret = 0; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + if (piface->name == NULL) { + ret = ERR_COMMAND_PARAMETER_WRONG; + CU_DEBUG("bridge name not set, direct goto out."); + goto out; + } + + if (persist_flag == 1) { + if (LINUX_REDHAT != get_host_linux_version()) { + ret = ERR_PERSIST_NOT_REDHAT; + CU_DEBUG("Host is not a RedHat version, return is %d", + get_host_linux_version()); + goto out; + } + path = combine_file_name(path_prefix, piface->name); + ret = configure_file_remove(path); + SAFE_FREE(path); + if (ret != 1) { + goto out; + } + } + + if (0 == host_br_is_present_cmd(piface)) { + CU_DEBUG("bridge %s do not exist, can't delete it.", piface->name); + ret = ERR_DEVICE_NOT_EXIST; + goto out; + } + + if ((strlen(cmd_prefix)+strlen(piface->name)) > (sizeof(cmd)-1)) { + CU_DEBUG("error in building up cmd line, name is %s.", piface->name); + ret = ERR_COMMAND_NO_READY; + goto out; + } + snprintf(cmd, sizeof(cmd), "%s%s", cmd_prefix, piface->name); + + /* bring down the iface */ + change_state_host_iface_cmd(piface, ETH_STATE_DOWN); + + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_EXECUTION; + goto out; + } + + ret = 1; + +out: + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + SAFE_FREE(buff); + + return ret; +} + +int mod_host_br_cmd(EthIface *piface, int persist_flag) +{ + FILE *stream = NULL; + char cmd[64]; + char *cmd_prefix = "brctl stp "; + char *path; + char *path_prefix = IFACE_CONFIG_FILE_PREFIX_RH; + char *c_stp; + char *buff = NULL; + int ret = 0; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + if (piface->name == NULL) { + ret = ERR_COMMAND_PARAMETER_WRONG; + CU_DEBUG("bridge name not set, direct goto out."); + goto out; + } + + if (0 == host_br_is_present_cmd(piface)) { + CU_DEBUG("bridge %s do not exist, cann't modify it.", piface->name); + ret = ERR_DEVICE_EXIST; + goto out; + } + + if ((piface->pbr_prop != NULL) && + (piface->pbr_prop->STP == 1)) { + c_stp = "on"; + } else { + c_stp = "off"; + } + + if ((strlen(cmd_prefix)+strlen(piface->name) + +strlen(c_stp)) > (sizeof(cmd)-2)) { + CU_DEBUG("error in building up cmd line, name is %s.", piface->name); + ret = ERR_COMMAND_NO_READY; + goto out; + } + snprintf(cmd, sizeof(cmd), "%s%s %s", cmd_prefix, piface->name, c_stp); + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_EXECUTION; + goto out; + } + + if (persist_flag == 1) { + if (LINUX_REDHAT != get_host_linux_version()) { + ret = ERR_PERSIST_NOT_REDHAT; + CU_DEBUG("Host is not a RedHat version, return is %d", + get_host_linux_version()); + goto out; + } + path = combine_file_name(path_prefix, piface->name); + ret = configure_file_replace_attr(path, "STP=", c_stp); + SAFE_FREE(path); + if (ret != 1) { + CU_DEBUG("error happened in persisting file."); + goto out; + } + } + ret = 1; + +out: + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + SAFE_FREE(buff); + + return ret; +} + +static int append_vlan_8021q_parameters(char *cmd, int cmd_size, + VLAN_Prop_8021q *p_8021q) +{ + char *reorder = NULL; + char *egress = NULL, *ingress = NULL; + char *cmd_prefix; + int ret = 0; + + if (p_8021q->reorder_hdr == 1) { + reorder = " reorder_hdr on"; + } else if (p_8021q->reorder_hdr == 0) { + reorder = " reorder_hdr off"; + } + if (reorder != NULL) { + if ((strlen(reorder)+strlen(cmd)) < (cmd_size-1)) { + strcat(cmd, reorder); + } else { + CU_DEBUG("cmd line too long, it is [%s]+[%s].", cmd, reorder); + ret = ERR_COMMAND_NO_READY; + goto out; + } + } + + vlan_8021q_qos_num_to_str(&ingress, &(p_8021q->ingress)); + if (ingress != NULL) { + cmd_prefix = " ingress-qos-map "; + if ((strlen(ingress)+strlen(cmd)+strlen(cmd_prefix)) < (cmd_size-1)) { + strcat(cmd, cmd_prefix); + strcat(cmd, ingress); + } else { + CU_DEBUG("cmd line too long, it is [%s]+[%s]+[%s].", + cmd, cmd_prefix, ingress); + ret = ERR_COMMAND_NO_READY; + goto out; + } + } + + vlan_8021q_qos_num_to_str(&egress, &(p_8021q->egress)); + if (egress != NULL) { + cmd_prefix = " egress-qos-map "; + if ((strlen(egress)+strlen(cmd)+strlen(cmd_prefix)) < (cmd_size-1)) { + strcat(cmd, cmd_prefix); + strcat(cmd, egress); + } else { + CU_DEBUG("cmd line too long, it is [%s]+[%s]+[%s].", + cmd, cmd_prefix, egress); + ret = ERR_COMMAND_NO_READY; + goto out; + } + } + + ret = 1; + + out: + SAFE_FREE(ingress); + SAFE_FREE(egress); + return ret; +} + +int add_host_vlan_8021q_cmd(EthIface *piface, int persist_flag) +{ + FILE *stream = NULL; + char cmd[192]; + char *path; + char *path_prefix = IFACE_CONFIG_FILE_PREFIX_RH; + char *cont; + char *buff = NULL; + int ret = 0; + int str_size; + EthIface iface; + VLAN_Prop_8021q *p_8021q; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + eth_iface_init(&iface); + if (piface->pvlan_prop == NULL) { + CU_DEBUG("pvlan_prop not set, direct goto out."); + goto out; + } + if (piface->pvlan_prop->vlan_type != VLAN_TYPE_802_1_Q) { + CU_DEBUG("not a 802.1.q vlan, direct goto out."); + goto out; + } + p_8021q = &(piface->pvlan_prop->props.prop_8021q); + if ((p_8021q->vlan_id < 1) || (p_8021q->vlan_id > 4095)) { + CU_DEBUG("vlan_id for 802.1.q must be 0-4095, " + "and 0 is kept by system, request is %d.", p_8021q->vlan_id); + goto out; + } + if ((p_8021q->parent == NULL)) { + CU_DEBUG("creation of vlan iface for 802.1.q need parent iface set"); + goto out; + } + iface.name = p_8021q->parent; + if (0 == host_iface_is_present_cmd(&iface)) { + CU_DEBUG("iface %s do not exist, cann't use it as parent iface.", + iface.name); + iface.name = NULL; + ret = ERR_DEVICE_NOT_EXIST; + goto out; + } + + /* restrict the iface name to ethx.x, so the name would be combined here */ + str_size = strlen(p_8021q->parent)+6; + SAFE_MALLOC(iface.name, str_size); + snprintf(iface.name, str_size, "%s.%d", + p_8021q->parent, p_8021q->vlan_id); + if (1 == host_iface_is_present_cmd(&iface)) { + CU_DEBUG("iface %s already exist, cann't create it as a 802.1.q vlan.", + iface.name); + ret = ERR_DEVICE_EXIST; + goto out; + } + + /* building up command line */ + cmd[sizeof(cmd)-1] = 1; + snprintf(cmd, sizeof(cmd), "ip link add link %s name %s type vlan id %d", + p_8021q->parent, iface.name, p_8021q->vlan_id); + if (cmd[sizeof(cmd)-1] == '\0') { + CU_DEBUG("cmd line too long, it is [%s].", cmd); + ret = ERR_COMMAND_NO_READY; + goto out; + } + + ret = append_vlan_8021q_parameters(cmd, sizeof(cmd), p_8021q); + if (ret != 1) { + goto out; + } + + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_EXECUTION; + goto out; + } + + if (persist_flag == 1) { + if (LINUX_REDHAT != get_host_linux_version()) { + ret = ERR_PERSIST_NOT_REDHAT; + CU_DEBUG("Host is not a RedHat version, return is %d", + get_host_linux_version()); + goto out; + } + path = combine_file_name(path_prefix, iface.name); + SAFE_CALLOC(cont, 1024, sizeof(char)); + cont[1023] = 1; + snprintf(cont, 1024, + "DEVICE=%s\nPEERDNS=yes\nVLAN=yes\n", iface.name); + if (cont[1023] == '\0') { + CU_DEBUG("failed to build up contents, check the parameter."); + ret = ERR_FILE_CONT_TOO_LARGE; + SAFE_FREE(path); + SAFE_FREE(cont); + goto out; + } + ret = configure_file_update(path, cont); + SAFE_FREE(path); + SAFE_FREE(cont); + if (ret != 1) { + goto out; + } + } + ret = 1; + +out: + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + eth_iface_uninit(&iface); + SAFE_FREE(buff); + + return ret; +} + +int del_host_vlan_8021q_cmd(EthIface *piface, int persist_flag) +{ + FILE *stream = NULL; + char cmd[128]; + char *path; + char *path_prefix = IFACE_CONFIG_FILE_PREFIX_RH; + char *buff = NULL; + int ret = 0; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + if (piface->name == NULL) { + CU_DEBUG("piface name was not set, direct goto out."); + ret = ERR_COMMAND_PARAMETER_WRONG; + goto out; + } + + if (persist_flag == 1) { + if (LINUX_REDHAT != get_host_linux_version()) { + ret = ERR_PERSIST_NOT_REDHAT; + CU_DEBUG("Host is not a RedHat version, return is %d", + get_host_linux_version()); + goto out; + } + path = combine_file_name(path_prefix, piface->name); + ret = configure_file_remove(path); + SAFE_FREE(path); + if (ret != 1) { + goto out; + } + } + + if (piface->pvlan_prop == NULL) { + CU_DEBUG("pvlan_prop not set, direct goto out."); + goto out; + } + if (piface->pvlan_prop->vlan_type != VLAN_TYPE_802_1_Q) { + CU_DEBUG("not a 802.1.q vlan, direct goto out."); + goto out; + } + + if (0 == host_vlan_is_present_8021q_cmd(piface)) { + CU_DEBUG("vlan %s do not exist, cann't delete it.", piface->name); + ret = ERR_DEVICE_EXIST; + goto out; + } + + /* building up command line */ + cmd[sizeof(cmd)-1] = 1; + snprintf(cmd, sizeof(cmd), "ip link del %s", piface->name); + if (cmd[sizeof(cmd)-1] == '\0') { + CU_DEBUG("cmd line too long, it is [%s].", cmd); + ret = ERR_COMMAND_NO_READY; + goto out; + } + + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + ret = ERR_COMMAND_PIPE_ERR; + goto out; + } + + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_EXECUTION; + goto out; + } + + ret = 1; + +out: + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + SAFE_FREE(buff); + + return ret; +} + +int mod_host_vlan_8021q_cmd(EthIface *piface, int persist_flag) +{ + FILE *stream = NULL; + char cmd[192]; + char *buff = NULL; + int ret = 0; + VLAN_Prop_8021q *p_8021q; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + if (piface->name == NULL) { + ret = ERR_COMMAND_PARAMETER_WRONG; + CU_DEBUG("piface name was not set, direct goto out."); + goto out; + } + if (piface->pvlan_prop == NULL) { + CU_DEBUG("pvlan_prop not set, direct goto out."); + goto out; + } + if (piface->pvlan_prop->vlan_type != VLAN_TYPE_802_1_Q) { + CU_DEBUG("not a 802.1.q vlan, direct goto out."); + goto out; + } + if (0 == host_vlan_is_present_8021q_cmd(piface)) { + CU_DEBUG("vlan %s do not exist, cann't modify it.", piface->name); + ret = ERR_DEVICE_EXIST; + goto out; + } + p_8021q = &(piface->pvlan_prop->props.prop_8021q); + + /* building up command line */ + cmd[sizeof(cmd)-1] = 1; + snprintf(cmd, sizeof(cmd), "ip link set %s type vlan", + piface->name); + if (cmd[sizeof(cmd)-1] == '\0') { + CU_DEBUG("cmd line too long, it is [%s].", cmd); + ret = ERR_COMMAND_NO_READY; + goto out; + } + + ret = append_vlan_8021q_parameters(cmd, sizeof(cmd), p_8021q); + if (ret != 1) { + goto out; + } + + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_EXECUTION; + goto out; + } + + if (persist_flag == 1) { + /* modification is logged by linux system itself in /proc/net/vlan */ + } + ret = 1; + +out: + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + SAFE_FREE(buff); + + return ret; +} + +int add_host_iface_to_br_cmd(EthIface *piface, EthIface *pbr, + int persist_flag) +{ + FILE *stream = NULL; + char cmd[64]; + char *buff = NULL; + int ret = 0; + int check_value; + char *path_prefix = IFACE_CONFIG_FILE_PREFIX_RH; + char *path; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + if ((piface->name == NULL) || (pbr->name == NULL)) { + ret = ERR_COMMAND_PARAMETER_WRONG; + CU_DEBUG("name was not set, direct goto out."); + goto out; + } + + check_value = host_br_have_iface_attached_cmd(pbr, piface, NULL); + if (check_value < 0) { + CU_DEBUG("iface %s or bridge %s do not exist, direct goto out.", + piface->name, pbr->name); + ret = ERR_DEVICE_NOT_EXIST; + goto out; + } else if (check_value == 1) { + CU_DEBUG("iface %s already attached to bridge %s, can't do it again.", + piface->name, pbr->name); + ret = ERR_DEVICE_ALREADY_DONE; + goto out; + } else if (check_value == 2) { + CU_DEBUG("iface %s is attached to another bridge, " + "can't direct change it.", + piface->name); + ret = ERR_DEVICE_CONNECT_OTHER; + goto out; + } + + /* building up command line */ + cmd[sizeof(cmd)-1] = 1; + snprintf(cmd, sizeof(cmd), "brctl addif %s %s", + pbr->name, piface->name); + if (cmd[sizeof(cmd)-1] == '\0') { + CU_DEBUG("cmd line too long, it is [%s].", cmd); + ret = ERR_COMMAND_NO_READY; + goto out; + } + + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_EXECUTION; + goto out; + } + + if (persist_flag == 1) { + /* if the configuration file do not exist, would not create it */ + if (LINUX_REDHAT != get_host_linux_version()) { + ret = ERR_PERSIST_NOT_REDHAT; + CU_DEBUG("Host is not a RedHat version, return is %d", + get_host_linux_version()); + goto out; + } + path = combine_file_name(path_prefix, piface->name); + ret = configure_file_replace_attr(path, "BRIDGE=", pbr->name); + SAFE_FREE(path); + if (ret != 1) { + CU_DEBUG("error happened in persisting file."); + goto out; + } + } + ret = 1; + +out: + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + SAFE_FREE(buff); + + return ret; +} + +int remove_host_iface_from_br_cmd(EthIface *piface, EthIface *pbr, + int persist_flag) +{ + FILE *stream = NULL; + char cmd[64]; + char *buff = NULL; + int ret = 0; + int check_value; + char *path_prefix = IFACE_CONFIG_FILE_PREFIX_RH; + char *path; + + SAFE_MALLOC(buff, CONT_BUFF_SIZE); + if ((piface->name == NULL) || (pbr->name == NULL)) { + ret = ERR_COMMAND_PARAMETER_WRONG; + CU_DEBUG("name was not set, direct goto out."); + goto out; + } + + check_value = host_br_have_iface_attached_cmd(pbr, piface, NULL); + if (check_value < 0) { + CU_DEBUG("iface %s or bridge %s do not exist, direct goto out.", + piface->name, pbr->name); + ret = ERR_DEVICE_NOT_EXIST; + goto out; + } else if (check_value == 0) { + CU_DEBUG("iface %s is not attached to bridge %s, can't remove it.", + piface->name, pbr->name); + ret = ERR_DEVICE_ALREADY_DONE; + goto out; + } else if (check_value == 2) { + CU_DEBUG("iface %s is attached to another device, can't remove it.", + piface->name); + ret = ERR_DEVICE_CONNECT_OTHER; + goto out; + } + + /* building up command line */ + cmd[sizeof(cmd)-1] = 1; + snprintf(cmd, sizeof(cmd), "brctl delif %s %s", + pbr->name, piface->name); + if (cmd[sizeof(cmd)-1] == '\0') { + CU_DEBUG("cmd line too long, it is [%s].", cmd); + ret = ERR_COMMAND_NO_READY; + goto out; + } + + stream = pipe_excute_command_type_write(cmd, sizeof(cmd), "r", &ret); + if (stream == NULL) { + goto out; + } + + while (fgets(buff, CONT_BUFF_SIZE, stream) != NULL) { + CU_DEBUG("get exception: %s", buff); + ret = ERR_COMMAND_EXECUTION; + goto out; + } + + if (persist_flag == 1) { + /* if the configuration file do not exist, would not create it */ + if (LINUX_REDHAT != get_host_linux_version()) { + ret = ERR_PERSIST_NOT_REDHAT; + CU_DEBUG("Host is not a RedHat version, return is %d", + get_host_linux_version()); + goto out; + } + path = combine_file_name(path_prefix, piface->name); + ret = configure_file_replace_attr(path, "BRIDGE=", NULL); + SAFE_FREE(path); + if (ret != 1) { + CU_DEBUG("error happened in persisting file."); + goto out; + } + } + ret = 1; + +out: + if (stream != NULL) { + pclose(stream); + stream = NULL; + } + SAFE_FREE(buff); + + return ret; +} + +static void merge_eth_list(EthIfacesList *pdest, EthIfacesList *psrc, int flag) +{ + int i, j; + i = 0; + while (i < pdest->count) { + j = 0; + while (j < psrc->count) { + if (1 == eth_iface_compare(pdest->pifaces[i], psrc->pifaces[j])) { + /* found the matched device, merge them */ + eth_iface_merge(pdest->pifaces[i], psrc->pifaces[j], flag); + break; + } + j++; + } + i++; + } + return; +} + +static void find_iface_attached_bridge(EthIfacesList *peth_list, EthIface *pbr) +{ + int i, j; + char *name_on_br, *name_iface; + if (pbr->pbr_prop == NULL) { + return; + } + i = 0; + while (i < pbr->pbr_prop->port_num) { + name_on_br = pbr->pbr_prop->port_names[i]; + j = 0; + while (j < peth_list->count) { + name_iface = peth_list->pifaces[j]->name; + if (0 == strcmp(name_on_br, name_iface)) { + if (peth_list->pifaces[j]->attach_bridge == NULL) { + peth_list->pifaces[j]->attach_bridge = + SAFE_STRDUP(pbr->name); + } + break; + } + j++; + } + i++; + } +} + +/* assuming that one peth would be attached to at most 1 bridge */ +static void merge_eth_list_for_bridge(EthIfacesList *peth_list, + EthIfacesList *pbr_list, + int flag) +{ + int i, j; + i = 0; + while (i < pbr_list->count) { + find_iface_attached_bridge(peth_list, pbr_list->pifaces[i]); + j = 0; + while (j < peth_list->count) { + if (1 == eth_iface_compare(peth_list->pifaces[j], + pbr_list->pifaces[i])) { + /* found the matched device, merge them */ + eth_iface_merge(peth_list->pifaces[j], + pbr_list->pifaces[i], flag); + break; + } + j++; + } + i++; + } + return; +} + +int get_host_eth_ifaces_cmd_all(EthIfacesList *plist, + eth_iface_filter_func filter_func, void *filter_opaque) +{ + int retvalue; + EthIfacesList *ifaces1, *ifaces2; + int i; + int filter_ret; + int count = 0; + SAFE_MALLOC(ifaces1, sizeof(EthIfacesList)); + SAFE_MALLOC(ifaces2, sizeof(EthIfacesList)); + eth_ifaceslist_init(ifaces1); + eth_ifaceslist_init(ifaces2); + + retvalue = get_host_eth_ifaces_ip_addr(ifaces1->pifaces, &(ifaces1->count), + MAX_IFACE_NUM, NULL, NULL); + if (retvalue != 1) { + goto out; + } + + + retvalue = get_host_eth_ifaces_ifconfig(ifaces2->pifaces, &(ifaces2->count), + MAX_IFACE_NUM, NULL, NULL); + if (retvalue != 1) { + goto out; + } + /* merge the information */ + merge_eth_list(ifaces1, ifaces2, 1); + eth_ifaceslist_uninit(ifaces2); + + retvalue = get_host_eth_ifaces_brctl(ifaces2->pifaces, &(ifaces2->count), + MAX_IFACE_NUM, NULL, NULL); + if (retvalue != 1) { + goto out; + } + /* merge the information */ + merge_eth_list_for_bridge(ifaces1, ifaces2, 1); + eth_ifaceslist_uninit(ifaces2); + + retvalue = get_host_eth_ifaces_cat_vlan_config(ifaces2->pifaces, + &(ifaces2->count), MAX_IFACE_NUM, NULL, NULL); + if (retvalue != 1) { + goto out; + } + + /* merge the information */ + merge_eth_list(ifaces1, ifaces2, 1); + eth_ifaceslist_uninit(ifaces2); + + /* filter the result */ + i = 0; + while (i < ifaces1->count) { + /* see if the result need to be put to the list */ + filter_ret = 1; + if (filter_func != NULL) { + filter_ret = filter_func(ifaces1->pifaces[i], filter_opaque); + } + if (filter_ret == 1) { + if (count >= MAX_IFACE_NUM) { + retvalue = ERR_DEVICE_EXCEED_MAXNUM; + goto out; + } + host_iface_adjust(ifaces1->pifaces[i]); + plist->pifaces[count] = ifaces1->pifaces[i]; + ifaces1->pifaces[i] = NULL; + count++; + } + i++; + } + + out: + eth_ifaceslist_uninit(ifaces1); + SAFE_FREE(ifaces1); + eth_ifaceslist_uninit(ifaces2); + SAFE_FREE(ifaces2); + plist->count = count; + return retvalue; +} diff --git a/libxkutil/host_network_implement_cmdline.h b/libxkutil/host_network_implement_cmdline.h new file mode 100644 index 0000000..90e5891 --- /dev/null +++ b/libxkutil/host_network_implement_cmdline.h @@ -0,0 +1,55 @@ +/* + * Copyright IBM Corp. 2011 + * + * Authors: + * Wenchao Xia <xiawenc(a)cn.ibm.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + */ + +#ifndef HOST_NETWORK_IMPLEMENT_CMDLINE_H +#define HOST_NETWORK_IMPLEMENT_CMDLINE_H + +#include "host_network_basic.h" + +int get_host_eth_ifaces_ip_addr(EthIface **ppifaces, int *retnum, int maxnum, + eth_iface_filter_func filter_func, void *filter_opaque); + +int get_host_eth_ifaces_ifconfig(EthIface **ppifaces, int *retnum, int maxnum, + eth_iface_filter_func filter_func, void *filter_opaque); + +int get_host_eth_ifaces_brctl(EthIface **ppifaces, int *retnum, int maxnum, + eth_iface_filter_func filter_func, void *filter_opaque); + +int get_host_eth_ifaces_cat_vlan_config(EthIface **ppifaces, int *retnum, + int maxnum, eth_iface_filter_func filter_func, void *filter_opaque); + +int get_host_eth_ifaces_cmd_all(EthIfacesList *plist, + eth_iface_filter_func filter_func, void *filter_opaque); + +int add_host_br_cmd(EthIface *piface, int persist_flag); +int del_host_br_cmd(EthIface *piface, int persist_flag); +int mod_host_br_cmd(EthIface *piface, int persist_flag); +int add_host_iface_to_br_cmd(EthIface *piface, EthIface *pbr, + int persist_flag); +int remove_host_iface_from_br_cmd(EthIface *piface, EthIface *pbr, + int persist_flag); + +int add_host_vlan_8021q_cmd(EthIface *piface, int persist_flag); +int del_host_vlan_8021q_cmd(EthIface *piface, int persist_flag); +int mod_host_vlan_8021q_cmd(EthIface *piface, int persist_flag); + +int change_state_host_iface_cmd(EthIface *piface, int state); + +int host_br_have_iface_attached_cmd(EthIface *pbr, EthIface *piface, + EthIface **ppbr_result); + +/* check a batch of iface's state with one call of get_host_ifaces, + retvalues must be allocated big enough */ +int host_ifacelist_is_present_cmd(EthIfacesList *plist, int *retvalues, + int compare_name_only); + +#endif -- 1.7.6