C++ PIN_ERR_CLEAR_ERR函数代码示例

/*******************************************************************
 * Main routine for the PCM_OP_CUST_POL_VALID_STATUS operation.
 *******************************************************************/
void
op_cust_pol_valid_status(
        cm_nap_connection_t	*connp,
	u_int			opcode,
        u_int			flags,
        pin_flist_t		*i_flistp,
        pin_flist_t		**ret_flistpp,
        pin_errbuf_t		*ebufp)
{
	pcm_context_t		*ctxp = connp->dm_ctx;
	pin_flist_t		*r_flistp = NULL;


	/*
	 * Null out results until we have some.
	 */
	*ret_flistpp = NULL;
	PIN_ERR_CLEAR_ERR(ebufp);

	/*
	 * Insanity check.
	 */
	if (opcode != PCM_OP_CUST_POL_VALID_STATUS) {
		pin_set_err(ebufp, PIN_ERRLOC_FM,
			PIN_ERRCLASS_SYSTEM_DETERMINATE,
			PIN_ERR_BAD_OPCODE, 0, 0, opcode);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"bad opcode in op_cust_pol_valid_status", ebufp);
		return; 
	}

	/*
	 * Debug: what did we get?
	 */
	PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
		"op_cust_pol_valid_status input flist", i_flistp);

	/*
	 * Call main function to do it
	 */
	fm_cust_pol_valid_status(ctxp, i_flistp, &r_flistp, ebufp);

	/*
	 * Results.
	 */
	if (PIN_ERR_IS_ERR(ebufp)) {
		*ret_flistpp = (pin_flist_t *)NULL;
		PIN_FLIST_DESTROY(r_flistp, NULL);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"op_cust_pol_valid_status error", ebufp);
	} else {
		*ret_flistpp = r_flistp;
		PIN_ERR_CLEAR_ERR(ebufp);
		PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
			"op_cust_pol_valid_status return flist", r_flistp);
	}

	return;
}

/*******************************************************************
 * Main routine for the PCM_OP_CUST_POL_READ_PLAN operation. 
 *******************************************************************/
void
op_cust_pol_read_plan(
        cm_nap_connection_t	*connp,
	int32			opcode,
        int32			flags,
        pin_flist_t		*i_flistp,
        pin_flist_t		**ret_flistpp,
        pin_errbuf_t		*ebufp)
{
	pcm_context_t		*ctxp = connp->dm_ctx;
	pin_flist_t		*r_flistp = NULL;

	/***********************************************************
	 * Null out results until we have some.
	 ***********************************************************/
	*ret_flistpp = NULL;
	PIN_ERR_CLEAR_ERR(ebufp);

	/***********************************************************
	 * Insanity check.
	 ***********************************************************/
	if (opcode != PCM_OP_CUST_POL_READ_PLAN) {
		pin_set_err(ebufp, PIN_ERRLOC_FM,
			PIN_ERRCLASS_SYSTEM_DETERMINATE,
			PIN_ERR_BAD_OPCODE, 0, 0, opcode);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"bad opcode in op_cust_pol_read_plan", ebufp);
		return;
	}

	/***********************************************************
	 * Debug: What did we get?
	 ***********************************************************/
	PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
		"op_cust_pol_read_plan input flist", i_flistp);

	/***********************************************************
	 * Call main function to do it
	 ***********************************************************/
	fm_cust_pol_read_plan(ctxp, i_flistp, &r_flistp, ebufp);

	/***********************************************************
	 * Set the results.
	 ***********************************************************/
	if (PIN_ERR_IS_ERR(ebufp)) {
		*ret_flistpp = NULL;
		PIN_FLIST_DESTROY_EX(&r_flistp, NULL);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"op_cust_pol_read_plan error", ebufp);
	} else {
		*ret_flistpp = r_flistp;
		PIN_ERR_CLEAR_ERR(ebufp);
		PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
			"op_cust_pol_read_plan return flist", *ret_flistpp);
	}

	return;
}

/*******************************************************************
 * Main routine for the PCM_OP_CUST_POL_PRE_COMMIT  command
 *******************************************************************/
