banmanagement.java

是一款国外的网络游戏平台的源码*不是类似浩方那种虚拟局域网技术

/*
 * Created on Apr 4, 2006
 *
 */
package org.GTADS.usermanager;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;

import org.GTADS.debug.ServerLogger;
import org.GTADS.server.ServerCacheHandler;
import org.GTADS.server.ServerConfig;

/**
 * @author sday
 *
 * Controls user bans to the server in terms of:
 * - Temporary Bans with expiration times
 * - Permanent Bans with indefinite times
 * 
 * Bans can consist of username bans and/or IP Address/Blocks bans
 * 
 */
public class BanManagement extends Thread {
	private static BanManagement instance;
	
	public static BanManagement getInstance(){
		if (instance == null){
			instance = new BanManagement();
		}
		return instance;
	}
	
	public static void clearInstance(){
		if (instance != null){
			instance = null;
		}
	}
	
	public boolean setBan(String bannedUser, boolean isIP, Long duration){
		boolean success = false;
		BannedUserInterval currentBan = new BannedUserInterval(duration);
		if (isIP){ // Is an IP Address
			success = true;
			ServerCacheHandler.ipBannedIntervalCache.put(bannedUser, currentBan);
		}
		else { // Is a user name
			if(ServerCacheHandler.userPasswordCache.containsKey(bannedUser)){
				success = true;
				ServerCacheHandler.userBannedIntervalCache.put(bannedUser, currentBan);
			}
		}
		if (success){
			// Write ban to file
			updateBanFile();
		}
		return success;
	}
	
	public boolean removeBan(String freedUser, boolean isIP){
		boolean success = false; // For writing to file
		if (isIP){
			if (ServerCacheHandler.ipBannedIntervalCache.containsKey(freedUser)){
				success = true;
				ServerCacheHandler.ipBannedIntervalCache.remove(freedUser);
			}
		}
		else {
			if (ServerCacheHandler.userBannedIntervalCache.containsKey(freedUser)){
				success = true;
				ServerCacheHandler.userBannedIntervalCache.remove(freedUser);
			}
		}
		// Write to file here
		if (success){
			updateBanFile();
		}
		return success;
	}
	
	public boolean checkIP(String ipAddr){
		boolean isBanned = false;
		// Cycle through IPs and IP wildcards
		// Check for a match
		if (ServerCacheHandler.ipBannedIntervalCache.containsKey(ipAddr)){
			BannedUserInterval ipBan = (BannedUserInterval)ServerCacheHandler.ipBannedIntervalCache.get(ipAddr);
			isBanned = !ipBan.isBanEnded();
		}
		
		return isBanned;
	}
	
	public boolean checkUser(String userName){
		boolean isBanned = false;
		// Cycle through usernames
		// Check for a match
		if (ServerCacheHandler.userBannedIntervalCache.containsKey(userName)){
			BannedUserInterval userBan = (BannedUserInterval)ServerCacheHandler.userBannedIntervalCache.get(userName);
			isBanned = !userBan.isBanEnded();
		}
		
		return isBanned;
	}
	
	public BanManagement(){
		ServerLogger.sendConsoleDebugMessage("Starting up Ban Management Component", this.getClass(), 3);
		// Read in ban file here
		// And populate Cache Lists
		readInBanFile();
		start();
	}
	
	public void run() {
		checkBansStatus();
	}
	
