diff options
Diffstat (limited to 'juick-ws/src/main/java/com/juick/ws')
10 files changed, 2206 insertions, 0 deletions
diff --git a/juick-ws/src/main/java/com/juick/ws/components/CrosspostComponent.java b/juick-ws/src/main/java/com/juick/ws/components/CrosspostComponent.java new file mode 100644 index 000000000..ec5716ee4 --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/components/CrosspostComponent.java @@ -0,0 +1,323 @@ +/* + * Juick + * Copyright (C) 2013, Ugnich Anton + * + * This program is free software: you can redistribute it and/or modify + * it 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 <http://www.gnu.org/licenses/>. + */ +package com.juick.ws.components; + +import com.juick.server.CrosspostQueries; +import com.juick.xmpp.JID; +import com.juick.xmpp.Message; +import com.juick.xmpp.Stream; +import com.juick.xmpp.StreamComponent; +import com.juick.xmpp.extensions.JuickMessage; +import org.apache.commons.codec.binary.Base64; +import org.apache.commons.lang3.tuple.Pair; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.datasource.DriverManagerDataSource; + +import javax.crypto.Mac; +import javax.crypto.spec.SecretKeySpec; +import javax.net.ssl.HttpsURLConnection; +import javax.servlet.ServletContextEvent; +import javax.servlet.ServletContextListener; +import java.io.*; +import java.net.Socket; +import java.net.URL; +import java.net.URLEncoder; +import java.security.Key; +import java.util.Properties; +import java.util.UUID; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.logging.Level; +import java.util.logging.LogManager; +import java.util.logging.Logger; + +/** + * + * @author Ugnich Anton + */ +public class CrosspostComponent implements ServletContextListener, Stream.StreamListener, Message.MessageListener { + + private static Logger logger = Logger.getLogger(CrosspostComponent.class.getName()); + + private ExecutorService executorService; + + public final static String TWITTERURL = "https://api.twitter.com/1.1/statuses/update.json"; + public final static String FBURL = "https://graph.facebook.com/me/feed"; + public final static String VKURL = "https://api.vk.com/method/wall.post"; + JdbcTemplate sql; + Stream xmpp; + String twitter_consumer_key; + String twitter_consumer_secret; + + @Override + public void contextInitialized(final ServletContextEvent sce) { + logger.info("component initialized"); + executorService = Executors.newSingleThreadExecutor(); + executorService.submit((Runnable) () -> { + try { + Properties conf = new Properties(); + conf.load(sce.getServletContext().getResourceAsStream("/WEB-INF/juick.conf")); + + LogManager.getLogManager().readConfiguration( + sce.getServletContext().getResourceAsStream("/WEB-INF/logging.properties")); + twitter_consumer_key = conf.getProperty("twitter_consumer_key", ""); + twitter_consumer_secret = conf.getProperty("twitter_consumer_secret", ""); + + setupSql(conf.getProperty("datasource_driver", "com.mysql.jdbc.Driver"), conf.getProperty("datasource_url", "")); + setupXmppComponent(conf.getProperty("xmpp_password", "")); + } catch (Exception e) { + logger.log(Level.SEVERE, e.getMessage(), e); + } + }); + } + + @Override + public void contextDestroyed(ServletContextEvent sce) { + executorService.shutdown(); + logger.info("component destroyed"); + } + + public void setupSql(String driver, String url) { + DriverManagerDataSource dataSource = new DriverManagerDataSource(); + dataSource.setDriverClassName(driver); + dataSource.setUrl(url); + sql = new JdbcTemplate(dataSource); + } + + public void setupXmppComponent(String password) { + try { + Socket socket = new Socket("localhost", 5347); + xmpp = new StreamComponent(new JID("", "crosspost.juick.com", ""), socket.getInputStream(), socket.getOutputStream(), password); + xmpp.addChildParser(new JuickMessage()); + xmpp.addListener((Stream.StreamListener) this); + xmpp.addListener((Message.MessageListener) this); + xmpp.startParsing(); + } catch (IOException e) { + logger.log(Level.SEVERE, e.getMessage(), e); + } + } + + @Override + public void onStreamReady() { + logger.info("XMPP STREAM READY"); + } + + @Override + public void onStreamFail(Exception e) {logger.log(Level.SEVERE, "XMPP STREAM FAIL", e);} + @Override + public void onMessage(com.juick.xmpp.Message msg) { + JuickMessage jmsg = (JuickMessage) msg.getChild(JuickMessage.XMLNS); + if (msg.to != null && msg.to.Username != null && jmsg != null && jmsg.getRID() == 0) { + if (msg.to.Username.equals("twitter")) { + twitterPost(jmsg); + } else if (msg.to.Username.equals("fb")) { + facebookPost(jmsg); + } else if (msg.to.Username.equals("vk")) { + vkontaktePost(jmsg); + } + } + } + + public boolean facebookPost(com.juick.Message jmsg) { + String token = CrosspostQueries.getFacebookToken(sql, jmsg.getUser().getUID()).orElse(""); + if (token.isEmpty()) { + return false; + } + + logger.info("FB: #" + jmsg.getMID()); + + String status = getMessageHashTags(jmsg) + "\n" + jmsg.getText(); + + boolean ret = false; + try { + String body = "access_token=" + URLEncoder.encode(token, "UTF-8") + "&message=" + URLEncoder.encode(status, "UTF-8") + "&link=http%3A%2F%2Fjuick.com%2F" + jmsg.getMID(); + + HttpsURLConnection conn = (HttpsURLConnection) new URL(FBURL).openConnection(); + conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); + conn.setRequestProperty("User-Agent", "Juick"); + conn.setRequestProperty("Content-Length", Integer.toString(body.length())); + conn.setUseCaches(false); + conn.setDoInput(true); + conn.setDoOutput(true); + conn.setRequestMethod("POST"); + conn.connect(); + + OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream()); + wr.write(body); + wr.close(); + + ret = streamToString(conn.getInputStream()) != null; + + conn.disconnect(); + } catch (Exception e) { + logger.log(Level.SEVERE, "fbPost: " + e.getMessage(), e); + } + return ret; + } + + public boolean vkontaktePost(com.juick.Message jmsg) { + Pair<String, String> tokens = CrosspostQueries.getVKTokens(sql, jmsg.getUser().getUID()).orElse(Pair.of("", "")); + if (tokens.getLeft().isEmpty() || tokens.getRight().isEmpty()) { + return false; + } + + logger.info("VK: #" + jmsg.getMID()); + + String status = getMessageHashTags(jmsg) + "\n" + jmsg.getText() + "\nhttp://juick.com/" + jmsg.getMID(); + + boolean ret = false; + try { + String body = "owner_id=" + tokens.getLeft() + "&access_token=" + URLEncoder.encode(tokens.getRight(), "UTF-8") + "&from_group=1&message=" + URLEncoder.encode(status, "UTF-8"); + + HttpsURLConnection conn = (HttpsURLConnection) new URL(VKURL).openConnection(); + conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); + conn.setRequestProperty("User-Agent", "Juick"); + conn.setRequestProperty("Content-Length", Integer.toString(body.length())); + conn.setUseCaches(false); + conn.setDoInput(true); + conn.setDoOutput(true); + conn.setRequestMethod("POST"); + conn.connect(); + + OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream()); + wr.write(body); + wr.close(); + + ret = streamToString(conn.getInputStream()) != null; + + conn.disconnect(); + } catch (Exception e) { + logger.log(Level.SEVERE, "vkPost: " + e.getMessage(), e); + } + return ret; + } + + public boolean twitterPost(com.juick.Message jmsg) { + Pair<String, String> tokens = CrosspostQueries.getTwitterTokens(sql, jmsg.getUser().getUID()).orElse(Pair.of("", "")); + if (tokens.getLeft().isEmpty() || tokens.getRight().isEmpty()) { + return false; + } + String token = percentEncode(tokens.getLeft()); + String token_secret = percentEncode(tokens.getRight()); + + logger.info("TWITTER: #" + jmsg.getMID()); + + String status = getMessageHashTags(jmsg) + jmsg.getText(); + if (status.length() > 115) { + status = status.substring(0, 114) + "…"; + } + status += " http://juick.com/" + jmsg.getMID(); + status = percentEncode(status); + + boolean ret = false; + try { + String nonce = UUID.randomUUID().toString(); + String timestamp = Long.toString(System.currentTimeMillis() / 1000L); + String signature = percentEncode(twitterSignature(status, nonce, timestamp, token, token_secret)); + String auth = "OAuth " + + "oauth_consumer_key=\"" + twitter_consumer_key + "\", " + + "oauth_nonce=\"" + nonce + "\", " + + "oauth_signature=\"" + signature + "\", " + + "oauth_signature_method=\"HMAC-SHA1\", " + + "oauth_timestamp=\"" + timestamp + "\", " + + "oauth_token=\"" + token + "\", " + + "oauth_version=\"1.0\""; + + HttpsURLConnection conn = (HttpsURLConnection) new URL(TWITTERURL).openConnection(); + conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); + conn.setRequestProperty("User-Agent", "Juick"); + conn.setRequestProperty("Content-Length", Integer.toString(status.length() + 7)); + conn.setRequestProperty("Authorization", auth); + conn.setUseCaches(false); + conn.setDoInput(true); + conn.setDoOutput(true); + conn.setRequestMethod("POST"); + conn.connect(); + + OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream()); + wr.write("status=" + status); + wr.close(); + + ret = streamToString(conn.getInputStream()) != null; + + conn.disconnect(); + } catch (Exception e) { + logger.log(Level.SEVERE, "twitterPost: " + e.getMessage(), e); + } + return ret; + } + + public String twitterSignature(String status, String nonce, String timestamp, String token, String token_secret) { + try { + // ALPHABET-SORTED + String params = "oauth_consumer_key=" + twitter_consumer_key + + "&oauth_nonce=" + nonce + + "&oauth_signature_method=HMAC-SHA1" + + "&oauth_timestamp=" + timestamp + + "&oauth_token=" + token + + "&oauth_version=1.0" + + "&status=" + status; + + String base = "POST&" + percentEncode(TWITTERURL) + "&" + percentEncode(params); + String key = twitter_consumer_secret + "&" + token_secret; + + Key signingKey = new SecretKeySpec(key.getBytes(), "HmacSHA1"); + Mac mac = Mac.getInstance("HmacSHA1"); + mac.init(signingKey); + byte[] rawHmac = mac.doFinal(base.getBytes()); + return Base64.encodeBase64String(rawHmac); + + } catch (Exception e) { + logger.log(Level.SEVERE, "twitterSignature: " + e.getMessage(), e); + } + return null; + } + + public String streamToString(InputStream is) { + try { + BufferedReader buf = new BufferedReader(new InputStreamReader(is)); + StringBuilder str = new StringBuilder(); + String line; + do { + line = buf.readLine(); + str.append(line).append("\n"); + } while (line != null); + return str.toString(); + } catch (Exception e) { + logger.log(Level.SEVERE, "streamToString: " + e.getMessage(), e); + } + return null; + } + + public String getMessageHashTags(com.juick.Message jmsg) { + String hashtags = ""; + for (int i = 0; i < jmsg.Tags.size(); i++) { + hashtags += "#" + jmsg.Tags.get(i) + " "; + } + return hashtags; + } + + public static String percentEncode(String s) { + String ret = ""; + try { + ret = URLEncoder.encode(s, "UTF-8").replace("+", "%20").replace("*", "%2A").replace("%7E", "~"); + } catch (UnsupportedEncodingException e) { + } + return ret; + } +} diff --git a/juick-ws/src/main/java/com/juick/ws/components/PushComponent.java b/juick-ws/src/main/java/com/juick/ws/components/PushComponent.java new file mode 100644 index 000000000..eeb271844 --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/components/PushComponent.java @@ -0,0 +1,311 @@ +/* + * Juick + * Copyright (C) 2013, Ugnich Anton + * + * This program is free software: you can redistribute it and/or modify + * it 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 <http://www.gnu.org/licenses/>. + */ +package com.juick.ws.components; + +import com.google.android.gcm.server.Message; +import com.google.android.gcm.server.MulticastResult; +import com.google.android.gcm.server.Result; +import com.google.android.gcm.server.Sender; +import com.juick.json.MessageSerializer; +import com.juick.server.PushQueries; +import com.juick.server.SubscriptionsQueries; +import com.juick.xmpp.JID; +import com.juick.xmpp.Message.MessageListener; +import com.juick.xmpp.Stream; +import com.juick.xmpp.StreamComponent; +import com.juick.xmpp.extensions.JuickMessage; +import com.juick.xmpp.utils.XmlUtils; +import com.notnoop.apns.APNS; +import com.notnoop.apns.ApnsService; +import org.apache.http.Consts; +import org.apache.http.Header; +import org.apache.http.HttpResponse; +import org.apache.http.NameValuePair; +import org.apache.http.client.HttpClient; +import org.apache.http.client.entity.UrlEncodedFormEntity; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.entity.StringEntity; +import org.apache.http.impl.client.HttpClientBuilder; +import org.apache.http.message.BasicNameValuePair; +import org.apache.http.util.EntityUtils; +import org.apache.http.util.TextUtils; +import org.json.JSONObject; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.datasource.DriverManagerDataSource; + +import javax.servlet.ServletContextEvent; +import javax.servlet.ServletContextListener; +import java.io.IOException; +import java.net.Socket; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Properties; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.logging.Level; +import java.util.logging.LogManager; +import java.util.logging.Logger; +import java.util.stream.Collectors; + +/** + * + * @author Ugnich Anton + */ +public class PushComponent implements ServletContextListener, Stream.StreamListener, MessageListener { + + private static Logger logger = Logger.getLogger(PushComponent.class.getName()); + + private ExecutorService executorService; + String wns_application_sip; + String wns_client_secret; + JdbcTemplate sql; + Socket socket; + Stream xmpp; + Sender GCMSender; + + @Override + public void contextInitialized(final ServletContextEvent sce) { + logger.info("component initialized"); + executorService = Executors.newSingleThreadExecutor(); + executorService.submit(() -> { + Properties conf = new Properties(); + try { + conf.load(sce.getServletContext().getResourceAsStream("/WEB-INF/juick.conf")); + LogManager.getLogManager().readConfiguration( + sce.getServletContext().getResourceAsStream("/WEB-INF/logging.properties")); + wns_application_sip = conf.getProperty("wns_application_sip", ""); + wns_client_secret = conf.getProperty("wns_client_secret", ""); + GCMSender = new Sender(conf.getProperty("gcm_key")); + + setupSql(conf.getProperty("datasource_driver", "com.mysql.jdbc.Driver"), conf.getProperty("datasource_url", "")); + setupXmppComponent(new JID("", conf.getProperty("push_jid"), ""), conf.getProperty("xmpp_host", "localhost"), + Integer.parseInt(conf.getProperty("xmpp_port", "5347")), conf.getProperty("push_xmpp_password", "")); + } catch (IOException e) { + logger.log(Level.SEVERE, e.getMessage(), e); + } + }); + } + + @Override + public void contextDestroyed(ServletContextEvent sce) { + executorService.shutdown(); + logger.info("component destroyed"); + } + + public void setupSql(String driver, String url) { + DriverManagerDataSource dataSource = new DriverManagerDataSource(); + dataSource.setDriverClassName(driver); + dataSource.setUrl(url); + sql = new JdbcTemplate(dataSource); + } + + public void setupXmppComponent(JID jid, String host, int port, String password) { + try { + socket = new Socket(host, port); + xmpp = new StreamComponent(jid, socket.getInputStream(), socket.getOutputStream(), password); + xmpp.addChildParser(new JuickMessage()); + xmpp.addListener((Stream.StreamListener) this); + xmpp.addListener((MessageListener) this); + xmpp.startParsing(); + } catch (IOException e) { + logger.log(Level.SEVERE, e.getMessage(), e); + } + } + + @Override + public void onStreamReady() { + logger.info("XMPP STREAM READY"); + } + + @Override + public void onStreamFail(Exception e) {logger.log(Level.SEVERE, "XMPP STREAM FAIL", e);} + + @Override + public void onMessage(com.juick.xmpp.Message msg) { + JuickMessage jmsg = (JuickMessage)msg.getChild(JuickMessage.XMLNS); + List<com.juick.User> subscribedUsers = new ArrayList<>(); + boolean isPM = jmsg.getMID() == 0; + boolean isReply = jmsg.getRID() > 0; + int pmTo = 0; + if (isPM) { + pmTo = Integer.parseInt(msg.to.Username); + } else { + if (isReply) { + subscribedUsers = + SubscriptionsQueries.getUsersSubscribedToComments(sql, jmsg.getMID(), jmsg.getUser().getUID()); + } else { + // new message + subscribedUsers = SubscriptionsQueries.getSubscribedUsers(sql, jmsg.getUser().getUID(), jmsg.getMID()); + } + } + + /*** ANDROID ***/ + final List<String> regids = new ArrayList<>(); + if (isPM) { + regids.addAll(PushQueries.getAndroidRegID(sql, pmTo)); + } else { + List<Integer> uids = subscribedUsers.stream().map(com.juick.User::getUID).collect(Collectors.toList()); + if (uids.size() > 0) { + regids.addAll(PushQueries.getAndroidTokens(sql, uids)); + } + } + + if (!regids.isEmpty()) { + MessageSerializer messageSerializer = new MessageSerializer(); + String json = messageSerializer.serialize(jmsg).toString(); + logger.info(json); + Message message = new Message.Builder().addData("message", json).build(); + try { + MulticastResult result = GCMSender.send(message, regids, 3); + List<Result> results = result.getResults(); + for (int i = 0; i < results.size(); i++) { + logger.info("RES " + i + ": " + results.get(i).toString()); + } + } catch (IOException e) { + logger.log(Level.SEVERE, e.getMessage(), e); + } catch (IllegalArgumentException err) { + logger.warning("Android: Invalid API Key"); + } + } else { + logger.info("GMS: no recipients"); + } + + /*** WinPhone ***/ + final List<String> urls = new ArrayList<>(); + if (isPM) { + urls.addAll(PushQueries.getWinPhoneURL(sql, pmTo)); + } else { + List<Integer> uids = subscribedUsers.stream().map(com.juick.User::getUID).collect(Collectors.toList()); + if (uids.size() > 0) { + urls.addAll(PushQueries.getWindowsTokens(sql, uids)); + } + } + + + if (urls.isEmpty()) { + logger.info("WNS: no recipients"); + } else { + try { + String wnsToken = getWnsAccessToken(); + String text1 = "@" + jmsg.getUser().getUName(); + if (!jmsg.Tags.isEmpty()) { + text1 += ":" + XmlUtils.escape(jmsg.getTagsString()); + } + String text2 = XmlUtils.escape(jmsg.getText()); + String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + + "<toast>" + + "<visual>" + + "<binding template=\"ToastImageAndText02\">" + + "<image id=\"1\" src=\"http://i.juick.com/as/" + jmsg.getUser().getUID() + ".png\" />" + + "<text id=\"1\">" + text1 + "</text>" + + "<text id=\"2\">" + text2 + "</text>" + + "</binding>" + + "</visual>" + + "<commands>" + + "<command arguments=\"?mid=" + jmsg.getMID() + "\" />" + + "</commands>" + + "</toast>"; + logger.fine(xml); + for (String url : urls) { + logger.info("WNS: " + url); + sendWNS(wnsToken, url, xml); + } + } catch (IOException | IllegalStateException e) { + logger.log(Level.SEVERE, "WNS: ", e); + } + } + + /*** iOS ***/ + final List<String> tokens = new ArrayList<>(); + if (isPM) { + tokens.addAll(PushQueries.getAPNSToken(sql, pmTo)); + } else { + List<Integer> uids = subscribedUsers.stream().map(com.juick.User::getUID).collect(Collectors.toList()); + if (uids.size() > 0) { + tokens.addAll(PushQueries.getAPNSTokens(sql, uids)); + } + } + if (!tokens.isEmpty()) { + ApnsService service = APNS.newService().withCert("/etc/juick/ios.p12", "juick") + .withSandboxDestination().build(); + for (String token : tokens) { + String payload = APNS.newPayload().alertTitle("@" + jmsg.getUser().getUName()).alertBody(jmsg.getText()).build(); + logger.info("APNS: " + token); + service.push(token, payload); + } + } else { + logger.info("APNS: no recipients"); + } + } + + String getWnsAccessToken() throws IOException, IllegalStateException { + if(TextUtils.isEmpty(wns_application_sip)) { + throw new IllegalStateException("'wns_application_sip' is not initialized"); + } + if(TextUtils.isEmpty(wns_client_secret)) { + throw new IllegalStateException("'wns_client_secret' is not initialized"); + } + HttpClient client = HttpClientBuilder.create().build(); + String url = "https://login.live.com/accesstoken.srf"; + List<NameValuePair> formParams = new ArrayList<>(); + formParams.add(new BasicNameValuePair("grant_type", "client_credentials")); + formParams.add(new BasicNameValuePair("client_id", wns_application_sip)); + formParams.add(new BasicNameValuePair("client_secret", wns_client_secret)); + formParams.add(new BasicNameValuePair("scope", "notify.windows.com")); + UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formParams, Consts.UTF_8); + HttpPost httppost = new HttpPost(url); + httppost.setEntity(entity); + HttpResponse response = client.execute(httppost); + int statusCode = response.getStatusLine().getStatusCode(); + String responseContent = EntityUtils.toString(response.getEntity(), Consts.UTF_8); + JSONObject json = new JSONObject(responseContent); + if(statusCode != 200) { + throw new IOException(json.opt("error") + ": " + json.opt("error_description")); + } + String tokenType = (String)json.get("token_type"); + if(tokenType.length() >= 1) { + tokenType = Character.toUpperCase(tokenType.charAt(0)) + tokenType.substring(1); + } + return tokenType + " " + json.get("access_token"); + } + + void sendWNS(String wnsToken, String url, String xml) throws IOException { + HttpClient client = HttpClientBuilder.create().build(); + StringEntity entity = new StringEntity(xml, Consts.UTF_8); + HttpPost httpPost = new HttpPost(url); + httpPost.setHeader("Content-Type", "text/xml"); + httpPost.setHeader("Authorization", wnsToken); + httpPost.setHeader("X-WNS-Type", "wns/toast"); + httpPost.setEntity(entity); + HttpResponse response = client.execute(httpPost); + int statusCode = response.getStatusLine().getStatusCode(); + if(statusCode != 200) { + String headersContent = stringifyWnsHttpHeaders(response.getAllHeaders()); + throw new IOException(headersContent); + } + } + + static String stringifyWnsHttpHeaders(Header[] allHeaders) { + String[] wnsHeaders = Arrays.stream(allHeaders) + .filter(x -> x.getName().startsWith("X-WNS-") || x.getName().startsWith("WWW-")) + .map(x -> x.getName() + ": " + x.getValue()) + .toArray(String[]::new); + return String.join("\n", wnsHeaders); + } +} diff --git a/juick-ws/src/main/java/com/juick/ws/components/XMPPComponent.java b/juick-ws/src/main/java/com/juick/ws/components/XMPPComponent.java new file mode 100644 index 000000000..4e2f6d57c --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/components/XMPPComponent.java @@ -0,0 +1,474 @@ +package com.juick.ws.components; + +import com.juick.User; +import com.juick.server.MessagesQueries; +import com.juick.server.SubscriptionsQueries; +import com.juick.server.UserQueries; +import com.juick.xmpp.*; +import com.juick.xmpp.extensions.JuickMessage; +import com.juick.xmpp.extensions.Nickname; +import com.juick.xmpp.extensions.XOOB; +import com.juick.ws.s2s.*; +import org.apache.commons.dbcp2.BasicDataSource; +import org.springframework.jdbc.core.JdbcTemplate; +import org.xmlpull.v1.XmlPullParserException; + +import javax.servlet.ServletContextEvent; +import javax.servlet.ServletContextListener; +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; +import java.security.KeyManagementException; +import java.security.KeyStoreException; +import java.security.NoSuchAlgorithmException; +import java.security.UnrecoverableKeyException; +import java.security.cert.CertificateException; +import java.util.*; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author ugnich + */ +public class XMPPComponent implements ServletContextListener, Stream.StreamListener, + Message.MessageListener, Iq.IqListener, Presence.PresenceListener { + + private static final Logger logger = Logger.getLogger(XMPPComponent.class.getName()); + + public final ExecutorService executorService = Executors.newCachedThreadPool(); + private StreamComponent router; + JuickBot bot; + + public String HOSTNAME, componentName; + public String STATSFILE = null; + public String keystore; + public String keystorePassword; + public List<String> brokenSSLhosts; + public List<String> bannedHosts; + private final List<ConnectionIn> inConnections = Collections.synchronizedList(new ArrayList<>()); + private final List<ConnectionOut> outConnections = Collections.synchronizedList(new ArrayList<>()); + private final List<CacheEntry> outCache = Collections.synchronizedList(new ArrayList<>()); + private JdbcTemplate sql; + final public HashMap<String, StanzaChild> childParsers = new HashMap<>(); + + public void addConnectionIn(ConnectionIn c) { + synchronized (getInConnections()) { + getInConnections().add(c); + } + } + + public void addConnectionOut(ConnectionOut c) { + synchronized (getOutConnections()) { + getOutConnections().add(c); + } + } + + public void removeConnectionIn(ConnectionIn c) { + synchronized (getInConnections()) { + getInConnections().remove(c); + } + } + + public void removeConnectionOut(ConnectionOut c) { + synchronized (getOutConnections()) { + getOutConnections().remove(c); + } + } + + public String getFromCache(String hostname) { + CacheEntry ret = null; + synchronized (getOutCache()) { + for (Iterator<CacheEntry> i = getOutCache().iterator(); i.hasNext();) { + CacheEntry c = i.next(); + if (c.hostname != null && c.hostname.equals(hostname)) { + ret = c; + i.remove(); + break; + } + } + } + return (ret != null) ? ret.xml : null; + } + + public ConnectionOut getConnectionOut(String hostname, boolean needReady) { + synchronized (getOutConnections()) { + for (ConnectionOut c : getOutConnections()) { + if (c.to != null && c.to.equals(hostname) && (!needReady || c.streamReady)) { + return c; + } + } + } + return null; + } + + public ConnectionIn getConnectionIn(String streamID) { + synchronized (getInConnections()) { + for (ConnectionIn c : getInConnections()) { + if (c.streamID != null && c.streamID.equals(streamID)) { + return c; + } + } + } + return null; + } + + public void sendOut(Stanza s) { + sendOut(s.to.Host, s.toString()); + } + + public void sendOut(String hostname, String xml) { + boolean haveAnyConn = false; + + ConnectionOut connOut = null; + synchronized (getOutConnections()) { + for (ConnectionOut c : getOutConnections()) { + if (c.to != null && c.to.equals(hostname)) { + if (c.streamReady) { + connOut = c; + break; + } else { + haveAnyConn = true; + break; + } + } + } + } + if (connOut != null) { + try { + connOut.sendStanza(xml); + } catch (IOException e) { + logger.warning("STREAM TO " + connOut.to + " " + connOut.streamID + " ERROR: " + e.toString()); + } + return; + } + + boolean haveCache = false; + synchronized (getOutCache()) { + for (CacheEntry c : getOutCache()) { + if (c.hostname != null && c.hostname.equals(hostname)) { + c.xml += xml; + c.tsUpdated = System.currentTimeMillis(); + haveCache = true; + break; + } + } + if (!haveCache) { + getOutCache().add(new CacheEntry(hostname, xml)); + } + } + + if (!haveAnyConn) { + try { + ConnectionOut connectionOut = new ConnectionOut(this, hostname); + executorService.submit(connectionOut); + } catch (CertificateException | UnrecoverableKeyException | NoSuchAlgorithmException | XmlPullParserException | KeyStoreException | KeyManagementException | IOException e) { + logger.log(Level.SEVERE, "s2s out error", e); + } + } + } + + @Override + public void contextInitialized(ServletContextEvent sce) { + + logger.info("component initialized"); + Properties conf = new Properties(); + try { + conf.load(sce.getServletContext().getResourceAsStream("/WEB-INF/juick.conf")); + HOSTNAME = conf.getProperty("hostname"); + componentName = conf.getProperty("componentname"); + JID Jid = new JID(conf.getProperty("xmppbot_jid")); + STATSFILE = conf.getProperty("statsfile"); + keystore = conf.getProperty("keystore"); + keystorePassword = conf.getProperty("keystore_password"); + brokenSSLhosts = Arrays.asList(conf.getProperty("broken_ssl_hosts", "").split(",")); + bannedHosts = Arrays.asList(conf.getProperty("banned_hosts", "").split(",")); + BasicDataSource dataSource = new BasicDataSource(); + dataSource.setDriverClassName(conf.getProperty("datasource_driver", "com.mysql.jdbc.Driver")); + dataSource.setUrl(conf.getProperty("datasource_url")); + setSql(new JdbcTemplate(dataSource)); + bot = new JuickBot(this, Jid); + + childParsers.put(JuickMessage.XMLNS, new JuickMessage()); + + executorService.submit(() -> { + Socket routerSocket = null; + try { + routerSocket = new Socket("localhost", 5347); + setRouter(new StreamComponent(new JID("s2s"), routerSocket.getInputStream(), routerSocket.getOutputStream(), conf.getProperty("xmpp_password"))); + getRouter().addChildParser(new JuickMessage()); + getRouter().addListener((Stream.StreamListener) this); + getRouter().addListener((Message.MessageListener) this); + getRouter().addListener((Iq.IqListener) this); + getRouter().startParsing(); + } catch (IOException e) { + logger.log(Level.SEVERE, "router error", e); + } + }); + executorService.submit(() -> { + final ServerSocket listener = new ServerSocket(5269); + logger.info("s2s listener ready"); + while (true) { + try { + Socket socket = listener.accept(); + ConnectionIn client = new ConnectionIn(this, bot, socket); + addConnectionIn(client); + executorService.submit(client); + } catch (Exception e) { + logger.log(Level.SEVERE, "s2s error", e); + } + } + }); + executorService.submit(new CleaningUp(this)); + + } catch (Exception e) { + logger.log(Level.SEVERE, "XMPPComponent error", e); + } + } + + + + @Override + public void contextDestroyed(ServletContextEvent sce) { + synchronized (getOutConnections()) { + for (Iterator<ConnectionOut> i = getOutConnections().iterator(); i.hasNext();) { + ConnectionOut c = i.next(); + c.closeConnection(); + i.remove(); + } + } + + synchronized (getInConnections()) { + for (Iterator<ConnectionIn> i = getInConnections().iterator(); i.hasNext();) { + ConnectionIn c = i.next(); + c.closeConnection(); + i.remove(); + } + } + + try { + closeRouterConnection(); + } catch (IOException e) { + logger.log(Level.WARNING, "router warning", e); + } + executorService.shutdown(); + logger.info("component destroyed"); + } + public void closeRouterConnection() throws IOException { + getRouter().logoff(); + } + + public void sendJuickMessage(JuickMessage jmsg) { + List<String> jids = new ArrayList<>(); + + if (jmsg.FriendsOnly) { + jids = SubscriptionsQueries.getJIDSubscribedToUser(getSql(), jmsg.getUser().getUID(), jmsg.FriendsOnly); + } else { + List<User> users = SubscriptionsQueries.getSubscribedUsers(getSql(), jmsg.getUser().getUID(), jmsg.getMID()); + for (User user : users) { + for (String jid : UserQueries.getJIDsbyUID(getSql(), user.getUID())) { + jids.add(jid); + } + } + } + + String txt = "@" + jmsg.getUser().getUName() + ":" + jmsg.getTagsString() + "\n"; + String attachment = jmsg.getAttachmentURL(); + if (attachment != null) { + txt += attachment + "\n"; + } + txt += jmsg.getText() + "\n\n"; + txt += "#" + jmsg.getMID() + " http://juick.com/" + jmsg.getMID(); + + Nickname nick = new Nickname(); + nick.Nickname = "@" + jmsg.getUser().getUName(); + + com.juick.xmpp.Message msg = new com.juick.xmpp.Message(); + msg.from = bot.JuickJID; + msg.body = txt; + msg.type = Message.Type.chat; + msg.thread = "juick-" + jmsg.getMID(); + msg.addChild(jmsg); + msg.addChild(nick); + if (attachment != null) { + XOOB oob = new XOOB(); + oob.URL = attachment; + msg.addChild(oob); + } + + for (String jid : jids) { + msg.to = new JID(jid); + sendOut(msg); + } + } + + public void sendJuickComment(JuickMessage jmsg) { + List<User> users; + String replyQuote; + String replyTo; + + users = SubscriptionsQueries.getUsersSubscribedToComments(getSql(), jmsg.getMID(), jmsg.getUser().getUID()); + com.juick.Message replyMessage = jmsg.ReplyTo > 0 ? MessagesQueries.getReply(getSql(), jmsg.getMID(), jmsg.ReplyTo) + : MessagesQueries.getMessage(getSql(), jmsg.getMID()); + replyTo = replyMessage.getUser().getUName(); + replyQuote = getReplyQuote(replyMessage); + + String txt = "Reply by @" + jmsg.getUser().getUName() + ":\n" + replyQuote + "\n@" + replyTo + " "; + String attachment = jmsg.getAttachmentURL(); + if (attachment != null) { + txt += attachment + "\n"; + } + txt += jmsg.getText() + "\n\n" + "#" + jmsg.getMID() + "/" + jmsg.getRID() + " http://juick.com/" + jmsg.getMID() + "#" + jmsg.getRID(); + + com.juick.xmpp.Message msg = new com.juick.xmpp.Message(); + msg.from = bot.JuickJID; + msg.body = txt; + msg.type = Message.Type.chat; + msg.addChild(jmsg); + for (User user : users) { + for (String jid : UserQueries.getJIDsbyUID(getSql(), user.getUID())) { + msg.to = new JID(jid); + sendOut(msg); + } + } + } + + private String getReplyQuote(com.juick.Message q) { + String quote = q.getText(); + if (quote.length() > 50) { + quote = ">" + quote.substring(0, 47).replace('\n', ' ') + "...\n"; + } else if (quote.length() > 0) { + quote = ">" + quote.replace('\n', ' ') + "\n"; + } + return quote; + } + + public void sendJuickRecommendation(JuickMessage recomm) { + List<User> users; + JuickMessage jmsg; + jmsg = new JuickMessage(MessagesQueries.getMessage(getSql(), recomm.getMID())); + users = SubscriptionsQueries.getUsersSubscribedToUserRecommendations(getSql(), + recomm.getUser().getUID(), recomm.getMID(), jmsg.getUser().getUID()); + + String txt = "Recommended by @" + recomm.getUser().getUName() + ":\n"; + txt += "@" + jmsg.getUser().getUName() + ":" + jmsg.getTagsString() + "\n"; + String attachment = jmsg.getAttachmentURL(); + if (attachment != null) { + txt += attachment + "\n"; + } + txt += jmsg.getText() + "\n\n"; + txt += "#" + jmsg.getMID(); + if (jmsg.Replies > 0) { + if (jmsg.Replies % 10 == 1 && jmsg.Replies % 100 != 11) { + txt += " (" + jmsg.Replies + " reply)"; + } else { + txt += " (" + jmsg.Replies + " replies)"; + } + } + txt += " http://juick.com/" + jmsg.getMID(); + + Nickname nick = new Nickname(); + nick.Nickname = "@" + jmsg.getUser().getUName(); + + com.juick.xmpp.Message msg = new com.juick.xmpp.Message(); + msg.from = bot.JuickJID; + msg.body = txt; + msg.type = Message.Type.chat; + msg.thread = "juick-" + jmsg.getMID(); + msg.addChild(jmsg); + msg.addChild(nick); + if (attachment != null) { + XOOB oob = new XOOB(); + oob.URL = attachment; + msg.addChild(oob); + } + + for (User user : users) { + for (String jid : UserQueries.getJIDsbyUID(getSql(), user.getUID())) { + msg.to = new JID(jid); + sendOut(msg); + } + } + } + + @Override + public boolean onIq(Iq iq) { + JID jid = iq.to; + if (!jid.Host.equals(componentName)) { + logger.info("STREAM ROUTER (IQ): " + iq.toString()); + sendOut(iq); + } + return false; + } + + @Override + public void onMessage(Message xmsg) { + logger.info("STREAM ROUTER (PROCESS): " + xmsg.toString()); + JuickMessage jmsg = (JuickMessage) xmsg.getChild(JuickMessage.XMLNS); + JID jid = xmsg.to; + if (jid.Host.equals(componentName)) { + if (jmsg != null) { + if (jid.Username != null && jid.Username.equals("recomm")) { + sendJuickRecommendation(jmsg); + } else { + if (jmsg.getRID() > 0) { + sendJuickComment(jmsg); + } else if (jmsg.getMID() > 0) { + sendJuickMessage(jmsg); + } + } + } + } else { + sendOut(xmsg); + } + } + + @Override + public void onPresence(Presence presence) { + JID jid = presence.to; + if (!jid.Host.equals(componentName)) { + logger.info("STREAM ROUTER (PRESENCE): " + presence.toString()); + sendOut(presence); + } + } + + @Override + public void onStreamReady() { + logger.info("STREAM ROUTER (READY)"); + } + + @Override + public void onStreamFail(Exception ex) { + logger.log(Level.SEVERE, "STREAM ROUTER (FAIL)", ex); + } + + public StreamComponent getRouter() { + return router; + } + + public void setRouter(StreamComponent router) { + this.router = router; + } + + public List<ConnectionIn> getInConnections() { + return inConnections; + } + + public List<ConnectionOut> getOutConnections() { + return outConnections; + } + + public List<CacheEntry> getOutCache() { + return outCache; + } + + public JdbcTemplate getSql() { + return sql; + } + + public void setSql(JdbcTemplate sql) { + this.sql = sql; + } +} diff --git a/juick-ws/src/main/java/com/juick/ws/s2s/CacheEntry.java b/juick-ws/src/main/java/com/juick/ws/s2s/CacheEntry.java new file mode 100644 index 000000000..e870e0d86 --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/s2s/CacheEntry.java @@ -0,0 +1,19 @@ +package com.juick.ws.s2s; + +/** + * + * @author ugnich + */ +public class CacheEntry { + + public String hostname; + public long tsCreated; + public long tsUpdated; + public String xml; + + public CacheEntry(String hostname, String xml) { + this.hostname = hostname; + this.tsCreated = this.tsUpdated = System.currentTimeMillis(); + this.xml = xml; + } +} diff --git a/juick-ws/src/main/java/com/juick/ws/s2s/CleaningUp.java b/juick-ws/src/main/java/com/juick/ws/s2s/CleaningUp.java new file mode 100644 index 000000000..8140c8292 --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/s2s/CleaningUp.java @@ -0,0 +1,109 @@ +package com.juick.ws.s2s; + +import com.juick.ws.components.XMPPComponent; + +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.io.UnsupportedEncodingException; +import java.util.Iterator; + +/** + * + * @author ugnich + */ +public class CleaningUp implements Runnable { + XMPPComponent xmpp; + + public CleaningUp(XMPPComponent xmpp) { + this.xmpp = xmpp; + } + + @Override + public void run() { + while (true) { + try { + PrintWriter statsFile = new PrintWriter(xmpp.STATSFILE, "UTF-8"); + statsFile.write("<html><body><h2>Threads: " + Thread.activeCount() + "</h2>"); + statsFile.write("<h2>Out (" + xmpp.getOutConnections().size() + ")</h2><table border=1><tr><th>to</th><th>sid</th><th>inactive</th><th>out packets</th><th>out bytes</th></tr>"); + + long now = System.currentTimeMillis(); + + synchronized (xmpp.getOutConnections()) { + for (Iterator<ConnectionOut> i = xmpp.getOutConnections().iterator(); i.hasNext();) { + ConnectionOut c = i.next(); + int inactive = (int) ((double) (now - c.tsLocalData) / 1000.0); + if (inactive > 900) { + c.closeConnection(); + i.remove(); + } else { + statsFile.write(" <tr>"); + statsFile.write(" <td>" + c.to + "</td>\n"); + statsFile.write(" <td>" + c.streamID + "</td>\n"); + statsFile.write(" <td>" + inactive + "</td>\n"); + statsFile.write(" <td>" + c.packetsLocal + "</td>\n"); + statsFile.write(" <td>" + c.bytesLocal + "</td>\n"); + statsFile.write(" <tr>"); + } + } + } + + statsFile.write("</table><h2>In (" + xmpp.getInConnections().size() + ")</h2><table border=1><tr><th>from</th><th>sid</th><th>inactive</th><th>in packets</th></tr>"); + + synchronized (xmpp.getInConnections()) { + for (Iterator<ConnectionIn> i = xmpp.getInConnections().iterator(); i.hasNext();) { + ConnectionIn c = i.next(); + int inactive = (int) ((double) (now - c.tsRemoteData) / 1000.0); + if (inactive > 900) { + c.closeConnection(); + i.remove(); + } else { + statsFile.write(" <tr>"); + if (c.from.isEmpty()) { + statsFile.write(" <td> </td>\n"); + } else if (c.from.size() == 1) { + statsFile.write(" <td>" + c.from.get(0) + "</td>\n"); + } else { + String out = " <td>"; + for (int n = 0; n < c.from.size(); n++) { + if (n > 0) { + out += "<br/>"; + } + out += c.from.get(n); + } + statsFile.write(out + "</td>\n"); + } + statsFile.write(" <td>" + c.streamID + "</td>\n"); + statsFile.write(" <td>" + inactive + "</td>\n"); + statsFile.write(" <td>" + c.packetsRemote + "</td>\n"); + statsFile.write(" <tr>"); + } + } + } + + statsFile.write("</table><h2>Cache (" + xmpp.getOutCache().size() + ")</h2><table border=1><tr><th>host</th><th>live</th><th>size</th></tr>"); + + synchronized (xmpp.getOutCache()) { + for (Iterator<CacheEntry> i = xmpp.getOutCache().iterator(); i.hasNext();) { + CacheEntry c = i.next(); + int inactive = (int) ((double) (now - c.tsCreated) / 1000.0); + if (inactive > 600) { + i.remove(); + } else { + statsFile.write("<tr><td>" + c.hostname + "</td><td>" + inactive + "</td><td>" + c.xml.length() + "</td></tr>"); + } + } + } + + statsFile.write("</table></body></html>"); + statsFile.close(); + + try { + Thread.sleep(10000); + } catch (InterruptedException e) { + } + } catch (FileNotFoundException e) { + } catch (UnsupportedEncodingException e) { + } + } + } +} diff --git a/juick-ws/src/main/java/com/juick/ws/s2s/Connection.java b/juick-ws/src/main/java/com/juick/ws/s2s/Connection.java new file mode 100644 index 000000000..77c12d1d5 --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/s2s/Connection.java @@ -0,0 +1,149 @@ +package com.juick.ws.s2s; + +import com.juick.ws.components.XMPPComponent; +import org.xmlpull.mxp1.MXParser; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import javax.crypto.Mac; +import javax.crypto.spec.SecretKeySpec; +import javax.net.ssl.KeyManagerFactory; +import javax.net.ssl.SSLContext; +import javax.net.ssl.TrustManager; +import javax.net.ssl.X509TrustManager; +import java.io.*; +import java.net.Socket; +import java.security.*; +import java.security.cert.CertificateException; +import java.util.UUID; +import java.util.logging.Logger; + +/** + * + * @author ugnich + */ +public class Connection { + + protected static final Logger logger = Logger.getLogger(Connection.class.getName()); + + public String streamID; + public long tsCreated = 0; + public long tsLocalData = 0; + public long bytesLocal = 0; + public long packetsLocal = 0; + XMPPComponent xmpp; + Socket socket; + public static final String NS_DB = "jabber:server:dialback"; + public static final String NS_TLS = "urn:ietf:params:xml:ns:xmpp-tls"; + public static final String NS_STREAM = "http://etherx.jabber.org/streams"; + XmlPullParser parser = new MXParser(); + OutputStreamWriter writer; + private boolean secured = false; + SSLContext sc; + private TrustManager[] trustAllCerts = new TrustManager[]{ + new X509TrustManager() { + public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) { + } + + public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) { + } + public java.security.cert.X509Certificate[] getAcceptedIssuers() { + return null; + } + } + }; + + + public Connection(XMPPComponent xmpp) throws XmlPullParserException, KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException, UnrecoverableKeyException, KeyManagementException { + this.xmpp = xmpp; + tsCreated = System.currentTimeMillis(); + parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true); + KeyStore ks = KeyStore.getInstance("JKS"); + try (InputStream ksIs = new FileInputStream(xmpp.keystore)) { + ks.load(ksIs, xmpp.keystorePassword.toCharArray()); + } + + KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory + .getDefaultAlgorithm()); + kmf.init(ks, xmpp.keystorePassword.toCharArray()); + sc = SSLContext.getInstance("TLSv1.2"); + + sc.init(kmf.getKeyManagers(), trustAllCerts, new SecureRandom()); + + } + + public void logParser() { + if (streamID == null) { + return; + } + String tag = "IN: <" + parser.getName(); + for (int i = 0; i < parser.getAttributeCount(); i++) { + tag += " " + parser.getAttributeName(i) + "=\"" + parser.getAttributeValue(i) + "\""; + } + tag += ">...</" + parser.getName() + ">\n"; + logger.fine(tag); + } + + public void sendStanza(String xml) throws IOException { + if (streamID != null) { + logger.fine("OUT: " + xml + "\n"); + } + writer.write(xml); + writer.flush(); + tsLocalData = System.currentTimeMillis(); + bytesLocal += xml.length(); + packetsLocal++; + } + + public void closeConnection() { + if (streamID != null) { + logger.info(String.format("CLOSING STREAM %s", streamID)); + } + + try { + writer.write("</stream:stream>"); + } catch (Exception e) { + } + + try { + writer.close(); + } catch (Exception e) { + } + + try { + socket.close(); + } catch (Exception e) { + } + } + + static String generateDialbackKey(String to, String from, String id) throws Exception { + Mac hmacSha256 = Mac.getInstance("hmacSHA256"); + + SecretKeySpec secret_key = new SecretKeySpec("$UppPerSeCCret4".getBytes(), "SHA-256"); + hmacSha256.init(secret_key); + byte key[] = hmacSha256.doFinal((to + " " + from + " " + id).getBytes()); + + StringBuilder hexkey = new StringBuilder(); + for (int i = 0; i < key.length; i++) { + hexkey.append(Integer.toHexString(0xFF & key[i])); + } + + return hexkey.toString(); + } + + public boolean isSecured() { + return secured; + } + + public void setSecured(boolean secured) { + this.secured = secured; + } + + public void restartParser() throws XmlPullParserException, IOException { + parser = new MXParser(); + parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true); + parser.setInput(new InputStreamReader(socket.getInputStream())); + writer = new OutputStreamWriter(socket.getOutputStream()); + streamID = UUID.randomUUID().toString(); + } +} diff --git a/juick-ws/src/main/java/com/juick/ws/s2s/ConnectionIn.java b/juick-ws/src/main/java/com/juick/ws/s2s/ConnectionIn.java new file mode 100644 index 000000000..a57623c4a --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/s2s/ConnectionIn.java @@ -0,0 +1,227 @@ +package com.juick.ws.s2s; + +import com.juick.ws.components.XMPPComponent; +import com.juick.xmpp.Iq; +import com.juick.xmpp.JID; +import com.juick.xmpp.Message; +import com.juick.xmpp.Presence; +import com.juick.xmpp.utils.XmlUtils; +import org.xmlpull.v1.XmlPullParser; + +import javax.net.ssl.SSLException; +import javax.net.ssl.SSLSocket; +import java.io.EOFException; +import java.io.IOException; +import java.net.Socket; +import java.net.SocketException; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author ugnich + */ +public class ConnectionIn extends Connection implements Runnable { + + private static final Logger LOGGER = Logger.getLogger(ConnectionIn.class.getName()); + + final public List<String> from = new ArrayList<>(); + public long tsRemoteData = 0; + public long packetsRemote = 0; + JuickBot bot; + + public ConnectionIn(XMPPComponent xmpp, JuickBot bot, Socket socket) throws Exception { + super(xmpp); + this.bot = bot; + this.socket = socket; + streamID = UUID.randomUUID().toString(); + restartParser(); + } + + @Override + public void run() { + LOGGER.info("STREAM FROM ? " + streamID + " START"); + try { + parser.next(); // stream:stream + updateTsRemoteData(); + if (!parser.getName().equals("stream") + || !parser.getNamespace("stream").equals(NS_STREAM)) { +// || !parser.getAttributeValue(null, "version").equals("1.0") +// || !parser.getAttributeValue(null, "to").equals(Main.HOSTNAME)) { + throw new Exception("STREAM FROM ? " + streamID + " INVALID FIRST PACKET"); + } + boolean xmppversionnew = parser.getAttributeValue(null, "version") != null; + String from = parser.getAttributeValue(null, "from"); + + if (xmpp.bannedHosts.contains(from)) { + closeConnection(); + return; + } + sendOpenStream(from, xmppversionnew); + + while (parser.next() != XmlPullParser.END_DOCUMENT) { + updateTsRemoteData(); + if (parser.getEventType() != XmlPullParser.START_TAG) { + continue; + } + logParser(); + + packetsRemote++; + + String tag = parser.getName(); + if (tag.equals("result") && parser.getNamespace().equals(NS_DB)) { + String dfrom = parser.getAttributeValue(null, "from"); + String to = parser.getAttributeValue(null, "to"); + LOGGER.info("STREAM FROM " + dfrom + " TO " + to + " " + streamID + " ASKING FOR DIALBACK"); + if (dfrom.endsWith(xmpp.HOSTNAME) && (dfrom.equals(xmpp.HOSTNAME) || dfrom.endsWith("." + xmpp.HOSTNAME))) { + break; + } + if (to != null && to.equals(xmpp.HOSTNAME)) { + String dbKey = XmlUtils.getTagText(parser); + updateTsRemoteData(); + + ConnectionOut c = xmpp.getConnectionOut(dfrom, false); + if (c != null) { + c.sendDialbackVerify(streamID, dbKey); + } else { + c = new ConnectionOut(xmpp, dfrom, streamID, dbKey); + xmpp.executorService.submit(c); + } + } else { + throw new HostUnknownException("STREAM FROM " + dfrom + " " + streamID + " INVALID TO " + to); + } + } else if (tag.equals("verify") && parser.getNamespace().equals(NS_DB)) { + String vfrom = parser.getAttributeValue(null, "from"); + String vto = parser.getAttributeValue(null, "to"); + String vid = parser.getAttributeValue(null, "id"); + String vkey = XmlUtils.getTagText(parser); + updateTsRemoteData(); + boolean valid = false; + if (vfrom != null && vto != null && vid != null && vkey != null) { + String vkey2 = generateDialbackKey(vfrom, vto, vid); + valid = vkey.equals(vkey2); + } + if (valid) { + sendStanza("<db:verify from='" + vto + "' to='" + vfrom + "' id='" + vid + "' type='valid'/>"); + LOGGER.info("STREAM FROM " + vfrom + " " + streamID + " DIALBACK VERIFY VALID"); + } else { + sendStanza("<db:verify from='" + vto + "' to='" + vfrom + "' id='" + vid + "' type='invalid'/>"); + LOGGER.warning("STREAM FROM " + vfrom + " " + streamID + " DIALBACK VERIFY INVALID"); + } + } else if (tag.equals("presence") && checkFromTo(parser)) { + Presence p = Presence.parse(parser, null); + if (p != null && (p.type == null || !p.type.equals(Presence.Type.error))) { + bot.incomingPresence(p); + } + } else if (tag.equals("message") && checkFromTo(parser)) { + updateTsRemoteData(); + Message msg = Message.parse(parser, xmpp.childParsers); + if (msg != null && (msg.type == null || !msg.type.equals(Message.Type.error))) { + LOGGER.info("STREAM " + streamID + ": " + msg.toString()); + if (!bot.incomingMessage(msg)) { + xmpp.getRouter().send(msg.toString()); + } + } + } else if (tag.equals("iq") && checkFromTo(parser)) { + updateTsRemoteData(); + String type = parser.getAttributeValue(null, "type"); + String xml = XmlUtils.parseToString(parser, true); + if (type == null || !type.equals(Iq.Type.error)) { + LOGGER.info("STREAM " + streamID + ": " + xml); + xmpp.getRouter().send(xml); + } + } else if (!isSecured() && tag.equals("starttls")) { + LOGGER.info("STREAM " + streamID + " SECURING"); + sendStanza("<proceed xmlns=\"" + NS_TLS + "\" />"); + try { + socket = sc.getSocketFactory().createSocket(socket, socket.getInetAddress().getHostAddress(), + socket.getPort(), true); + ((SSLSocket) socket).setUseClientMode(false); + ((SSLSocket) socket).startHandshake(); + setSecured(true); + LOGGER.info("STREAM " + streamID + " SECURED"); + restartParser(); + } catch (SSLException sex) { + LOGGER.warning("STREAM " + streamID + " SSL ERROR"); + sendStanza("<failed xmlns\"" + NS_TLS + "\" />"); + xmpp.removeConnectionIn(this); + closeConnection(); + } + } else if (isSecured() && tag.equals("stream") && parser.getNamespace().equals(NS_STREAM)) { + sendOpenStream(null, true); + } else { + LOGGER.info("STREAM " + streamID + ": " + XmlUtils.parseToString(parser, true)); + } + } + LOGGER.warning("STREAM " + streamID + " FINISHED"); + xmpp.removeConnectionIn(this); + closeConnection(); + } catch (EOFException | SocketException ex) { + LOGGER.info(String.format("STREAM %s CLOSED (dirty)", streamID)); + xmpp.removeConnectionIn(this); + closeConnection(); + } catch (HostUnknownException e) { + LOGGER.warning(e.getMessage()); + } catch (Exception e) { + LOGGER.log(Level.WARNING, "STREAM " + streamID + " ERROR", e); + xmpp.removeConnectionIn(this); + closeConnection(); + } + } + + void updateTsRemoteData() { + tsRemoteData = System.currentTimeMillis(); + } + + void sendOpenStream(String from, boolean xmppversionnew) throws IOException { + String openStream = "<?xml version='1.0'?><stream:stream xmlns='jabber:server' " + + "xmlns:stream='http://etherx.jabber.org/streams' xmlns:db='jabber:server:dialback' from='" + + xmpp.HOSTNAME + "' id='" + streamID + "' version='1.0'>"; + if (xmppversionnew) { + openStream += "<stream:features>"; + if (!isSecured() && !xmpp.brokenSSLhosts.contains(from)) { + openStream += "<starttls xmlns=\"" + NS_TLS + "\"><optional/></starttls>"; + } + openStream += "</stream:features>"; + } + sendStanza(openStream); + } + + public void sendDialbackResult(String sfrom, String type) { + try { + sendStanza("<db:result from='" + xmpp.HOSTNAME + "' to='" + sfrom + "' type='" + type + "'/>"); + if (type.equals("valid")) { + from.add(sfrom); + LOGGER.info("STREAM FROM " + sfrom + " " + streamID + " READY"); + } + } catch (IOException e) { + LOGGER.warning("STREAM FROM " + sfrom + " " + streamID + " ERROR: " + e.toString()); + } + } + + boolean checkFromTo(XmlPullParser parser) throws Exception { + String cfrom = parser.getAttributeValue(null, "from"); + String cto = parser.getAttributeValue(null, "to"); + if (cfrom != null && cto != null && !cfrom.isEmpty() && !cto.isEmpty()) { + JID jidto = new JID(cto); + if (jidto.Host != null && jidto.Username != null && jidto.Host.equals(xmpp.HOSTNAME) && jidto.Username.matches("^[a-zA-Z0-9\\-]{2,16}$")) { + JID jidfrom = new JID(cfrom); + int size = from.size(); + for (int i = 0; i < size; i++) { + if (from.get(i).equals(jidfrom.Host)) { + return true; + } + } + } + } + return false; + } + class HostUnknownException extends Exception { + public HostUnknownException(String message) { + super(message); + } + } +} diff --git a/juick-ws/src/main/java/com/juick/ws/s2s/ConnectionOut.java b/juick-ws/src/main/java/com/juick/ws/s2s/ConnectionOut.java new file mode 100644 index 000000000..1de16329b --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/s2s/ConnectionOut.java @@ -0,0 +1,168 @@ +package com.juick.ws.s2s; + +import com.juick.ws.components.XMPPComponent; +import com.juick.xmpp.extensions.StreamFeatures; +import com.juick.xmpp.utils.XmlUtils; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import javax.net.ssl.SSLException; +import javax.net.ssl.SSLSocket; +import java.io.EOFException; +import java.io.IOException; +import java.net.Socket; +import java.net.SocketException; +import java.security.KeyManagementException; +import java.security.KeyStoreException; +import java.security.NoSuchAlgorithmException; +import java.security.UnrecoverableKeyException; +import java.security.cert.CertificateException; +import java.util.UUID; +import java.util.logging.Level; + +/** + * @author ugnich + */ +public class ConnectionOut extends Connection implements Runnable { + + public boolean streamReady = false; + public String to; + String checkSID = null; + String dbKey = null; + + public ConnectionOut(XMPPComponent xmpp, String hostname) throws CertificateException, UnrecoverableKeyException, NoSuchAlgorithmException, XmlPullParserException, KeyManagementException, KeyStoreException, IOException { + super(xmpp); + to = hostname; + } + + public ConnectionOut(XMPPComponent xmpp, String hostname, String checkSID, String dbKey) throws Exception { + super(xmpp); + to = hostname; + this.checkSID = checkSID; + this.dbKey = dbKey; + streamID = UUID.randomUUID().toString(); + } + + void sendOpenStream() throws IOException { + sendStanza("<?xml version='1.0'?><stream:stream xmlns='jabber:server' id='" + streamID + + "' xmlns:stream='http://etherx.jabber.org/streams' xmlns:db='jabber:server:dialback' from='" + + xmpp.HOSTNAME + "' to='" + to + "' version='1.0'>"); + } + + void processDialback() throws Exception { + if (checkSID != null) { + sendDialbackVerify(checkSID, dbKey); + } + sendStanza("<db:result from='" + xmpp.HOSTNAME + "' to='" + to + "'>" + + generateDialbackKey(to, xmpp.HOSTNAME, streamID) + "</db:result>"); + } + + @Override + public void run() { + logger.info("STREAM TO " + to + " START"); + try { + socket = new Socket(); + socket.connect(DNSQueries.getServerAddress(to)); + restartParser(); + + sendOpenStream(); + + parser.next(); // stream:stream + streamID = parser.getAttributeValue(null, "id"); + if (streamID == null || streamID.isEmpty()) { + throw new Exception("STREAM TO " + to + " INVALID FIRST PACKET"); + } + + logger.info("STREAM TO " + to + " " + streamID + " OPEN"); + xmpp.addConnectionOut(ConnectionOut.this); + boolean xmppversionnew = parser.getAttributeValue(null, "version") != null; + if (!xmppversionnew) { + processDialback(); + } + + while (parser.next() != XmlPullParser.END_DOCUMENT) { + if (parser.getEventType() != XmlPullParser.START_TAG) { + continue; + } + logParser(); + + String tag = parser.getName(); + if (tag.equals("result") && parser.getNamespace().equals(NS_DB)) { + String type = parser.getAttributeValue(null, "type"); + if (type != null && type.equals("valid")) { + streamReady = true; + logger.info("STREAM TO " + to + " " + streamID + " READY"); + + String cache = xmpp.getFromCache(to); + if (cache != null) { + logger.info("STREAM TO " + to + " " + streamID + " SENDING CACHE"); + sendStanza(cache); + } + + } else { + logger.info("STREAM TO " + to + " " + streamID + " DIALBACK FAIL"); + } + XmlUtils.skip(parser); + } else if (tag.equals("verify") && parser.getNamespace().equals(NS_DB)) { + String from = parser.getAttributeValue(null, "from"); + String type = parser.getAttributeValue(null, "type"); + String sid = parser.getAttributeValue(null, "id"); + if (from != null && from.equals(to) && sid != null && !sid.isEmpty() && type != null) { + ConnectionIn c = xmpp.getConnectionIn(sid); + if (c != null) { + c.sendDialbackResult(from, type); + } + } + XmlUtils.skip(parser); + } else if (tag.equals("features") && parser.getNamespace().equals(NS_STREAM)) { + StreamFeatures features = StreamFeatures.parse(parser); + if (!isSecured() && features.STARTTLS >= 0 && !xmpp.brokenSSLhosts.contains(to)) { + logger.info("STREAM TO " + to + " " + streamID + " SECURING"); + sendStanza("<starttls xmlns=\"" + NS_TLS + "\" />"); + } else { + processDialback(); + } + } else if (tag.equals("proceed") && parser.getNamespace().equals(NS_TLS)) { + try { + socket = sc.getSocketFactory().createSocket(socket, socket.getInetAddress().getHostAddress(), + socket.getPort(), true); + ((SSLSocket) socket).startHandshake(); + setSecured(true); + logger.info("STREAM " + streamID + " SECURED"); + restartParser(); + sendOpenStream(); + } catch (SSLException sex) { + logger.log(Level.SEVERE, String.format("s2s ssl error: %s %s", to, streamID), sex); + sendStanza("<failed xmlns\"" + NS_TLS + "\" />"); + xmpp.removeConnectionOut(this); + closeConnection(); + } + } else if (isSecured() && tag.equals("stream") && parser.getNamespace().equals(NS_STREAM)) { + streamID = parser.getAttributeValue(null, "id"); + } else { + logger.info("STREAM TO " + to + " " + streamID + ": " + XmlUtils.parseToString(parser, true)); + } + } + + logger.warning("STREAM TO " + to + " " + streamID + " FINISHED"); + xmpp.removeConnectionOut(ConnectionOut.this); + closeConnection(); + } catch (EOFException | SocketException eofex) { + logger.info(String.format("STREAM %s %s CLOSED (dirty)", to, streamID)); + xmpp.removeConnectionOut(ConnectionOut.this); + closeConnection(); + } catch (Exception e) { + logger.log(Level.SEVERE, String.format("s2s out exception: %s %s", to, streamID), e); + xmpp.removeConnectionOut(ConnectionOut.this); + closeConnection(); + } + } + + public void sendDialbackVerify(String sid, String key) { + try { + sendStanza("<db:verify from='" + xmpp.HOSTNAME + "' to='" + to + "' id='" + sid + "'>" + key + "</db:verify>"); + } catch (IOException e) { + logger.log(Level.WARNING, "STREAM TO " + to + " " + streamID + " ERROR", e); + } + } +} diff --git a/juick-ws/src/main/java/com/juick/ws/s2s/DNSQueries.java b/juick-ws/src/main/java/com/juick/ws/s2s/DNSQueries.java new file mode 100644 index 000000000..35e72c2be --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/s2s/DNSQueries.java @@ -0,0 +1,47 @@ +package com.juick.ws.s2s; + +import java.net.InetSocketAddress; +import java.net.UnknownHostException; +import java.util.Hashtable; +import java.util.Random; +import javax.naming.NamingException; +import javax.naming.directory.Attribute; +import javax.naming.directory.DirContext; +import javax.naming.directory.InitialDirContext; + +/** + * + * @author ugnich + */ +public class DNSQueries { + + private static Random rand = new Random(); + + public static InetSocketAddress getServerAddress(String hostname) throws UnknownHostException { + + String host = hostname; + int port = 5269; + + try { + Hashtable<String, String> env = new Hashtable<String, String>(5); + env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory"); + DirContext ctx = new InitialDirContext(env); + Attribute att = ctx.getAttributes("_xmpp-server._tcp." + hostname, new String[]{"SRV"}).get("SRV"); + + if (att != null && att.size() > 0) { + int i = rand.nextInt(att.size()); + try { + String srv[] = att.get(i).toString().split(" "); + port = Integer.parseInt(srv[2]); + host = srv[3]; + } catch (Exception e) { + } + } + + ctx.close(); + } catch (NamingException e) { + } + + return new InetSocketAddress(host, port); + } +} diff --git a/juick-ws/src/main/java/com/juick/ws/s2s/JuickBot.java b/juick-ws/src/main/java/com/juick/ws/s2s/JuickBot.java new file mode 100644 index 000000000..f55002427 --- /dev/null +++ b/juick-ws/src/main/java/com/juick/ws/s2s/JuickBot.java @@ -0,0 +1,379 @@ +package com.juick.ws.s2s; + +import com.juick.User; +import com.juick.ws.components.XMPPComponent; +import com.juick.server.PMQueries; +import com.juick.server.TagQueries; +import com.juick.server.UserQueries; +import com.juick.xmpp.JID; +import com.juick.xmpp.Message; +import com.juick.xmpp.Presence; +import com.juick.xmpp.extensions.Error; +import com.juick.xmpp.extensions.JuickMessage; + +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * + * @author ugnich + */ +public class JuickBot { + XMPPComponent xmpp; + public JuickBot(XMPPComponent xmpp, JID JuickJID) { + this.xmpp = xmpp; + this.JuickJID = JuickJID; + } + + public final JID JuickJID; + private static final String HELPTEXT = + "@username text - Send private message\n" + + "*tagname Blah-blah-blah - Post a message with tag 'tagname'\n" + + "#1234 Blah-blah-blah - Answer to message #1234\n" + + "#1234/5 Blah - Answer to reply #1234/5\n" + + "! #1234 - Recommend post\n" + + "\n" + + "# - Show last messages from your feed (## - second page, ...)\n" + + "@ - Show recomendations and popular personal blogs\n" + + "* - Show your tags\n" + + "#1234 - Show message\n" + + "#1234+ - Show message with replies\n" + + "@username - Show user's info\n" + + "@username+ - Show user's info and last 10 messages\n" + + "@username *tag - User's messages with this tag\n" + + "*tag - Show last 10 messages with this tag\n" + + "? blah - Search posts for 'blah'\n" + + "? @username blah - Searching among user\'s posts for 'blah'\n" + + "D #123 - Delete message\n" + + "D #123/45 - Delete reply\n" + + "DL - Delete last message/reply\n" + + "S - Show your subscriptions\n" + + "S #123 - Subscribe to message replies\n" + + "S @username - Subscribe to user's blog\n" + + "U #123 - Unsubscribe from comments\n" + + "U @username - Unsubscribe from user's blog\n" + + "BL - Show your blacklist\n" + + "BL @username - Add/delete user to/from your blacklist\n" + + "BL *tag - Add/delete tag to/from your blacklist\n" + + "ON / OFF - Enable/disable subscriptions delivery\n" + + "PING - Pong\n" + + "\n" + + "Read more: http://juick.com/help/"; + + public boolean incomingPresence(Presence p) throws Exception { + final String username = p.to.Username.toLowerCase(); + final boolean toJuick = username.equals("juick"); + + if (p.type == null) { + Presence reply = new Presence(); + reply.from = new JID(p.to.Username, p.to.Host, null); + reply.to = new JID(p.from.Username, p.from.Host, null); + reply.type = Presence.Type.unsubscribe; + xmpp.sendOut(reply); + return true; + } else if (p.type.equals(Presence.Type.probe)) { + int uid_to = 0; + if (!toJuick) { + uid_to = UserQueries.getUIDbyName(xmpp.getSql(), username); + } + + if (toJuick || uid_to > 0) { + Presence reply = new Presence(); + reply.from = p.to; + reply.from.Resource = "Juick"; + reply.to = p.from; + reply.priority = 10; + xmpp.sendOut(reply); + } else { + Presence reply = new Presence(p.to, p.from, Presence.Type.error); + reply.id = p.id; + reply.addChild(new Error(Error.Type.cancel, "item-not-found")); + xmpp.sendOut(reply); + return true; + } + return true; + } else if (p.type.equals(Presence.Type.subscribe)) { + boolean canSubscribe = false; + if (toJuick) { + canSubscribe = true; + } else { + int uid_to = UserQueries.getUIDbyName(xmpp.getSql(), username); + if (uid_to > 0) { + PMQueries.addPMinRoster(xmpp.getSql(), uid_to, p.from.Bare()); + canSubscribe = true; + } + } + + if (canSubscribe) { + Presence reply = new Presence(p.to, p.from, Presence.Type.subscribed); + xmpp.sendOut(reply); + + reply.from.Resource = "Juick"; + reply.priority = 10; + reply.type = null; + xmpp.sendOut(reply); + + return true; + } else { + Presence reply = new Presence(p.to, p.from, Presence.Type.error); + reply.id = p.id; + reply.addChild(new Error(Error.Type.cancel, "item-not-found")); + xmpp.sendOut(reply); + return true; + } + } else if (p.type.equals(Presence.Type.unsubscribe)) { + if (!toJuick) { + int uid_to = UserQueries.getUIDbyName(xmpp.getSql(), username); + if (uid_to > 0) { + PMQueries.removePMinRoster(xmpp.getSql(), uid_to, p.from.Bare()); + } + } + + Presence reply = new Presence(p.to, p.from, Presence.Type.unsubscribed); + xmpp.sendOut(reply); + } + + return false; + } + + public boolean incomingMessage(Message msg) throws Exception { + if (msg.body == null || msg.body.isEmpty()) { + return true; + } + + String username = msg.to.Username.toLowerCase(); + + User user_from = null; + String signuphash = ""; + user_from = UserQueries.getUserByJID(xmpp.getSql(), msg.from.Bare()); + if (user_from == null) { + signuphash = UserQueries.getSignUpHashByJID(xmpp.getSql(), msg.from.Bare()); + } + + if (user_from == null) { + Message reply = new Message(msg.to, msg.from, Message.Type.chat); + if (username.equals("juick")) { + reply.body = "Для того, чтобы начать пользоваться сервисом, пожалуйста пройдите быструю регистрацию: http://juick.com/signup?type=xmpp&hash=" + signuphash + "\nЕсли у вас уже есть учетная запись на Juick, вы сможете присоединить этот JabberID к ней.\n\nTo start using Juick, please sign up: http://juick.com/signup?type=xmpp&hash=" + signuphash + "\nIf you already have an account on Juick, you will be proposed to attach this JabberID to your existing account."; + } else { + reply.body = "Внимание, системное сообщение!\nВаш JabberID не обнаружен в списке доверенных. Для того, чтобы отправить сообщение пользователю " + username + "@juick.com, пожалуйста зарегистрируйте свой JabberID в системе: http://juick.com/signup?type=xmpp&hash=" + signuphash + "\nЕсли у вас уже есть учетная запись на Juick, вы сможете присоединить этот JabberID к ней.\n\nWarning, system message!\nYour JabberID is not found in our server's white list. To send a message to " + username + "@juick.com, please sign up: http://juick.com/signup?type=xmpp&hash=" + signuphash + "\nIf you already have an account on Juick, you will be proposed to attach this JabberID to your existing account."; + } + xmpp.sendOut(reply); + return true; + } + + if (username.equals("juick")) { + return incomingMessageJuick(user_from, msg); + } + + int uid_to = UserQueries.getUIDbyName(xmpp.getSql(), username); + + if (uid_to == 0) { + Message reply = new Message(msg.to, msg.from, Message.Type.error); + reply.id = msg.id; + reply.addChild(new Error(Error.Type.cancel, "item-not-found")); + xmpp.sendOut(reply); + return true; + } + + boolean success = false; + if (!UserQueries.isInBLAny(xmpp.getSql(), uid_to, user_from.getUID())) { + success = PMQueries.createPM(xmpp.getSql(), user_from.getUID(), uid_to, msg.body); + } + + if (success) { + Message m = new Message(); + m.from = new JID("juick", "juick.com", null); + m.to = new JID(Integer.toString(uid_to), "push.juick.com", null); + JuickMessage jmsg = new JuickMessage(); + jmsg.setUser(user_from); + jmsg.setText(msg.body); + m.childs.add(jmsg); + xmpp.getRouter().send(m.toString()); + + m.to.Host = "ws.juick.com"; + xmpp.getRouter().send(m.toString()); + + List<String> jids; + boolean inroster = false; + jids = UserQueries.getJIDsbyUID(xmpp.getSql(), uid_to); + for (String jid : jids) { + Message mm = new Message(); + mm.to = new JID(jid); + mm.type = Message.Type.chat; + inroster = PMQueries.havePMinRoster(xmpp.getSql(), user_from.getUID(), jid); + if (inroster) { + mm.from = new JID(jmsg.getUser().getUName(), "juick.com", "Juick"); + mm.body = msg.body; + } else { + mm.from = new JID("juick", "juick.com", "Juick"); + mm.body = "Private message from @" + jmsg.getUser().getUName() + ":\n" + msg.body; + } + xmpp.sendOut(mm); + } + } else { + Message reply = new Message(msg.to, msg.from, Message.Type.error); + reply.id = msg.id; + reply.addChild(new Error(Error.Type.cancel, "not-allowed")); + xmpp.sendOut(reply); + } + + return true; + } + private static Pattern regexPM = Pattern.compile("^\\@(\\S+)\\s+([\\s\\S]+)$"); + + public boolean incomingMessageJuick(User user_from, Message msg) throws Exception { + String command = msg.body.trim(); + int commandlen = command.length(); + + // COMPATIBILITY + if (commandlen > 7 && command.substring(0, 3).equalsIgnoreCase("PM ")) { + command = command.substring(3).trim(); + commandlen = command.length(); + } + + if (commandlen == 4) { + if (command.equalsIgnoreCase("PING")) { + commandPing(msg); + return true; + } else if (command.equalsIgnoreCase("HELP")) { + commandHelp(msg); + return true; + } + } else if (commandlen == 5 && command.equalsIgnoreCase("LOGIN")) { + commandLogin(msg, user_from); + return true; + } else if (command.charAt(0) == '@') { + Matcher matchPM = regexPM.matcher(command); + if (matchPM.find()) { + String user_to = matchPM.group(1); + String msgtxt = matchPM.group(2); + commandPM(msg, user_from, user_to, msgtxt); + return true; + } + } else if (commandlen == 2 && command.equalsIgnoreCase("BL")) { + commandBLShow(msg, user_from); + return true; + } + + return false; + } + + private void commandPing(Message m) throws Exception { + Presence p = new Presence(JuickJID, m.from); + p.priority = 10; + xmpp.sendOut(p); + + Message reply = new Message(JuickJID, m.from, Message.Type.chat); + reply.body = "PONG"; + xmpp.sendOut(reply); + } + + private void commandHelp(Message m) throws Exception { + Message reply = new Message(JuickJID, m.from, Message.Type.chat); + reply.body = HELPTEXT; + xmpp.sendOut(reply); + } + + private void commandLogin(Message m, User user_from) throws Exception { + Message reply = new Message(JuickJID, m.from, Message.Type.chat); + reply.body = "http://juick.com/login?" + UserQueries.getHashByUID(xmpp.getSql(), user_from.getUID()); + xmpp.sendOut(reply); + } + + private void commandPM(Message m, User user_from, String user_to, String body) throws Exception { + int ret = 0; + + int uid_to = 0; + List<String> jids_to = null; + boolean haveInRoster = false; + + if (user_to.indexOf('@') > 0) { + uid_to = UserQueries.getUIDbyJID(xmpp.getSql(), user_to); + } else { + uid_to = UserQueries.getUIDbyName(xmpp.getSql(), user_to); + } + + if (uid_to > 0) { + if (!UserQueries.isInBLAny(xmpp.getSql(), uid_to, user_from.getUID())) { + if (PMQueries.createPM(xmpp.getSql(), user_from.getUID(), uid_to, body)) { + jids_to = UserQueries.getJIDsbyUID(xmpp.getSql(), uid_to); + ret = 200; + } else { + ret = 500; + } + } else { + ret = 403; + } + } else { + ret = 404; + } + + if (ret == 200) { + Message msg = new Message(); + msg.from = new JID("juick", "juick.com", null); + msg.to = new JID(Integer.toString(uid_to), "push.juick.com", null); + JuickMessage jmsg = new JuickMessage(); + jmsg.setUser(user_from); + jmsg.setText(body); + msg.childs.add(jmsg); + xmpp.getRouter().send(msg.toString()); + + msg.to.Host = "ws.juick.com"; + xmpp.getRouter().send(msg.toString()); + + for (String jid : jids_to) { + Message mm = new Message(); + mm.to = new JID(jid); + mm.type = Message.Type.chat; + haveInRoster = PMQueries.havePMinRoster(xmpp.getSql(), user_from.getUID(), jid); + if (haveInRoster) { + mm.from = new JID(user_from.getUName(), "juick.com", "Juick"); + mm.body = body; + } else { + mm.from = new JID("juick", "juick.com", "Juick"); + mm.body = "Private message from @" + user_from.getUName() + ":\n" + body; + } + xmpp.sendOut(mm); + } + } + + Message reply = new Message(m.to, m.from); + if (ret == 200) { + reply.type = m.type; + reply.body = "Private message sent"; + } else { + reply.type = Message.Type.error; + reply.body = "Error " + ret; + } + xmpp.sendOut(reply); + } + + private void commandBLShow(Message m, User user_from) throws Exception { + List<User> blusers = UserQueries.getUserBLUsers(xmpp.getSql(), user_from.getUID()); + List<String> bltags = TagQueries.getUserBLTags(xmpp.getSql(), user_from.getUID()); + + String txt = ""; + if (bltags.size() > 0) { + for (String bltag : bltags) { + txt += "*" + bltag + "\n"; + } + + if (blusers.size() > 0) { + txt += "\n"; + } + } + if (blusers.size() > 0) { + for (User bluser : blusers) { + txt += "@" + bluser.getUName() + "\n"; + } + } + if (txt.isEmpty()) { + txt = "You don't have any users or tags in your blacklist."; + } + + Message reply = new Message(JuickJID, m.from, Message.Type.chat); + reply.body = txt; + xmpp.sendOut(reply); + } +} |