void
op_cust_pol_pre_commit(
        cm_nap_connection_t	*connp,
	u_int			opcode,
        u_int			flags,
        pin_flist_t		*in_flistp,
        pin_flist_t		**ret_flistpp,
        pin_errbuf_t		*ebufp)
{
	pcm_context_t		*ctxp = connp->dm_ctx;
	pin_flist_t		*r_flistp = NULL;

	/***********************************************************
	 * Null out results until we have some.
	 ***********************************************************/
	*ret_flistpp = NULL;
	PIN_ERR_CLEAR_ERR(ebufp);

	/***********************************************************
	 * Insanity check.
	 ***********************************************************/
	if (opcode != PCM_OP_CUST_POL_PRE_COMMIT) {
		pin_set_err(ebufp, PIN_ERRLOC_FM,
			PIN_ERRCLASS_SYSTEM_DETERMINATE,
			PIN_ERR_BAD_OPCODE, 0, 0, opcode);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"bad opcode in op_cust_pol_pre_commit", ebufp);
		return;
	}

	/***********************************************************
	 * We will not open any transactions with Policy FM
	 * since policies should NEVER modify the database.
	 ***********************************************************/

	/***********************************************************
	 * Call main function to do it
	 ***********************************************************/
	fm_cust_pol_pre_commit(ctxp, flags, in_flistp, &r_flistp, ebufp);

	/***********************************************************
	 * Results.
	 ***********************************************************/
	if (PIN_ERR_IS_ERR(ebufp)) {
		*ret_flistpp = (pin_flist_t *)NULL;
		PIN_FLIST_DESTROY(r_flistp, NULL);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"op_cust_pol_pre_commit error", ebufp);
	} else {
		*ret_flistpp = r_flistp;
		PIN_ERR_CLEAR_ERR(ebufp);
		PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
			"op_cust_pol_pre_commit return flist", r_flistp);
	}

	return;
}

/*******************************************************************
 * Main routine for the PCM_OP_CUST_POL_GET_CONFIG operation.
 *******************************************************************/
void
op_cust_pol_get_config(
        cm_nap_connection_t	*connp,
	u_int			opcode,
        u_int			flags,
        pin_flist_t		*in_flistp,
        pin_flist_t		**ret_flistpp,
        pin_errbuf_t		*ebufp)
{
	pcm_context_t		*ctxp = connp->dm_ctx;
	pin_flist_t		*r_flistp = NULL;

	if (PIN_ERR_IS_ERR(ebufp))
		return;
	PIN_ERR_CLEAR_ERR(ebufp);

	/***********************************************************
	 * Insanity check.
	 ***********************************************************/
	if (opcode != PCM_OP_CUST_POL_GET_CONFIG) {
		pin_set_err(ebufp, PIN_ERRLOC_FM,
			PIN_ERRCLASS_SYSTEM_DETERMINATE,
			PIN_ERR_BAD_OPCODE, 0, 0, opcode);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"bad opcode in op_cust_pol_get_config",  ebufp);
		return;
	}

	/***********************************************************
	 * Debug: What did we get?
	 ***********************************************************/
	PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
		"op_cust_pol_get_config input flist", in_flistp);

	/***********************************************************
	 * Call main function to do it
	 ***********************************************************/
	fm_cust_pol_get_config(ctxp, in_flistp, &r_flistp, ebufp);

	/***********************************************************
	 * Results.
	 ***********************************************************/
	if (PIN_ERR_IS_ERR(ebufp)) {
		*ret_flistpp = (pin_flist_t *)NULL;
		PIN_FLIST_DESTROY(r_flistp, NULL);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"op_cust_pol_get_config error", ebufp);
	} else {
		*ret_flistpp = r_flistp;
		PIN_ERR_CLEAR_ERR(ebufp);
		PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
			"op_cust_pol_get_config return flist", r_flistp);
	}

	return;
}

/*******************************************************************
 * Main routine for PCM_OP_BILL_POL_REVERSE_PAYMENT  
 *******************************************************************/
