/**
 @Name:		<TEMPLATE>.c
 @Purpose:	@User:  Fill in purpose

 Message Types:
	@User:  Document messages (requests and replies) here
	Op	Short Descr	Request			Reply
	-----------------------------------------------------------
	0	Hello		[0]  instance #		plugin id
				[1]  command = 0	instance #
 Notation:
	- this:  struct rp_instance * (ptr to plugin instance)
 Post-Conditions:
   <TEMPLATE>_load
	- Plugin class (<TEMPLATE>_class) structure is initialized
	- <TEMPLATE>_get_class() is registered with PCU
   <TEMPLATE>_create_instance
	- Plugin instance memory is allocated and initialized
	  (base class and its extension):
	  this->rpclass = &<TEMPLATE>_class
	  ... other members of base class ...
   <TEMPLATE>_bind_instance
   
   <TEMPLATE>_handle_packet
   
   <TEMPLATE>_handle_message
   
   <TEMPLATE>_unbind_instance
   
   <TEMPLATE>_free_instance
	- Plugin instance memory is free
   <TEMPLATE>_unload
	- All instances are free
	- Class is not registered with PCU
*/

#include "stdinc.h"

#include "<TEMPLATE>.h"

MOD_MISC("<TEMPLATE>")

// Static plugin class structure.
// Each kernel module has one class structure that is initialized by
// the plugin and a pointer to it is returned. The class structure can then
// be used to create plugin instances. Note that this is a structure and 
// not a pointer.
static struct rp_class <TEMPLATE>_class;

// @User:  Add class-wide global variables here

void
<TEMPLATE>_init_class() {		// initialize plugin class
//
// Initialize class struct:
//   classid - user defined
//   itype   - RP_INTERFACE_TYPE_PKT - for read-only plugins. The handle packet
//             signature is <handle_packet(struct rp_instance *this, void *pkt)>
//             RP_INTERFACE_TYPE_HLIST for plugins that will modify pkts or want
//             to source or sink data. The signature is
//              <handle_packet(struct rp_instance *this, void *plist)>
//   create_instance = function pointer to your create instance method.

  <TEMPLATE>_class.classid = <TEMPLATE>_ID;
  <TEMPLATE>_class.itype   = RP_INTERFACE_TYPE_HLIST;
  <TEMPLATE>_class.create_instance = <TEMPLATE>_create_instance;
  return;
}

// --| create and initialize an instance of <TEMPLATE> |--
struct rp_instance *
<TEMPLATE>_create_instance(
  struct rp_class *myclass,		// points to class structure
  u_int32_t instanceid)			// new instance identifier
{
  struct <TEMPLATE>_instance *myinst; 

  // allocate memory for local instance struct
  MSR_PLUGIN_MALLOC(myinst,struct <TEMPLATE>_instance *, 
                    sizeof(struct <TEMPLATE>_instance),
                    M_MSR, 
                    M_WAITOK);
  if (myinst == NULL)	return NULL;

  // fill in instance pointers to local methods
  myinst->rootinstance.rpclass         = &<TEMPLATE>_class;
  myinst->rootinstance.handle_packet   = <TEMPLATE>_handle_packet;
  myinst->rootinstance.free_instance   = <TEMPLATE>_free_instance;
  myinst->rootinstance.bind_instance   = <TEMPLATE>_bind_instance;
  myinst->rootinstance.unbind_instance = <TEMPLATE>_unbind_instance;
  myinst->rootinstance.handle_msg      = <TEMPLATE>_handle_msg;

  myinst->rootinstance.instanceid = instanceid;

  // @User:  Initialize instance variables here

  return (struct rp_instance *)myinst;
}

void
<TEMPLATE>_handle_packet(
  struct rp_instance *this,		// points to instance structure
  void *bufferList)			// points to list of pkt buffers
{
  struct <TEMPLATE>_instance *inst = (struct <TEMPLATE>_instance *)this;

  // @User:  Add code to handle packets here

}

