// messageAddAVPsWithPath will dynamically add AVPs into the message
// append: append to the message, on false overwrite if AVP is single or add to group if AVP is Grouped
func messageSetAVPsWithPath(m *diam.Message, path []interface{}, avpValStr string, appnd bool, timezone string) error {
if len(path) == 0 {
return errors.New("Empty path as AVP filter")
}
dictAVPs := make([]*dict.AVP, len(path)) // for each subpath, one dictionary AVP
for i, subpath := range path {
if dictAVP, err := m.Dictionary().FindAVP(m.Header.ApplicationID, subpath); err != nil {
return err
} else if dictAVP == nil {
return fmt.Errorf("Cannot find AVP with id: %s", path[len(path)-1])
} else {
dictAVPs[i] = dictAVP
}
}
if dictAVPs[len(path)-1].Data.Type == diam.GroupedAVPType {
return errors.New("Last AVP in path needs not to be GroupedAVP")
}
var msgAVP *diam.AVP // Keep a reference here towards last AVP
lastAVPIdx := len(path) - 1
for i := lastAVPIdx; i >= 0; i-- {
var typeVal datatype.Type
if i == lastAVPIdx {
avpValByte, err := serializeAVPValueFromString(dictAVPs[i], avpValStr, timezone)
if err != nil {
return err
}
typeVal, err = datatype.Decode(dictAVPs[i].Data.Type, avpValByte)
if err != nil {
return err
}
} else {
typeVal = &diam.GroupedAVP{
AVP: []*diam.AVP{msgAVP}}
}
newMsgAVP := diam.NewAVP(dictAVPs[i].Code, avp.Mbit, dictAVPs[i].VendorID, typeVal) // FixMe: maybe Mbit with dictionary one
if i == lastAVPIdx-1 && !appnd { // last AVP needs to be appended in group
avps, _ := m.FindAVPsWithPath(path[:lastAVPIdx], dict.UndefinedVendorID)
if len(avps) != 0 { // Group AVP already in the message
prevGrpData := avps[0].Data.(*diam.GroupedAVP)
prevGrpData.AVP = append(prevGrpData.AVP, msgAVP)
m.Header.MessageLength += uint32(msgAVP.Len())
return nil
}
}
msgAVP = newMsgAVP
}
if !appnd { // Not group AVP, replace the previous set one with this one
avps, _ := m.FindAVPsWithPath(path, dict.UndefinedVendorID)
if len(avps) != 0 { // Group AVP already in the message
m.Header.MessageLength -= uint32(avps[0].Len()) // decrease message length since we overwrite
*avps[0] = *msgAVP
m.Header.MessageLength += uint32(msgAVP.Len())
return nil
}
}
m.AVP = append(m.AVP, msgAVP)
m.Header.MessageLength += uint32(msgAVP.Len())
return nil
}
// Parse parses and validates the given message.
func (cea *CEA) Parse(m *diam.Message) (err error) {
if err = m.Unmarshal(cea); err != nil {
return err
}
if err = cea.sanityCheck(); err != nil {
return err
}
app := &Application{
AcctApplicationID: cea.AcctApplicationID,
AuthApplicationID: cea.AuthApplicationID,
VendorSpecificApplicationID: cea.VendorSpecificApplicationID,
}
if _, err := app.Parse(m.Dictionary()); err != nil {
return err
}
cea.appID = app.ID()
return nil
}
// Parse parses and validates the given message, and returns nil when
// all AVPs are ok, and all accounting or authentication applications
// in the CER match the applications in our dictionary. If one or more
// mandatory AVPs are missing, it returns a nil failedAVP and a proper
// error. If all mandatory AVPs are present but no common application
// is found, then it returns the failedAVP (with the application that
// we don't support in our dictionary) and an error. Another cause
// for error is the presence of Inband Security, we don't support that.
func (cer *CER) Parse(m *diam.Message) (failedAVP *diam.AVP, err error) {
if err = m.Unmarshal(cer); err != nil {
return nil, err
}
if err = cer.sanityCheck(); err != nil {
return nil, err
}
if cer.InbandSecurityID != nil {
if v := cer.InbandSecurityID.Data.(datatype.Unsigned32); v != 0 {
return cer.InbandSecurityID, ErrNoCommonSecurity
}
}
app := &Application{
AcctApplicationID: cer.AcctApplicationID,
AuthApplicationID: cer.AuthApplicationID,
VendorSpecificApplicationID: cer.VendorSpecificApplicationID,
}
if failedAVP, err = app.Parse(m.Dictionary()); err != nil {
return failedAVP, err
}
cer.appID = app.ID()
return nil, nil
}