	private void checkBansStatus(){
		// Run in the background checking if bans have expired
		// Then removing them from the system
		try {
			while(true){
				Thread.sleep(5000);
				// Use less redundant code by going through both cache types
				// Using an ArrayList of Keys
				ArrayList banTypes = new ArrayList();
				banTypes.add(ServerCacheHandler.ipBannedIntervalCache.keys());
				banTypes.add(ServerCacheHandler.userBannedIntervalCache.keys());	
				
				for (int i = 0; i < banTypes.size(); i++){
					Enumeration banKeys = (Enumeration)banTypes.get(i);
					while(banKeys.hasMoreElements()){
						String banKey = (String)banKeys.nextElement();
						BannedUserInterval currentBan;
						if (ServerCacheHandler.ipBannedIntervalCache.containsKey(banKey)){
							currentBan = (BannedUserInterval)ServerCacheHandler.ipBannedIntervalCache.get(banKey);
							if (currentBan.isBanEnded()){
								ServerLogger.sendConsoleDebugMessage("Removing ban for IP: " + banKey, this.getClass(), 5);
								this.removeBan(banKey, true);
							}
						}
						else if (ServerCacheHandler.userBannedIntervalCache.containsKey(banKey)){
							currentBan = (BannedUserInterval)ServerCacheHandler.userBannedIntervalCache.get(banKey);
							if (currentBan.isBanEnded()){
								ServerLogger.sendConsoleDebugMessage("Removing ban for user: " + banKey, this.getClass(), 5);
								this.removeBan(banKey, false);
							}
						}
						else 
							continue;
					}
					
				}
			}
		} catch (InterruptedException ioe){
			ServerLogger.sendConsoleDebugMessage("Ban Management Thread interrupted! Restarting...", this.getClass());
			BanManagement.clearInstance();
			BanManagement.getInstance();
		}
	}
	
	public void updateBanFile(){
		String banFileName = ServerConfig.getInstance().getBannedFileName();
		File banFile = new File(banFileName);
		ArrayList banStringList = new ArrayList();
		// Grab all bans and convert them to strings
		// Ban Type, user/ip,timestamp,duration
		
		// Convert all ban types into strings in the arraylist
		Enumeration userBans = ServerCacheHandler.userBannedIntervalCache.keys();
		
		while (userBans.hasMoreElements()){
			String aUser = (String)userBans.nextElement();
			BannedUserInterval b = (BannedUserInterval)ServerCacheHandler.userBannedIntervalCache.get(aUser);
			banStringList.add(convertBanToString(aUser,b,true));
		}
		
		Enumeration ipBans = ServerCacheHandler.ipBannedIntervalCache.keys();
		
		while (ipBans.hasMoreElements()){
			String anIP = (String)ipBans.nextElement();
			BannedUserInterval b = (BannedUserInterval)ServerCacheHandler.ipBannedIntervalCache.get(anIP);
			banStringList.add(convertBanToString(anIP,b,false));
		}
		
		try {
		if (!banFile.exists()){
			banFile.createNewFile();
		}
		
		FileWriter banFileWrite = new FileWriter(banFile);
		BufferedWriter outputBuffer = new BufferedWriter(banFileWrite);
		
		for (int i = 0; i < banStringList.size();i++){
			outputBuffer.write((String)banStringList.get(i));
			outputBuffer.newLine();
		}
		
		outputBuffer.close();
		
		} catch (IOException ioe){
			ServerLogger.sendConsoleDebugMessage("Error Writing to file " + banFileName, this.getClass());
			return;
		}
	}
	
