mipagentstat_server.c revision 63360950109af2ce85a962ca61f40b8782f11100
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdio.h>
#include <unistd.h>
#include <door.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <syslog.h>
#include "mipagentstat_door.h"
#include "conflib.h"
#include "mip.h"
#include "hash.h"
#include "agent.h"
/*
* Server for mipagentstat. This uses the protocol defined in
* "mipagentstat_door.h" to act as a door server for home and
* foreign agent statistics.
*
* The door server is created with the entry point dispatch;
* the door itself is created and bound to the rendezvous point
* on the filesystem by start_stat_server. dispatch simply
* sets up the enumeration if the operation is FIRST_ENT, and
* dispatches the enumeration call and it parameters to either
* the home or foreign agent enumeration function.
*
* This module and the hash module both use the enumeration state
* passed to and from the client. The are currently two different
* types of hash tables to enumerate: the faVisitorHash is two
* dimensional, the first being the hash buckets, and the second
* being the chains on each bucket; the haMobileNodeHash is three
* dimensional, the first and second dimensions being the same
* as faVisitorHash, and the extra third dimension being chains
* of bindings off each node in the hash chain.
*
* We use the notion of dimensions to optimize hash table
* enumeration. The first dimension corresponds to the hash
* table bucket, the second to the offset from that bucket,
* and the third (in the case of haMobileNodeHash) to the
* binding (which is an offset from the second offset). The state
* is decomposed into four 32-bit counters, of which only the
* first three are currently used. The first holds the bucket
* counter, the second the offset counter, and the third the
* binding offset counter. enumerateAllHashTableEntries handles
* the bucket and offset state, which enumerateHABindings handles
* the binding offset state.
*
* The counters are used as follows: we first jump to the bucket
* indicated by the bucket counter; next we count off into the
* chain until we reach the node following the node indicated by
* the offset counter, and finally, in the case of haMobileNodeHash,
* we count off from that node into the bindings list up to the
* node following the binding counter. If either the offset or
* binding offset counter reaches the end of its chain, we reset
* it to zero, and proceed with the next bucket or chain. This
* algorithm has the same computational complexity as the hash
* algorithm itself, with respect to finding the next node.
*
* The following #defines specify which 32-bit words in the enumeration
* state are used for what:
*/
#define BUCKET 0
#define OFFSET 1
#define BINDING 2
extern int logVerbosity;
/*
* Function: enumerateHABindings
*
* entry returned. If an entry was returned,
* lck will point to the node lock which
* the caller MUST unlock when done.
*
* Description: This function gets the next mobile node binding
* from the hash table haMobileNodeHash. The HA
* hastable is three dimensional: The first is the
* hashtable bucket array, the second is the linked
* list of HashEntries off each bucket, and the
* third is the linked list of bindings associated
* with each HaMobileNodeEntry. Hence we need three
* state counters for this enumeration.
*
* The enumeration state is contained in the state
* parameter, which is here cast to an array
* of four 32-bit unsigned integers. This function
* only used the first three words; the first two
* are used as enumeration state for
* enumerateAllHashTableEntries, while the third is
* used to find the next HaBindingEntry.
*
* Returns: a HaBindingEntry on success
* NULL if there are no more entries in the table
*/
uint32_t i;
/* Find the next HaMobileNodeEntry */
/* Find the next HaBindingEntry */
/* got it */
/* Pass the nodeLock back to the caller to unlock */
return (habe);
}
}
/* If we got here, there are no more bindings for this node */
}
/* If we got here, we have enumerated the whole table */
return (NULL);
}
/*
* Function: enumerateHAStats
*
*
* Description: This function uses enumerateHABindings to retrieve the
* next binding in the enumeration and then extracts
* the data needed for the stats call into the
* DoorStatArgs args.
*
* Returns: 1 on success, more entries to come
* 0 on success, no more entries
*/
/*LINTED pointer cast may result in improper alignment*/
/* enumeration has completed */
return (0);
}
/* copy out mobile node's address */
&(habe->haBindingMN),
sizeof (habe->haBindingMN));
/* copy out foreign agent's address */
&(habe->haBindingCOA),
sizeof (habe->haBindingCOA));
/* Copy out time granted and remaining */
/* Finally, copy in the flags! */
return (1);
}
/*
* Function: enumerateFAStats
*
*
* Description: This function uses enumerateAllHashTableEntries
* to retrieve the next FaVisitorEntry in the enumeration
* and then extracts the data needed for the stats call
* into the DoorStatArgs args.
*
* Returns: 1 on success, more entries to come
* 0 on success, no more entries
*/
/*LINTED pointer cast may result in improper alignment*/
/* enumeration has completed */
return (0);
}
/* copy out mobile node's home address */
&(fave->faVisitorHomeAddr),
sizeof (fave->faVisitorHomeAddr));
/* copy out home agent's address */
sizeof (fave->faVisitorHomeAgentAddr));
/* Copy out time granted and remaining */
/* Finally, copy in the flags! */
return (1);
}
/*
* Function: enumerateAgentPeerStats
*
*
* Description: This function uses enumerateAllHashTableEntres to
* retrieve the next MobilityAgentEntry in mipAgentHash,
* and then extracts the data needed for the stats call
* into the DoorStatArgs args.
*
* Returns: 1 on success, more entries to come
* 0 on success, no more entries
*/
/* LINTED pointer cast may result in improper alignment */
/* skip the agent-peers that we're not looking for */
do {
return (0);
/* copy out agent-peer's address */
/* Copy the flags */
/*
* User wants FA_PEER SAs, so this is us as the HA. Pass
* the SA bits which are relevant to us as HA peer, namely:
* request apply, and tunnel apply, and reply permit and
* reverse tunnel permit. Also make sure we're only showing
* what's invoked (not just what's configured)!
*/
else
/*
* For us as FA peer, we pass: request apply, reply permit,
* tunnel permit, and reverse tunnel apply.
*/
/* fin */
return (1);
}
/*
* Function: dispatch
*
* Arguments: see door_create(3x) for the description of the
* arguments passed to this function. The DoorStatArgs
* structure used for the IPC is in argp.
*
* Description: Sets up the enumeration if the operation is FIRST_ENT,
* and then dispatches to either enumerateHAStats or
* enumerateFAStats. This is entry point to the door
* created by start_stat_server.
*/
/*ARGSUSED*/
{
/*LINTED pointer cast may result in improper alignment*/
mipverbose(("stats server: call buffer too small\n"));
}
/* Set up the enumeration operation */
sizeof (*(args->enum_state)));
/* sanity check: if the op isn't FIRST_ENT, it must be NEXT_ENT */
mipverbose(("stats server: Unknown enumeration operation\n"));
}
/* Dispatch to the HA or FA stat function */
case HOME_AGENT:
if (enumerateHAStats(args) == 0)
break;
case FOREIGN_AGENT:
if (enumerateFAStats(args) == 0)
break;
case HOME_AGENT_PEER:
break;
case FOREIGN_AGENT_PEER:
break;
default:
mipverbose(("stats server: Unknown agent type requested\n"));
}
}
/*
* Function: startStatServer
*
* Description: Creates the server door for receiving stat requests.
* If the door rendezvous file does not exist, creates it.
* This is the only entry point from mipagent into this
* module.
*
* Returns: 1 on error
* 0 on success
*/
int startStatServer() {
if (did != -1) {
/* Door server is already running */
return (0);
}
/* Create the filesystem rendezvous point if not already there */
int fd;
return (1);
}
}
/* Create the door ... */
DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) < 0) {
return (1);
}
/*
* And attach it to the rendezvous point, cleaning up any
* stale associations first.
*/
(void) fdetach(MIPAGENTSTAT_DOOR);
return (1);
}
return (0);
}
/*
* Function: killStatServer
*
* Description: This function is used to shut down the stat
* door server.
*
* Returns: 0 if successful, -1 on failure
*/
int killStatServer() {
did = -1;
return (err);
}