org.jdiameter.common.impl.validation.DictionaryImpl Maven / Gradle / Ivy
The newest version!
/*
* TeleStax, Open Source Cloud Communications
* Copyright 2011-2016, TeleStax Inc. and individual contributors
* by the @authors tag.
*
* This program is free software: you can redistribute it and/or modify
* under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation; either version 3 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see avpMap = new HashMap();
private Map avpByNameMap = new HashMap();
private Map vendorMap = new HashMap();
private Map commandMap = new HashMap();
private Map typedefMap = new HashMap();
private boolean configured = false;
private DictionaryImpl(InputStream is) {
init(is);
}
public static Dictionary getInstance(InputStream is) {
if (is == null) {
if (INSTANCE != null) {
return INSTANCE;
}
// Maintaining 1.7.0 behaviour
String confFile = "dictionary.xml";
is = getInputStream(confFile);
}
if (INSTANCE != null) {
((DictionaryImpl) INSTANCE).init(is);
}
else {
INSTANCE = new DictionaryImpl(is);
}
return INSTANCE;
}
public static Dictionary getInstance(String confFile) {
if (confFile == null) {
if (INSTANCE != null) {
return INSTANCE;
}
confFile = "dictionary.xml";
}
InputStream is = getInputStream(confFile);
return getInstance((InputStream) is);
}
private static InputStream getInputStream(String confFile) {
InputStream is = null;
try {
is = DictionarySingleton.class.getResourceAsStream(confFile);
if (is == null) {
logger.debug("Failed to locate dictionary configuration file: {}, in class classloader. Trying thread context class loader.", confFile);
is = Thread.currentThread().getContextClassLoader().getResourceAsStream(confFile);
}
if (is == null) {
logger.debug("Failed to locate dictionary configuration file: {}, in thread context class loader. Trying using 'config/' prefix.", confFile);
is = Thread.currentThread().getContextClassLoader().getResourceAsStream("config/" + confFile);
}
if (is == null) {
logger.debug("Failed to locate dictionary configuration file: {}, in thread context class loader. Trying regular file.", confFile);
File fDict = new File(confFile);
if (fDict.exists()) {
is = new FileInputStream(fDict);
}
else {
logger.debug("Failed to locate dictionary configuration file: {}, from regular file. Trying using 'config/' prefix.", confFile);
fDict = new File("config/" + confFile);
if (fDict.exists()) {
is = new FileInputStream(fDict);
}
}
}
}
catch (FileNotFoundException fnfe) {
logger.debug("Could not load configuration file: {}, from any known location.", confFile);
}
return is;
}
private void init(InputStream is) {
try {
if (is != null) {
this.configure(is);
}
else {
this.setEnabled(false);
logger.warn("Failed to initialize and configure Diameter Dictionary since configuration file was not found. Validator is disabled.");
}
}
finally {
if (is != null) {
try {
is.close();
}
catch (IOException e) {
logger.error("", e);
}
}
}
}
// Parser functions ---------------------------------------------------------
/*
* (non-Javadoc)
*
* @see org.jdiameter.api.validation.Dictionary#configure(java.io.InputStream)
*/
@Override
public void configure(InputStream is) {
if (is == null) {
logger.error("No input stream to configure dictionary from?");
return;
}
try {
long startTime = System.currentTimeMillis();
this.avpByNameMap = new TreeMap(new Comparator() {
@Override
public int compare(String o1, String o2) {
return (o1 == null) ? 1 : (o2 == null) ? -1 : o1.compareTo(o2);
}
});
this.vendorMap = new HashMap();
this.typedefMap = new HashMap();
this.avpMap = new HashMap();
this.commandMap = new HashMap();
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setValidating(false);
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(is);
doc.getDocumentElement().normalize();
this.parseVendors(doc);
this.parseTypeDefs(doc);
this.parseAvps(doc);
this.parseCommands(doc);
this.configured = true;
long endTime = System.currentTimeMillis();
if (logger.isInfoEnabled()) {
logger.info("Mobicents Diameter Dictionary loaded in {}ms -- Vendors[{}] Commands[{}] Types[{}] AVPs[{}]",
new Object[] { (endTime - startTime), vendorMap.size(), commandMap.size(), typedefMap.size(), avpMap.size() });
}
if (logger.isInfoEnabled()) {
StringBuffer sb = new StringBuffer();
int c = 0;
for (AvpRepresentation key : this.avpMap.keySet()) {
if (this.avpMap.get(key).isWeak()) {
c++;
sb.append("---------------------------------\n").append("Found incomplete AVP definition:\n").append(this.avpMap.get(key)).append("\n");
}
}
if (c > 0) {
sb.append("------- TOTAL INCOMPLETE AVPS COUNT: ").append(c).append(" -------");
logger.info(sb.toString());
}
}
}
catch (Exception e) {
this.enabled = false;
this.configured = false;
logger.error("Failed to parse validator configuration. Validator disabled.", e);
}
finally {
// close?
try {
is.close();
}
catch (IOException e) {
logger.debug("Failed to close InputStream for Dictionary XML.", e);
}
}
}
/**
* Parses the
//
NodeList avpDefnNodes = doc.getElementsByTagName("avpdefn");
for (int i = 0; i < avpDefnNodes.getLength(); i++) {
Node avpNode = avpDefnNodes.item(i);
Element avpDefnElement = (Element) avpNode;
String avpName = avpDefnElement.getAttribute("name");
String avpCode = avpDefnElement.getAttribute("code");
String avpVendorId = avpDefnElement.getAttribute("vendor-id");
String avpMandatory = avpDefnElement.getAttribute("mandatory");
String avpProtected = avpDefnElement.getAttribute("protected").equals("") ? "may" : avpDefnElement.getAttribute("protected");
String avpMayEncrypt = avpDefnElement.getAttribute("may-encrypt");
String avpVendorBit = avpDefnElement.getAttribute("vendor-bit");
long vendorCode = getVendorCode(avpVendorId);
// Let's figure out the type
// It can be:
//
// OR
// groupedAvpChilds = new ArrayList();
NodeList avpDefnChildNodes = avpNode.getChildNodes();
for (int j = 0; j < avpDefnChildNodes.getLength(); j++) {
Node avpDefnChildNode = avpDefnChildNodes.item(j);
if (avpDefnChildNode.getNodeType() == Node.ELEMENT_NODE) {
Element avpDefnChildElement = (Element) avpDefnChildNode;
if (avpDefnChildElement.getNodeName().equals("grouped")) {
avpOriginalType = "Grouped";
avpType = avpOriginalType;
// Let's fetch the childs
// Format: avpChilds = avp.getChildren();
for (int n = 0; n < avpChilds.size(); n++) {
AvpRepresentation avpChild = avpChilds.get(n);
if (avpChild.getName().equals(newAvp.getName())) {
try {
AvpRepresentationImpl strongAvp = (AvpRepresentationImpl) newAvp.clone();
strongAvp.setMultiplicityIndicator(avpChild.getMultiplicityIndicator());
strongAvp.markFixPosition(avpChild.getPositionIndex());
strongAvp.markWeak(false);
avpChilds.set(n, strongAvp);
resolveWeakLinks(avp);
}
catch (CloneNotSupportedException cnse) {
// It should not happen, but anyway
if (logger.isWarnEnabled()) {
logger.warn("Unable to clone AVP " + newAvp, cnse);
}
}
}
}
}
}
}
/**
* @param doc
* @param nameToCode
* @param avpMap
* @return
*/
private void parseCommands(Document doc) {
// here all grouped AVPs should have proper filling.
// now lets go through message definition, we have to respect application nodes
NodeList applicationNodes = doc.getElementsByTagName("application");
// Map commandMap = new
// HashMap();
for (int applicationIndex = 0; applicationIndex < applicationNodes.getLength(); applicationIndex++) {
if (applicationNodes.item(applicationIndex).getNodeType() == Node.ELEMENT_NODE) {
Element applicationElement = (Element) applicationNodes.item(applicationIndex);
if (!applicationElement.hasAttribute("id")) {
logger.debug("[ERROR] Application definition does not have ID, skipping message");
continue;
}
long applicationCode = Long.valueOf(applicationElement.getAttribute("id"));
NodeList commandNodes = applicationElement.getElementsByTagName("command");
for (int c = 0; c < commandNodes.getLength(); c++) {
Node commandNode = commandNodes.item(c);
if (commandNode.getNodeType() == Node.ELEMENT_NODE) {
Element commandElement = (Element) commandNode;
if (!commandElement.hasAttribute("request")) {
logger.debug("[ERROR] Command for application: {} does not define if its request or answer, skipping.", applicationCode);
continue;
}
String commandName = commandElement.getAttribute("name");
String commandCode = commandElement.getAttribute("code");
String isRequest = commandElement.getAttribute("request");
MessageRepresentationImpl msg = new MessageRepresentationImpl(Integer.valueOf(commandCode), applicationCode,
Boolean.parseBoolean(isRequest), commandName);
Map commandAvpList = new HashMap();
commandMap.put(msg, msg);
// now we have to process avp defs for this message :)
NodeList commandAvpsList = commandElement.getElementsByTagName("avp");
for (int commandAvpIndex = 0; commandAvpIndex < commandAvpsList.getLength(); commandAvpIndex++) {
if (commandAvpsList.item(commandAvpIndex).getNodeType() == Node.ELEMENT_NODE) {
Element commandAvpElement = (Element) commandAvpsList.item(commandAvpIndex);
String multiplicity = null;
String name = null;
String index = null;
if (!commandAvpElement.hasAttribute("name")) {
logger.debug("[ERROR] Command defines avp without name! Command: {}, Code: {}, ApplicationID: {}",
new Object[] { msg.getName(), msg.getCommandCode(), msg.getApplicationId() });
continue;
}
else {
name = commandAvpElement.getAttribute("name");
}
if (!commandAvpElement.hasAttribute("multiplicity")) {
logger.debug("[WARN] Command defines avp without multiplicity.");
multiplicity = AvpRepresentation._MP_ZERO_OR_MORE;
}
else {
multiplicity = commandAvpElement.getAttribute("multiplicity");
}
index = commandAvpElement.hasAttribute("index") ? commandAvpElement.getAttribute("index") : "-1";
String avpCode = commandAvpElement.getAttribute("code");
String avpVendor = commandAvpElement.getAttribute("vendor");
if (avpCode == null) {
logger.debug("[ERROR] Command defines avp without code! Command: {}, Code: {}, ApplicationID: {}",
new Object[] { msg.getName(), msg.getCommandCode(), msg.getApplicationId() });
continue;
}
if (avpVendor == null) {
logger.debug("[WARN] Command defines avp without vendor, assuming default. Command: {}, Code: {}, ApplicationID: {}",
new Object[] { msg.getName(), msg.getCommandCode(), msg.getApplicationId() });
avpVendor = "0";
}
// here we have name and multiplicity. we have to get avp def from name, clone and set multiplicity.
AvpRepresentation strongRepresentation = null;
AvpRepresentation strongKey = getMapKey(Integer.valueOf(avpCode), Long.valueOf(avpVendor));
strongRepresentation = this.avpMap.get(strongKey);
if (strongRepresentation != null && !strongRepresentation.isWeak()) {
AvpRepresentationImpl clone;
try {
clone = (AvpRepresentationImpl) strongRepresentation.clone();
clone.setMultiplicityIndicator(multiplicity);
clone.markFixPosition(Integer.valueOf(index));
commandAvpList.put(clone, clone);
}
catch (CloneNotSupportedException cnse) {
// It should not happen, but anyway
if (logger.isWarnEnabled()) {
logger.warn("Unable to clone AVP " + strongRepresentation, cnse);
}
}
}
else {
logger.debug("[WARN] No strong avp for key {}, in name: {}", new Object[] {strongKey, name});
continue;
}
}
}
msg.setMessageAvps(commandAvpList);
}
}
}
}
}
/*
* (non-Javadoc)
*
* @see org.jdiameter.api.validation.Dictionary#isConfigured()
*/
@Override
public boolean isConfigured() {
return this.configured;
}
@Override
public AvpRepresentation getAvp(int code) {
return getAvp(code, 0);
}
@Override
public AvpRepresentation getAvp(int code, long vendorId) {
if (!this.configured) {
return null;
}
AvpRepresentation avp = avpMap.get(getMapKey(code, vendorId));
if (avp == null) {
logger.warn("AVP with code {} and Vendor-Id {} not present in dictionary!", code, vendorId);
}
return avp;
}
@Override
public AvpRepresentation getAvp(String avpName) {
return this.configured ? avpByNameMap.get(avpName) : null;
}
private long getVendorCode(String vendorId) {
long value = -1;
if (vendorId == null) {
value = 0;
}
else {
String vendorCode = vendorMap.get(vendorId);
value = vendorCode == null ? 0 : Long.parseLong(vendorCode);
}
return value;
}
private AvpRepresentation getMapKey(int avpCode, long vendorId) {
return new AvpRepresentationImpl(avpCode, vendorId);
}
/*
* (non-Javadoc)
*
* @see org.jdiameter.api.validation.Dictionary#getMessage(int, boolean)
*/
@Override
public MessageRepresentation getMessage(int commandCode, boolean isRequest) {
return this.getMessage(commandCode, 0, isRequest);
}
/*
* (non-Javadoc)
*
* @see org.jdiameter.api.validation.Dictionary#getMessage(int, long, boolean)
*/
@Override
public MessageRepresentation getMessage(int commandCode, long applicationId, boolean isRequest) {
if (!this.configured) {
return null;
}
MessageRepresentation key = new MessageRepresentationImpl(commandCode, applicationId, isRequest);
return this.commandMap.get(key);
}
// Validation ---------------------------------------------------------------
private boolean enabled = true;
private ValidatorLevel sendValidationLevel = ValidatorLevel.ALL;
private ValidatorLevel receiveValidationLevel = ValidatorLevel.OFF;
/*
* (non-Javadoc)
*
* @see org.jdiameter.api.validation.Dictionary#isValidate()
*/
@Override
public boolean isEnabled() {
return this.enabled;
}
/*
* (non-Javadoc)
*
* @see org.jdiameter.api.validation.Dictionary#getSendLevel()
*/
@Override
public ValidatorLevel getSendLevel() {
return this.sendValidationLevel;
}
/*
* (non-Javadoc)
*
* @see org.jdiameter.api.validation.Dictionary#getReceiveLevel()
*/
@Override
public ValidatorLevel getReceiveLevel() {
return this.receiveValidationLevel;
}
@Override
public void setSendLevel(ValidatorLevel level) {
this.sendValidationLevel = level;
}
@Override
public void setReceiveLevel(ValidatorLevel level) {
this.receiveValidationLevel = level;
}
@Override
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public void setConfigured(boolean configured) {
this.configured = configured;
}
@Override
public void validate(Message msg, boolean incoming) throws AvpNotAllowedException {
if (!enabled || !configured) {
return;
}
MessageRepresentationImpl rep = new MessageRepresentationImpl(msg.getCommandCode(), msg.getApplicationId(), msg.isRequest());
rep = (MessageRepresentationImpl) this.commandMap.get(rep);
if (rep == null) {
// no notion, lets leave it.
logger.warn("Validation could not be performed, command not defined!. Code={}, Application-Id={}, Req={}",
new Object[] { msg.getCommandCode(), msg.getApplicationId(), msg.isRequest() });
return;
}
rep.validate(msg, (incoming ? receiveValidationLevel : sendValidationLevel));
}
// Helper methods -----------------------------------------------------------
public Map getAvpMap() {
return avpMap;
}
public Map getVendorMap() {
return vendorMap;
}
public Map getCommandMap() {
return commandMap;
}
public Map getTypedefMap() {
return typedefMap;
}
public Map getNameToCodeMap() {
return avpByNameMap;
}
protected void printAvpTree(AvpRepresentation rep, String tab) {
String x = tab + "+-- " + rep.getCode() + "/" + rep.getVendorId();
while (x.length() < 25) {
x += ".";
}
System.out.println(x + rep.getName() + " > " + rep.getType());
if (rep.isGrouped()) {
for (AvpRepresentation repC : rep.getChildren()) {
printAvpTree(repC, " " + tab);
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy