/*
* Copyright (C) 2005-2008 Jive Software. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.openfire.audit.spi;
import org.jivesoftware.util.JiveGlobals;
import org.jivesoftware.util.PropertyEventDispatcher;
import org.jivesoftware.util.PropertyEventListener;
import org.jivesoftware.openfire.XMPPServer;
import org.jivesoftware.openfire.audit.AuditManager;
import org.jivesoftware.openfire.audit.Auditor;
import org.jivesoftware.openfire.container.BasicModule;
import org.jivesoftware.openfire.interceptor.InterceptorManager;
import org.jivesoftware.openfire.interceptor.PacketInterceptor;
import org.jivesoftware.openfire.session.Session;
import org.xmpp.packet.JID;
import org.xmpp.packet.Packet;
import java.io.File;
import java.util.*;
/**
* Implementation of the AuditManager interface.
*/
public class AuditManagerImpl extends BasicModule implements AuditManager, PropertyEventListener {
private boolean enabled;
private boolean auditMessage;
private boolean auditPresence;
private boolean auditIQ;
private boolean auditXPath;
private List<String> xpath = new LinkedList<>();
private AuditorImpl auditor = null;
/**
* Max size in bytes that all audit log files may have. When the limit is reached
* oldest audit log files will be removed until total size is under the limit.
*/
private int maxTotalSize;
/**
* Max size in bytes that each audit log file may have. Once the limit has been
* reached a new audit file will be created.
*/
private int maxFileSize;
/**
* Max number of days to keep audit information. Once the limit has been reached
* audit files that contain information that exceed the limit will be deleted.
*/
private int maxDays;
private int logTimeout;
private String logDir;
private Collection<String> ignoreList = new ArrayList<>();
private static final int MAX_TOTAL_SIZE = 1000;
private static final int MAX_FILE_SIZE = 10;
private static final int MAX_DAYS = -1;
private static final int DEFAULT_LOG_TIMEOUT = 120000;
private AuditorInterceptor interceptor;
public AuditManagerImpl() {
super("Audit Manager");
}
@Override
public boolean isEnabled() {
return enabled;
}
@Override
public void setEnabled(boolean enabled) {
this.enabled = enabled;
JiveGlobals.setProperty("xmpp.audit.active", enabled ? "true" : "false");
processEnabled(enabled);
}
@Override
public Auditor getAuditor() {
if (auditor == null) {
throw new IllegalStateException("Must initialize audit manager first");
}
return auditor;
}
@Override
public int getMaxTotalSize() {
return maxTotalSize;
}
@Override
public void setMaxTotalSize(int size) {
maxTotalSize = size;
auditor.setMaxValues(maxTotalSize, maxFileSize, maxDays);
JiveGlobals.setProperty("xmpp.audit.totalsize", Integer.toString(size));
}
@Override
public int getMaxFileSize() {
return maxFileSize;
}
@Override
public void setMaxFileSize(int size) {
maxFileSize = size;
auditor.setMaxValues(maxTotalSize, maxFileSize, maxDays);
JiveGlobals.setProperty("xmpp.audit.filesize", Integer.toString(size));
}
@Override
public int getMaxDays() {
return maxDays;
}
@Override
public void setMaxDays(int count) {
maxDays = validateMaxDays(count);
auditor.setMaxValues(maxTotalSize, maxFileSize, maxDays);
JiveGlobals.setProperty("xmpp.audit.days", Integer.toString(count));
}
@Override
public int getLogTimeout() {
return logTimeout;
}
@Override
public void setLogTimeout(int logTimeout) {
this.logTimeout = logTimeout;
auditor.setLogTimeout(logTimeout);
JiveGlobals.setProperty("xmpp.audit.logtimeout", Integer.toString(logTimeout));
}
@Override
public String getLogDir() {
return logDir;
}
@Override
public void setLogDir(String logDir) {
this.logDir = logDir;
auditor.setLogDir(logDir);
JiveGlobals.setProperty("xmpp.audit.logdir", logDir);
}
@Override
public boolean isAuditMessage() {
return auditMessage;
}
@Override
public void setAuditMessage(boolean auditMessage) {
this.auditMessage = auditMessage;
JiveGlobals.setProperty("xmpp.audit.message", auditMessage ? "true" : "false");
}
@Override
public boolean isAuditPresence() {
return auditPresence;
}
@Override
public void setAuditPresence(boolean auditPresence) {
this.auditPresence = auditPresence;
JiveGlobals.setProperty("xmpp.audit.presence", auditPresence ? "true" : "false");
}
@Override
public boolean isAuditIQ() {
return auditIQ;
}
@Override
public void setAuditIQ(boolean auditIQ) {
this.auditIQ = auditIQ;
JiveGlobals.setProperty("xmpp.audit.iq", Boolean.toString(auditIQ));
}
@Override
public boolean isAuditXPath() {
return auditXPath;
}
@Override
public void setAuditXPath(boolean auditXPath) {
this.auditXPath = auditXPath;
JiveGlobals.setProperty("xmpp.audit.xpath", Boolean.toString(auditXPath));
}
@Override
public void addXPath(String xpathExpression) {
xpath.add(xpathExpression);
saveXPath();
}
@Override
public void removeXPath(String xpathExpression) {
xpath.remove(xpathExpression);
saveXPath();
}
private void saveXPath() {
// TODO: save XPath values!
//String[] filters = new String[xpath.size()];
//filters = (String[]) xpath.toArray(filters);
}
@Override
public Iterator getXPathFilters() {
return xpath.iterator();
}
@Override
public void setIgnoreList(Collection<String> usernames) {
if (ignoreList.equals(usernames)) {
return;
}
ignoreList = usernames;
// Encode the collection
StringBuilder ignoreString = new StringBuilder();
for (String username : ignoreList) {
if (ignoreString.length() == 0) {
ignoreString.append(username);
}
else {
ignoreString.append(',').append(username);
}
}
JiveGlobals.setProperty("xmpp.audit.ignore", ignoreString.toString());
}
@Override
public Collection<String> getIgnoreList() {
return Collections.unmodifiableCollection(ignoreList);
}
// #########################################################################
// Basic module methods
// #########################################################################
@Override
public void initialize(XMPPServer server) {
super.initialize(server);
enabled = JiveGlobals.getBooleanProperty("xmpp.audit.active");
auditMessage = JiveGlobals.getBooleanProperty("xmpp.audit.message");
auditPresence = JiveGlobals.getBooleanProperty("xmpp.audit.presence");
auditIQ = JiveGlobals.getBooleanProperty("xmpp.audit.iq");
auditXPath = JiveGlobals.getBooleanProperty("xmpp.audit.xpath");
// TODO: load xpath values!
// String[] filters = context.getProperties("xmpp.audit.filter.xpath");
// for (int i = 0; i < filters.length; i++) {
// xpath.add(filters[i]);
// }
maxTotalSize = JiveGlobals.getIntProperty("xmpp.audit.totalsize", MAX_TOTAL_SIZE);
maxFileSize = JiveGlobals.getIntProperty("xmpp.audit.filesize", MAX_FILE_SIZE);
maxDays = JiveGlobals.getIntProperty("xmpp.audit.days", MAX_DAYS);
logTimeout = JiveGlobals.getIntProperty("xmpp.audit.logtimeout", DEFAULT_LOG_TIMEOUT);
logDir = JiveGlobals.getProperty("xmpp.audit.logdir", JiveGlobals.getHomeDirectory() +
File.separator + "logs");
processIgnoreString(JiveGlobals.getProperty("xmpp.audit.ignore", ""));
auditor = new AuditorImpl(this);
auditor.setMaxValues(maxTotalSize, maxFileSize, maxDays);
auditor.setLogDir(logDir);
auditor.setLogTimeout(logTimeout);
interceptor = new AuditorInterceptor();
processEnabled(enabled);
PropertyEventDispatcher.addListener(this);
}
private void processIgnoreString(String ignoreString) {
ignoreList.clear();
// Decode the ignore list
StringTokenizer tokenizer = new StringTokenizer(ignoreString, ",");
while (tokenizer.hasMoreTokens()) {
String username = tokenizer.nextToken().trim();
ignoreList.add(username);
}
}
private void processEnabled(boolean enabled) {
// Add or remove the auditor interceptor depending on the enabled status
if (enabled) {
InterceptorManager.getInstance().addInterceptor(interceptor);
} else {
InterceptorManager.getInstance().removeInterceptor(interceptor);
}
}
private int validateMaxDays(int count) {
if (count < -1) {
count = -1;
}
if (count == 0) {
count = 1;
}
return count;
}
@Override
public void stop() {
if (auditor != null) {
auditor.stop();
}
}
@Override
public void propertySet(String property, Map<String, Object> params) {
final Object val = params.get("value");
if (!( val instanceof String ))
{
return;
}
String value = (String) val;
switch (property) {
case "xmpp.audit.active":
enabled = Boolean.parseBoolean(value);
processEnabled(enabled);
break;
case "xmpp.audit.message":
auditMessage = Boolean.parseBoolean(value);
break;
case "xmpp.audit.presence":
auditPresence = Boolean.parseBoolean(value);
break;
case "xmpp.audit.iq":
auditIQ = Boolean.parseBoolean(value);
break;
case "xmpp.audit.xpath":
auditXPath = Boolean.parseBoolean(value);
break;
case "xmpp.audit.totalsize":
maxTotalSize = parseIntegerOrDefault(value, MAX_TOTAL_SIZE);
auditor.setMaxValues(maxTotalSize, maxFileSize, maxDays);
break;
case "xmpp.audit.filesize":
maxFileSize = parseIntegerOrDefault(value, MAX_FILE_SIZE);
auditor.setMaxValues(maxTotalSize, maxFileSize, maxDays);
break;
case "xmpp.audit.days":
maxDays = validateMaxDays(parseIntegerOrDefault(value, MAX_DAYS));
auditor.setMaxValues(maxTotalSize, maxFileSize, maxDays);
break;
case "xmpp.audit.logtimeout":
logTimeout = parseIntegerOrDefault(value, DEFAULT_LOG_TIMEOUT);
auditor.setLogTimeout(logTimeout);
break;
case "xmpp.audit.logdir":
File d = null;
if (value != null && !"".equals(value.trim())) {
d = new File(value);
}
logDir = (d == null || !d.exists() || !d.canRead() || !d.canWrite() || !d
.isDirectory()) ? JiveGlobals.getHomeDirectory()
+ File.separator + "logs" : value;
auditor.setLogDir(logDir);
break;
case "xmpp.audit.ignore":
processIgnoreString(value);
break;
}
}
private int parseIntegerOrDefault(String intValue, int defaultValue) {
try {
return Integer.parseInt(intValue);
} catch (NumberFormatException nfe) {
return defaultValue;
}
}
@Override
public void propertyDeleted(String property, Map<String, Object> params) {
propertySet(property, Collections.<String, Object>emptyMap());
}
@Override
public void xmlPropertySet(String property, Map<String, Object> params) {
}
@Override
public void xmlPropertyDeleted(String property, Map<String, Object> params) {
}
private class AuditorInterceptor implements PacketInterceptor {
@Override
public void interceptPacket(Packet packet, Session session, boolean read, boolean processed) {
if (!processed) {
// Ignore packets sent or received by users that are present in the ignore list
JID from = packet.getFrom();
JID to = packet.getTo();
if ((from == null || !ignoreList.contains(from.getNode())) &&
(to == null || !ignoreList.contains(to.getNode()))) {
auditor.audit(packet, session);
}
}
}
}
}