275 lines
6.8 KiB
C
275 lines
6.8 KiB
C
/*
|
|
* lib/dect/cluster.c DECT Cluster objects
|
|
*
|
|
* 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 version 2.1
|
|
* of the License.
|
|
*
|
|
* Copyright (c) 2009 Patrick McHardy <kaber@trash.net>
|
|
*/
|
|
|
|
#include <netlink-private/netlink.h>
|
|
#include <netlink/netlink.h>
|
|
#include <netlink/cache.h>
|
|
#include <netlink/utils.h>
|
|
#include <netlink/data.h>
|
|
#include <netlink/dect/cluster.h>
|
|
#include <netlink/dect/ari.h>
|
|
#include <linux/dect_netlink.h>
|
|
#include <linux/dect.h>
|
|
|
|
/** @cond SKIP */
|
|
#define CL_ATTR_NAME 0x0001
|
|
#define CL_ATTR_MODE 0x0002
|
|
#define CL_ATTR_PARI 0x0004
|
|
/** @endcond */
|
|
|
|
char *nl_dect_mbc_state2string(enum dect_mbc_state state,
|
|
char *buf, size_t len);
|
|
char *nl_dect_mbc_service2string(enum dect_mac_service_types type,
|
|
char *buf, size_t len);
|
|
char *nl_dect_mbc_cipher2string(enum dect_cipher_states state,
|
|
char *buf, size_t len);
|
|
|
|
static void cluster_free_data(struct nl_object *obj)
|
|
{
|
|
struct nl_dect_cluster *cl = nl_object_priv(obj);
|
|
|
|
if (cl == NULL)
|
|
return;
|
|
free(cl->cl_name);
|
|
}
|
|
|
|
static void mbc_tb_dump(struct nl_dect_mbc_tb *mtb, struct nl_dump_params *p)
|
|
{
|
|
nl_dump(p, "\t TB: LBN: %u ECN: %u Cell: %u RX/TX-Slots: %u/%u\n",
|
|
mtb->mtb_lbn, mtb->mtb_ecn,
|
|
mtb->mtb_cell, mtb->mtb_rx_slot, mtb->mtb_tx_slot);
|
|
}
|
|
|
|
static void mbc_dump(struct nl_dect_mbc *mbc, struct nl_dump_params *p)
|
|
{
|
|
unsigned int i;
|
|
char buf[64];
|
|
|
|
nl_dump(p, "\tMBC: MCEI %u\n", mbc->mbc_mcei);
|
|
nl_dump(p, "\t State: %s\n",
|
|
nl_dect_mbc_state2string(mbc->mbc_state,
|
|
buf, sizeof(buf)));
|
|
nl_dump(p, "\t Service: %s\n",
|
|
nl_dect_mbc_service2string(mbc->mbc_service,
|
|
buf, sizeof(buf)));
|
|
nl_dump(p, "\t Cipher state: %s\n",
|
|
nl_dect_mbc_cipher2string(mbc->mbc_cipher_state,
|
|
buf, sizeof(buf)));
|
|
nl_dump(p, "\t Cs-channel RX-Bytes: %u TX-Bytes: %u\n",
|
|
mbc->mbc_cs_rx_bytes, mbc->mbc_cs_tx_bytes);
|
|
nl_dump(p, "\t I-channel RX-Bytes: %u TX-Bytes: %u\n",
|
|
mbc->mbc_i_rx_bytes, mbc->mbc_i_tx_bytes);
|
|
|
|
for (i = 0; i < mbc->mbc_ntbs; i++)
|
|
mbc_tb_dump(&mbc->mbc_tbs[i], p);
|
|
}
|
|
|
|
static void cluster_dump(struct nl_object *obj, struct nl_dump_params *p)
|
|
{
|
|
struct nl_dect_cluster *cl = nl_object_priv(obj);
|
|
unsigned int i;
|
|
char buf[64];
|
|
|
|
if (cl->ce_mask & CL_ATTR_NAME)
|
|
nl_dump_line(p, "%d: DECT Cluster %s:\n",
|
|
cl->cl_index, cl->cl_name);
|
|
|
|
if (cl->ce_mask & CL_ATTR_MODE)
|
|
nl_dump_line(p, "\tMode: %s\n",
|
|
nl_dect_cluster_mode2str(cl->cl_mode,
|
|
buf, sizeof(buf)));
|
|
|
|
if (cl->ce_mask & CL_ATTR_PARI) {
|
|
nl_dump(p, "\tPARI: ");
|
|
nl_dect_dump_ari(&cl->cl_pari, p);
|
|
nl_dump(p, "\n");
|
|
}
|
|
|
|
nl_dump(p, "\n");
|
|
for (i = 0; i < cl->cl_nmbcs; i++)
|
|
mbc_dump(&cl->cl_mbcs[i], p);
|
|
}
|
|
|
|
/**
|
|
* @name Allocation/Freeing
|
|
* @{
|
|
*/
|
|
|
|
struct nl_dect_cluster *nl_dect_cluster_alloc(void)
|
|
{
|
|
return (struct nl_dect_cluster *)nl_object_alloc(&nl_dect_cluster_obj_ops);
|
|
}
|
|
|
|
void nl_dect_cluster_get(struct nl_dect_cluster *cl)
|
|
{
|
|
nl_object_get((struct nl_object *)cl);
|
|
}
|
|
|
|
void nl_dect_cluster_put(struct nl_dect_cluster *cl)
|
|
{
|
|
nl_object_put((struct nl_object *)cl);
|
|
}
|
|
|
|
/** @} */
|
|
|
|
/**
|
|
* @name Attributes
|
|
* @{
|
|
*/
|
|
|
|
unsigned int nl_dect_cluster_get_index(const struct nl_dect_cluster *cl)
|
|
{
|
|
return cl->cl_index;
|
|
}
|
|
|
|
void nl_dect_cluster_set_name(struct nl_dect_cluster *cl, const char *name)
|
|
{
|
|
cl->cl_name = strdup(name);
|
|
cl->ce_mask |= CL_ATTR_NAME;
|
|
}
|
|
|
|
bool nl_dect_cluster_test_name(const struct nl_dect_cluster *cl)
|
|
{
|
|
return !!(cl->ce_mask & CL_ATTR_NAME);
|
|
}
|
|
|
|
const char *nl_dect_cluster_get_name(const struct nl_dect_cluster *cl)
|
|
{
|
|
return cl->cl_name;
|
|
}
|
|
|
|
void nl_dect_cluster_set_mode(struct nl_dect_cluster *cl, uint8_t mode)
|
|
{
|
|
cl->cl_mode = mode;
|
|
cl->ce_mask |= CL_ATTR_MODE;
|
|
}
|
|
|
|
bool nl_dect_cluster_test_mode(const struct nl_dect_cluster *cl)
|
|
{
|
|
return !!(cl->ce_mask & CL_ATTR_MODE);
|
|
}
|
|
|
|
uint8_t nl_dect_cluster_get_mode(const struct nl_dect_cluster *cl)
|
|
{
|
|
return cl->cl_mode;
|
|
}
|
|
|
|
void nl_dect_cluster_set_pari(struct nl_dect_cluster *cl, const struct nl_dect_ari *pari)
|
|
{
|
|
memcpy(&cl->cl_pari, pari, sizeof(cl->cl_pari));
|
|
cl->ce_mask |= CL_ATTR_PARI;
|
|
}
|
|
|
|
bool nl_dect_cluster_test_pari(const struct nl_dect_cluster *cl)
|
|
{
|
|
return !!(cl->ce_mask & CL_ATTR_PARI);
|
|
}
|
|
|
|
const struct nl_dect_ari *nl_dect_cluster_get_pari(const struct nl_dect_cluster *cl)
|
|
{
|
|
return &cl->cl_pari;
|
|
}
|
|
|
|
int nl_dect_cluster_build_msg(struct nl_msg *msg, struct nl_dect_cluster *cl)
|
|
{
|
|
struct dectmsg dm = {
|
|
.dm_index = cl->cl_index,
|
|
};
|
|
|
|
if (nlmsg_append(msg, &dm, sizeof(dm), NLMSG_ALIGNTO) < 0)
|
|
goto nla_put_failure;
|
|
|
|
if (cl->ce_mask & CL_ATTR_NAME)
|
|
NLA_PUT_STRING(msg, DECTA_CLUSTER_NAME, cl->cl_name);
|
|
if (nl_dect_fill_ari(msg, &cl->cl_pari, DECTA_CLUSTER_PARI) < 0)
|
|
goto nla_put_failure;
|
|
if (cl->ce_mask & CL_ATTR_MODE)
|
|
NLA_PUT_U8(msg, DECTA_CLUSTER_MODE, cl->cl_mode);
|
|
return 0;
|
|
|
|
nla_put_failure:
|
|
return -NLE_MSGSIZE;
|
|
}
|
|
|
|
static struct trans_tbl cluster_modes[] = {
|
|
__ADD(DECT_MODE_FP, FP)
|
|
__ADD(DECT_MODE_PP, PP)
|
|
};
|
|
|
|
char *nl_dect_cluster_mode2str(enum dect_cluster_modes mode, char *buf, size_t len)
|
|
{
|
|
return __type2str(mode, buf, len, cluster_modes,
|
|
ARRAY_SIZE(cluster_modes));
|
|
}
|
|
|
|
enum dect_cluster_modes nl_dect_cluster_str2mode(const char *str)
|
|
{
|
|
return __str2type(str, cluster_modes, ARRAY_SIZE(cluster_modes));
|
|
}
|
|
|
|
static struct trans_tbl mbc_states[] = {
|
|
__ADD(DECT_MBC_NONE, none)
|
|
__ADD(DECT_MBC_INITIATED, initiated)
|
|
__ADD(DECT_MBC_ESTABLISHED, established)
|
|
__ADD(DECT_MBC_RELEASED, released)
|
|
};
|
|
|
|
char *nl_dect_mbc_state2string(enum dect_mbc_state state,
|
|
char *buf, size_t len)
|
|
{
|
|
return __type2str(state, buf, len, mbc_states,
|
|
ARRAY_SIZE(mbc_states));
|
|
}
|
|
|
|
static struct trans_tbl mac_service_types[] = {
|
|
__ADD(DECT_SERVICE_IN_MIN_DELAY, IN_min_delay)
|
|
__ADD(DECT_SERVICE_IPX_ENCODED_PROTECTED, IPX_encoded_protected)
|
|
__ADD(DECT_SERVICE_IN_NORMAL_DELAY, IN_normal_delay)
|
|
__ADD(DECT_SERVICE_UNKNOWN, unknown)
|
|
__ADD(DECT_SERVICE_C_CHANNEL_ONLY, C_channel_only)
|
|
__ADD(DECT_SERVICE_IP_ERROR_DETECTION, IP_error_detection)
|
|
__ADD(DECT_SERVICE_IPQ_ERROR_DETECTION, IPQ_error_detection)
|
|
};
|
|
|
|
char *nl_dect_mbc_service2string(enum dect_mac_service_types type,
|
|
char *buf, size_t len)
|
|
{
|
|
return __type2str(type, buf, len, mac_service_types,
|
|
ARRAY_SIZE(mac_service_types));
|
|
}
|
|
|
|
static struct trans_tbl cipher_states[] = {
|
|
__ADD(DECT_CIPHER_DISABLED, disabled)
|
|
__ADD(DECT_CIPHER_ENABLED, enabled)
|
|
};
|
|
|
|
char *nl_dect_mbc_cipher2string(enum dect_cipher_states state,
|
|
char *buf, size_t len)
|
|
{
|
|
return __type2str(state, buf, len, cipher_states,
|
|
ARRAY_SIZE(cipher_states));
|
|
}
|
|
|
|
/** @cond SKIP */
|
|
struct nl_object_ops nl_dect_cluster_obj_ops = {
|
|
.oo_name = "nl_dect/cluster",
|
|
.oo_size = sizeof(struct nl_dect_cluster),
|
|
.oo_free_data = cluster_free_data,
|
|
.oo_dump = {
|
|
[NL_DUMP_LINE] = cluster_dump,
|
|
},
|
|
.oo_id_attrs = CL_ATTR_NAME,
|
|
};
|
|
|
|
/** @endcond */
|
|
|
|
/** @} */
|