	private void readInBanFile(){
		String banFileName = ServerConfig.getInstance().getBannedFileName();
		ArrayList banUserStringList = new ArrayList();
		ArrayList banIPStringList = new ArrayList();
		File banFile = new File(banFileName);
		ServerCacheHandler.userBannedIntervalCache.clear();
		ServerCacheHandler.ipBannedIntervalCache.clear();
		
		ServerLogger.sendConsoleDebugMessage("Reading in ban items from " + banFileName, this.getClass());
		
		try {
		FileReader banFileReader = new FileReader(banFile);
		BufferedReader inputBuffer = new BufferedReader(banFileReader);
		boolean isEOF = false;
		int count = 0;
		while (!isEOF){
			String tempLine = inputBuffer.readLine();
			if (tempLine == null)
				isEOF = true;
			else {
				if (tempLine.split(",").length >= 4){
					count++;
					if (isBanStringUser(tempLine)){
						banUserStringList.add(tempLine);
					}
					else {
						banIPStringList.add(tempLine);
					}
				}
			}
		}
		
		ServerLogger.sendConsoleDebugMessage("Read in " + count + " bans", this.getClass());
		inputBuffer.close();
		
		for (int i = 0; i < banUserStringList.size(); i++){
			String banStringLine = (String)banUserStringList.get(i);
			String user = getUserFromBanString(banStringLine);
			BannedUserInterval b = this.convertStringToBan(banStringLine);
			if (b != null && user != null){
				ServerCacheHandler.userBannedIntervalCache.put(user,b);
			}
		}
		
		for (int i = 0; i < banIPStringList.size(); i++){
			String banStringLine = (String)banIPStringList.get(i);
			String ip = getUserFromBanString(banStringLine);
			BannedUserInterval b = this.convertStringToBan(banStringLine);
			if (b != null && ip != null){
				ServerCacheHandler.ipBannedIntervalCache.put(ip,b);
			}
		}
		
		} catch (FileNotFoundException fne){
			ServerLogger.sendConsoleDebugMessage("Could not read ban file " + banFileName + ": file not found", this.getClass());
			return;
		} catch (IOException ioe){
			ServerLogger.sendConsoleDebugMessage("I/O Error reading in ban file " + banFileName, this.getClass());
		}
	}
	
	public String convertBanToString(String user, BannedUserInterval b, boolean isUser){
		String banString = null;
		String banType = isUser ? "USER" : "IP";
		
		banString = new String();
		banString = banType + "," + user + ",";
		banString += b.getTimeBanned().longValue() + "," + b.getDuration().longValue();
		
		return banString;
	}
	
	public BannedUserInterval convertStringToBan(String banStringLine){
		BannedUserInterval b = null;
		String[] banLineSplit = banStringLine.split(",");
		try {
			if (banLineSplit.length >= 4){
				String timestampStr = banLineSplit[2];
				String durationStr = banLineSplit[3];
				
				Long timeStamp = Long.valueOf(timestampStr);
				Long duration = Long.valueOf(durationStr);
				b = new BannedUserInterval(duration);
				b.setTimeStamp(timeStamp);
			}
		} catch (NumberFormatException nfe){
			b = null;
		}
		return b;
	}
	
	public boolean isBanStringUser(String banStringLine){
		boolean isUser = false;
		
		if (banStringLine.split(",").length >= 4){
			String banType = banStringLine.split(",")[0];
			
			if (banType.equalsIgnoreCase("USER")){
				isUser = true;
			}
		}
		
		return isUser;
	}
	
	public String getUserFromBanString(String banStringLine){
		String bannedUser = null;
		
		if (banStringLine.split(",").length >= 4){
			bannedUser = banStringLine.split(",")[1];
		}
		return bannedUser;
	}
	
	public class BannedUserInterval {
		Long timeBanned;
		Long duration;
		
		public BannedUserInterval (Long duration){
			Date d = new Date();
			timeBanned = new Long(d.getTime());
			if (duration == null){
				duration = new Long(0);
			}
			this.duration = new Long(duration.longValue());
		}
		
		public Long getTimeBanned(){
			return timeBanned;
		}
		
		public Long getDuration(){
			return duration;
		}
		
		public void setDuration(Long duration){
			this.duration = duration;
		}
		
		public void setTimeStamp(Long timestamp){
			timeBanned = timestamp;
		}
		
		public boolean isBanEnded(){
			boolean isBanned;
			if (duration.longValue() == 0){
				isBanned = false;
			}
			else {
				Date d = new Date();
				long timeElapsed = d.getTime() - timeBanned.longValue();
				
				if (timeElapsed >= duration.longValue()){
					isBanned = true;
				}
				else {
					isBanned = false;
				}
			}
			return isBanned;
		}
	}
}