void
op_bill_pol_reverse_payment(
	cm_nap_connection_t	*connp,
	int			opcode,
	int			flags,
	pin_flist_t		*in_flistp,
	pin_flist_t		**ret_flistpp,
	pin_errbuf_t		*ebufp)
{
	pcm_context_t		*ctxp = connp->dm_ctx;

	if (PIN_ERR_IS_ERR(ebufp)) {
		return;
	}
	PIN_ERR_CLEAR_ERR(ebufp);

	/***********************************************************
	 * Null out results until we have some.
	 ***********************************************************/
	*ret_flistpp = (pin_flist_t *)NULL;

	/***********************************************************
	 * Insanity check.
	 ***********************************************************/
	if (opcode != PCM_OP_BILL_POL_REVERSE_PAYMENT) {
		pin_set_err(ebufp, PIN_ERRLOC_FM,
			PIN_ERRCLASS_SYSTEM_DETERMINATE,
			PIN_ERR_BAD_OPCODE, 0, 0, opcode);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"bad opcode in op_bill_pol_reverse_payment", ebufp);
		return;
	}

	/***********************************************************
	 * Debug: What did we get?
	 ***********************************************************/
	PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
		"op_bill_pol_reverse_payment input flist", in_flistp);
	
	fm_bill_pol_reverse_payment(ctxp, flags, in_flistp, ret_flistpp, ebufp);	

	/***********************************************************
	* Results.
	***********************************************************/
	if (PIN_ERR_IS_ERR(ebufp)) {
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"op_bill_pol_reverse_payment error", ebufp);
	} else {
		PIN_ERR_CLEAR_ERR(ebufp);
		PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
			"op_bill_pol_reverse_payment return flist", 
			*ret_flistpp);
	}

	return;
}

/*******************************************************************
 * Main routine for the PCM_OP_PRICE_POL_PREP_DEPENDENCY  command
 *******************************************************************/
EXPORT_OP void
op_price_pol_prep_dependency(
        cm_nap_connection_t	*connp,
	u_int32			opcode,
        u_int32			flags,
        pin_flist_t		*i_flistp,
        pin_flist_t		**o_flistpp,
        pin_errbuf_t		*ebufp)
{
	pcm_context_t		*ctxp = connp->dm_ctx;
	pin_flist_t		*r_flistp = NULL;

	if (PIN_ERR_IS_ERR(ebufp))
		return;
	PIN_ERR_CLEAR_ERR(ebufp);

	/*
	 * Null out results until we have some.
	 */
	*o_flistpp = NULL;

	/*
	 * Insanity check.
	 */
	if (opcode != PCM_OP_PRICE_POL_PREP_DEPENDENCY) {
		pin_set_err(ebufp, PIN_ERRLOC_FM,
			PIN_ERRCLASS_SYSTEM_DETERMINATE,
			PIN_ERR_BAD_OPCODE, 0, 0, opcode);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"bad opcode in op_price_pol_prep_dependency", ebufp);
		return;
	}

	/*
	 * Do the actual prep in a lower routine
	 */
	fm_price_pol_prep_dependency(ctxp, flags, i_flistp, &r_flistp, ebufp);

	/*
	 * Results.
	 */
	if (PIN_ERR_IS_ERR(ebufp)) {
		*o_flistpp = (pin_flist_t *)NULL;
		PIN_FLIST_DESTROY(r_flistp, NULL);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"op_price_pol_prep_dependency error", ebufp);
	} else {
		*o_flistpp = r_flistp;
		PIN_ERR_CLEAR_ERR(ebufp);
		PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
			"op_price_pol_prep_dependency return flist", r_flistp);
	}

	return;
}

/********************************************************************
 * fm_bal_pol_get_bal_grp_and_svc()
 ********************************************************************/
static void 
fm_bal_pol_get_bal_grp_and_svc(
	pcm_context_t           *ctxp,
	int			flags,
	pin_flist_t 		*i_flistp,
	pin_flist_t 		*r_flistp,
	pin_errbuf_t            *ebufp)
{
	int             err = PIN_ERR_NONE;
	

	if (PIN_ERR_IS_ERR(ebufp))
	{
		return ;
	}
        PIN_ERR_CLEAR_ERR(ebufp);


	if (PIN_ERR_IS_ERR(ebufp)){
		/***************************************************
		 * Log Error Buffer and return.
		 ***************************************************/
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"fm_bal_pol_get_bal_grp_and_svc error", ebufp);
	}
	return ;
}