/*
 @Purpose: Handle control messages.
	The request buffer 'buf' is 44 Bytes (11 ints) long. The same array
	will be used for the reply msg (i.e., request buffer is reused for
	the reply buffer and is overwritten).
 	Request Buffer (1 word = 1 int):
		Word 0	Instance number of receiver
		Word 1	Command (Operation Code)
		Word 2	Arg 0 (if any)
		...
		Word 10	Arg 8 (if any)
	Note 1:	By convention, command 0 is the 'hello' command which returns
		the plugin id and the instance number.  All other commands are
		at the discretion of the user.
	Note 2: The word preceding buf[0] contains the message header and
		contains the values of 'flags', 'seq' and '*len' which are
		passed to this routine.
 @User: Append request codes and reply args to the list below.
 Request Codes:		Reply (#: args):
	0: Hello	2: <TEMPLATE>_ID, id
	*: Hello	2: <TEMPLATE>_ID, id
*/
int
<TEMPLATE>_handle_msg(
  struct rp_instance *this,	// points to instance structure
  void *buf,			// points to request/reply buffer
  u_int8_t flags,		// flags
  u_int8_t seq,			// sequence number
  u_int8_t *len)		// IN:  request is in buf[0] thru buf[*len/4-1]
				// OUT:	reply is in buf[0] thru buf[*len/4-1]
{
  struct <TEMPLATE>_instance *inst = (struct <TEMPLATE>_instance *)this;
  u_int32_t *vals	= (u_int32_t *)buf;
  u_int32_t id		= (u_int32_t)ntohl(*vals);
  u_int32_t cmnd	= (u_int32_t)ntohl(*(vals + 1));
  struct msr_bufhdr_t *hdr;

  *vals	= (u_int32_t)htonl(<TEMPLATE>_ID);
  *(vals + 1)	= (u_int32_t)htonl(id);

  switch (cmnd) {
    case 0:	// Hello
      *len = 2 * sizeof(u_int32_t);
      break;
    case 1:
      // @User:  Add code to handle other messages here
    default:
      // @User:  Usually, a copy of the most common command reply
      *len = 2 * sizeof(u_int32_t);
      break;
  }

  return 0;
}

// --| Free instance structure |--
void
<TEMPLATE>_free_instance(
  struct rp_instance *this)	// points to instance structure
{
  if (this) {
    MSR_PLUGIN_FREE(this, M_MSR);
  }
}

// --| Bind plugin instance to filter |--
void
<TEMPLATE>_bind_instance(
  struct rp_instance *this)	// points to instance structure
{
  struct <TEMPLATE>_instance *inst = (struct <TEMPLATE>_instance *)this;

  // @User:  Define what occurs when binding your plugin here
}

// --| Unbind plugin instance from filter
void
<TEMPLATE>_unbind_instance(
  struct rp_instance *this)	// points to instance structure
{
  struct <TEMPLATE>_instance *inst = (struct <TEMPLATE>_instance *)this;

  // @User:  Define what occurs when unbinding your plugin here
}

/**
	----------------------------------------------------------------
 @User: YOU SHOULD NOT NEED TO MAKE ANY CHANGES TO THE REST OF THIS FILE
	----------------------------------------------------------------
*/

struct rp_class *
<TEMPLATE>_get_class() {	// return class structure
  return &<TEMPLATE>_class;
}

// External kernel module entry point.
//
// This function must match the name of the .o file.
// It is called each time the module is loaded or unloaded.
// The stat information is not needed here, so we will 
// leave it lkm_nofunc().
//

int
<TEMPLATE>  (
  struct lkm_table *lkmtp,	// points to loadable kernel module table
  int cmd,			// command:  load or unload
  int ver,			// version
  struct kernel_plugin_fct_struct *fctPtr)
				// points to table of kernel functions
{
  // Do NOT put anything before the kernel_plugin_fcts is set, especially if
  // it uses any of the MSR_ macros!!!
  if (kernel_plugin_fcts == NULL) {
    kernel_plugin_fcts = fctPtr;
    kernel_plugin_variables = fctPtr->pluginVariables;
  }

  MSR_PLUGIN_DISPATCH(lkmtp, cmd, ver, <TEMPLATE>_load, <TEMPLATE>_unload,
							PLUGIN_LKM_NOFUNC_FCT);
}

// This function is called each time the module is loaded
int
<TEMPLATE>_load(
  struct lkm_table *lkmtp,	// points to loadable kernel module table
  int cmd)			// command (should be load)
{
  int err;

  if (PLUGIN_LKM_EXISTS_FCT(lkmtp)) {	// avoid loading twice
    return (EEXIST);
  }
  <TEMPLATE>_init_class();

  err = PLUGIN_PCU_REGISTER_CLASS_FCT(<TEMPLATE>_get_class());
  if (err != RP_OK) {
    return -1;
  }

  return 0;
}

// This function is called each time the module is unloaded.
// Remove all existing instances and then remove class.
int
<TEMPLATE>_unload(
  struct lkm_table *lkmtp,	// points to loadable kernel module table
  int cmd)			// command (should beunload)
{
  struct rp_class *rpclass;
  u_int32_t cid;

  rpclass = <TEMPLATE>_get_class();
  cid = rpclass->classid;

  if (PLUGIN_PCU_FREE_ALL_INSTANCES_FCT(rpclass) != RP_OK) {
    return -1;
  }


  return 0;
}