| Current Path : /sys/amd64/compile/hs32/modules/usr/src/sys/modules/usb/urio/@/amd64/compile/hs32/modules/usr/src/sys/modules/usb/uss820dci/@/netgraph/atm/ccatm/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //sys/amd64/compile/hs32/modules/usr/src/sys/modules/usb/urio/@/amd64/compile/hs32/modules/usr/src/sys/modules/usb/uss820dci/@/netgraph/atm/ccatm/ng_ccatm.c |
/*-
* Copyright (c) 2001-2002
* Fraunhofer Institute for Open Communication Systems (FhG Fokus).
* All rights reserved.
* Copyright (c) 2003-2004
* Hartmut Brandt
* All rights reserved.
*
* Author: Harti Brandt <harti@freebsd.org>
*
* Redistribution of this software and documentation and use in source and
* binary forms, with or without modification, are permitted provided that
* the following conditions are met:
*
* 1. Redistributions of source code or documentation must retain the above
* copyright notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE AUTHOR
* AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE AUTHOR OR ITS 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.
*
* $FreeBSD: release/9.1.0/sys/netgraph/atm/ccatm/ng_ccatm.c 220768 2011-04-18 09:12:27Z glebius $
*
* ATM call control and API
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: release/9.1.0/sys/netgraph/atm/ccatm/ng_ccatm.c 220768 2011-04-18 09:12:27Z glebius $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/errno.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/sbuf.h>
#include <machine/stdarg.h>
#include <netgraph/ng_message.h>
#include <netgraph/netgraph.h>
#include <netgraph/ng_parse.h>
#include <netnatm/unimsg.h>
#include <netnatm/msg/unistruct.h>
#include <netnatm/api/unisap.h>
#include <netnatm/sig/unidef.h>
#include <netgraph/atm/ngatmbase.h>
#include <netgraph/atm/ng_uni.h>
#include <netnatm/api/atmapi.h>
#include <netgraph/atm/ng_ccatm.h>
#include <netnatm/api/ccatm.h>
MODULE_DEPEND(ng_ccatm, ngatmbase, 1, 1, 1);
MALLOC_DEFINE(M_NG_CCATM, "ng_ccatm", "netgraph uni api node");
/*
* Command structure parsing
*/
/* ESI */
static const struct ng_parse_fixedarray_info ng_ccatm_esi_type_info =
NGM_CCATM_ESI_INFO;
static const struct ng_parse_type ng_ccatm_esi_type = {
&ng_parse_fixedarray_type,
&ng_ccatm_esi_type_info
};
/* PORT PARAMETERS */
static const struct ng_parse_struct_field ng_ccatm_atm_port_type_info[] =
NGM_CCATM_ATM_PORT_INFO;
static const struct ng_parse_type ng_ccatm_atm_port_type = {
&ng_parse_struct_type,
ng_ccatm_atm_port_type_info
};
/* PORT structure */
static const struct ng_parse_struct_field ng_ccatm_port_type_info[] =
NGM_CCATM_PORT_INFO;
static const struct ng_parse_type ng_ccatm_port_type = {
&ng_parse_struct_type,
ng_ccatm_port_type_info
};
/* the ADDRESS array itself */
static const struct ng_parse_fixedarray_info ng_ccatm_addr_array_type_info =
NGM_CCATM_ADDR_ARRAY_INFO;
static const struct ng_parse_type ng_ccatm_addr_array_type = {
&ng_parse_fixedarray_type,
&ng_ccatm_addr_array_type_info
};
/* one ADDRESS */
static const struct ng_parse_struct_field ng_ccatm_uni_addr_type_info[] =
NGM_CCATM_UNI_ADDR_INFO;
static const struct ng_parse_type ng_ccatm_uni_addr_type = {
&ng_parse_struct_type,
ng_ccatm_uni_addr_type_info
};
/* ADDRESS request */
static const struct ng_parse_struct_field ng_ccatm_addr_req_type_info[] =
NGM_CCATM_ADDR_REQ_INFO;
static const struct ng_parse_type ng_ccatm_addr_req_type = {
&ng_parse_struct_type,
ng_ccatm_addr_req_type_info
};
/* ADDRESS var-array */
static int
ng_ccatm_addr_req_array_getlen(const struct ng_parse_type *type,
const u_char *start, const u_char *buf)
{
const struct ngm_ccatm_get_addresses *p;
p = (const struct ngm_ccatm_get_addresses *)
(buf - offsetof(struct ngm_ccatm_get_addresses, addr));
return (p->count);
}
static const struct ng_parse_array_info ng_ccatm_addr_req_array_type_info =
NGM_CCATM_ADDR_REQ_ARRAY_INFO;
static const struct ng_parse_type ng_ccatm_addr_req_array_type = {
&ng_parse_array_type,
&ng_ccatm_addr_req_array_type_info
};
/* Outer get_ADDRESSes structure */
static const struct ng_parse_struct_field ng_ccatm_get_addresses_type_info[] =
NGM_CCATM_GET_ADDRESSES_INFO;
static const struct ng_parse_type ng_ccatm_get_addresses_type = {
&ng_parse_struct_type,
ng_ccatm_get_addresses_type_info
};
/* Port array */
static int
ng_ccatm_port_array_getlen(const struct ng_parse_type *type,
const u_char *start, const u_char *buf)
{
const struct ngm_ccatm_portlist *p;
p = (const struct ngm_ccatm_portlist *)
(buf - offsetof(struct ngm_ccatm_portlist, ports));
return (p->nports);
}
static const struct ng_parse_array_info ng_ccatm_port_array_type_info =
NGM_CCATM_PORT_ARRAY_INFO;
static const struct ng_parse_type ng_ccatm_port_array_type = {
&ng_parse_array_type,
&ng_ccatm_port_array_type_info
};
/* Portlist structure */
static const struct ng_parse_struct_field ng_ccatm_portlist_type_info[] =
NGM_CCATM_PORTLIST_INFO;
static const struct ng_parse_type ng_ccatm_portlist_type = {
&ng_parse_struct_type,
ng_ccatm_portlist_type_info
};
/*
* Command list
*/
static const struct ng_cmdlist ng_ccatm_cmdlist[] = {
{
NGM_CCATM_COOKIE,
NGM_CCATM_DUMP,
"dump",
NULL,
NULL
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_STOP,
"stop",
&ng_ccatm_port_type,
NULL
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_START,
"start",
&ng_ccatm_port_type,
NULL
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_GETSTATE,
"getstate",
&ng_ccatm_port_type,
&ng_parse_uint32_type
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_GET_ADDRESSES,
"get_addresses",
&ng_ccatm_port_type,
&ng_ccatm_get_addresses_type
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_CLEAR,
"clear",
&ng_ccatm_port_type,
NULL
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_ADDRESS_REGISTERED,
"address_reg",
&ng_ccatm_addr_req_type,
NULL
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_ADDRESS_UNREGISTERED,
"address_unreg",
&ng_ccatm_addr_req_type,
NULL
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_SET_PORT_PARAM,
"set_port_param",
&ng_ccatm_atm_port_type,
NULL
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_GET_PORT_PARAM,
"get_port_param",
&ng_ccatm_port_type,
&ng_ccatm_atm_port_type,
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_GET_PORTLIST,
"get_portlist",
NULL,
&ng_ccatm_portlist_type,
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_SETLOG,
"setlog",
&ng_parse_hint32_type,
&ng_parse_hint32_type,
},
{
NGM_CCATM_COOKIE,
NGM_CCATM_RESET,
"reset",
NULL,
NULL,
},
{ 0 }
};
/*
* Module data
*/
static ng_constructor_t ng_ccatm_constructor;
static ng_rcvmsg_t ng_ccatm_rcvmsg;
static ng_shutdown_t ng_ccatm_shutdown;
static ng_newhook_t ng_ccatm_newhook;
static ng_rcvdata_t ng_ccatm_rcvdata;
static ng_disconnect_t ng_ccatm_disconnect;
static int ng_ccatm_mod_event(module_t, int, void *);
static struct ng_type ng_ccatm_typestruct = {
.version = NG_ABI_VERSION,
.name = NG_CCATM_NODE_TYPE,
.mod_event = ng_ccatm_mod_event,
.constructor = ng_ccatm_constructor, /* Node constructor */
.rcvmsg = ng_ccatm_rcvmsg, /* Control messages */
.shutdown = ng_ccatm_shutdown, /* Node destructor */
.newhook = ng_ccatm_newhook, /* Arrival of new hook */
.rcvdata = ng_ccatm_rcvdata, /* receive data */
.disconnect = ng_ccatm_disconnect, /* disconnect a hook */
.cmdlist = ng_ccatm_cmdlist,
};
NETGRAPH_INIT(ccatm, &ng_ccatm_typestruct);
static ng_rcvdata_t ng_ccatm_rcvuni;
static ng_rcvdata_t ng_ccatm_rcvdump;
static ng_rcvdata_t ng_ccatm_rcvmanage;
/*
* Private node data.
*/
struct ccnode {
node_p node; /* the owning node */
hook_p dump; /* dump hook */
hook_p manage; /* hook to ILMI */
struct ccdata *data;
struct mbuf *dump_first;
struct mbuf *dump_last; /* first and last mbuf when dumping */
u_int hook_cnt; /* count user and port hooks */
};
/*
* Private UNI hook data
*/
struct cchook {
int is_uni; /* true if uni hook, user otherwise */
struct ccnode *node; /* the owning node */
hook_p hook;
void *inst; /* port or user */
};
static void ng_ccatm_send_user(struct ccuser *, void *, u_int, void *, size_t);
static void ng_ccatm_respond_user(struct ccuser *, void *, int, u_int,
void *, size_t);
static void ng_ccatm_send_uni(struct ccconn *, void *, u_int, u_int,
struct uni_msg *);
static void ng_ccatm_send_uni_glob(struct ccport *, void *, u_int, u_int,
struct uni_msg *);
static void ng_ccatm_log(const char *, ...) __printflike(1, 2);
static const struct cc_funcs cc_funcs = {
.send_user = ng_ccatm_send_user,
.respond_user = ng_ccatm_respond_user,
.send_uni = ng_ccatm_send_uni,
.send_uni_glob = ng_ccatm_send_uni_glob,
.log = ng_ccatm_log,
};
/************************************************************
*
* Create a new node
*/
static int
ng_ccatm_constructor(node_p node)
{
struct ccnode *priv;
priv = malloc(sizeof(*priv), M_NG_CCATM, M_WAITOK | M_ZERO);
priv->node = node;
priv->data = cc_create(&cc_funcs);
if (priv->data == NULL) {
free(priv, M_NG_CCATM);
return (ENOMEM);
}
NG_NODE_SET_PRIVATE(node, priv);
return (0);
}
/*
* Destroy a node. The user list is empty here, because all hooks are
* previously disconnected. The connection lists may not be empty, because
* connections may be waiting for responses from the stack. This also means,
* that no orphaned connections will be made by the port_destroy routine.
*/
static int
ng_ccatm_shutdown(node_p node)
{
struct ccnode *priv = NG_NODE_PRIVATE(node);
cc_destroy(priv->data);
free(priv, M_NG_CCATM);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
return (0);
}
/*
* Retrieve the registered addresses for one port or all ports.
* Returns an error code or 0 on success.
*/
static int
ng_ccatm_get_addresses(node_p node, uint32_t portno, struct ng_mesg *msg,
struct ng_mesg **resp)
{
struct ccnode *priv = NG_NODE_PRIVATE(node);
struct uni_addr *addrs;
u_int *ports;
struct ngm_ccatm_get_addresses *list;
u_int count, i;
size_t len;
int err;
err = cc_get_addrs(priv->data, portno, &addrs, &ports, &count);
if (err != 0)
return (err);
len = sizeof(*list) + count * sizeof(list->addr[0]);
NG_MKRESPONSE(*resp, msg, len, M_NOWAIT);
if (*resp == NULL) {
free(addrs, M_NG_CCATM);
free(ports, M_NG_CCATM);
return (ENOMEM);
}
list = (struct ngm_ccatm_get_addresses *)(*resp)->data;
list->count = count;
for (i = 0; i < count; i++) {
list->addr[i].port = ports[i];
list->addr[i].addr = addrs[i];
}
free(addrs, M_NG_CCATM);
free(ports, M_NG_CCATM);
return (0);
}
/*
* Dumper function. Pack the data into an mbuf chain.
*/
static int
send_dump(struct ccdata *data, void *uarg, const char *buf)
{
struct mbuf *m;
struct ccnode *priv = uarg;
if (priv->dump == NULL) {
m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
if (m == NULL)
return (ENOBUFS);
priv->dump_first = priv->dump_last = m;
m->m_pkthdr.len = 0;
} else {
m = m_getcl(M_DONTWAIT, MT_DATA, 0);
if (m == 0) {
m_freem(priv->dump_first);
return (ENOBUFS);
}
priv->dump_last->m_next = m;
priv->dump_last = m;
}
strcpy(m->m_data, buf);
priv->dump_first->m_pkthdr.len += (m->m_len = strlen(buf));
return (0);
}
/*
* Dump current status to dump hook
*/
static int
ng_ccatm_dump(node_p node)
{
struct ccnode *priv = NG_NODE_PRIVATE(node);
struct mbuf *m;
int error;
priv->dump_first = priv->dump_last = NULL;
error = cc_dump(priv->data, MCLBYTES, send_dump, priv);
if (error != 0)
return (error);
if ((m = priv->dump_first) != NULL) {
priv->dump_first = priv->dump_last = NULL;
NG_SEND_DATA_ONLY(error, priv->dump, m);
return (error);
}
return (0);
}
/*
* Control message
*/
static int
ng_ccatm_rcvmsg(node_p node, item_p item, hook_p lasthook)
{
struct ng_mesg *resp = NULL;
struct ng_mesg *msg;
struct ccnode *priv = NG_NODE_PRIVATE(node);
int error = 0;
NGI_GET_MSG(item, msg);
switch (msg->header.typecookie) {
case NGM_CCATM_COOKIE:
switch (msg->header.cmd) {
case NGM_CCATM_DUMP:
if (priv->dump)
error = ng_ccatm_dump(node);
else
error = ENOTCONN;
break;
case NGM_CCATM_STOP:
{
struct ngm_ccatm_port *arg;
if (msg->header.arglen != sizeof(*arg)) {
error = EINVAL;
break;
}
arg = (struct ngm_ccatm_port *)msg->data;
error = cc_port_stop(priv->data, arg->port);
break;
}
case NGM_CCATM_START:
{
struct ngm_ccatm_port *arg;
if (msg->header.arglen != sizeof(*arg)) {
error = EINVAL;
break;
}
arg = (struct ngm_ccatm_port *)msg->data;
error = cc_port_start(priv->data, arg->port);
break;
}
case NGM_CCATM_GETSTATE:
{
struct ngm_ccatm_port *arg;
int state;
if (msg->header.arglen != sizeof(*arg)) {
error = EINVAL;
break;
}
arg = (struct ngm_ccatm_port *)msg->data;
error = cc_port_isrunning(priv->data, arg->port,
&state);
if (error == 0) {
NG_MKRESPONSE(resp, msg, sizeof(uint32_t),
M_NOWAIT);
if (resp == NULL) {
error = ENOMEM;
break;
}
*(uint32_t *)resp->data = state;
}
break;
}
case NGM_CCATM_GET_ADDRESSES:
{
struct ngm_ccatm_port *arg;
if (msg->header.arglen != sizeof(*arg)) {
error = EINVAL;
break;
}
arg = (struct ngm_ccatm_port *)msg->data;
error = ng_ccatm_get_addresses(node, arg->port, msg,
&resp);
break;
}
case NGM_CCATM_CLEAR:
{
struct ngm_ccatm_port *arg;
if (msg->header.arglen != sizeof(*arg)) {
error = EINVAL;
break;
}
arg = (struct ngm_ccatm_port *)msg->data;
error = cc_port_clear(priv->data, arg->port);
break;
}
case NGM_CCATM_ADDRESS_REGISTERED:
{
struct ngm_ccatm_addr_req *arg;
if (msg->header.arglen != sizeof(*arg)) {
error = EINVAL;
break;
}
arg = (struct ngm_ccatm_addr_req *)msg->data;
error = cc_addr_register(priv->data, arg->port,
&arg->addr);
break;
}
case NGM_CCATM_ADDRESS_UNREGISTERED:
{
struct ngm_ccatm_addr_req *arg;
if (msg->header.arglen != sizeof(*arg)) {
error = EINVAL;
break;
}
arg = (struct ngm_ccatm_addr_req *)msg->data;
error = cc_addr_unregister(priv->data, arg->port,
&arg->addr);
break;
}
case NGM_CCATM_GET_PORT_PARAM:
{
struct ngm_ccatm_port *arg;
if (msg->header.arglen != sizeof(*arg)) {
error = EINVAL;
break;
}
arg = (struct ngm_ccatm_port *)msg->data;
NG_MKRESPONSE(resp, msg, sizeof(struct atm_port_info),
M_NOWAIT);
if (resp == NULL) {
error = ENOMEM;
break;
}
error = cc_port_get_param(priv->data, arg->port,
(struct atm_port_info *)resp->data);
if (error != 0) {
free(resp, M_NETGRAPH_MSG);
resp = NULL;
}
break;
}
case NGM_CCATM_SET_PORT_PARAM:
{
struct atm_port_info *arg;
if (msg->header.arglen != sizeof(*arg)) {
error = EINVAL;
break;
}
arg = (struct atm_port_info *)msg->data;
error = cc_port_set_param(priv->data, arg);
break;
}
case NGM_CCATM_GET_PORTLIST:
{
struct ngm_ccatm_portlist *arg;
u_int n, *ports;
if (msg->header.arglen != 0) {
error = EINVAL;
break;
}
error = cc_port_getlist(priv->data, &n, &ports);
if (error != 0)
break;
NG_MKRESPONSE(resp, msg, sizeof(*arg) +
n * sizeof(arg->ports[0]), M_NOWAIT);
if (resp == NULL) {
free(ports, M_NG_CCATM);
error = ENOMEM;
break;
}
arg = (struct ngm_ccatm_portlist *)resp->data;
arg->nports = 0;
for (arg->nports = 0; arg->nports < n; arg->nports++)
arg->ports[arg->nports] = ports[arg->nports];
free(ports, M_NG_CCATM);
break;
}
case NGM_CCATM_SETLOG:
{
uint32_t log_level;
log_level = cc_get_log(priv->data);
if (msg->header.arglen != 0) {
if (msg->header.arglen != sizeof(log_level)) {
error = EINVAL;
break;
}
cc_set_log(priv->data, *(uint32_t *)msg->data);
}
NG_MKRESPONSE(resp, msg, sizeof(uint32_t), M_NOWAIT);
if (resp == NULL) {
error = ENOMEM;
if (msg->header.arglen != 0)
cc_set_log(priv->data, log_level);
break;
}
*(uint32_t *)resp->data = log_level;
break;
}
case NGM_CCATM_RESET:
if (msg->header.arglen != 0) {
error = EINVAL;
break;
}
if (priv->hook_cnt != 0) {
error = EBUSY;
break;
}
cc_reset(priv->data);
break;
case NGM_CCATM_GET_EXSTAT:
{
struct atm_exstatus s;
struct atm_exstatus_ep *eps;
struct atm_exstatus_port *ports;
struct atm_exstatus_conn *conns;
struct atm_exstatus_party *parties;
size_t offs;
if (msg->header.arglen != 0) {
error = EINVAL;
break;
}
error = cc_get_extended_status(priv->data,
&s, &eps, &ports, &conns, &parties);
if (error != 0)
break;
offs = sizeof(s) + s.neps * sizeof(*eps) +
s.nports * sizeof(*ports) +
s.nconns * sizeof(*conns) +
s.nparties * sizeof(*parties);
NG_MKRESPONSE(resp, msg, offs, M_NOWAIT);
if (resp == NULL) {
error = ENOMEM;
break;
}
memcpy(resp->data, &s, sizeof(s));
offs = sizeof(s);
memcpy(resp->data + offs, eps,
sizeof(*eps) * s.neps);
offs += sizeof(*eps) * s.neps;
memcpy(resp->data + offs, ports,
sizeof(*ports) * s.nports);
offs += sizeof(*ports) * s.nports;
memcpy(resp->data + offs, conns,
sizeof(*conns) * s.nconns);
offs += sizeof(*conns) * s.nconns;
memcpy(resp->data + offs, parties,
sizeof(*parties) * s.nparties);
offs += sizeof(*parties) * s.nparties;
free(eps, M_NG_CCATM);
free(ports, M_NG_CCATM);
free(conns, M_NG_CCATM);
free(parties, M_NG_CCATM);
break;
}
default:
error = EINVAL;
break;
}
break;
default:
error = EINVAL;
break;
}
NG_RESPOND_MSG(error, node, item, resp);
NG_FREE_MSG(msg);
return (error);
}
/************************************************************
*
* New hook arrival
*/
static int
ng_ccatm_newhook(node_p node, hook_p hook, const char *name)
{
struct ccnode *priv = NG_NODE_PRIVATE(node);
struct ccport *port;
struct ccuser *user;
struct cchook *hd;
u_long lport;
char *end;
if (strncmp(name, "uni", 3) == 0) {
/*
* This is a UNI hook. Should be a new port.
*/
if (name[3] == '\0')
return (EINVAL);
lport = strtoul(name + 3, &end, 10);
if (*end != '\0' || lport == 0 || lport > 0xffffffff)
return (EINVAL);
hd = malloc(sizeof(*hd), M_NG_CCATM, M_NOWAIT);
if (hd == NULL)
return (ENOMEM);
hd->is_uni = 1;
hd->node = priv;
hd->hook = hook;
port = cc_port_create(priv->data, hd, (u_int)lport);
if (port == NULL) {
free(hd, M_NG_CCATM);
return (ENOMEM);
}
hd->inst = port;
NG_HOOK_SET_PRIVATE(hook, hd);
NG_HOOK_SET_RCVDATA(hook, ng_ccatm_rcvuni);
NG_HOOK_FORCE_QUEUE(hook);
priv->hook_cnt++;
return (0);
}
if (strcmp(name, "dump") == 0) {
priv->dump = hook;
NG_HOOK_SET_RCVDATA(hook, ng_ccatm_rcvdump);
return (0);
}
if (strcmp(name, "manage") == 0) {
priv->manage = hook;
NG_HOOK_SET_RCVDATA(hook, ng_ccatm_rcvmanage);
return (0);
}
/*
* User hook
*/
hd = malloc(sizeof(*hd), M_NG_CCATM, M_NOWAIT);
if (hd == NULL)
return (ENOMEM);
hd->is_uni = 0;
hd->node = priv;
hd->hook = hook;
user = cc_user_create(priv->data, hd, NG_HOOK_NAME(hook));
if (user == NULL) {
free(hd, M_NG_CCATM);
return (ENOMEM);
}
hd->inst = user;
NG_HOOK_SET_PRIVATE(hook, hd);
NG_HOOK_FORCE_QUEUE(hook);
priv->hook_cnt++;
return (0);
}
/*
* Disconnect a hook
*/
static int
ng_ccatm_disconnect(hook_p hook)
{
node_p node = NG_HOOK_NODE(hook);
struct ccnode *priv = NG_NODE_PRIVATE(node);
struct cchook *hd = NG_HOOK_PRIVATE(hook);
struct ccdata *cc;
if (hook == priv->dump) {
priv->dump = NULL;
} else if (hook == priv->manage) {
priv->manage = NULL;
cc_unmanage(priv->data);
} else {
if (hd->is_uni)
cc_port_destroy(hd->inst, 0);
else
cc_user_destroy(hd->inst);
cc = hd->node->data;
free(hd, M_NG_CCATM);
NG_HOOK_SET_PRIVATE(hook, NULL);
priv->hook_cnt--;
cc_work(cc);
}
/*
* When the number of hooks drops to zero, delete the node.
*/
if (NG_NODE_NUMHOOKS(node) == 0 && NG_NODE_IS_VALID(node))
ng_rmnode_self(node);
return (0);
}
/************************************************************
*
* Receive data from user hook
*/
static int
ng_ccatm_rcvdata(hook_p hook, item_p item)
{
struct cchook *hd = NG_HOOK_PRIVATE(hook);
struct uni_msg *msg;
struct mbuf *m;
struct ccatm_op op;
int err;
NGI_GET_M(item, m);
NG_FREE_ITEM(item);
if ((err = uni_msg_unpack_mbuf(m, &msg)) != 0) {
m_freem(m);
return (err);
}
m_freem(m);
if (uni_msg_len(msg) < sizeof(op)) {
printf("%s: packet too short\n", __func__);
uni_msg_destroy(msg);
return (EINVAL);
}
bcopy(msg->b_rptr, &op, sizeof(op));
msg->b_rptr += sizeof(op);
err = cc_user_signal(hd->inst, op.op, msg);
cc_work(hd->node->data);
return (err);
}
/*
* Pack a header and a data area into an mbuf chain
*/
static struct mbuf *
pack_buf(void *h, size_t hlen, void *t, size_t tlen)
{
struct mbuf *m, *m0, *last;
u_char *buf = (u_char *)t;
size_t n;
/* header should fit into a normal mbuf */
MGETHDR(m0, M_NOWAIT, MT_DATA);
if (m0 == NULL)
return NULL;
KASSERT(hlen <= MHLEN, ("hlen > MHLEN"));
bcopy(h, m0->m_data, hlen);
m0->m_len = hlen;
m0->m_pkthdr.len = hlen;
last = m0;
while ((n = tlen) != 0) {
if (n > MLEN) {
m = m_getcl(M_NOWAIT, MT_DATA, 0);
if (n > MCLBYTES)
n = MCLBYTES;
} else
MGET(m, M_NOWAIT, MT_DATA);
if(m == NULL)
goto drop;
last->m_next = m;
last = m;
bcopy(buf, m->m_data, n);
buf += n;
tlen -= n;
m->m_len = n;
m0->m_pkthdr.len += n;
}
return (m0);
drop:
m_freem(m0);
return NULL;
}
/*
* Send an indication to the user.
*/
static void
ng_ccatm_send_user(struct ccuser *user, void *uarg, u_int op,
void *val, size_t len)
{
struct cchook *hd = uarg;
struct mbuf *m;
struct ccatm_op h;
int error;
h.op = op;
m = pack_buf(&h, sizeof(h), val, len);
if (m == NULL)
return;
NG_SEND_DATA_ONLY(error, hd->hook, m);
if (error != 0)
printf("%s: error=%d\n", __func__, error);
}
/*
* Send a response to the user.
*/
static void
ng_ccatm_respond_user(struct ccuser *user, void *uarg, int err, u_int data,
void *val, size_t len)
{
struct cchook *hd = uarg;
struct mbuf *m;
struct {
struct ccatm_op op;
struct atm_resp resp;
} resp;
int error;
resp.op.op = ATMOP_RESP;
resp.resp.resp = err;
resp.resp.data = data;
m = pack_buf(&resp, sizeof(resp), val, len);
if (m == NULL)
return;
NG_SEND_DATA_ONLY(error, hd->hook, m);
if (error != 0)
printf("%s: error=%d\n", __func__, error);
}
/*
* Receive data from UNI.
*/
static int
ng_ccatm_rcvuni(hook_p hook, item_p item)
{
struct cchook *hd = NG_HOOK_PRIVATE(hook);
struct uni_msg *msg;
struct uni_arg arg;
struct mbuf *m;
int err;
NGI_GET_M(item, m);
NG_FREE_ITEM(item);
if ((err = uni_msg_unpack_mbuf(m, &msg)) != 0) {
m_freem(m);
return (err);
}
m_freem(m);
if (uni_msg_len(msg) < sizeof(arg)) {
printf("%s: packet too short\n", __func__);
uni_msg_destroy(msg);
return (EINVAL);
}
bcopy(msg->b_rptr, &arg, sizeof(arg));
msg->b_rptr += sizeof(arg);
if (arg.sig == UNIAPI_ERROR) {
if (uni_msg_len(msg) != sizeof(struct uniapi_error)) {
printf("%s: bad UNIAPI_ERROR size %zu\n", __func__,
uni_msg_len(msg));
uni_msg_destroy(msg);
return (EINVAL);
}
err = cc_uni_response(hd->inst, arg.cookie,
((struct uniapi_error *)msg->b_rptr)->reason,
((struct uniapi_error *)msg->b_rptr)->state);
uni_msg_destroy(msg);
} else
err = cc_uni_signal(hd->inst, arg.cookie, arg.sig, msg);
cc_work(hd->node->data);
return (err);
}
/*
* Uarg is the port's uarg.
*/
static void
ng_ccatm_send_uni(struct ccconn *conn, void *uarg, u_int op, u_int cookie,
struct uni_msg *msg)
{
struct cchook *hd = uarg;
struct uni_arg arg;
struct mbuf *m;
int error;
arg.sig = op;
arg.cookie = cookie;
m = uni_msg_pack_mbuf(msg, &arg, sizeof(arg));
uni_msg_destroy(msg);
if (m == NULL)
return;
NG_SEND_DATA_ONLY(error, hd->hook, m);
if (error != 0)
printf("%s: error=%d\n", __func__, error);
}
/*
* Send a global message to the UNI
*/
static void
ng_ccatm_send_uni_glob(struct ccport *port, void *uarg, u_int op, u_int cookie,
struct uni_msg *msg)
{
struct cchook *hd = uarg;
struct uni_arg arg;
struct mbuf *m;
int error;
arg.sig = op;
arg.cookie = cookie;
m = uni_msg_pack_mbuf(msg, &arg, sizeof(arg));
if (msg != NULL)
uni_msg_destroy(msg);
if (m == NULL)
return;
NG_SEND_DATA_ONLY(error, hd->hook, m);
if (error != 0)
printf("%s: error=%d\n", __func__, error);
}
/*
* Receive from ILMID
*/
static int
ng_ccatm_rcvmanage(hook_p hook, item_p item)
{
NG_FREE_ITEM(item);
return (0);
}
static int
ng_ccatm_rcvdump(hook_p hook, item_p item)
{
NG_FREE_ITEM(item);
return (0);
}
static void
ng_ccatm_log(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vprintf(fmt, ap);
printf("\n");
va_end(ap);
}
/*
* Loading and unloading of node type
*/
static int
ng_ccatm_mod_event(module_t mod, int event, void *data)
{
int s;
int error = 0;
s = splnet();
switch (event) {
case MOD_LOAD:
break;
case MOD_UNLOAD:
break;
default:
error = EOPNOTSUPP;
break;
}
splx(s);
return (error);
}