MessageProcessor.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: MessageProcessor.java
 * Description: Static class which parses and process XML with messages
 */

/**
 * @file MessageProcessor.java
 *
 * @brief Static class which parses and process XML with messages
 */

package cz.vutbr.fit.knot.annotations.comet;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.comet.AnnotCometServlet.AnnotHandler;
import cz.vutbr.fit.knot.annotations.comet.protocolV1.P1Processor;
import cz.vutbr.fit.knot.annotations.comet.protocolV2_0.P2Processor;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.*;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * Static class which parses and process XML with messages
 *
 * @brief Static class which parses and process XML with messages
 * @author idytrych
 */
public class MessageProcessor {
  
  // used as a patterns when removing escaped apostrophe from XML node content
  private static String unescapeXMLApos = "'";
  private static String unescapeXMLQuotes = """;
  private static String unescapeXMLLT = "<";
  private static String unescapeXMLGT = ">";
  private static String unescapeXMLAmp = "&";

  /**
   * Parses and process XML with messages from client
   *
   * @param XMLString String with XML with messages from client
   * @return Object with informations about client request
   */
  public static RequestInfo processXML(String XMLString) {
    RequestInfo requestInfo = new RequestInfo();

    // parse XML
    Document doc = parseXml(XMLString);
    if (doc == null) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        String msg = "Bad XML from client: " + XMLString;
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
      }
      return null;  // bad request
    }
    
    Element docEl = doc.getDocumentElement();
    requestInfo.setRequestString(XMLString);
    requestInfo.setRequestDocument(doc);
    
    EditorSession session;
    Flier flier = new Flier();  // create flier for comet handlers
    requestInfo.setFlier(flier);
    
    // get session id or create session
    NodeList sessNodes = docEl.getElementsByTagName("session");
    ArrayList<Element> sessElements = new ArrayList<Element>();
    for (int i = 0; i < sessNodes.getLength(); i++) {
      Element sessEl = (Element) sessNodes.item(i);
      sessElements.add(sessEl);
    }
    
    String idString = docEl.getAttribute("sessionID");
    
    if ((sessElements.isEmpty() && idString.isEmpty()) 
        || (sessElements.isEmpty() && idString.equals("undefined")) ) {
      // Session id not presented - new session?
      NodeList connNodes = docEl.getElementsByTagName("connect");
      Element connEl = (Element) connNodes.item(0);
      if (connEl == null) { // if connect message not sent
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
          String msg = "Unknown session (not sent).";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED);
        return requestInfo;  // nothing else can be done without valid session
      }
      // get protocol version from attribute of connect
      String protVersion = connEl.getAttribute("protocolVersion");
      if (protVersion.length() == 0) {  // if protocol version is invalid
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Bad protocol version.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.SEVERE, msg);
        }
        requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_0_PROTO_VERSION);
        return requestInfo;  // nothing else can be done without valid session
      }
      String attachCometToStr = connEl.getAttribute("attachCometTo");
      EditorSession attachCometSession = null;
      if (attachCometToStr != null && !attachCometToStr.isEmpty()) {
        try {
          Long attachCometTo = Long.decode(attachCometToStr);
          if (attachCometTo != null) {
            attachCometSession = AppBean.getSession(attachCometTo);
          }
        } catch (NumberFormatException ex) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
            String msg = "Can not attach comet to another session.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.SEVERE, msg);
          }
        }
      }

      // create new session
      session = new EditorSession(protVersion);
      requestInfo.setSession(session);
      AppBean.addSession(session);
      flier.setCreatedInSessId(session.getSessionId());
      flier.setCreatedInSession(session);
      // prepare connected message for client
      if(!protVersion.startsWith("1.") && !protVersion.startsWith("2.") && !protVersion.equals("1") && !protVersion.equals("2")){
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
          String msg = "Unsupported protocol version. Client is trying to connect with version = " + protVersion;
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_0_PROTO_VERSION);
        return requestInfo;
      }
      if (session.getProtocolLOD() == Constants.PROTOCOL_LOD_V2) {
        requestInfo.appendToReply("<connected protocolVersion=\"2.0\" sessionID=\""
          + session.getSessionId() + "\"/>");
      } else if (session.getProtocolLOD() == Constants.PROTOCOL_LOD_V1_1) {
        requestInfo.appendToReply("<connected protocolVersion=\"1.1\" sessionID=\""
          + session.getSessionId() + "\"/>");
      } else {
        requestInfo.appendToReply("<connected protocolVersion=\"1.0\" sessionID=\""
          + session.getSessionId() + "\"/>");
      }
      
      if (attachCometSession != null) {
        session.setCometContext(attachCometSession.getCometContext());
        AnnotHandler handler = attachCometSession.getCometHandler();
        if (handler != null) {
          session.setCometHandler(handler);
          handler.addSessionInSessionList(session);
        }
      }

      // set information about protocol version
      requestInfo.setConnectWPV(protVersion);
    } else if(!sessElements.isEmpty() && sessElements.size() < 2) {  // If one session message was sent
      Element sessEl = sessElements.get(0);
      // get session id and convert to Long
      String sessIdStr = sessEl.getAttribute("id");
      if (sessIdStr.isEmpty()) {
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
          String msg = "Unknown session (id not sent).";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED);
        return requestInfo;  // nothing else can be done without valid session
      }
      
      long sessId;
      
      try{
        sessId = Long.decode(sessIdStr);
      }catch(Exception ex){
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
          String msg = "Can't decode session ID.";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        
        requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED, "", "Can't decode session ID.");
        return requestInfo;  // nothing else can be done without valid session
      }

      // find session
      session = AppBean.getSession(sessId);
      if (session == null) {
        // if session not found, prepare error message
        requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
          String msg = "Unknown session (not found).";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return requestInfo;  // nothing else can be done without valid session
      }

      requestInfo.setSession(session);
      flier.setCreatedInSessId(sessId);
      flier.setCreatedInSession(session);

      // Check whether there are sibling nodes
      if (sessEl.getNextSibling() == null && sessEl.getPreviousSibling() == null) {
        // If only one message in this request is session, set appropriate information
        requestInfo.setSessionOnly(true);
        requestInfo.setCanNotify(false);  // nothing to notify
        return requestInfo;  // all messages was processed
      }

      // Check whether sibling nodes aren't text or comment nodes (no other messages)
      Node auxNode = sessEl;
      auxNode = auxNode.getNextSibling();
      if (auxNode != null) {
        while (auxNode.getNextSibling() != null && auxNode.getNodeType() != Node.ELEMENT_NODE) {
          auxNode = auxNode.getNextSibling();
        }
      }
      if (auxNode == null || auxNode.getNodeType() != Node.ELEMENT_NODE) {
        auxNode = sessEl;
        auxNode = auxNode.getPreviousSibling();
        if (auxNode != null) {
          while (auxNode.getPreviousSibling() != null && auxNode.getNodeType() != Node.ELEMENT_NODE) {
            auxNode = auxNode.getPreviousSibling();
          }
        }
        if (auxNode == null || auxNode.getNodeType() != Node.ELEMENT_NODE) {
          // If only one message in this request is session, set appropriate information
          requestInfo.setSessionOnly(true);
          requestInfo.setCanNotify(false);  // nothing to notify
          return requestInfo;  // all messages was processed
        }
      }
    } else if (!sessElements.isEmpty()) {  // If more session messages was sent
      
      //Check whethere there are any other elements in request
      NodeList nl = docEl.getChildNodes();
      for(int i = 0; i < nl.getLength(); i++){
        Node n = nl.item(i);
        
        if(n.getNodeType() == Node.TEXT_NODE && n.getNodeValue().trim().length() == 0){
            continue;
        }
        
        if((!n.getNodeName().equals("session")) && (!n.getNodeName().equals("comet"))){
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Illegal elements in request.";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_32_BAD_REQUEST);
          return requestInfo;  // nothing else can be done without valid session
        }
      }


      ArrayList<EditorSession> sessAL = new ArrayList<EditorSession>();
      Iterator<Element> sessElIt = sessElements.iterator();
      EditorSession tmpSess;

      while(sessElIt.hasNext()){
        Element e = sessElIt.next();

        String sessIdStr = e.getAttribute("id");

        if (sessIdStr.isEmpty()) {
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Unknown session (id not sent).";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED);
          return requestInfo;  // nothing else can be done without valid session
        }

        Long sessId = null;
        try {
          sessId = Long.decode(sessIdStr);
        } catch (NumberFormatException numberFormatException) {
          requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Bad session id: ";
            if (sessIdStr != null) {
              msg += sessIdStr;
            }
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return requestInfo;  // nothing else can be done without valid session
        }

        //Search for session
        tmpSess = AppBean.getSession(sessId);
        
        if (tmpSess == null) {
          // if session not found, prepare error message
          requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED);
          if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
            String msg = "Unknown session (not found).";
            Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
          }
          return requestInfo;  // nothing else can be done without valid session
        }

        sessAL.add(tmpSess);
      }
      
      requestInfo.setCometSessionList(sessAL);
      session = sessAL.get(0);
      
      requestInfo.setSession(session);
      requestInfo.setSessionOnly(true);
      requestInfo.setCanNotify(false);  // nothing to notify
      return requestInfo;  // all messages was processed

    } else {
      if (idString.isEmpty()) {
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
          String msg = "Unknown session (id not sent).";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED);
        return requestInfo;  // nothing else can be done without valid session
      }
      
      Long sessId = null;
      try {
        sessId = Long.decode(idString);
      } catch (NumberFormatException numberFormatException) {
      }

      // find session
      session = null;
      if (sessId != null) {
        session = AppBean.getSession(sessId);
      }
      if (session == null) {
        // if session not found, prepare error message
        requestInfo.addError(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED);
        if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
          String msg = "Unknown session (not found).";
          Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg);
        }
        return requestInfo;  // nothing else can be done without valid session
      }

      requestInfo.setSession(session);
      flier.setCreatedInSessId(sessId);
      flier.setCreatedInSession(session);
    }
    
    //choose which processor will proces the document (by version of protocol)
    switch(session.getProtocolLOD()){
      case Constants.PROTOCOL_LOD_V2 :{
        // parse by processor for version 2
        P2Processor proc = new P2Processor();
        proc.processXMLDocument(docEl,requestInfo);
      }break;
        
      case Constants.PROTOCOL_LOD_V1_1 :
      case Constants.PROTOCOL_LOD_V1 :{
        // parse by processor for version 1
        P1Processor proc = new P1Processor();
        return proc.processXML(docEl, requestInfo);
      }
    } 
    
    return requestInfo;
  }  // processXML()

  /**
   * Parses XML with messages from client
   *
   * @param XMLString String with XML with messages from client
   * @return Parsed XML in w3c.dom.Document
   */
  private static Document parseXml(String XMLString) {
    Document dom;
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);

    try {
      DocumentBuilder db = dbf.newDocumentBuilder();
      InputSource is = new InputSource();
      is.setCharacterStream(new StringReader(XMLString));
      dom = db.parse(is);
    } catch (ParserConfigurationException pce) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_INTERNAL_ERRORS) {
        String msg = "ParserConfigurationException while parsing messages from the client.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.SEVERE, msg, pce);
      }
      return null;  // bad request
    } catch (SAXException se) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        String msg = "SAXException while parsing messages from the client.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.ALL, msg, se);
      }
      return null;
    } catch (IOException ioe) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_SERVER_ERRORS) {
        String msg = "IOException while parsing messages from the client.";
        Logger.getLogger(MessageProcessor.class.getName()).log(Level.SEVERE, msg, ioe);
      }
      return null;
    }

    return dom;
  }  // parseXml()
  
  /**
   * Gets content of XML emement
   * If element have only child with textual content, it returns this content.
   * If element have CDATA section eventually surrounded with text nodes,
   * content of CDATA section is returned.
   *
   * @param contentEl Element with content
   * @return Content of XML emement
   */
  public static String getElementContent(Element contentEl) {
    String content = null;
    if (contentEl != null) {  // if element is not null
      // get child node(s) with content
      NodeList contentCSNL = contentEl.getChildNodes();
      if (contentCSNL.getLength() == 3) {  // if it has 3 childs (text, CDATA, text)
        // get CDATA section
        Node contentCSEl = contentCSNL.item(1);
        if (contentCSEl != null) {
          content = contentCSEl.getNodeValue();  // get content of CDATA section
        }
      } else if (contentCSNL.getLength() == 2) {  // if it has 2 childs (text, CDATA or CDATA, text)
        // assume that CDATA is first
        Node contentCSEl = contentCSNL.item(0);
        if (contentCSEl != null) {
          content = contentCSEl.getNodeValue();  // get content of CDATA
        }
        if ((content.trim()).isEmpty()) {  // if content contains only white spaces
          // CDATA is second (or missing, but it has a same effect)
          contentCSEl = contentCSNL.item(1);
          if (contentCSEl != null) {
            content = contentCSEl.getNodeValue();  // get content of CDATA
          }
        }
      } else if (contentCSNL.getLength() == 1) {  // if it has 1 child (CDATA or text)
        Node contentCSEl = contentCSNL.item(0);
        if (contentCSEl != null) {
          content = contentCSEl.getNodeValue();  // get content of child node
        }
      } else {  // if it hasn't childs
        content = contentEl.getNodeValue();  // get content of node
      }
    }  // if element is not null
    return unescapeXML(content);
  }  // getElementContent()
  
  /**
   * Replaces arrows with spaces in given string by slashes
   * " -> ", " ->", "-> " and "->" are replaced by "/"
   *
   * @param aString String with arrows
   * @return Returns string with slashes instead arrows
   */
  public static String replaceArrows(String aString) {
    String retStr = aString.replace(" -> ", "/");
    retStr = retStr.replace(" ->", "/");
    retStr = retStr.replace("-> ", "/");
    retStr = retStr.replace("->", "/");
    return retStr;
  }
  
  /**
   * Replaces escaped characters in XML with its original character representation.
   * 
   * @param escaped Character string containing items escaped by XML processor
   * @return Common character string free of escaped version of characters
   */
  public static String unescapeXML(String escaped) {
    if (escaped != null) {
      escaped = escaped.replaceAll(unescapeXMLApos, "\'");
      escaped = escaped.replaceAll(unescapeXMLQuotes, "\"");
      escaped = escaped.replaceAll(unescapeXMLLT, "<");
      escaped = escaped.replaceAll(unescapeXMLGT, ">");
      escaped = escaped.replaceAll(unescapeXMLAmp, "&");
    }
    return escaped;
  }

  /**
   * Converts array of bytes to hex string
   * from http://rgagnon.com/javadetails/java-0596.html
   *
   * @param b Array of bytes
   * @return Hex string
   */
  public static String getHexString(byte[] b) {
    String result = "";
    for (int i = 0; i < b.length; i++) {
      result += Integer.toString((b[i] & 0xff) + 0x100, 16).substring(1);
    }
    return result;
  }
  
  /**
   * Checks whether id of user group is included in beginning of given string
   *
   * @param gStr Checked string
   * @return If id of user group is included, returns true, false otherwise
   */
  public static boolean isGroupIncluded(String gStr) {
    if (!gStr.startsWith("g")) {
      // if string doesn't start with letter g, id of group can't be correctly included
      return false;
    }
    gStr = MessageProcessor.replaceArrows(gStr);
    // find end of group id
    int index = gStr.indexOf("/");
    if (index < 1) {  // if group id doesn't end, it's incorrect or it's not id of group
      return false;
    }
    // get id of group from string
    String gIdStr = gStr.substring(1, index);
    // parse id of user group
    Integer gId = null;
    try {
      gId = Integer.parseInt(gIdStr);
    } catch (NumberFormatException nfe) {  // if it's not number, it's not id of group
      return false;
    }
    // query database for user group
    Object[] params = new Object[2];
    params[0] = "id";
    params[1] = gId;
    List gList = AppBean.getPersistenceManager().queryDB("UserGroup.findById", params);
    if (gList != null && !gList.isEmpty()) {  // if group was not found, it's not id of group
      return true;
    }
    return false;  // id of group is included
  }  // isGroupIncluded()
}  // class MessageProcessor