/********************************************************************
* 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 ;
}
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;
}
/*******************************************************************
* 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;
}
/*******************************************************************
* 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;
}
/*******************************************************************
* 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;
}
/*******************************************************************
* 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;
}
/*******************************************************************
* 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;
}
/*******************************************************************
* 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;
}
/*******************************************************************
* 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_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;
}
/*******************************************************************
* 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_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_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;
}
/*******************************************************************
* 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_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;
}
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;
}
/*******************************************************************
* 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;
}
/************************************************************************
* 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;
}
/*******************************************************************
* 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;
}
bool
bs_CreateLECRecourse::createRecourse(
pin_Session * pinp,
c_NvRecord& nv,
pin_flist_t **return_flistpp,
pin_errbuf_t *ebufp )
{
const char * file_name = NULL;
string title("LEC Recourse nvRec"); nv.StringBuffer(title);
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG, (char*)title.c_str() );
///
/// -- translation ---------------------------
///
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG,(char*)"Unpacking..." );
string sBtn = nv.value("BTN");
string sAmount = nv.value("AMOUNT");
string sRecordType = nv.value("TYPE");
string sAuthDate = nv.value("DATE");
string sReasonCode = nv.value("RESULT");
string fn = nv.value("FILENAME");
string sVersion = nv.value("VER");
if (! fn.empty() )
file_name = fn.c_str();
//---e default values
if (sReasonCode.empty())sReasonCode.assign("00");
if (sAuthDate.empty())sAuthDate.assign("080228");
///
/// -- call base function ---------------------------
///
PIN_ERR_LOG_MSG(PIN_ERR_LEVEL_DEBUG,(char*)"Calling base function..." );
PIN_ERR_CLEAR_ERR(ebufp);
bs_CreateLECRecourse::createRecourse(
pinp,
sRecordType.c_str(),
sBtn.c_str(),
sAuthDate.c_str(),
sReasonCode.c_str(),
sAmount.c_str(),
sVersion.c_str(),
file_name,
return_flistpp, ebufp );
if (PIN_ERR_IS_ERR(ebufp))
return false;
return true;
};
/*******************************************************************
* 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;
}
/*******************************************************************
* 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;
}
/****************************************************************
* Function : fm_cust_pol_prep_modify_sponsored_topup
* Description : Noting to prepare. late custer can add.
****************************************************************/
static void fm_cust_pol_prep_modify_sponsored_topup(
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;
PIN_ERR_CLEAR_ERR(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;
}
/*******************************************************************
* fm_bill_pol_spec_billno()
*
* Prep the billno for the given bill obj.
*
*******************************************************************/
static void
fm_bill_pol_spec_billno(
pcm_context_t *ctxp,
u_int flags,
pin_flist_t *in_flistp,
pin_flist_t **out_flistpp,
pin_errbuf_t *ebufp)
{
pin_flist_t *b_flistp = NULL;
poid_t *pdp = NULL;
void *vp = NULL;
int64 poid_db;
int64 poid_id;
char billno[60];
if (PIN_ERR_IS_ERR(ebufp))
return;
PIN_ERR_CLEAR_ERR(ebufp);
b_flistp = PIN_FLIST_COPY(in_flistp, ebufp);
/***********************************************************
* We don't need a bill_no if the bill type is subordinate.
***********************************************************/
vp = PIN_FLIST_FLD_GET(b_flistp, PIN_FLD_PAY_TYPE, 0, ebufp);
if (vp != (void *)NULL) {
PIN_FLIST_FLD_DROP(b_flistp, PIN_FLD_PAY_TYPE, ebufp);
}
/***********************************************************
* Set the BILL_NO field according to poid.
***********************************************************/
vp = PIN_FLIST_FLD_GET(b_flistp, PIN_FLD_BILL_NO, 1, ebufp);
if ((vp == (void *)NULL) || (strlen((char *)vp) <= 0)) {
pdp = (poid_t *)PIN_FLIST_FLD_GET(in_flistp,
PIN_FLD_POID, 0, ebufp);
poid_db = PIN_POID_GET_DB(pdp);
poid_id = PIN_POID_GET_ID(pdp);
sprintf(billno, "%u.%u.%u.%u-%llu",
(u_int)((poid_db & (u_int64)MASKUPPER) >> 48),
(u_int)((poid_db & (u_int64)MASKSECOND) >> 32),
(u_int)((poid_db & (u_int64)MASKTHIRD) >> 16),
(u_int)(poid_db & (u_int64)0xFFFF), poid_id);
PIN_FLIST_FLD_SET(b_flistp, PIN_FLD_BILL_NO,
(void *)billno, ebufp);
}
/*******************************************************************
* fm_device_pol_set_state:
*
*******************************************************************/
static void
fm_device_pol_set_state(
pcm_context_t *ctxp,
int32 flags,
pin_flist_t *i_flistp,
pin_flist_t **r_flistpp,
pin_errbuf_t *ebufp)
{
poid_t *dev_poidp = NULL;
char *poid_type = NULL;
if (PIN_ERR_IS_ERR(ebufp)) {
return;
}
PIN_ERR_CLEAR_ERR(ebufp);
/*
* Get the old device object poid
*/
dev_poidp = PIN_FLIST_FLD_GET(i_flistp, PIN_FLD_POID, 0, ebufp);
/*
* Get the device poid type
* this poid will be used in identifiing different Devices like sim,num..
*/
poid_type = (char *) PIN_POID_GET_TYPE(dev_poidp);
if (strcmp(poid_type, PIN_OBJ_TYPE_DEVICE_IP) == 0) {
/*
* call IP policy to do the work we want
*/
PCM_OP(ctxp, PCM_OP_IP_POL_DEVICE_SET_STATE, flags, i_flistp,
r_flistpp, ebufp);
} else if (strcmp(poid_type, PIN_OBJ_TYPE_DEVICE_APN) == 0) {
/*
* call APN policy to do the work we want
*/
PCM_OP(ctxp, PCM_OP_APN_POL_DEVICE_SET_STATE, flags, i_flistp,
r_flistpp, ebufp);
}
else {
/***********************************************************
* Prepare return flist
***********************************************************/
*r_flistpp = PIN_FLIST_COPY(i_flistp, 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;
}