/************************************************************************
 * fm_validate_existence_and_get ()
 *
 *   	Function to validate the existence of a field.  If a null
 *	pointer was found, an error is returned.  If not, then the
 *      (pointer to the) value is returned.
 *
 ************************************************************************/
void
fm_validate_existence_and_get(
pin_flist_t	*flistp,		/* Pointer to input flist	*/
int		partial,		/* If set, no mandatory fields  */
u_int		pin_fld_field_num,	/* Field currently checked	*/
void		**valpp,  		/* Set if empty field found	*/
pin_errbuf_t	*ebufp)			/* Error buffer pointer		*/

{
	void	*vp = NULL;			/* Void pointer			*/

	if (PIN_ERR_IS_ERR(ebufp))
		return;
	PIN_ERR_CLEAR_ERR(ebufp);

	if (partial) {
		vp = PIN_FLIST_FLD_GET(flistp, pin_fld_field_num, 1, ebufp);
	} else {
		vp = PIN_FLIST_FLD_GET(flistp, pin_fld_field_num, 0, ebufp);
	}

	if ( (vp == (void *)NULL)  && !partial) {
		pin_set_err(ebufp, PIN_ERRLOC_FM,
			    PIN_ERRCLASS_SYSTEM_DETERMINATE, 
			    PIN_ERR_MISSING_ARG,
			    pin_fld_field_num, 0, 0);
                PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
				 "fm_validate_existence(): NULL ptr.", ebufp);
	}
	*valpp = vp;
	return;
}

static void
fm_cust_pol_set_brandinfo(
	pcm_context_t		*ctxp,
	int32			opflags,
	pin_flist_t		*i_flistp,
	pin_flist_t		**r_flistpp,
	pin_errbuf_t		*ebufp)
{
	/*
	 * If there are pending errors, then short circuit immediately
	 */
        if (PIN_ERR_IS_ERR(ebufp))
                return;
        PIN_ERR_CLEAR_ERR(ebufp);

	/* Attempt to set the brand name */
	fm_cust_pol_set_brandname(ctxp, opflags, i_flistp, r_flistpp, ebufp);

	/* If there's no pending errors, then just use what we got */
	if(!PIN_ERR_IS_ERR(ebufp)) {
		*r_flistpp = PIN_FLIST_COPY(i_flistp, ebufp);
	}

	return;
}

/*******************************************************************
 * Configuration
 *
 *	Reads the pin.conf file to determine the database we want.
 *
 *	Not actually needed here since we use PCM_CONNECT to
 *	open our database connection and get the database #
 *	returned as a by product. But this does illustrate
 *	how to use pin_conf to retrieve conf'ed info.
 *
 *******************************************************************/
void
sample_read_pin_conf(
	u_int64		*databasep,
	pin_errbuf_t	*ebufp)
{
	poid_t		*db_pdp;
	int32		err;

	/***********************************************************
	 * Clear the error buffer.
	 ***********************************************************/
	PIN_ERR_CLEAR_ERR(ebufp);

	/***********************************************************
	 * Get the config userid to determine DB.
	 *
	 * Note: This allocates a poid that we must free.
	 ***********************************************************/
        pin_conf("-", "userid", PIN_FLDT_POID, (caddr_t *)&(db_pdp), &err);
        if (err != PIN_ERR_NONE) {
		ebufp->pin_err = err;
                return;
        }
	*databasep = PIN_POID_GET_DB(db_pdp);
	PIN_POID_DESTROY(db_pdp, NULL);

	return;
}

/*******************************************************************
 * fm_price_pol_prep_dependency():
 *
 *	Prepare the given dependency flist for database insertion.
 *
 *	XXX NOOP - STUBBED PROTOTYPE ONLY XXX
 *
 *******************************************************************/
