ipmsg.java

飞鸽java源代码

			RSAPublicKeySpec keyspec = makePublicKeySpec(token.nextToken());
			PublicKey pubkey = kf.generatePublic(keyspec);
			CryptoInfo ci = new CryptoInfo(cap, pubkey);
			publickeys.put(ipme.getIPMAddress().toString(), ci);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
	
	RSAPublicKeySpec makePublicKeySpec(String src) throws Exception {
		StringTokenizer token = new StringTokenizer(src, "-");
		BigInteger exponent = new BigInteger(token.nextToken(), 16);
		BigInteger modulus = new BigInteger(token.nextToken(), 16);
		return new RSAPublicKeySpec(modulus, exponent);
	}

	RSAPrivateKeySpec makePrivateKeySpec(String src) throws Exception {
		StringTokenizer token = new StringTokenizer(src, "-");
		BigInteger exponent = new BigInteger(token.nextToken(), 16);
		BigInteger modulus = new BigInteger(token.nextToken(), 16);
		return new RSAPrivateKeySpec(modulus, exponent);
	}

	String makeRSAPublicKeyString(RSAPublicKey key) throws Exception {
		return key.getPublicExponent().toString(16).toUpperCase() + "-"
			+ key.getModulus().toString(16).toUpperCase();
	}

	String makeRSAPrivateKeyString(RSAPrivateKey key) throws Exception {
		return key.getPrivateExponent().toString(16).toUpperCase() + "-"
			+ key.getModulus().toString(16).toUpperCase();
	}

	long setupEncryption() {
		if (publickey != null && privatekey != null)
			return IPMSG_ENCRYPTOPT;
		else if (!hasJCE)
			return 0L;
		try {
			Class c = Class.forName(pref.getProperty("jceProvider"));
			Security.addProvider((Provider) c.newInstance());
		} catch (Exception ex) {
			System.err.println("Can't instanciate JCE Provider.->" + ex);
			hasJCE = false;
			return 0L;
		}
		try {
			try {
				KeyFactory kf = KeyFactory.getInstance("RSA");
				RSAPublicKeySpec pubspec
					= makePublicKeySpec(pref.getProperty("publicKey"));
				publickey = kf.generatePublic(pubspec);
				RSAPrivateKeySpec privspec
					= makePrivateKeySpec(pref.getProperty("privateKey"));
				privatekey = kf.generatePrivate(privspec);
			} catch (Exception e) {
				KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
				kpg.initialize(1024);
				KeyPair kp = kpg.generateKeyPair();
				publickey = kp.getPublic();
				privatekey = kp.getPrivate();
				pref.setProperty("publicKey", makeRSAPublicKeyString(
					(RSAPublicKey) publickey));
				pref.setProperty("privateKey", makeRSAPrivateKeyString(
					(RSAPrivateKey) privatekey));
			}
		} catch (Exception ex) {
			System.err.println("Can't create key pair.->" + ex);
			return 0L;
		}
		return IPMSG_ENCRYPTOPT;
	}

	long getEntryOpt() {
		long absence = (new Boolean(pref.getProperty("absenceState"))
			.booleanValue()) ? IPMSG_ABSENCEOPT : 0;
		long dialup = (new Boolean(pref.getProperty("dialupState"))
			.booleanValue()) ? IPMSG_DIALUPOPT: 0;
		return absence | dialup | setupEncryption();
	}
	
	void makeBroadcastRecvSockets() throws SocketException {
		try {
			String tmpstr = pref.getProperty("ports");
			String[] strports = cutCString(tmpstr);
			ports = new int[strports.length];
			for (int i = 0; i < ports.length; i++)
				ports[i] = Integer.parseInt(strports[i]);
		} catch (MissingResourceException ex) {
			ports = new int[1];
			ports[0] = 2425;
		}
		DatagramSocket[] tmpds = new DatagramSocket[ports.length];
		for (int i = 0; i < ports.length; i++)
			tmpds[i] = new DatagramSocket(ports[i]);
		InetAddress proxyaddr = null;
		try {
			String tmpstr = pref.getProperty("proxy");
			proxyaddr = InetAddress.getByName(tmpstr);
		} catch (Exception ex) {
			proxyaddr = null;
		}
		proxy = new IPMProxy(this, proxyaddr, new Boolean(
			pref.getProperty("proxyBroadcastAll")).booleanValue());
		for (int i = 0; i < ports.length; i++) {
			proxy.addBroadcastPort(ports[i]);
			IPMRecv tmprecv = new IPMRecv(tmpds[i]);
			tmprecv.addIPMComListener(this);
			tmprecv.addIPMComListener(proxy);
			tmprecv.start();
		}
	}
	
	class Child extends Thread {
		private DataInputStream din;
		
		public Child() {
			this.start();
		}
		
		public void run() {
			Socket sock;
			while (true) {
				try {
					sock = new Socket(localaddr, IPMProxy.PROXY_PORT);
					din = new DataInputStream(sock.getInputStream());
				} catch (IOException ex) {
					return;
				}
				byte[] buf = new byte[8192];
				IPMByteBuffer ipmbb = new IPMByteBuffer();
				outer:
				while (true) {
					while (!ipmbb.eop()) {
						int count = 0;
						try {
							count = din.read(buf);
						} catch (IOException ex) {
							break outer;
						}
						if (count == -1)
							break outer;
						ipmbb.append(buf, 0, count);
					}
					buf = ipmbb.getBytes();
					IPMProxyEvent ipmpe = new IPMProxyEvent(this, buf);
					try {
						if (!ipmpe.getToIPMAddress().getInetAddress()
							.equals(InetAddress.getByName("255.255.255.255")))
							continue;
					} catch (UnknownHostException ex) {
						continue;
					}
					IPMComEvent ipmce = new IPMComEvent(this
						, ipmpe.getToIPMAddress().getPort(), ipmpe.getPack()
						, ipmpe.getFromIPMAddress());
					receive(ipmce);
				}
				try {
					makeBroadcastRecvSockets();
					try {
						din.close();
						sock.close();
					} catch (IOException ex) {}
					return;
				} catch (SocketException ex) {
					ex.printStackTrace();
				}
			}
		}
	}
	
	public IPMsg() {
		try {
			FileInputStream filein = new FileInputStream(P_FILE);
			pref.load(filein);
			filein.close();
		} catch (FileNotFoundException ex) {
		} catch (IOException ex) {}
		user = System.getProperty("user.name", "No Name");
		try {
			host = InetAddress.getLocalHost().getHostName();
		} catch (UnknownHostException ex) {
			host = "Unknown Hostname";
		}
		try {
			try {
				localaddr
					= InetAddress.getByName(pref.getProperty("localAddress"));
			} catch (MissingResourceException ex) {
				localaddr = InetAddress.getLocalHost();
			}
		} catch (UnknownHostException ex) {
			ex.printStackTrace();
		}
	}
	
	public InetAddress getLocalAddress() {
		return localaddr;
	}
	
	public void entry() {
		DatagramSocket tmpds;
		Random rand = new Random(System.currentTimeMillis());
		while (true) {
			/* 49154 - 65534 */
			port = (int) (rand.nextLong() % 8192 + 57342);
			try {
				tmpds = new DatagramSocket(port);
			} catch (SocketException ex) {
				continue;
			}
			break;
		}
		dsock = tmpds;
		IPMRecv tmprecv = new IPMRecv(tmpds);
		tmprecv.addIPMComListener(this);
		tmprecv.start();
		try {
			makeBroadcastRecvSockets();
		} catch (SocketException ex) {
			ex.printStackTrace();
			new Child();
		}
		state = true;
		String nickname = pref.getProperty("nickName");
		new BroadcastSend(dsock, makePack(IPMSG_BR_ENTRY | getEntryOpt()
			, nickname, true), getBroadcastAddr());
	}
	
	public synchronized void savePref() {
		try {
			FileOutputStream fileout = new FileOutputStream(P_FILE);
			pref.save(fileout, "IP Messenger Runtime Resource");
		} catch (IOException ex) {}
	}
	
	public synchronized void exit() {
		state = false;
		BroadcastSend bs = new BroadcastSend(dsock, makePack(IPMSG_BR_EXIT
			, "", false), getBroadcastAddr());
		try {
			bs.join();
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		savePref();
	}
	
	public synchronized void addIPMListener(IPMListener listener) {
		ipmlistener.put(listener, listener);
	}
	
	public synchronized void removeIPMListener(IPMListener listener) {
		ipmlistener.remove(listener);
	}
	
	public synchronized void setPref(String key, String value) {
		pref.put(key, value);
	}
	
	public synchronized String getPref(String key) {
		return pref.getProperty(key);
	}
	
	public Hashtable getUserlist() {
		return userlist;
	}

	public synchronized void incReceiveCount() {
		receivecount++;
	}
	public synchronized void decReceiveCount() {
		receivecount--;
	}
	public boolean lessThanReceiveMax() {
		int recvmax = 500;
		try {
			recvmax = Integer.parseInt(pref.getProperty("receiveMax", "500"));
		} catch (NumberFormatException ex) {}
		return (recvmax > receivecount);
	}

	public void sendMsg(IPMAddress[] addrs, String msg, long flag) {
		if (addrs == null) {
			IPMPack ipmp = makePack(IPMSG_SENDMSG | IPMSG_BROADCASTOPT | flag
				, msg, false);
			BroadcastSend bs
				= new BroadcastSend(dsock, ipmp, getBroadcastAddr());
		} else if (addrs.length == 1) {
			if (publickeys.containsKey(addrs[0].toString())) {
				try {
					msg = encryptMessage(
						(CryptoInfo) publickeys.get(addrs[0].toString()), msg);
					flag |= IPMSG_ENCRYPTOPT;
				} catch (Exception ex) {}
			}
			IPMPack ipmp = makePack(IPMSG_SENDMSG | IPMSG_SENDCHECKOPT
				| flag, msg, false);
			NormalSend ns = new NormalSend(dsock, ipmp, addrs[0]);
			ns.addIPMComListener(new IPMComListener() {
				public void receive(IPMComEvent ipmce) {
					recentsend.remove(new Long(ipmce.getPack().getNo()));
					IPMEvent ie = new IPMEvent(this, IPMEvent.CANTSENDMSG_EVENT
						, new Date(System.currentTimeMillis()), ipmce);
					invokeListener(ie);
				}
			});
			recentsend.put(new Long(ipmp.getNo()), ns);
			ns.start();
		} else {
			for (int i = 0; i < addrs.length; i++) {
				long tmpflag = flag;
				String tmpmsg = msg;
				if (publickeys.containsKey(addrs[i].toString())) {
					try {
						tmpmsg = encryptMessage(
							(CryptoInfo) publickeys.get(addrs[i].toString())
							, msg);
						tmpflag |= IPMSG_ENCRYPTOPT;
					} catch (Exception ex) {}
				}
				IPMPack ipmp = makePack(IPMSG_SENDMSG | IPMSG_MULTICASTOPT
					| tmpflag, tmpmsg, false);
				IPMSend.send(dsock, ipmp, addrs[i]);
			}
		}
	}
	
	public void sendReadMsg(IPMEvent ipme) {
		IPMPack ipmp = makePack(IPMSG_READMSG | IPMSG_AUTORETOPT
			, new Long(ipme.getPack().getNo()).toString(), false);
		IPMSend.send(dsock, ipmp, ipme.getIPMAddress());
	}
	
	public void sendDeleteMsg(IPMEvent ipme) {
		IPMPack ipmp = makePack(IPMSG_DELMSG | IPMSG_AUTORETOPT
			, new Long(ipme.getPack().getNo()).toString(), false);
		IPMSend.send(dsock, ipmp, ipme.getIPMAddress());
	}
	
	public void getInfo() {
		BroadcastSend bs = new BroadcastSend(dsock, makePack(IPMSG_GETINFO
			, "", false), getBroadcastAddr());
	}
	
	public synchronized void refreshList() {
		IPMAddress[] tmpaddr = getBroadcastAddr();
		userlist = new Hashtable();
		dialupmember = new Hashtable();
		String nickname = pref.getProperty("nickName");
		new BroadcastSend(dsock, makePack(IPMSG_BR_ENTRY | getEntryOpt()
			, nickname, true), tmpaddr);
	}
	
	public void absenceStateChanged() {
		String nickname = pref.getProperty("nickName");
		new BroadcastSend(dsock, makePack(IPMSG_BR_ABSENCE | getEntryOpt()
			, nickname, true), getBroadcastAddr());
	}
	
	public String makeDateStr(Date now) {
		SimpleDateFormat dateformatter
			= new SimpleDateFormat("EEE MMM dd HH:mm:ss yyyy", Locale.US);
		dateformatter.setTimeZone(
			DateFormat.getDateInstance().getTimeZone());
		return "at " + dateformatter.format(now);
	}
	
	public String makeListStr(IPMPack aPack) {
		String tmpuser = null;
		if (aPack.getExtra() == null)
			tmpuser = aPack.getUser();
		else
			tmpuser = aPack.getExtra();
		StringBuffer strbuf = new StringBuffer();
		if ((aPack.getCommand() & IPMsg.IPMSG_ABSENCEOPT) != 0)
			tmpuser = tmpuser + "*";
		strbuf.append(tmpuser + " (");
		if (aPack.getGroup() != null)
			strbuf.append(aPack.getGroup() + "/");
		strbuf.append(aPack.getHost() + ")");
		return new String(strbuf);
	}

	public String[] makeListStrs(IPMPack aPack) {
		String tmpuser = "", tmpgroup = "", tmphost = "";
		if (aPack.getExtra() == null)
			tmpuser = aPack.getUser();
		else
			tmpuser = aPack.getExtra();
		if ((aPack.getCommand() & IPMsg.IPMSG_ABSENCEOPT) != 0)
			tmpuser = tmpuser + "*";
		if (aPack.getGroup() != null)
			tmpgroup = aPack.getGroup();
		tmphost = aPack.getHost();
		String[] result = { tmpuser, tmpgroup, tmphost };
		return result;
	}

	public String makeListStr(String auser, String agroup, String ahost) {
		StringBuffer strbuf = new StringBuffer();
		strbuf.append(auser);
		strbuf.append(" (");
		if (agroup != null && !agroup.equals("")) {
			strbuf.append(agroup);
			strbuf.append("/");
		}
		strbuf.append(ahost);
		strbuf.append(")");
		return new String(strbuf);
	}
	
	public synchronized void writeLog(String str1, String str2, String body) {
		String cr = System.getProperty("line.separator", "\n");
		try {
			String logname = pref.getProperty("logFilename");
			FileWriter fw = new FileWriter(logname, true);
			String tmpstr = "=====================================" + cr;
			fw.write(tmpstr, 0, tmpstr.length());
			tmpstr = " " + str1 + cr;
			fw.write(tmpstr, 0, tmpstr.length());
			tmpstr = "	" + str2 + cr;
			fw.write(tmpstr, 0, tmpstr.length());
			tmpstr = "-------------------------------------" + cr;
			fw.write(tmpstr, 0, tmpstr.length());
			tmpstr = StringReplacer.replaceString(body, "\n", cr) + cr + cr;
			fw.write(tmpstr, 0, tmpstr.length());
			fw.close();
		} catch (MissingResourceException ex) {
		} catch (IOException ex) {}
	}
}