965 lines
21 KiB
C
Executable File
965 lines
21 KiB
C
Executable File
/*
|
|
* FST Manager: FST Configuration Manager
|
|
*
|
|
* Copyright (c) 2015-2016,2019-2020, The Linux Foundation. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of The Linux Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <sys/ioctl.h>
|
|
#include <net/if.h>
|
|
#include <net/if_arp.h>
|
|
#include <linux/sockios.h>
|
|
#include "fst_cfgmgr.h"
|
|
#include "fst_rateupg.h"
|
|
#include "fst_ini_conf.h"
|
|
|
|
#define FST_MGR_COMPONENT "CFGMGR"
|
|
#include "fst_manager.h"
|
|
|
|
static struct fst_config_ctx
|
|
{
|
|
enum fst_config_method method;
|
|
struct fst_ini_config *handle;
|
|
int skfd;
|
|
} fstcfg = {FST_CONFIG_CLI, NULL, -1};
|
|
|
|
static int _get_iface_flags(int sock, const char *ifname, short int *flags)
|
|
{
|
|
struct ifreq ifr;
|
|
|
|
os_memset(&ifr, 0, sizeof(ifr));
|
|
os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
|
|
|
|
if (ioctl(sock, SIOCGIFFLAGS, &ifr) != 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Error getting interface %s flags", ifname);
|
|
return -2;
|
|
}
|
|
*flags = ifr.ifr_flags;
|
|
return 0;
|
|
}
|
|
|
|
static int set_iface_flags(int sock, const char *ifname, short int flags)
|
|
{
|
|
struct ifreq ifr;
|
|
|
|
os_memset(&ifr, 0, sizeof(ifr));
|
|
os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
|
|
ifr.ifr_flags = flags;
|
|
|
|
if (ioctl(sock, SIOCSIFFLAGS, &ifr) != 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Error setting interface %s flags", ifname);
|
|
return -2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int set_iface_txqueuelen(int sock, const char *ifname, int txqueuelen)
|
|
{
|
|
struct ifreq ifr;
|
|
|
|
os_memset(&ifr, 0, sizeof(ifr));
|
|
os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
|
|
ifr.ifr_qlen = txqueuelen;
|
|
|
|
fst_mgr_printf(MSG_INFO, "Setting %s txqueuelen %d", ifname, txqueuelen);
|
|
|
|
if (ioctl(sock, SIOCSIFTXQLEN, &ifr) != 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Error setting interface %s txqueuelen", ifname);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int _set_iface_up(int sock, const char *ifname, Boolean up)
|
|
{
|
|
short int flags;
|
|
int ret;
|
|
|
|
if (sock < 0)
|
|
return -1;
|
|
|
|
ret = _get_iface_flags(sock, ifname, &flags);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
if (up) {
|
|
if (flags & IFF_UP)
|
|
return 0;
|
|
flags |= IFF_UP;
|
|
} else {
|
|
if (!(flags & IFF_UP))
|
|
return 0;
|
|
flags &= ~IFF_UP;
|
|
}
|
|
|
|
return set_iface_flags(sock, ifname, flags);
|
|
}
|
|
|
|
int set_iface_up(const char *ifname, Boolean up)
|
|
{
|
|
return _set_iface_up(fstcfg.skfd, ifname, up);
|
|
}
|
|
|
|
int get_iface_flags(const char *ifname, short int *flags)
|
|
{
|
|
return _get_iface_flags(fstcfg.skfd, ifname, flags);
|
|
}
|
|
|
|
static int enslave_device(int sock, const char *bond, const char *ifname)
|
|
{
|
|
struct ifreq if_enslave;
|
|
short int iface_flags;
|
|
|
|
if (sock < 0)
|
|
return -1;
|
|
|
|
if (_get_iface_flags(sock, ifname, &iface_flags) < 0)
|
|
return -1;
|
|
|
|
if (iface_flags & IFF_SLAVE) {
|
|
fst_mgr_printf(MSG_INFO, "Interface %s already enslaved", ifname);
|
|
return 0;
|
|
}
|
|
|
|
/* Device should be down before bonding in new kernels */
|
|
iface_flags &= ~IFF_UP;
|
|
if (set_iface_flags(sock, ifname, iface_flags) < 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot down slave %s", ifname);
|
|
return -2;
|
|
}
|
|
|
|
/* Enslave the device */
|
|
os_strlcpy(if_enslave.ifr_name, bond, IFNAMSIZ);
|
|
os_strlcpy(if_enslave.ifr_slave, ifname, IFNAMSIZ);
|
|
if ((ioctl(sock, SIOCBONDENSLAVE, &if_enslave) < 0)) {
|
|
fst_mgr_printf(MSG_ERROR, "Error enslaving %s to %s: %s",
|
|
ifname, bond, strerror(errno));
|
|
return -2;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int release_device(int sock, const char *bond, const char *ifname)
|
|
{
|
|
struct ifreq if_enslave;
|
|
short int iface_flags;
|
|
|
|
if (sock < 0)
|
|
return -1;
|
|
|
|
if (_get_iface_flags(sock, ifname, &iface_flags) < 0)
|
|
return -1;
|
|
|
|
if (!(iface_flags & IFF_SLAVE)) {
|
|
fst_mgr_printf(MSG_INFO, "Interface %s not enslaved", ifname);
|
|
return 0;
|
|
}
|
|
|
|
/* Release the device */
|
|
os_strlcpy(if_enslave.ifr_name, bond, IFNAMSIZ);
|
|
os_strlcpy(if_enslave.ifr_slave, ifname, IFNAMSIZ);
|
|
if ((ioctl(sock, SIOCBONDRELEASE, &if_enslave) < 0)) {
|
|
fst_mgr_printf(MSG_ERROR, "Error releasing %s from %s: %s",
|
|
ifname, bond, strerror(errno));
|
|
return -2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int fst_cfgmgr_get_txqueuelen(const char *gname)
|
|
{
|
|
int res = -1;
|
|
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_txqueuelen(fstcfg.handle, gname);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
int fst_set_mac_address(struct fst_group_info *ginfo, const u8 *mac)
|
|
{
|
|
struct ifreq ifr;
|
|
int ret;
|
|
char bond[80];
|
|
|
|
if (fst_cfgmgr_get_mux_ifname(ginfo->id, bond, sizeof(bond)-1) <= 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot get mux name for %s", ginfo->id);
|
|
return -1;
|
|
}
|
|
|
|
os_strlcpy(ifr.ifr_name, bond, IFNAMSIZ);
|
|
memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ALEN);
|
|
ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
|
|
|
|
ret = ioctl(fstcfg.skfd, SIOCSIFHWADDR, &ifr);
|
|
if (ret < 0)
|
|
fst_mgr_printf(MSG_ERROR, "SIOCSIFHWADDR failed on %s: %s",
|
|
bond, strerror(errno));
|
|
|
|
return ret;
|
|
}
|
|
|
|
int fst_iface_enslave(struct fst_group_info *ginfo, const char *ifname, Boolean enslave)
|
|
{
|
|
int res;
|
|
char bond[80];
|
|
|
|
if (fst_cfgmgr_get_mux_ifname(ginfo->id, bond, sizeof(bond)-1) <= 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot get mux name for %s", ginfo->id);
|
|
return -1;
|
|
}
|
|
|
|
fst_mgr_printf(MSG_DEBUG,
|
|
"%s interface %s to mux %s (group %s)",
|
|
enslave ? "Enslaving":"Releasing", ifname,
|
|
bond, ginfo->id);
|
|
|
|
if (enslave)
|
|
res = enslave_device(fstcfg.skfd, bond, ifname);
|
|
else
|
|
res = release_device(fstcfg.skfd, bond, ifname);
|
|
if (res < 0)
|
|
fst_mgr_printf(MSG_ERROR, "Cannot enslave/release %s", ifname);
|
|
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_update_txqueuelen(const struct fst_group_info *group)
|
|
{
|
|
int sock = fstcfg.skfd, txqueuelen, res = 0;
|
|
char buf[80];
|
|
|
|
if (fst_cfgmgr_get_mux_ifname(group->id, buf, sizeof(buf)-1) <= 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot get mux name for %s",
|
|
group->id);
|
|
return -1;
|
|
}
|
|
|
|
txqueuelen = fst_cfgmgr_get_txqueuelen(group->id);
|
|
if (txqueuelen >= 0)
|
|
res = set_iface_txqueuelen(sock, buf, txqueuelen);
|
|
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_set_mux_iface_up(const struct fst_group_info *group, Boolean up)
|
|
{
|
|
int sock = fstcfg.skfd, res;
|
|
char buf[80];
|
|
|
|
if (fst_cfgmgr_get_mux_ifname(group->id, buf, sizeof(buf)-1) <= 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot get mux name for %s",
|
|
group->id);
|
|
return -1;
|
|
}
|
|
|
|
res = (_set_iface_up(sock, buf, up) < 0);
|
|
if (res) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot set iface %s to state %s",
|
|
buf, up ? "UP" : "DOWN");
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static int do_bonding_operations(Boolean enslave)
|
|
{
|
|
struct fst_group_info *groups;
|
|
struct fst_iface_info *ifaces;
|
|
int gcnt, icnt, muxtype, sock = fstcfg.skfd, i, j, res;
|
|
char buf[80];
|
|
Boolean enslaved_any;
|
|
|
|
if (fstcfg.handle == NULL) {
|
|
fst_mgr_printf(MSG_ERROR, "Interfaces configuration not found");
|
|
goto error_handle;
|
|
}
|
|
|
|
gcnt = fst_ini_config_get_groups(fstcfg.handle, &groups);
|
|
if (gcnt < 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot read groups");
|
|
goto error_groups;
|
|
}
|
|
|
|
for (i = 0; i < gcnt; i++) {
|
|
muxtype = fst_cfgmgr_get_mux_type(groups[i].id,
|
|
buf, sizeof(buf)-1);
|
|
if (muxtype && os_strncmp(buf, "bonding", sizeof(buf)-1) &&
|
|
os_strncmp(buf, "bonding_l2da", sizeof(buf)-1)) {
|
|
fst_mgr_printf(MSG_DEBUG,
|
|
"Group %s mux type %s not supported, skipping",
|
|
groups[i].id, buf);
|
|
continue;
|
|
}
|
|
if (!fst_cfgmgr_is_mux_managed(groups[i].id)) {
|
|
fst_mgr_printf(MSG_DEBUG,
|
|
"Group %s mux is unmanaged, skipping",
|
|
groups[i].id);
|
|
continue;
|
|
}
|
|
if (fst_cfgmgr_get_mux_ifname(groups[i].id, buf, sizeof(buf)-1) <= 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot get mux name for %s",
|
|
groups[i].id);
|
|
goto error_muxname;
|
|
}
|
|
icnt = fst_ini_config_get_group_ifaces(fstcfg.handle,
|
|
&groups[i], &ifaces);
|
|
if (icnt < 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot read interfaces for %s",
|
|
groups[i].id);
|
|
goto error_ifaces;
|
|
}
|
|
enslaved_any = FALSE;
|
|
for (j = 0; j < icnt; j++) {
|
|
if (enslave && ifaces[j].manual_enslave)
|
|
continue;
|
|
|
|
res = fst_iface_enslave(&groups[i], ifaces[j].name, enslave);
|
|
if (res < 0)
|
|
goto error_enslave;
|
|
enslaved_any = TRUE;
|
|
}
|
|
|
|
if (enslaved_any) {
|
|
res = fst_cfgmgr_update_txqueuelen(&groups[i]);
|
|
if (res)
|
|
goto error_set_iface;
|
|
|
|
fst_mgr_printf(MSG_DEBUG, "Setting bonding iface %s %s",
|
|
buf, enslave ? "up":"down");
|
|
if (_set_iface_up(sock, buf, enslave) < 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot set iface %s",
|
|
buf);
|
|
goto error_set_iface;
|
|
}
|
|
}
|
|
free(ifaces);
|
|
}
|
|
free(groups);
|
|
return 0;
|
|
error_set_iface:
|
|
error_enslave:
|
|
free(ifaces);
|
|
error_ifaces:
|
|
error_muxname:
|
|
free(groups);
|
|
error_groups:
|
|
error_handle:
|
|
return -1;
|
|
}
|
|
|
|
static int bonding_ifaces_prepare()
|
|
{
|
|
return do_bonding_operations(TRUE);
|
|
}
|
|
|
|
static int bonding_ifaces_cleanup()
|
|
{
|
|
return do_bonding_operations(FALSE);
|
|
}
|
|
|
|
static int group_sessions_cleanup(const struct fst_group_info *gi)
|
|
{
|
|
uint32_t *sids = NULL;
|
|
int n, i, res = 0;
|
|
|
|
n = fst_get_sessions(gi, &sids);
|
|
if (n < 0) {
|
|
fst_mgr_printf(MSG_WARNING, "cannot get sessions for group %s",
|
|
gi->id);
|
|
return 0;
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
if (fst_session_remove(sids[i])) {
|
|
fst_mgr_printf(MSG_ERROR, "cannot remove session %u",
|
|
sids[i]);
|
|
res = -1;
|
|
}
|
|
}
|
|
fst_free(sids);
|
|
|
|
return res;
|
|
}
|
|
|
|
static int group_detach_all(const struct fst_group_info *group)
|
|
{
|
|
struct fst_iface_info *ifaces;
|
|
int i, res;
|
|
|
|
res = fst_get_group_ifaces(group, &ifaces);
|
|
if (res < 0) {
|
|
fst_mgr_printf(MSG_ERROR,
|
|
"Cannot get ifaces for group %s", group->id);
|
|
return -1;
|
|
}
|
|
for (i = 0; i < res; i++) {
|
|
if (fst_detach_iface(&ifaces[i]))
|
|
fst_mgr_printf(MSG_WARNING,
|
|
"Error detaching interface %s", ifaces[i].name);
|
|
}
|
|
fst_free(ifaces);
|
|
return 0;
|
|
}
|
|
|
|
int fst_cfgmgr_init(enum fst_config_method m, void *ctx)
|
|
{
|
|
if ((fstcfg.skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
|
|
fst_mgr_printf(MSG_ERROR, "cannot open socket: %s",
|
|
strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
fstcfg.method = m;
|
|
switch (m) {
|
|
case FST_CONFIG_CLI:
|
|
fstcfg.handle = NULL;
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
fstcfg.handle = fst_ini_config_init((const char*)ctx);
|
|
if (fstcfg.handle == NULL) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot initialize config");
|
|
return -1;
|
|
}
|
|
if(bonding_ifaces_prepare()) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot prepare bonding ifaces");
|
|
return -1;
|
|
}
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Invalid config method %d", m);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void fst_cfgmgr_deinit()
|
|
{
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
bonding_ifaces_cleanup();
|
|
fst_ini_config_deinit(fstcfg.handle);
|
|
fstcfg.handle = NULL;
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
break;
|
|
}
|
|
|
|
close(fstcfg.skfd);
|
|
}
|
|
|
|
|
|
int fst_cfgmgr_get_groups(struct fst_group_info **groups)
|
|
{
|
|
int res;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
res = fst_get_groups(groups);
|
|
if (res < 0)
|
|
fst_mgr_printf(MSG_ERROR, "Cannot get groups");
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_groups(fstcfg.handle, groups);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Cannot get groups in current config");
|
|
res = -1;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_get_ctrl_iface(char *buf, int size)
|
|
{
|
|
int res = -1;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_ctrl_iface(fstcfg.handle, buf, size);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR,
|
|
"Cannot get ctrl_path in current config");
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_get_group_ifaces(const struct fst_group_info *group,
|
|
struct fst_iface_info **ifaces)
|
|
{
|
|
int res;
|
|
|
|
fst_mgr_printf(MSG_INFO, "group: %s", group->id);
|
|
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
res = fst_get_group_ifaces(group, ifaces);
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_group_ifaces(fstcfg.handle,
|
|
group, ifaces);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Cannot get ifaces in current config");
|
|
res = -1;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_get_iface_group_cipher(const struct fst_iface_info *iface,
|
|
char *buf, int len)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
res = 0;
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_iface_group_cipher(fstcfg.handle, iface,
|
|
buf, len);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_get_iface_pairwise_cipher(const struct fst_iface_info *iface,
|
|
char *buf, int len)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
res = 0;
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_iface_pairwise_cipher(fstcfg.handle, iface,
|
|
buf, len);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_get_iface_hw_mode(const struct fst_iface_info *iface,
|
|
char *buf, int len)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
res = 0;
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_iface_hw_mode(fstcfg.handle, iface,
|
|
buf, len);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_get_iface_channel(const struct fst_iface_info *iface,
|
|
char *buf, int len)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
res = 0;
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_iface_channel(fstcfg.handle, iface,
|
|
buf, len);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
|
|
int fst_cfgmgr_on_iface_init(const struct fst_group_info *group,
|
|
struct fst_iface_info *iface)
|
|
{
|
|
int res = 0;
|
|
|
|
fst_mgr_printf(MSG_INFO, "group: %s", group->id);
|
|
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_attach_iface(group, iface);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_on_iface_deinit(struct fst_iface_info *iface)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_detach_iface(iface);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_on_global_init(void)
|
|
{
|
|
struct fst_group_info *groups;
|
|
int i, res = 0;
|
|
|
|
fst_mgr_printf(MSG_INFO, "enter");
|
|
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
/* Remove existing configuration */
|
|
res = fst_get_groups(&groups);
|
|
if (res < 0) {
|
|
fst_mgr_printf(MSG_ERROR, "Cannot get groups");
|
|
return -1;
|
|
}
|
|
for (i=0; i < res; i++) {
|
|
group_sessions_cleanup(&groups[i]);
|
|
group_detach_all(&groups[i]);
|
|
}
|
|
if (res)
|
|
fst_free(groups);
|
|
res = fst_rate_upgrade_init(fstcfg.handle);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void fst_cfgmgr_on_global_deinit(void)
|
|
{
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
fst_rate_upgrade_deinit();
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
break;
|
|
}
|
|
}
|
|
|
|
int fst_cfgmgr_on_group_init(const struct fst_group_info *group)
|
|
{
|
|
if (group_sessions_cleanup(group))
|
|
return -1;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
if (fst_rate_upgrade_add_group(group))
|
|
return -1;
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int fst_cfgmgr_on_group_deinit(const struct fst_group_info *group)
|
|
{
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
if (fst_rate_upgrade_del_group(group))
|
|
return -1;
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int fst_cfgmgr_on_connect(struct fst_group_info *group, const char *iface,
|
|
const u8* addr)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_rate_upgrade_on_connect(group, iface, addr);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_on_disconnect(struct fst_group_info *group, const char *iface,
|
|
const u8* addr)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_rate_upgrade_on_disconnect(group, iface, addr);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void fst_cfgmgr_on_switch_completed(const struct fst_group_info *group,
|
|
const char *old_iface, const char *new_iface, const u8* peer_addr)
|
|
{
|
|
if (fstcfg.method != FST_CONFIG_INI)
|
|
return;
|
|
|
|
fst_rate_upgrade_on_switch_completed(group, old_iface,
|
|
new_iface, peer_addr);
|
|
}
|
|
|
|
int fst_cfgmgr_get_mux_type(const char *gname, char *buf, int blen)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
res = 0;
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_mux_type(fstcfg.handle, gname, buf, blen);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_get_mux_ifname(const char *gname, char *buf, int blen)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
os_strlcpy(buf, gname, blen);
|
|
res = os_strlen(buf);
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_mux_ifname(fstcfg.handle, gname,
|
|
buf, blen);
|
|
if (res == 0) {
|
|
/* Fallback to mux==group_name if no mux name key */
|
|
os_strlcpy(buf, gname, blen);
|
|
res = os_strlen(buf);
|
|
}
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_get_l2da_ap_default_ifname(const char *gname, char *buf,
|
|
int blen)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_get_l2da_ap_default_ifname(fstcfg.handle, gname,
|
|
buf, blen);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
Boolean fst_cfgmgr_is_mux_managed(const char *gname)
|
|
{
|
|
Boolean res = FALSE;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
res = FALSE;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_is_mux_managed(fstcfg.handle, gname);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = FALSE;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_get_rate_upgrade_master(const char *gname, char *buf, int blen)
|
|
{
|
|
int res = 0;
|
|
char *sres;
|
|
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
sres = fst_ini_config_get_rate_upgrade_master(fstcfg.handle, gname);
|
|
if (!sres)
|
|
break;
|
|
res = os_strlcpy(buf, sres, blen);
|
|
free(sres);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_set_mux_ifname(const char *gname, const char *newname)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
/* not supported */
|
|
res = -1;
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_set_mux_ifname(fstcfg.handle, gname,
|
|
newname);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int fst_cfgmgr_rename_interface(const char *gname, const char *ifname, const char *newifname)
|
|
{
|
|
int res = 0;
|
|
switch (fstcfg.method) {
|
|
case FST_CONFIG_CLI:
|
|
/* not supported */
|
|
res = -1;
|
|
break;
|
|
case FST_CONFIG_INI:
|
|
res = fst_ini_config_rename_interface(fstcfg.handle, gname, ifname, newifname);
|
|
if (res)
|
|
break;
|
|
|
|
fst_rate_upgrade_rename_interface(gname, ifname, newifname);
|
|
break;
|
|
default:
|
|
fst_mgr_printf(MSG_ERROR, "Wrong config method");
|
|
res = -1;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void fst_cfgmgr_on_scan_started(const struct fst_group_info *group, const char *iface)
|
|
{
|
|
if (fstcfg.method != FST_CONFIG_INI)
|
|
return;
|
|
|
|
fst_rate_upgrade_on_scan_started(group, iface);
|
|
}
|
|
|
|
void fst_cfgmgr_on_scan_completed(const struct fst_group_info *group, const char *iface)
|
|
{
|
|
if (fstcfg.method != FST_CONFIG_INI)
|
|
return;
|
|
|
|
fst_rate_upgrade_on_scan_completed(group, iface);
|
|
}
|
|
|
|
void fst_cfgmgr_on_signal_change(const struct fst_group_info *group, const char *iface)
|
|
{
|
|
if (fstcfg.method != FST_CONFIG_INI)
|
|
return;
|
|
|
|
fst_rate_upgrade_on_signal_change(group, iface);
|
|
}
|