void
fm_price_pol_prep_dependency(
	pcm_context_t		*ctxp,
	u_int32			flags,
	pin_flist_t		*i_flistp,
	pin_flist_t		**o_flistpp,
        pin_errbuf_t		*ebufp)
{
	if (PIN_ERR_IS_ERR(ebufp))
		return;
	PIN_ERR_CLEAR_ERR(ebufp);

	/*
	 * Copy the input to output
	 */

	*o_flistpp = PIN_FLIST_COPY(i_flistp, ebufp);


	/*
	 * Error?
	 */
	if (PIN_ERR_IS_ERR(ebufp)) {
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"fm_price_pol_prep_dependency error", ebufp);
	}

	return;
}

/*******************************************************************
 * fm_cust_pol_get_config()
 *
 *	Policy that takes the incoming flist of info contained
 *	on an srvc array and other, and adds more information and
 *	sends out the config information in big flist.
 *
 *******************************************************************/
static void
fm_cust_pol_get_config(
	pcm_context_t		*ctxp,
	pin_flist_t		*in_flistp,
	pin_flist_t		**out_flistpp,
        pin_errbuf_t		*ebufp)
{
	if (PIN_ERR_IS_ERR(ebufp))
		return;
	PIN_ERR_CLEAR_ERR(ebufp);

	/***********************************************************
	 * Copy the incoming flist.
	 ***********************************************************/
	*out_flistpp = PIN_FLIST_COPY(in_flistp, ebufp);

	/***********************************************************
	 * Add the file configed parameters.
	 ***********************************************************/
	fm_cust_pol_read_config(*out_flistpp, in_flistp, ebufp);

	/***********************************************************
	 * Error?
	 ***********************************************************/
	if(PIN_ERR_IS_ERR(ebufp)) {
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"fm_cust_pol_get_config error", ebufp);
	}

	return;
}

bool
bs_UpdateContactInfo::updateContactInfo(
  pin_Session * pinp,
  bs_NvRecord& nv,
  pin_flist_t   **return_flistpp,
  pin_errbuf_t  *ebufp  )
{
  c_Decimal amount_cp;
  poid_t * account_pdp = NULL;
  pin_decimal_t * amountp = NULL;

  string account_no = nv.value(ACCOUNT_NO);
  string str_poid_id0 = nv.value(ACCOUNT_OBJ_ID0);
  string str_source = nv.value(SOURCE);
  bool rc = false;


  int64 database = pinp->getDBNumber();
  ostringstream account_descr;

  ///
  /// -- translation ---------------------------
  ///
  string title("updateContactInfo nvRec");
  PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG,
    (char*)nv.StringBuffer(title).c_str());

  //-- translate account poid-----------
  c_Poid account_cp;
  if ( ! nv.resolve_AccountPoid(pinp, account_cp))
  {
    pin_set_err(ebufp, PIN_ERRLOC_APP,  PIN_ERRCLASS_APPLICATION,
        PIN_ERR_NOT_FOUND,PIN_FLD_ACCOUNT_OBJ, 0, 0);
    PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
        (char*)"bad account info", ebufp );
    return false;
  };

  //-- translate others -----------
  bs_SignupRec bsr;
  sprintf(bsr.s_caddress, "%s\0", nv.value(CONTACT_ADDRESS).c_str());
  sprintf(bsr.s_ccity,  "%s\0",nv.value(CONTACT_CITY).c_str());
  sprintf(bsr.s_cstate, "%s\0",nv.value(CONTACT_STATE).c_str());
  sprintf(bsr.s_czip,   "%s\0",nv.value(CONTACT_ZIPCODE).c_str());
  sprintf(bsr.s_lastName, "%s\0",nv.value(CONTACT_LASTNAME).c_str());
  sprintf(bsr.s_firstName, "%s\0",  nv.value(CONTACT_FIRSTNAME).c_str());
  sprintf(bsr.s_cemail_addr,  "%s\0",nv.value(CONTACT_EMAIL).c_str());
  sprintf(bsr.s_evePhone, "%s\0", nv.value(EVENING_PHONE).c_str());
  sprintf(bsr.s_dayPhone, "%s\0", nv.value(DAY_PHONE).c_str());

  ///
  /// -- call base function ---------------------------
  ///
  PIN_ERR_CLEAR_ERR(ebufp);

  rc = bs_UpdateContactInfo::updateContactInfo(
    pinp, account_cp.borrow(), &bsr, str_source, return_flistpp, ebufp );

  return rc;
};

