/*******************************************************************
* 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;
}
/*******************************************************************
* 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;
}
/*******************************************************************
* PCM_OP_BILL_POL_GET_PENDING_ITEMS
*
* This policy provides a hook to the Bill Now opcode for selecting
* the Pending Items to be included in the Bill. The default
* implementation select all the Pending Items to be included in the
* Bill.
*******************************************************************/
void
op_bill_pol_get_pending_items(
cm_nap_connection_t *connp,
int32 opcode,
int32 flags,
pin_flist_t *i_flistp,
pin_flist_t **r_flistpp,
pin_errbuf_t *ebufp)
{
void *vp = NULL;
pcm_context_t *ctxp = connp->dm_ctx;
*r_flistpp = NULL;
if (PIN_ERR_IS_ERR(ebufp)) {
return;
}
PIN_ERR_CLEAR_ERR(ebufp);
/*******************************************************************
* Insanity Check
*******************************************************************/
if (opcode != PCM_OP_BILL_POL_GET_PENDING_ITEMS) {
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_bill_pol_get_pending_items error",
ebufp);
return;
}
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_bill_pol_get_pending_items input flist", i_flistp);
/*******************************************************************
* Call the function in order to get pending items to be included
* into the Bill Now.
*******************************************************************/
fm_bill_pol_get_pending_items(ctxp, i_flistp, r_flistpp, ebufp);
/******************************************************************
* Set account poid and bill_type to the output flist.
******************************************************************/
vp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp);
PIN_FLIST_FLD_SET(*r_flistpp, PIN_FLD_POID, vp, ebufp);
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_bill_pol_get_pending_items error", ebufp);
}
else {
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_bill_pol_get_pending_items output flist", *r_flistpp);
}
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_RATE_POL_GET_TAXCODE operation.
*******************************************************************/
void
op_rate_pol_get_taxcode(
cm_nap_connection_t *connp,
u_int opcode,
u_int flags,
pin_flist_t *i_flistp,
pin_flist_t **o_flistpp,
pin_errbuf_t *ebufp)
{
pcm_context_t *ctxp = connp->dm_ctx;
if (PIN_ERR_IS_ERR(ebufp)) {
return;
}
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Insanity check.
***********************************************************/
if (opcode != PCM_OP_RATE_POL_GET_TAXCODE) {
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_rate_pol_get_taxcode opcode error", ebufp);
return;
/*****/
}
/***********************************************************
* Debug: What we got.
***********************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_rate_pol_get_taxcode input flist", i_flistp);
/***********************************************************
* Do the actual op in a sub.
***********************************************************/
fm_rate_pol_get_taxcode(ctxp, i_flistp, o_flistpp, ebufp);
/***********************************************************
* Error?
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_rate_pol_get_taxcode error", ebufp);
} else {
/***************************************************
* Debug: What we're sending back.
***************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_rate_pol_get_taxcode return flist", *o_flistpp);
}
return;
}
/*******************************************************************
* PCM_OP_ACT_POL_POST_AUTHORIZE
*******************************************************************/
void
op_act_pol_post_authorize(
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;
*r_flistpp = NULL;
if (PIN_ERR_IS_ERR(ebufp)) {
return;
}
PIN_ERR_CLEAR_ERR(ebufp);
/*******************************************************************
* Insanity Check
*******************************************************************/
if (opcode != PCM_OP_ACT_POL_POST_AUTHORIZE) {
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_act_pol_post_authorize error",
ebufp);
return;
}
/*******************************************************************
* Debug: Input flist
*******************************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_act_pol_post_authorize input flist", i_flistp);
/*******************************************************************
* Call the default implementation
*******************************************************************/
fm_act_pol_post_authorize(ctxp, flags, i_flistp, r_flistpp, ebufp);
/*******************************************************************
* Errors?
*******************************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_act_pol_post_authorize error", ebufp);
}
else {
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_act_pol_post_authorize output flist",
*r_flistpp);
}
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_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 the PCM_OP_CUST_POL_PREP_TOPUP operation
*******************************************************************/
void
op_cust_pol_prep_topup(
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;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/*
* Null out results until we have some.
*/
*r_flistpp = NULL;
/*
* Insanity check.
*/
if (opcode != PCM_OP_CUST_POL_PREP_TOPUP) {
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_prep_topup", ebufp);
return;
}
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_prep_topup input flist:",
i_flistp);
/*
* Call the main function.
*/
fm_cust_pol_prep_topup(ctxp, flags, i_flistp, r_flistpp, ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_prep_topup output flist:",
*r_flistpp);
if (PIN_ERR_IS_ERR(ebufp))
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_cust_pol_prep_topup flist error",
ebufp);
return;
}
/*******************************************************************
* Main routine for the PCM_OP_BILL_POL_POST_BILLING
*******************************************************************/
void
op_bill_pol_post_billing(
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;
void *vp = NULL;
*r_flistpp = NULL;
if (PIN_ERR_IS_ERR(ebufp)) {
return;
}
PIN_ERR_CLEAR_ERR(ebufp);
/*******************************************************************
* Insanity check.
*******************************************************************/
if (opcode != PCM_OP_BILL_POL_POST_BILLING) {
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_bill_pol_post_billing bad opcode error",
ebufp);
return;
}
/*******************************************************************
* Debug: What we got.
*******************************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_bill_pol_post_billing input flist", i_flistp);
/*******************************************************************
* Call the default implementation in order to stop billing of the
* closed accounts
*******************************************************************/
fm_bill_pol_stop_billing(ctxp, flags, i_flistp, r_flistpp, ebufp);
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"op_bill_pol_post_billing error", ebufp);
} else {
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_bill_pol_post_billing output flist", *r_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;
}
/*******************************************************************
* Main routine for the PCM_OP_CUST_POL_TAX_INIT command
*******************************************************************/
void
op_cust_pol_tax_init(
cm_nap_connection_t *connp,
int32 opcode,
int32 flags,
pin_flist_t *in_flistp,
pin_flist_t **out_flistpp,
pin_errbuf_t *ebufp)
{
pcm_context_t *ctxp = connp->dm_ctx;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/*
* Insanity check.
*/
if (opcode != PCM_OP_CUST_POL_TAX_INIT) {
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_cust_pol_tax_init opcode error", ebufp);
return;
}
/*
* Debug - What we got.
*/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_tax_init input flist", in_flistp);
/*
* Do the actual op in a sub.
*/
fm_cust_pol_tax_init(ctxp, in_flistp, out_flistpp, ebufp);
/*
* Error?
*/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_tax_init error", ebufp);
} else {
/*
* Debug: What we're sending back.
*/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG,
"op_cust_pol_tax_init return flist", *out_flistpp);
}
return;
}
/*******************************************************************
* Main routine for the PCM_OP_CREATE_METAFIELD operation.
*******************************************************************/
void
op_create_metafield(
cm_nap_connection_t *connp,
int32 opcode,
int32 flags,
pin_flist_t *in_flistp,
pin_flist_t **ret_flistpp,
pin_errbuf_t *ebufp)
{
pcm_context_t *ctxp = connp->dm_ctx;
void *vp =NULL;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Insanity check.
***********************************************************/
if (opcode != PCM_OP_CREATE_METAFIELD) {
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_create_metafield opcode error", ebufp);
return;
}
/***********************************************************
* Debug: What we got.
***********************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_create_metafield input flist", in_flistp);
/***********************************************************
* Do the actual op in a sub-function.
***********************************************************/
fm_cust_pol_create_metafield_obj(ctxp, flags, in_flistp, ret_flistpp, ebufp);
/***********************************************************
* Error?
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp))
{
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR, "op_create_metafield error", ebufp);
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_ERROR, "op_create_metafield return flist", *ret_flistpp);
}
else
{
/***************************************************
* Debug: What we're sending back.
***************************************************/
PIN_ERR_LOG_FLIST(PIN_ERR_LEVEL_DEBUG, "op_create_metafield return flist", *ret_flistpp);
vp = PIN_FLIST_FLD_GET(*ret_flistpp,PIN_FLD_POID,1,ebufp);
if(PIN_POID_IS_NULL(vp)==0)
PIN_ERR_LOG_POID(PIN_ERR_LEVEL_DEBUG, "metafield poid created is", vp);
}
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;
};
/*******************************************************************
* fm_cust_pol_str_to_time_t ()
*
*******************************************************************/
static void
fm_cust_pol_str_to_time_t(
char *str,
time_t *time_ptr,
int32 flag)
{
struct tm *tm = 0;
time_t cur_time = 0;
int32 dd = 0;
int32 mm = 0;
int32 yy = 0;
char delim[5] = {0};
pin_errbuf_t *ebufp = NULL;
*time_ptr = 0;
if (*str == '\0') {
if (flag) {
strcpy(str, "01/01/2038");
} else {
strcpy(str, "01/01/1970");
}
}
/* parse the date */
sscanf(str, "%d%[/.-]%d%[/.-]%d", &mm, delim, &dd, delim, &yy);
/* get virtual time to set defaults */
pin_virtual_time(&cur_time);
tm = localtime(&cur_time);
if(!tm) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_BAD_VALUE,
0, 0, 0);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"NULL pointer returned from localtime", ebufp);
return;
}
if (yy < 70) {
/* assume years < 70 are after 2000 */
yy += 100;
} else if (yy > 1900) {
yy -= 1900;
}
tm->tm_mday = dd;
tm->tm_mon = mm - 1;
tm->tm_year = yy;
tm->tm_sec = 0;
tm->tm_min = 0;
tm->tm_hour = 0;
tm->tm_isdst = -1;
if (flag) {
/* make it the end of the day */
tm->tm_mday = dd + 1;
tm->tm_sec = -1;
}
*time_ptr = mktime(tm);
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;
}
/*******************************************************************
* 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;
}
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;
}
/*******************************************************************
* fm_cust_pol_valid_passwd()
*
* Validate the given passwd according to the given poid type.
*
*******************************************************************/
static void
fm_cust_pol_valid_passwd(
pcm_context_t *ctxp,
pin_flist_t *in_flistp,
pin_flist_t **out_flistpp,
pin_errbuf_t *ebufp)
{
pin_flist_t *r_flistp = NULL;
poid_t *o_pdp;
const char *o_type = NULL;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Create outgoing flist
***********************************************************/
r_flistp = PIN_FLIST_CREATE(ebufp);
*out_flistpp = r_flistp;
/***********************************************************
* Get (and add) the object poid.
***********************************************************/
o_pdp = (poid_t *)PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp);
PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_POID, (void *)o_pdp, ebufp);
/***********************************************************
* We might have different rules for different services.
***********************************************************/
o_type = PIN_POID_GET_TYPE(o_pdp);
if (!strncmp(o_type, "/service", 8)) {
/* Any service password */
fm_cust_pol_valid_pwd_srvc(ctxp, in_flistp, r_flistp, ebufp);
} else {
/* Error - unknown/usupported type */
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_BAD_POID_TYPE, PIN_FLD_POID, 0, 0);
}
/***********************************************************
* Error?
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_cust_pol_valid_passwd error", ebufp);
}
return;
}
/*******************************************************************
* fm_cust_pol_valid_pwd_srvc():
*
* Validate the service level password.
*
*******************************************************************/
static void
fm_cust_pol_valid_pwd_srvc(
pcm_context_t *ctxp,
pin_flist_t *i_flistp,
pin_flist_t *r_flistp,
pin_errbuf_t *ebufp)
{
u_int result;
const char *pwd = NULL;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Pass by default.
***********************************************************/
result = PIN_CUST_VERIFY_PASSED;
PIN_FLIST_FLD_SET(r_flistp, PIN_FLD_RESULT, (void *)&result, ebufp);
pwd = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_PASSWD_CLEAR, 0, ebufp);
if (pwd && !strncmp(pwd, FM_PWD_INVALID_PASSWD, strlen(FM_PWD_INVALID_PASSWD))) {
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_ERROR, " Invalid Password.");
pin_errbuf_set_err( ebufp, PIN_ERRLOC_FM, PIN_ERRCLASS_SYSTEM_DETERMINATE,
PIN_ERR_VALIDATION_FAILED, 0, 0, 0, PIN_DOMAIN_ERRORS,
PIN_ERR_VALIDATE_PASSWORD,1, 0, NULL);
goto cleanup;
/***********/
}
/***********************************************************
* If it's there, is it too long?
* Try to validate based on /config/fld_validate (Pswd) obj.
***********************************************************/
fm_cust_pol_validate_fld_value( ctxp, i_flistp, i_flistp, r_flistp,
PIN_FLD_PASSWD_CLEAR,
0, /* element_id */
"Pswd",
1,
ebufp);
cleanup:
/***********************************************************
* Error?
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_cust_pol_valid_pwd_srvc error", ebufp);
}
return;
}
/************************************************************************
* fm_bill_pol_reverse_payment()
************************************************************************/
static void
fm_bill_pol_reverse_payment(
pcm_context_t *ctxp,
int flags,
pin_flist_t *in_flistp,
pin_flist_t **ret_flistpp,
pin_errbuf_t *ebufp)
{
poid_t *a_pdp = NULL;
pin_flist_t *inh_flistp = NULL;
if (PIN_ERR_IS_ERR(ebufp)){
return;
}
PIN_ERR_CLEAR_ERR(ebufp);
*ret_flistpp = PIN_FLIST_CREATE(ebufp);
/***********************************************************
* Get and set PIN_FLD_POID in the output flist
***********************************************************/
a_pdp = PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp);
PIN_FLIST_FLD_SET(*ret_flistpp, PIN_FLD_POID, (void *)a_pdp, ebufp);
/***********************************************************
* Get INHERITED_INFO from the input flist and
* Set in the ouput flist if present
***********************************************************/
inh_flistp = PIN_FLIST_SUBSTR_GET(in_flistp,
PIN_FLD_INHERITED_INFO, 1, ebufp);
if ( inh_flistp ) {
PIN_FLIST_SUBSTR_SET(*ret_flistpp, inh_flistp,
PIN_FLD_INHERITED_INFO, ebufp);
}
fm_bill_pol_reverse_payment_writeoff_account(ctxp, flags, in_flistp,
ebufp);
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_bill_pol_reverse_payment error", ebufp);
} else {
PIN_ERR_CLEAR_ERR(ebufp);
}
return;
}
/************************************************************************
* fm_validate_existence ()
*
* Function to validate the existence of a field. If a null
* pointer was found, an error is returned. The *empty_field
* flag will be set to PIN_BOOLEAN_TRUE if there's a 0 length
* string found. This routine does NOT initialize this flag.
*
************************************************************************/
void
fm_validate_existence(
pin_flist_t *flistp, /* Pointer to input flist */
int partial, /* if set, no mandatory fields */
pin_flist_t *r_flistp, /* Pointer to return flist */
u_int pin_fld_field_num, /* Field currently checked */
u_int pin_fld_element_id, /* Element id of current array */
u_int *empty_field, /* 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);
/****************************************************************
* Only fill the failed field descriptor if the field exists but
* there is nothing there (i.e. *vp == '\0').
****************************************************************/
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 != (char *)NULL && (!partial))
{
if (strlen(vp) == 0)
{
(void)fm_cust_pol_valid_add_fail(r_flistp,
pin_fld_field_num, pin_fld_element_id,
PIN_CUST_VAL_ERR_MISSING,
"Missing field.", vp, ebufp);
*empty_field = PIN_BOOLEAN_TRUE;
}
} else if (!partial) {
pin_set_err(ebufp, PIN_ERRLOC_FM,
PIN_ERRCLASS_SYSTEM_DETERMINATE, PIN_ERR_MISSING_ARG,
pin_fld_field_num, pin_fld_element_id, 0);
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_validate_existence(): NULL ptr.", ebufp);
}
return;
}
/*******************************************************************
* fm_pymt_pol_charge()
******************************************************************/
static void
fm_pymt_pol_charge(
pcm_context_t *ctxp,
pin_flist_t *i_flistp,
pin_flist_t *r_flistp,
pin_errbuf_t *ebufp)
{
if (PIN_ERR_IS_ERR(ebufp))
{
return ;
}
PIN_ERR_CLEAR_ERR(ebufp);
fm_pymt_pol_charge_set_reason_id(ctxp,r_flistp, ebufp);
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_pymt_pol_charge", ebufp);
}
return;
}
/*******************************************************************
* fm_cust_pol_pre_commit()
*
* Pre-creation legacy system hook.
*
* XXX NOOP - STUBBED ONLY XXX
*
*******************************************************************/
static void
fm_cust_pol_pre_commit(
pcm_context_t *ctxp,
u_int flags,
pin_flist_t *in_flistp,
pin_flist_t **out_flistpp,
pin_errbuf_t *ebufp)
{
void *vp;
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
/***********************************************************
* Create outgoing flist
***********************************************************/
*out_flistpp = PIN_FLIST_CREATE(ebufp);
vp = PIN_FLIST_FLD_GET(in_flistp, PIN_FLD_POID, 0, ebufp);
PIN_FLIST_FLD_SET(*out_flistpp, PIN_FLD_POID, vp, ebufp);
/***********************************************************
* Check if Out Of Order detection feature is enabled.
* If so, create the /profile/event_ordering object.
***********************************************************/
if (fm_cust_pol_pre_commit_is_OOD_feature_enabled(ctxp, in_flistp, ebufp)) {
fm_cust_pol_pre_commit_create_profile_OOD_obj(ctxp, flags, in_flistp, ebufp);
}
/***********************************************************
* Error?
***********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_cust_pol_pre_commit error", ebufp);
}
return;
}
/*******************************************************************
* This is the default implementation for this policy
*******************************************************************/
static void
fm_act_pol_pre_reauthorize(
pcm_context_t *ctxp,
int32 flags,
pin_flist_t *i_flistp,
pin_flist_t **r_flistpp,
pin_errbuf_t *ebufp)
{
if (PIN_ERR_IS_ERR(ebufp))
return;
*r_flistpp = PIN_FLIST_COPY(i_flistp, ebufp);
/*********************************************************
* Errors..?
*********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_act_pol_pre_reauthorize error",ebufp);
}
return;
}
/*******************************************************************
* This is the default implementation for this policy
*******************************************************************/
static void
fm_act_pol_post_authorize(
pcm_context_t *ctxp,
int32 flags,
pin_flist_t *i_flistp,
pin_flist_t **r_flistpp,
pin_errbuf_t *ebufp)
{
pin_flist_t *rate_flistp = NULL;
int32 elemid = 0;
if (PIN_ERR_IS_ERR(ebufp))
return;
*r_flistpp = PIN_FLIST_COPY(i_flistp, ebufp);
/* IF rating result is present in the output flist, drop it.
* By default we will drop this flist, to trim the final output flist.
* If any of the vertical managers need this rating output, they need
* to customize the policy.
*/
rate_flistp = PIN_FLIST_ELEM_GET(*r_flistpp, PIN_FLD_RESULTS,
elemid, 1, ebufp);
if (rate_flistp) {
PIN_FLIST_ELEM_DROP(*r_flistpp, PIN_FLD_RESULTS, elemid, ebufp);
}
/*********************************************************
* Errors..?
*********************************************************/
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_act_pol_post_authorize error",ebufp);
}
return;
}
/*****************************************************************
* fm_pymt_pol_charge_set_domain_id()
* Function to set the reason domain ID
******************************************************************/
static void
fm_pymt_pol_charge_set_domain_id(
pcm_context_t *ctxp,
pin_flist_t *i_flistp,
pin_flist_t *res_flistp,
int32 *domain_idp,
pin_errbuf_t *ebufp)
{
void *vp = NULL;
if (PIN_ERR_IS_ERR(ebufp))
{
return ;
}
PIN_ERR_CLEAR_ERR(ebufp);
vp = PIN_FLIST_FLD_GET(i_flistp,
PIN_FLD_REASON_DOMAIN_ID, 1,ebufp);
/*****************************************************
* Set the domain ID in the Results array
*****************************************************/
if(!vp){
PIN_FLIST_FLD_SET(res_flistp, PIN_FLD_REASON_DOMAIN_ID,
(void *) domain_idp, ebufp);
}
else{
PIN_FLIST_FLD_SET(res_flistp, PIN_FLD_REASON_DOMAIN_ID,
vp, ebufp);
}
if (PIN_ERR_IS_ERR(ebufp)) {
PIN_ERR_LOG_EBUF(PIN_ERR_LEVEL_ERROR,
"fm_pymt_pol_charge_set_domain_id", ebufp);
}
return ;
}