/*******************************************************************
 * Main routine for the PCM_OP_DEVICE_POL_SET_STATE operation.
 *******************************************************************/
void
op_device_pol_set_state(
	cm_nap_connection_t	*connp,
	int32			opcode,
	int32			flags,
	pin_flist_t		*i_flistp,
	pin_flist_t		**r_flistpp,
	pin_errbuf_t		*ebufp)
{
	pcm_context_t		*ctxp = connp->dm_ctx;
	pin_flist_t	*r_flistp = NULL;

	if (PIN_ERR_IS_ERR(ebufp))
		return;
	PIN_ERR_CLEAR_ERR(ebufp);

	/***********************************************************
	 * Null out results
	 ***********************************************************/
	*r_flistpp = NULL;

	/***********************************************************
	 * Insanity check.
	 ***********************************************************/
	if (opcode != PCM_OP_DEVICE_POL_SET_STATE) {
		pin_set_err(ebufp, PIN_ERRLOC_FM,
			PIN_ERRCLASS_SYSTEM_DETERMINATE,
			PIN_ERR_BAD_OPCODE, 0, 0, opcode);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"op_device_pol_set_state opcode error", ebufp);

		return;
	}
	
	/***********************************************************
	 * Debut what we got.
         ***********************************************************/
	PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
		"op_device_pol_set_state input flist", i_flistp);

	/***********************************************************
	 * Main rountine for this opcode
	 ***********************************************************/
	fm_device_pol_set_state(ctxp, flags, i_flistp, r_flistpp, ebufp);
	
	/***********************************************************
	 * Error?
	 ***********************************************************/
	if (PIN_ERR_IS_ERR(ebufp)) {
		PIN_FLIST_DESTROY_EX(r_flistpp, ebufp);
		PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
			"op_device_pol_set_state error", ebufp);
	} else {
		PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
			"op_device_pol_set_state output flist", *r_flistpp);
	}

	return;
}

void
op_cust_pol_set_brandinfo(
	cm_nap_connection_t	*connp,
	int32			opcode,
	int32			opflags,
	pin_flist_t		*i_flistp,
	pin_flist_t		**r_flistpp,
	pin_errbuf_t		*ebufp)
{
        pcm_context_t           *ctxp = connp->dm_ctx;

	/*
	 * If there are pending errors, then short circuit immediately
	 */
        if (PIN_ERR_IS_ERR(ebufp))
                return;
        PIN_ERR_CLEAR_ERR(ebufp);

        /*
         * Null out results until we're sure there's something to send back
         */
        *r_flistpp = NULL;

        /*
         * Sanity check -- make sure we've routed the opcode appropriately
         */
        if (opcode != PCM_OP_CUST_POL_SET_BRANDINFO) {
                pin_set_err(ebufp, PIN_ERRLOC_FM,
                        PIN_ERRCLASS_SYSTEM_DETERMINATE,
                        PIN_ERR_BAD_OPCODE, 0, 0, opcode);
                PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
                        "bad opcode in op_cust_pol_set_brandinfo", ebufp);
                return;
        }

	/*
	 * For completeness, dump the input flist if debugging is enabled.
	 */
        PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
                          "op_cust_pol_set_brandinfo input flist:",
                          i_flistp);

	/*
 	 * Call the main function -- this is where all the real work is done.
	 */
	fm_cust_pol_set_brandinfo(ctxp, opflags, i_flistp, r_flistpp, ebufp);

	/*
	 * For completeness, dump the results flist if debugging is enabled
	 * and we actually have a results flist.
	 */
	if(*r_flistpp != (pin_flist_t *)NULL) {
		PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
			"op_cust_pol_set_brandinfo output flist:",
			*r_flistpp);
	}

	return;
}