Example usage for java.math BigInteger toString

List of usage examples for java.math BigInteger toString

Introduction

In this page you can find the example usage for java.math BigInteger toString.

Prototype

public String toString() 

Source Link

Document

Returns the decimal String representation of this BigInteger.

Usage

From source file:com.netscape.cms.servlet.cert.RenewalProcessor.java

public HashMap<String, Object> processRenewal(CertEnrollmentRequest data, HttpServletRequest request,
        AuthCredentials credentials) throws EBaseException {
    try {//from  w  w  w  .  j  a v  a  2  s  .  co  m
        if (CMS.debugOn()) {
            HashMap<String, String> params = data.toParams();
            printParameterValues(params);
        }

        CMS.debug("RenewalProcessor: processRenewal()");

        startTiming("enrollment");
        request.setAttribute("reqType", "renewal");

        // in case of renew, "profile" is the orig profile
        // while "renewProfile" is the current profile used for renewal
        String renewProfileId = (this.profileID == null) ? data.getProfileId() : this.profileID;
        CMS.debug("RenewalProcessor: profile: " + renewProfileId);

        IProfile renewProfile = ps.getProfile(renewProfileId);
        if (renewProfile == null) {
            CMS.debug(CMS.getUserMessage(locale, "CMS_PROFILE_NOT_FOUND",
                    CMSTemplate.escapeJavaScriptStringHTML(renewProfileId)));
            throw new BadRequestDataException(CMS.getUserMessage(locale, "CMS_PROFILE_NOT_FOUND",
                    CMSTemplate.escapeJavaScriptStringHTML(renewProfileId)));
        }
        if (!ps.isProfileEnable(renewProfileId)) {
            CMS.debug("RenewalProcessor: Profile " + renewProfileId + " not enabled");
            throw new BadRequestDataException("Profile " + renewProfileId + " not enabled");
        }

        BigInteger certSerial = null;

        // get serial number from <SerialNumber> element (no auth required)
        CertId serial = data.getSerialNum();
        if (serial != null) {
            CMS.debug("RenewalProcessor: serial number: " + serial);
            certSerial = serial.toBigInteger();
        }

        // if not found, get serial number from profile input (no auth required)
        if (certSerial == null) {

            IPluginRegistry registry = (IPluginRegistry) CMS.getSubsystem(CMS.SUBSYSTEM_REGISTRY);

            // find SerialNumRenewInput
            for (ProfileInput input : data.getInputs()) {

                String inputId = input.getId();
                if (inputId == null) {
                    throw new BadRequestException("Missing input ID");
                }

                String classId = input.getClassId();
                if (classId == null) {
                    throw new BadRequestException("Missing class ID in input " + inputId);
                }

                IPluginInfo pluginInfo = registry.getPluginInfo("profileInput", classId);
                if (pluginInfo == null) {
                    throw new BadRequestException("Unregistered class ID " + classId + " in input " + inputId);
                }

                String className = pluginInfo.getClassName();
                if (!SerialNumRenewInput.class.getName().equals(className)) {
                    // check the next input
                    continue;
                }

                CMS.debug("RenewalProcessor: found SerialNumRenewInput");
                ProfileAttribute attribute = input.getAttribute(SerialNumRenewInput.SERIAL_NUM);

                if (attribute == null) {
                    throw new BadRequestException(
                            "Missing attribute " + SerialNumRenewInput.SERIAL_NUM + " in input " + inputId);
                }

                String value = attribute.getValue();
                CMS.debug("RenewalProcessor: profile input " + SerialNumRenewInput.SERIAL_NUM + " value: "
                        + value);

                if (!StringUtils.isEmpty(value)) {
                    serial = new CertId(value);
                    certSerial = serial.toBigInteger();
                    break;
                }
            }
        }

        // if still not found, get serial number from client certificate (if provided)
        if (certSerial == null) {

            if (!request.isSecure()) {
                throw new BadRequestException("Missing serial number");
            }

            // ssl client auth is to be used
            // this is not authentication. Just use the cert to search
            // for orig request and find the right profile
            CMS.debug("RenewalProcessor: get serial number from client certificate");
            certSerial = getSerialNumberFromCert(request);
        }

        CMS.debug("processRenewal: serial number of cert to renew:" + certSerial.toString());
        ICertRecord rec = certdb.readCertificateRecord(certSerial);
        if (rec == null) {
            CMS.debug("processRenewal: cert record not found for serial number " + certSerial.toString());
            throw new EBaseException(CMS.getUserMessage(locale, "CMS_INTERNAL_ERROR"));
        }

        // check to see if the cert is revoked or revoked_expired
        if ((rec.getStatus().equals(ICertRecord.STATUS_REVOKED))
                || (rec.getStatus().equals(ICertRecord.STATUS_REVOKED_EXPIRED))) {
            CMS.debug("processRenewal: cert found to be revoked. Serial number = " + certSerial.toString());
            throw new BadRequestDataException(CMS.getUserMessage(locale, "CMS_CA_CANNOT_RENEW_REVOKED_CERT"));
        }

        X509CertImpl origCert = rec.getCertificate();
        if (origCert == null) {
            CMS.debug("processRenewal: original cert not found in cert record for serial number "
                    + certSerial.toString());
            throw new EBaseException(CMS.getUserMessage(locale, "CMS_INTERNAL_ERROR"));
        }

        Date origNotAfter = origCert.getNotAfter();
        CMS.debug("processRenewal: origNotAfter =" + origNotAfter.toString());

        String origSubjectDN = origCert.getSubjectDN().getName();
        CMS.debug("processRenewal: orig subj dn =" + origSubjectDN);

        IRequest origReq = getOriginalRequest(certSerial, rec);
        if (origReq == null) {
            CMS.debug("processRenewal: original request not found");
            throw new EBaseException(CMS.getUserMessage(locale, "CMS_INTERNAL_ERROR"));
        }

        String profileId = origReq.getExtDataInString(IRequest.PROFILE_ID);
        CMS.debug("RenewalSubmitter: renewal original profileId=" + profileId);

        String aidString = origReq.getExtDataInString(IRequest.AUTHORITY_ID);

        Integer origSeqNum = origReq.getExtDataInInteger(IEnrollProfile.REQUEST_SEQ_NUM);
        IProfile profile = ps.getProfile(profileId);
        if (profile == null) {
            CMS.debug(CMS.getUserMessage(locale, "CMS_PROFILE_NOT_FOUND",
                    CMSTemplate.escapeJavaScriptStringHTML(profileId)));
            throw new EBaseException(CMS.getUserMessage(locale, "CMS_PROFILE_NOT_FOUND",
                    CMSTemplate.escapeJavaScriptStringHTML(profileId)));
        }
        if (!ps.isProfileEnable(profileId)) {
            CMS.debug("RenewalSubmitter: Profile " + profileId + " not enabled");
            throw new BadRequestDataException("Profile " + profileId + " not enabled");
        }

        IProfileContext ctx = profile.createContext();

        if (aidString != null)
            ctx.set(IEnrollProfile.REQUEST_AUTHORITY_ID, aidString);

        IProfileAuthenticator authenticator = renewProfile.getAuthenticator();
        IProfileAuthenticator origAuthenticator = profile.getAuthenticator();

        if (authenticator != null) {
            CMS.debug("RenewalSubmitter: authenticator " + authenticator.getName() + " found");
            setCredentialsIntoContext(request, credentials, authenticator, ctx);
        }

        // for renewal, this will override or add auth info to the profile context
        if (origAuthenticator != null) {
            CMS.debug("RenewalSubmitter: for renewal, original authenticator " + origAuthenticator.getName()
                    + " found");
            setCredentialsIntoContext(request, credentials, origAuthenticator, ctx);
        }

        // for renewal, input needs to be retrieved from the orig req record
        CMS.debug("processRenewal: set original Inputs into profile Context");
        setInputsIntoContext(origReq, profile, ctx, locale);
        ctx.set(IEnrollProfile.CTX_RENEWAL, "true");
        ctx.set("renewProfileId", renewProfileId);
        ctx.set(IEnrollProfile.CTX_RENEWAL_SEQ_NUM, origSeqNum.toString());

        // for ssl authentication; pass in servlet for retrieving
        // ssl client certificates
        SessionContext context = SessionContext.getContext();
        context.put("profileContext", ctx);
        context.put("sslClientCertProvider", new SSLClientCertProvider(request));
        CMS.debug("RenewalSubmitter: set sslClientCertProvider");
        if (origSubjectDN != null)
            context.put("origSubjectDN", origSubjectDN);

        // before creating the request, authenticate the request
        IAuthToken authToken = null;
        Principal principal = request.getUserPrincipal();
        if (principal instanceof PKIPrincipal)
            authToken = ((PKIPrincipal) principal).getAuthToken();
        if (authToken == null)
            authToken = authenticate(request, origReq, authenticator, context, true, credentials);

        // authentication success, now authorize
        authorize(profileId, renewProfile, authToken);

        ///////////////////////////////////////////////
        // create and populate requests
        ///////////////////////////////////////////////
        startTiming("request_population");
        IRequest[] reqs = profile.createRequests(ctx, locale);
        populateRequests(data, true, locale, origNotAfter, origSubjectDN, origReq, profileId, profile, ctx,
                authenticator, authToken, reqs);
        endTiming("request_population");

        ///////////////////////////////////////////////
        // submit request
        ///////////////////////////////////////////////
        String errorCode = submitRequests(locale, profile, authToken, reqs);
        String errorReason = null;

        List<String> errors = new ArrayList<String>();
        if (errorCode != null) {
            for (IRequest req : reqs) {
                String error = req.getError(locale);
                if (error != null) {
                    String code = req.getErrorCode(locale);
                    errors.add(codeToReason(locale, code, error, req.getRequestId()));
                }
            }
            errorReason = StringUtils.join(errors, '\n');
        }

        HashMap<String, Object> ret = new HashMap<String, Object>();
        ret.put(ARG_REQUESTS, reqs);
        ret.put(ARG_ERROR_CODE, errorCode);
        ret.put(ARG_ERROR_REASON, errorReason);
        ret.put(ARG_PROFILE, profile);

        CMS.debug("RenewalSubmitter: done serving");
        endTiming("enrollment");

        return ret;
    } finally {
        SessionContext.releaseContext();
        endAllEvents();
    }
}

From source file:org.apache.chemistry.opencmis.client.bindings.spi.http.AbstractApacheClientHttpInvoker.java

protected Response invoke(UrlBuilder url, String method, String contentType, Map<String, String> headers,
        final Output writer, final BindingSession session, BigInteger offset, BigInteger length) {
    int respCode = -1;

    try {/* w  ww.j a  va 2 s  .c  o  m*/
        // log before connect
        if (LOG.isDebugEnabled()) {
            LOG.debug("Session {}: {} {}", session.getSessionId(), method, url);
        }

        // get HTTP client object from session
        DefaultHttpClient httpclient = (DefaultHttpClient) session.get(HTTP_CLIENT);
        if (httpclient == null) {
            session.writeLock();
            try {
                httpclient = (DefaultHttpClient) session.get(HTTP_CLIENT);
                if (httpclient == null) {
                    httpclient = createHttpClient(url, session);
                    session.put(HTTP_CLIENT, httpclient, true);
                }
            } finally {
                session.writeUnlock();
            }
        }

        HttpRequestBase request = null;

        if ("GET".equals(method)) {
            request = new HttpGet(url.toString());
        } else if ("POST".equals(method)) {
            request = new HttpPost(url.toString());
        } else if ("PUT".equals(method)) {
            request = new HttpPut(url.toString());
        } else if ("DELETE".equals(method)) {
            request = new HttpDelete(url.toString());
        } else {
            throw new CmisRuntimeException("Invalid HTTP method!");
        }

        // set content type
        if (contentType != null) {
            request.setHeader("Content-Type", contentType);
        }
        // set other headers
        if (headers != null) {
            for (Map.Entry<String, String> header : headers.entrySet()) {
                request.addHeader(header.getKey(), header.getValue());
            }
        }

        // authenticate
        AuthenticationProvider authProvider = CmisBindingsHelper.getAuthenticationProvider(session);
        if (authProvider != null) {
            Map<String, List<String>> httpHeaders = authProvider.getHTTPHeaders(url.toString());
            if (httpHeaders != null) {
                for (Map.Entry<String, List<String>> header : httpHeaders.entrySet()) {
                    if (header.getKey() != null && isNotEmpty(header.getValue())) {
                        String key = header.getKey();
                        if (key.equalsIgnoreCase("user-agent")) {
                            request.setHeader("User-Agent", header.getValue().get(0));
                        } else {
                            for (String value : header.getValue()) {
                                if (value != null) {
                                    request.addHeader(key, value);
                                }
                            }
                        }
                    }
                }
            }
        }

        // range
        if ((offset != null) || (length != null)) {
            StringBuilder sb = new StringBuilder("bytes=");

            if ((offset == null) || (offset.signum() == -1)) {
                offset = BigInteger.ZERO;
            }

            sb.append(offset.toString());
            sb.append('-');

            if ((length != null) && (length.signum() == 1)) {
                sb.append(offset.add(length.subtract(BigInteger.ONE)).toString());
            }

            request.setHeader("Range", sb.toString());
        }

        // compression
        Object compression = session.get(SessionParameter.COMPRESSION);
        if ((compression != null) && Boolean.parseBoolean(compression.toString())) {
            request.setHeader("Accept-Encoding", "gzip,deflate");
        }

        // locale
        if (session.get(CmisBindingsHelper.ACCEPT_LANGUAGE) instanceof String) {
            request.setHeader("Accept-Language", session.get(CmisBindingsHelper.ACCEPT_LANGUAGE).toString());
        }

        // send data
        if (writer != null) {
            Object clientCompression = session.get(SessionParameter.CLIENT_COMPRESSION);
            final boolean clientCompressionFlag = (clientCompression != null)
                    && Boolean.parseBoolean(clientCompression.toString());
            if (clientCompressionFlag) {
                request.setHeader("Content-Encoding", "gzip");
            }

            AbstractHttpEntity streamEntity = new AbstractHttpEntity() {
                @Override
                public boolean isChunked() {
                    return true;
                }

                @Override
                public boolean isRepeatable() {
                    return false;
                }

                @Override
                public long getContentLength() {
                    return -1;
                }

                @Override
                public boolean isStreaming() {
                    return false;
                }

                @Override
                public InputStream getContent() throws IOException {
                    throw new UnsupportedOperationException();
                }

                @Override
                public void writeTo(final OutputStream outstream) throws IOException {
                    OutputStream connOut = null;

                    if (clientCompressionFlag) {
                        connOut = new GZIPOutputStream(outstream, 4096);
                    } else {
                        connOut = outstream;
                    }

                    OutputStream out = new BufferedOutputStream(connOut, BUFFER_SIZE);
                    try {
                        writer.write(out);
                    } catch (IOException ioe) {
                        throw ioe;
                    } catch (Exception e) {
                        throw new IOException(e);
                    }
                    out.flush();

                    if (connOut instanceof GZIPOutputStream) {
                        ((GZIPOutputStream) connOut).finish();
                    }
                }
            };
            ((HttpEntityEnclosingRequestBase) request).setEntity(streamEntity);
        }

        // connect
        HttpResponse response = httpclient.execute(request);
        HttpEntity entity = response.getEntity();

        // get stream, if present
        respCode = response.getStatusLine().getStatusCode();
        InputStream inputStream = null;
        InputStream errorStream = null;

        if ((respCode == 200) || (respCode == 201) || (respCode == 203) || (respCode == 206)) {
            if (entity != null) {
                inputStream = entity.getContent();
            } else {
                inputStream = new ByteArrayInputStream(new byte[0]);
            }
        } else {
            if (entity != null) {
                errorStream = entity.getContent();
            } else {
                errorStream = new ByteArrayInputStream(new byte[0]);
            }
        }

        // collect headers
        Map<String, List<String>> responseHeaders = new HashMap<String, List<String>>();
        for (Header header : response.getAllHeaders()) {
            List<String> values = responseHeaders.get(header.getName());
            if (values == null) {
                values = new ArrayList<String>();
                responseHeaders.put(header.getName(), values);
            }
            values.add(header.getValue());
        }

        // log after connect
        if (LOG.isTraceEnabled()) {
            LOG.trace("Session {}: {} {} > Headers: {}", session.getSessionId(), method, url,
                    responseHeaders.toString());
        }

        // forward response HTTP headers
        if (authProvider != null) {
            authProvider.putResponseHeaders(url.toString(), respCode, responseHeaders);
        }

        // get the response
        return new Response(respCode, response.getStatusLine().getReasonPhrase(), responseHeaders, inputStream,
                errorStream);
    } catch (Exception e) {
        String status = (respCode > 0 ? " (HTTP status code " + respCode + ")" : "");
        throw new CmisConnectionException("Cannot access \"" + url + "\"" + status + ": " + e.getMessage(), e);
    }
}

From source file:edu.pitt.apollo.db.ApolloDbUtils.java

private BigInteger addDataServiceRunForAllMessageTypes(Object message, int md5CollisionId,
        Authentication authentication, SoftwareIdentification dataServiceSoftwareId, int sourceSoftwareId)
        throws ApolloDatabaseException, Md5UtilsException {

    String userName = authentication.getRequesterId();
    String password = authentication.getRequesterPassword();

    String[] userIdTokens = parseUserId(userName);
    userName = userIdTokens[0];//from   w w w .  j  av a  2 s.  co  m

    int softwareKey = getSoftwareIdentificationKey(dataServiceSoftwareId);
    int userKey = getUserKey(userName, password);

    try (Connection conn = datasource.getConnection()) {
        BigInteger simulationGroupId = getNewSimulationGroupId();

        String query = "INSERT INTO run (md5_hash_of_run_message, software_id, requester_id, last_service_to_be_called, simulation_group_id, md5_collision_id) VALUES (?, ?, ?, ?, ?, ?)";
        PreparedStatement pstmt = conn.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
        pstmt.setString(1, md5Utils.getMd5(message));
        pstmt.setInt(2, softwareKey);
        pstmt.setInt(3, userKey);
        pstmt.setInt(4, 1);
        pstmt.setInt(5, simulationGroupId.intValue());
        pstmt.setInt(6, md5CollisionId);
        pstmt.execute();

        ResultSet rs = pstmt.getGeneratedKeys();
        BigInteger runId;
        if (rs.next()) {
            runId = new BigInteger(rs.getString(1));
        } else {
            throw new ApolloDatabaseRecordNotInsertedException("Record not inserted!");
        }

        // ALSO NEED TO ADD serialized run data service message (JSON) to
        // run_data_content table...
        // use insertDataContentForRun for this
        int dataContentKey = addTextDataContent(jsonUtils.getJSONString(message));
        int runDataDescriptionId = getRunDataDescriptionId(ContentDataFormatEnum.TEXT,
                "data_retrieval_request_message.json", ContentDataTypeEnum.RUN_MESSAGE, sourceSoftwareId,
                getSoftwareIdentificationKey(dataServiceSoftwareId));
        // int runDataId = the following line returns the runDataId, but
        // it's not used at this point.
        associateContentWithRunId(new BigInteger(String.valueOf(runId)), dataContentKey, runDataDescriptionId);

        List<BigInteger> runIdsForDataService = new ArrayList<>();
        runIdsForDataService.add(runId);
        addRunIdsToSimulationGroup(simulationGroupId, runIdsForDataService);

        updateStatusOfRun(runId, MethodCallStatusEnum.LOADED_RUN_CONFIG_INTO_DATABASE,
                "Adding config information to the database for runId: " + runId.toString());

        return runId;
    } catch (SQLException ex) {
        throw new ApolloDatabaseException("SQLException attempting to add simulation run: " + ex.getMessage());
    }
}

From source file:edu.pitt.apollo.db.ApolloDbUtils.java

public BigInteger[] addSimulationRun(RunMessage runMessage, int md5CollisionId,
        SoftwareIdentification identificationOfSoftwareToRun, int sourceSoftwareIdKey,
        SoftwareIdentification destinationSoftwareForRunSimulationMessage, Authentication authentication)
        throws ApolloDatabaseException, Md5UtilsException {

    String userName = authentication.getRequesterId();
    String password = authentication.getRequesterPassword();

    runMessage.setAuthentication(new Authentication());

    String[] userIdTokens = parseUserId(userName);
    userName = userIdTokens[0];//from   www  .j a  v  a  2  s. c  om

    Integer softwareKey = null;
    if (identificationOfSoftwareToRun != null) {
        softwareKey = getSoftwareIdentificationKey(identificationOfSoftwareToRun);
    }
    int userKey = getUserKey(userName, password);

    BigInteger simulationGroupId = null;
    String additionalInsertField = "";
    String additionalParamHolder = "";
    BigInteger[] runIdSimulationGroupId = new BigInteger[2];
    String md5 = md5Utils.getMd5(runMessage);

    try (Connection conn = datasource.getConnection()) {

        simulationGroupId = getNewSimulationGroupId();
        runIdSimulationGroupId[1] = simulationGroupId;
        additionalInsertField = ", simulation_group_id";
        additionalParamHolder = ",?";

        String query = "INSERT IGNORE INTO run (md5_hash_of_run_message, software_id, requester_id, last_service_to_be_called, md5_collision_id "
                + additionalInsertField + ") VALUES (?, ?, ?, ?, ? " + additionalParamHolder + ")";
        PreparedStatement pstmt = conn.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
        pstmt.setString(1, md5);
        if (softwareKey != null) {
            pstmt.setInt(2, softwareKey);
        } else {
            pstmt.setNull(2, Types.INTEGER);
        }
        pstmt.setInt(3, userKey);
        pstmt.setInt(4, 1);
        pstmt.setInt(5, md5CollisionId);
        pstmt.setLong(6, simulationGroupId.longValue());

        ResultSet rs;
        int rowsAffected = pstmt.executeUpdate();

        if (rowsAffected > 0) {
            rs = pstmt.getGeneratedKeys();
        } else {
            query = "SELECT id FROM run WHERE md5_hash_of_run_message = ? and md5_collision_id = ?";
            pstmt = conn.prepareStatement(query);
            pstmt.setString(1, md5);
            pstmt.setInt(2, md5CollisionId);
            rs = pstmt.executeQuery();
        }

        BigInteger runId;
        if (rs.next()) {
            runId = new BigInteger(rs.getString(1));
        } else {
            throw new ApolloDatabaseRecordNotInsertedException("Record not inserted!");
        }

        List<BigInteger> runIds = new ArrayList<>();
        runIds.add(runId);
        if (!(runMessage instanceof RunSimulationsMessage)) {
            addRunIdsToSimulationGroup(simulationGroupId, runIds);
        }

        // ALSO NEED TO ADD serialized runSimulationMessage(JSON) to
        // run_data_content table...
        // use insertDataContentForRun for this
        int dataContentKey = addTextDataContent(jsonUtils.getJSONString(runMessage));
        int runDataDescriptionId = getRunDataDescriptionId(ContentDataFormatEnum.TEXT, "run_message.json",
                ContentDataTypeEnum.RUN_MESSAGE, sourceSoftwareIdKey,
                getSoftwareIdentificationKey(destinationSoftwareForRunSimulationMessage));
        // int runDataId = the following line returns the runDataId, but
        // it's not used at this point.
        associateContentWithRunId(new BigInteger(String.valueOf(runId)), dataContentKey, runDataDescriptionId);

        runIdSimulationGroupId[0] = runId;
        if (runIdSimulationGroupId.length == 2) {
            runIdSimulationGroupId[1] = simulationGroupId;
        }

        updateStatusOfRun(runId, MethodCallStatusEnum.LOADED_RUN_CONFIG_INTO_DATABASE,
                "Adding config information to the database for runId: " + runId.toString());

        return runIdSimulationGroupId;
        // } catch (ClassNotFoundException ex) {
        //     throw new ApolloDatabaseException(
        //             "ClassNotFoundException attempting to add simulation run: "
        //                     + ex.getMessage());
    } catch (SQLException ex) {
        throw new ApolloDatabaseException("SQLException attempting to add simulation run: " + ex.getMessage());
    }
}

From source file:com.cisco.dvbu.ps.common.util.CommonUtils.java

/**
 * Process the custom path list and create .cmf files for each folder path using the template folders that come with PDTool.
 * /*from   w ww.  java  2s.  co m*/
 * @param customPathList
 * @param templateFolderPath
 * @param forceCopy
 * @param toFilePath
 */
public static void processTemplateFolder(String customPathList, String templateFolderPath, String toFilePath,
        boolean forceCopy) {

    // Initialize variables.
    String templateSharedFolder = getFileAsString(templateFolderPath + "/sharedFolder.cmf");
    String templateVirtualFolder = getFileAsString(templateFolderPath + "/virtualFolder.cmf");
    String templateDatabase = getFileAsString(templateFolderPath + "/database.cmf");
    String templateCatalog = getFileAsString(templateFolderPath + "/catalog.cmf");
    String templateSchema = getFileAsString(templateFolderPath + "/schema.cmf");
    String templateText = null;
    String pathStart = null;
    String remainderPath = null;
    String resourcePath = null;
    String resourcePathEncoded = null;
    String resourceName = null;
    String resourceNameEncoded = null;
    String fsPath = null;
    BigInteger bigIntTime = null;
    String regexSize = "200000";
    String regexReplacePatternDoubleQuote = "\\,(?=[^\"]{0," + regexSize + "}\"(?:[^\"\\r\\n]{0," + regexSize
            + "}\"[^\"]{0," + regexSize + "}\"){0," + regexSize + "}[^\"\\r\\n]{0," + regexSize + "}$)";

    // Replace commas within double quotes with encoded commas
    customPathList = customPathList.replaceAll(regexReplacePatternDoubleQuote, "_002c");

    // Iterate over the comma separated paths
    StringTokenizer pst = new StringTokenizer(customPathList, ",");
    while (pst.hasMoreTokens()) {
        String token = pst.nextToken();

        // Make sure all paths have forward slashes
        token = token.replaceAll(Matcher.quoteReplacement("\\\\"), "/");
        token = token.replaceAll(Matcher.quoteReplacement("\\"), "/");
        // Make sure all paths have a single forward slash
        token = token.replaceAll("//", "/");
        // Make sure no paths have double quotes
        token = token.replaceAll("\"", "");
        // Replace encoded commas with real commas
        token = token.replaceAll("_002c", ",");

        // Create custom shared folders
        // e.g. /shared/My Folder,/shared/My Folder/My.Folder/My-Folder/""My,Folder""
        pathStart = "/shared/";
        if (token.startsWith(pathStart)) {
            remainderPath = token.replaceFirst(pathStart, "");
            resourcePath = pathStart;
            resourcePathEncoded = pathStart;
            fsPath = toFilePath;

            StringTokenizer st = new StringTokenizer(remainderPath, "/");
            while (st.hasMoreTokens()) {
                resourceName = st.nextToken();
                resourceNameEncoded = ResourceNameCodec.encode(resourceName);
                templateText = templateSharedFolder;

                // CIS resource path
                resourcePath = (resourcePath + "/" + resourceName).replaceAll("//", "/");
                resourcePathEncoded = (resourcePathEncoded + "/" + resourceNameEncoded).replaceAll("//", "/");

                // Files system path
                fsPath = (toFilePath + "/" + resourcePathEncoded).replaceAll("//", "/");
                mkdirs(fsPath);

                /*
                 *  Create File content
                 */
                // Encode name
                resourceName = encodePath(resourceName);
                templateText = templateText.replaceAll(Matcher.quoteReplacement("$RESOURCE_NAME"),
                        resourceName);

                // Encode path
                resourcePath = encodePath(resourcePath);
                templateText = templateText.replaceAll(Matcher.quoteReplacement("$RESOURCE_PATH"),
                        resourcePath);

                bigIntTime = TimestampToBigint(getCurrentDateAsString("yyyy-MM-dd HH:mm:ss.SSS"));
                templateText = templateText.replaceAll(Matcher.quoteReplacement("$CREATE_DATE_LONG"),
                        bigIntTime.toString());

                // Decode path
                templateText = decodePath(templateText);

                // Write out the file
                fsPath = fsPath + "/" + resourceNameEncoded + ".cmf";
                boolean fileExists = fileExists(fsPath);
                if (!fileExists) {
                    CommonUtils.createFileWithContent(fsPath, templateText);
                }
                if (fileExists && forceCopy) {
                    removeFile(fsPath);
                    CommonUtils.createFileWithContent(fsPath, templateText);
                }
            }
        }

        // Create custom database folders
        // e.g. /services/databases/My Database{TYPE:DATABASE}/My.Catalog{TYPE:CATALOG}/My$Schema{TYPE:SCHEMA}
        pathStart = "/services/databases/";
        if (token.startsWith(pathStart)) {
            remainderPath = token.replaceFirst(pathStart, "");
            resourcePath = pathStart;
            resourcePathEncoded = pathStart;
            fsPath = toFilePath;
            int pathCount = 0;

            StringTokenizer st = new StringTokenizer(remainderPath, "/");
            while (st.hasMoreTokens()) {
                token = st.nextToken();
                ++pathCount;

                // Convert square bracket characters to angle bracket characters
                if (token.contains("["))
                    token = token.replace("[", "<");
                if (token.contains("]"))
                    token = token.replace("]", ">");

                // If this is the first path extracted then assume it is a database token
                if (pathCount == 1)
                    templateText = templateDatabase;

                // Determine if the token is a database type token: "/services/databases/My Database[TYPE=DATABASE]/My Catalog[type=catalog]/My Schema[Type=Schema]"
                if (token.toUpperCase().trim().contains("<TYPE=DATABASE>")) {
                    int beg = token.toUpperCase().indexOf("<");
                    int end = token.toUpperCase().indexOf(">");
                    resourceName = token.substring(0, beg);
                    if (end + 1 < token.length())
                        resourceName = resourceName + token.substring(end + 1);
                    templateText = templateDatabase;
                }
                // Determine if the token is a catalog type token: "/services/databases/My Database[TYPE=DATABASE]/My Catalog[type=catalog]/My Schema[Type=Schema]"
                else if (token.toUpperCase().trim().contains("<TYPE=CATALOG>")) {
                    int beg = token.toUpperCase().indexOf("<");
                    int end = token.toUpperCase().indexOf(">");
                    resourceName = token.substring(0, beg);
                    if (end + 1 < token.length())
                        resourceName = resourceName + token.substring(end + 1);
                    templateText = templateCatalog;
                }
                // Determine if the token is a schema type token: "/services/databases/My Database[TYPE=DATABASE]/My Catalog[type=catalog]/My Schema[Type=Schema]"
                else if (token.toUpperCase().trim().contains("<TYPE=SCHEMA>")) {
                    int beg = token.toUpperCase().indexOf("<");
                    int end = token.toUpperCase().indexOf(">");
                    resourceName = token.substring(0, beg);
                    if (end + 1 < token.length())
                        resourceName = resourceName + token.substring(end + 1);
                    templateText = templateSchema;
                    // Otherwise default to a folder token
                } else {
                    resourceName = token;
                    templateText = templateVirtualFolder;
                }
                resourceNameEncoded = ResourceNameCodec.encode(resourceName);

                // CIS resource path
                resourcePath = (resourcePath + "/" + resourceName).replaceAll("//", "/");
                resourcePathEncoded = (resourcePathEncoded + "/" + resourceNameEncoded).replaceAll("//", "/");

                // Files system path
                fsPath = (toFilePath + "/" + resourcePathEncoded).replaceAll("//", "/");
                mkdirs(fsPath);

                /*
                 *  Create File content
                 */
                // Encode name
                resourceName = encodePath(resourceName);
                templateText = templateText.replaceAll(Matcher.quoteReplacement("$RESOURCE_NAME"),
                        resourceName);

                // Encode path
                resourcePath = encodePath(resourcePath);
                templateText = templateText.replaceAll(Matcher.quoteReplacement("$RESOURCE_PATH"),
                        resourcePath);

                bigIntTime = TimestampToBigint(getCurrentDateAsString("yyyy-MM-dd HH:mm:ss.SSS"));
                templateText = templateText.replaceAll(Matcher.quoteReplacement("$CREATE_DATE_LONG"),
                        bigIntTime.toString());

                // Decode path
                templateText = decodePath(templateText);

                // Write out the file
                fsPath = fsPath + "/" + resourceNameEncoded + ".cmf";
                boolean fileExists = fileExists(fsPath);
                if (!fileExists) {
                    CommonUtils.createFileWithContent(fsPath, templateText);
                }
                if (fileExists && forceCopy) {
                    removeFile(fsPath);
                    CommonUtils.createFileWithContent(fsPath, templateText);
                }
            }
        }

        // Create custom web services folders
        // e.g. /services/webservices/My Folder/My.Folder/My-Folder
        pathStart = "/services/webservices/";
        if (token.startsWith(pathStart)) {
            remainderPath = token.replaceFirst(pathStart, "");
            resourcePath = pathStart;
            resourcePathEncoded = pathStart;
            fsPath = toFilePath;

            StringTokenizer st = new StringTokenizer(remainderPath, "/");
            while (st.hasMoreTokens()) {
                resourceName = st.nextToken();
                resourceNameEncoded = ResourceNameCodec.encode(resourceName);
                templateText = templateVirtualFolder;

                // CIS resource path
                resourcePath = (resourcePath + "/" + resourceName).replaceAll("//", "/");
                resourcePathEncoded = (resourcePathEncoded + "/" + resourceNameEncoded).replaceAll("//", "/");

                // Files system path
                fsPath = (toFilePath + "/" + resourcePathEncoded).replaceAll("//", "/");
                mkdirs(fsPath);

                /*
                 *  Create File content
                 */
                // Encode name
                resourceName = encodePath(resourceName);
                templateText = templateText.replaceAll(Matcher.quoteReplacement("$RESOURCE_NAME"),
                        resourceName);

                // Encode path
                resourcePath = encodePath(resourcePath);
                templateText = templateText.replaceAll(Matcher.quoteReplacement("$RESOURCE_PATH"),
                        resourcePath);

                bigIntTime = TimestampToBigint(getCurrentDateAsString("yyyy-MM-dd HH:mm:ss.SSS"));
                templateText = templateText.replaceAll(Matcher.quoteReplacement("$CREATE_DATE_LONG"),
                        bigIntTime.toString());

                // Decode path
                templateText = decodePath(templateText);

                // Write out the file
                fsPath = fsPath + "/" + resourceNameEncoded + ".cmf";
                boolean fileExists = fileExists(fsPath);
                if (!fileExists) {
                    CommonUtils.createFileWithContent(fsPath, templateText);
                }
                if (fileExists && forceCopy) {
                    removeFile(fsPath);
                    CommonUtils.createFileWithContent(fsPath, templateText);
                }
            }
        }
    }
}

From source file:org.apache.openjpa.jdbc.sql.DBDictionary.java

/**
 * Set the given value as a parameter to the statement.
 *///w  ww  .  j a  v  a  2  s.  c  o  m
public void setBigInteger(PreparedStatement stmnt, int idx, BigInteger val, Column col) throws SQLException {
    if ((col != null && col.isCompatible(Types.VARCHAR, null, 0, 0))
            || (col == null && storeLargeNumbersAsStrings))
        setString(stmnt, idx, val.toString(), col);
    else
        setBigDecimal(stmnt, idx, new BigDecimal(val), col);
}

From source file:org.energy_home.jemma.javagal.layers.data.implementations.IDataLayerImplementation.DataFreescale.java

public void processMessages() throws Exception {
    // Look on received messages
    int _size = 0;
    synchronized (this) {
        _size = messages.size();//from   ww  w. j a  va 2 s.co m
    }

    while (_size > 0) {
        short[] message = null;
        synchronized (this) {
            message = messages.remove(0);
        }

        ByteBuffer bb = ByteBuffer.allocate(2);
        bb.order(ByteOrder.BIG_ENDIAN);
        bb.put((byte) message[0]);
        bb.put((byte) message[1]);
        short _command = bb.getShort(0);

        /* APSDE-DATA.Indication */
        if (_command == FreescaleConstants.APSDEDataIndication) {
            final APSMessageEvent messageEvent = new APSMessageEvent();
            short destAddressMode = message[3];
            messageEvent.setDestinationAddressMode((long) destAddressMode);
            BigInteger _ieee = null;
            Address address = new Address();
            switch (destAddressMode) {
            case 0x00:
                // Reserved (No source address supplied)
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Message Discarded: found reserved 0x00 as Destination Address Mode ");
                } // Error found, we don't proceed and discard the
                  // message
                return;
            case 0x01:
                // Value16bitgroupfordstAddr (DstEndpoint not
                // present)
                // No destination end point (so FF broadcast),
                // present
                // short
                // address on 2 bytes
                address.setNetworkAddress(
                        DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));

                _ieee = gal.getIeeeAddress_FromNetworkCache(address.getNetworkAddress());
                if (_ieee != null)
                    address.setIeeeAddress(_ieee);

                messageEvent.setDestinationAddress(address);
                messageEvent.setDestinationEndpoint((short) 0xff);

                break;
            case 0x02:
                // Value16bitAddrandDstEndpoint (16 bit address
                // supplied)
                address.setNetworkAddress(
                        DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));
                _ieee = gal.getIeeeAddress_FromNetworkCache(address.getNetworkAddress());
                if (_ieee != null)
                    address.setIeeeAddress(_ieee);

                messageEvent.setDestinationAddress(address);
                messageEvent.setDestinationEndpoint(message[6]);
                break;
            default:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.error("Message Discarded: not valid Destination Address Mode");
                }
                // Error found, we don't proceed and discard the
                // message
                return;
            }
            messageEvent.setSourceAddressMode((long) message[7]);
            address = new Address();
            address.setNetworkAddress(DataManipulation.toIntFromShort((byte) message[9], (byte) message[8]));
            _ieee = gal.getIeeeAddress_FromNetworkCache(address.getNetworkAddress());
            if (_ieee != null)
                address.setIeeeAddress(_ieee);
            messageEvent.setSourceAddress(address);
            messageEvent.setSourceEndpoint(message[10]);
            messageEvent.setProfileID(DataManipulation.toIntFromShort((byte) message[12], (byte) message[11]));
            messageEvent.setClusterID(DataManipulation.toIntFromShort((byte) message[14], (byte) message[13]));

            if (gal.getGatewayStatus() == GatewayStatus.GW_RUNNING && gal.get_GalNode() != null) {
                /* Update The Node Data */

                int _indexOnCache = -1;
                _indexOnCache = gal.existIntoNetworkCache(address.getNetworkAddress());
                if (_indexOnCache != -1) {
                    /* The node is already into the DB */
                    if (gal.getPropertiesManager().getKeepAliveThreshold() > 0) {
                        if (!gal.getNetworkcache().get(_indexOnCache).isSleepy()) {
                            gal.getNetworkcache().get(_indexOnCache).reset_numberOfAttempt();
                            gal.getNetworkcache().get(_indexOnCache)
                                    .setTimerFreshness(gal.getPropertiesManager().getKeepAliveThreshold());
                            if (gal.getPropertiesManager().getDebugEnabled()) {
                                //System.out.println("\n\rPostponing  timer Freshness by Aps.Indication for node:" + gal.getNetworkcache().get(_indexOnCache).get_node().getAddress().getNetworkAddress() + "\n\r");
                                logger.info("Postponing  timer Freshness by Aps.Indication for node:"
                                        + gal.getNetworkcache().get(_indexOnCache).get_node().getAddress()
                                                .getNetworkAddress());
                            }
                        }

                    }
                } else {
                    // 0x8034 is a LeaveAnnouncement, 0x0013 is a
                    // DeviceAnnouncement, 0x8001 is a IEEE_Addr_Rsp
                    if ((gal.getPropertiesManager().getAutoDiscoveryUnknownNodes() > 0)
                            && (!(messageEvent.getProfileID() == 0x0000
                                    && (messageEvent.getClusterID() == 0x0013
                                            || messageEvent.getClusterID() == 0x8034
                                            || messageEvent.getClusterID() == 0x8001)))) {

                        if (address.getNetworkAddress() != gal.get_GalNode().get_node().getAddress()
                                .getNetworkAddress()) {
                            Runnable thr = new MyThread(address) {
                                @Override
                                public void run() {
                                    Address _address = (Address) this.getParameter();
                                    int _indexOnCache = -1;
                                    _indexOnCache = gal.existIntoNetworkCache(_address.getNetworkAddress());
                                    if (_indexOnCache == -1) {

                                        if (gal.getPropertiesManager().getDebugEnabled()) {
                                            //System.out.println("\n\rAutoDiscoveryUnknownNodes procedure of Node:" + messageEvent.getSourceAddress().getNetworkAddress() + "\n\r");

                                            logger.info("AutoDiscoveryUnknownNodes procedure of Node:"
                                                    + messageEvent.getSourceAddress().getNetworkAddress());
                                        }
                                        try {

                                            // Insert the node into cache,
                                            // but with the
                                            // discovery_completed flag a
                                            // false
                                            BigInteger ieee = null;
                                            WrapperWSNNode o = new WrapperWSNNode(gal);
                                            WSNNode _newNode = new WSNNode();
                                            o.set_discoveryCompleted(false);
                                            _newNode.setAddress(_address);
                                            o.set_node(_newNode);
                                            gal.getNetworkcache().add(o);

                                            Thread.sleep(500);
                                            /*
                                             * Reading the IEEEAddress of
                                             * the new node
                                             */

                                            if (gal.getPropertiesManager().getDebugEnabled())
                                                logger.info(
                                                        "Sending IeeeReq to:" + _address.getNetworkAddress());
                                            System.out.println(
                                                    "Sending IeeeReq to:" + _address.getNetworkAddress());
                                            ieee = readExtAddress(INTERNAL_TIMEOUT,
                                                    _address.getNetworkAddress().shortValue());
                                            _address.setIeeeAddress(ieee);
                                            if (gal.getPropertiesManager().getDebugEnabled()) {
                                                logger.info("Readed Ieee of the new node:"
                                                        + _address.getNetworkAddress() + " Ieee: "
                                                        + ieee.toString());
                                                System.out.println("Readed Ieee of the new node:"
                                                        + _address.getNetworkAddress() + " Ieee: "
                                                        + ieee.toString());

                                            }
                                            if (gal.getPropertiesManager().getDebugEnabled())
                                                logger.info("Sending NodeDescriptorReq to:"
                                                        + _address.getNetworkAddress());
                                            NodeDescriptor _ndesc = getNodeDescriptorSync(INTERNAL_TIMEOUT,
                                                    _address);
                                            _newNode.setCapabilityInformation(_ndesc.getMACCapabilityFlag());

                                            if (gal.getPropertiesManager().getDebugEnabled()) {
                                                logger.info("Readed NodeDescriptor of the new node:"
                                                        + _address.getNetworkAddress());
                                                System.out.println("Readed NodeDescriptor of the new node:"
                                                        + _address.getNetworkAddress());

                                            }

                                            o.reset_numberOfAttempt();
                                            o.set_discoveryCompleted(true);
                                            if (!o.isSleepy()) {

                                                if (gal.getPropertiesManager().getKeepAliveThreshold() > 0) {
                                                    o.setTimerFreshness(
                                                            gal.getPropertiesManager().getKeepAliveThreshold());
                                                }
                                                if (gal.getPropertiesManager().getForcePingTimeout() > 0) {
                                                    o.setTimerForcePing(
                                                            gal.getPropertiesManager().getForcePingTimeout());
                                                }
                                            }

                                            _indexOnCache = gal.existIntoNetworkCache(
                                                    _newNode.getAddress().getNetworkAddress());
                                            if (_indexOnCache > -1) {
                                                gal.getNetworkcache().remove(_indexOnCache);

                                            }

                                            // Updating the node
                                            // informations
                                            gal.getNetworkcache().add(o);
                                            o.set_discoveryCompleted(true);
                                            Status _st = new Status();
                                            _st.setCode((short) GatewayConstants.SUCCESS);
                                            gal.get_gatewayEventManager().nodeDiscovered(_st, _newNode);

                                        } catch (GatewayException e) {
                                            logger.error("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());

                                            System.out.println("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());

                                            _indexOnCache = gal
                                                    .existIntoNetworkCache(_address.getNetworkAddress());
                                            if (_indexOnCache > -1) {
                                                gal.getNetworkcache().get(_indexOnCache).abortTimers();
                                                gal.getNetworkcache().remove(_indexOnCache);
                                            }

                                        } catch (Exception e) {
                                            logger.error("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());
                                            System.out.println("Error on getAutoDiscoveryUnknownNodes for node:"
                                                    + _address.getNetworkAddress() + " Error:"
                                                    + e.getMessage());
                                            _indexOnCache = gal
                                                    .existIntoNetworkCache(_address.getNetworkAddress());
                                            if (_indexOnCache > -1) {
                                                gal.getNetworkcache().get(_indexOnCache).abortTimers();
                                                gal.getNetworkcache().remove(_indexOnCache);

                                            }

                                        }
                                    }
                                }
                            };

                            Thread _thr0 = new Thread(thr);
                            _thr0.setName("Thread getAutoDiscoveryUnknownNodes:" + address.getNetworkAddress());
                            _thr0.start();
                        }
                    }
                }

            }
            int lastAsdu = 16 + message[15] - 1;

            messageEvent.setData(DataManipulation.subByteArray(message, 16, lastAsdu));
            messageEvent.setAPSStatus(message[lastAsdu + 1]);
            // ASK Jump WasBroadcast
            // Security Status
            switch (message[lastAsdu + 3]) {
            case 0x00:
                messageEvent.setSecurityStatus(SecurityStatus.UNSECURED);
                break;
            case 0x01:
                messageEvent.setSecurityStatus(SecurityStatus.SECURED_NWK_KEY);
                break;
            case 0x02:
                messageEvent.setSecurityStatus(SecurityStatus.SECURED_LINK_KEY);
                break;
            // ASK 0x03 not present on telecomitalia object
            default:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Message Discarded: not valid Security Status");
                }
                // Error found, we don't proceed and discard the
                // message
                return;
            }
            messageEvent.setLinkQuality(message[lastAsdu + 4]);
            messageEvent.setRxTime((long) DataManipulation.toIntFromShort((byte) message[(lastAsdu + 8)],
                    (byte) message[(lastAsdu + 5)]));
            // ASK: jumped iMsgType, pNext, iDataSize, pData,
            // iBufferNumber
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSDE-DATA.Indication", message);
            if ((messageEvent.getDestinationAddressMode() == GatewayConstants.ADDRESS_MODE_SHORT)
                    && (messageEvent.getDestinationAddress().getIeeeAddress() == null))
                messageEvent.getDestinationAddress().setIeeeAddress(gal.getIeeeAddress_FromNetworkCache(
                        messageEvent.getDestinationAddress().getNetworkAddress()));

            if ((messageEvent.getDestinationAddressMode() == GatewayConstants.EXTENDED_ADDRESS_MODE)
                    && (messageEvent.getDestinationAddress().getNetworkAddress() == null))
                messageEvent.getDestinationAddress().setNetworkAddress(gal.getShortAddress_FromNetworkCache(
                        messageEvent.getDestinationAddress().getIeeeAddress()));

            if ((messageEvent.getSourceAddressMode() == GatewayConstants.ADDRESS_MODE_SHORT)
                    && (messageEvent.getDestinationAddress().getIeeeAddress() == null))
                messageEvent.getSourceAddress().setIeeeAddress(gal
                        .getIeeeAddress_FromNetworkCache(messageEvent.getSourceAddress().getNetworkAddress()));

            if ((messageEvent.getSourceAddressMode() == GatewayConstants.EXTENDED_ADDRESS_MODE)
                    && (messageEvent.getDestinationAddress().getNetworkAddress() == null))
                messageEvent.getSourceAddress().setNetworkAddress(
                        gal.getShortAddress_FromNetworkCache(messageEvent.getSourceAddress().getIeeeAddress()));

            if (messageEvent.getProfileID().equals(0)) {/*
                                                        * ZDO Command
                                                        */
                if (messageEvent.getClusterID() == 0x8031) {
                    String __key = "";
                    __key = String.format("%04X", messageEvent.getSourceAddress().getNetworkAddress());
                    synchronized (listLocker) {
                        for (ParserLocker pl : listLocker) {
                            if ((pl.getType() == TypeMessage.LQI_REQ) && __key.equalsIgnoreCase(pl.get_Key())) {
                                synchronized (pl) {
                                    pl.getStatus().setCode((short) messageEvent.getAPSStatus());
                                    Mgmt_LQI_rsp _res = new Mgmt_LQI_rsp(messageEvent.getData());
                                    pl.set_objectOfResponse(_res);
                                    pl.notify();
                                }
                                break;
                            }
                        }
                    }
                }
                // profileid == 0
                gal.getZdoManager().ZDOMessageIndication(messageEvent);
            } else {
                // profileid > 0
                ZCLMessage _zm = new ZCLMessage();
                _zm.setAPSStatus(messageEvent.getAPSStatus());
                _zm.setClusterID(messageEvent.getClusterID());
                _zm.setDestinationEndpoint(messageEvent.getDestinationEndpoint());
                _zm.setProfileID(messageEvent.getProfileID());
                _zm.setRxTime(messageEvent.getRxTime());
                _zm.setSourceAddress(messageEvent.getSourceAddress());
                _zm.setSourceAddressMode(messageEvent.getSourceAddressMode());
                _zm.setSourceEndpoint(messageEvent.getSourceEndpoint());

                byte[] data = messageEvent.getData();
                // ZCL Header
                // Frame control 8bit
                // Manufacturer code 0/16bits
                // Transaction sequence number 8bit
                // Command identifier 8 bit
                ByteArrayObject _header = new ByteArrayObject();
                ByteArrayObject _payload = new ByteArrayObject();
                if ((data[0] & 0x04) == 1)/* Check manufacturer code */
                {
                    _header.addByte(data[0]);// Frame control
                    _header.addByte(data[1]);// Manufacturer Code(1/2)
                    _header.addByte(data[2]);// Manufacturer Code(2/2)
                    _header.addByte(data[3]);// Transaction sequence number
                    _header.addByte(data[4]);// Command Identifier
                    for (int i = 5; i < data.length; i++)
                        _payload.addByte(data[i]);
                } else {
                    _header.addByte(data[0]);// Frame control
                    _header.addByte(data[1]);// Transaction sequence number
                    _header.addByte(data[2]);// Command Identifier
                    for (int i = 3; i < data.length; i++)
                        _payload.addByte(data[i]);
                }

                _zm.setZCLHeader(_header.getRealByteArray());
                _zm.setZCLPayload(_payload.getRealByteArray());
                gal.get_gatewayEventManager().notifyZCLCommand(_zm);
                gal.getApsManager().APSMessageIndication(messageEvent);

            }
        }

        /* APSDE-DATA.Confirm */
        else if (_command == FreescaleConstants.APSDEDataConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSDE-DATA.Confirm", message);

            /* DestAddress + DestEndPoint + SourceEndPoint */
            long destAddress = DataManipulation.toLong((byte) message[11], (byte) message[10],
                    (byte) message[9], (byte) message[8], (byte) message[7], (byte) message[6],
                    (byte) message[5], (byte) message[4]);
            byte destEndPoint = (byte) message[12];
            byte sourceEndPoint = (byte) message[13];
            String Key = String.format("%016X", destAddress) + String.format("%02X", destEndPoint)
                    + String.format("%02X", sourceEndPoint);

            // Found APSDE-DATA.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    /* DestAddress + DestEndPoint + SourceEndPoint */
                    /*
                     * if (gal.getPropertiesManager().getDebugEnabled())
                     * logger.info("APSDE-DATA.Confirm KEY SEND: " +
                     * pl.get_Key() + " -- KEY Received: " + Key);
                     */
                    if ((pl.getType() == TypeMessage.APS) && pl.get_Key().equalsIgnoreCase(Key)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[14]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* ZTC-Error.event */
        else if (_command == FreescaleConstants.ZTCErrorevent) {

            byte len = (byte) message[2];
            String MessageStatus = "";
            if (len > 0) {
                int status = message[3];
                switch (status) {
                case 0x00:
                    MessageStatus = "0x00: gSuccess_c (Should not be seen in this event.)";
                    break;
                case 0xF4:
                    MessageStatus = "0xF4: gZtcOutOfMessages_c (ZTC tried to allocate a message, but the allocation failed.)";
                    break;
                case 0xF5:
                    MessageStatus = "0xF5: gZtcEndPointTableIsFull_c (Self explanatory.)";
                    break;
                case 0xF6:
                    MessageStatus = "0xF6: gZtcEndPointNotFound_c (Self explanatory.)";
                    break;
                case 0xF7:
                    MessageStatus = "0xF7: gZtcUnknownOpcodeGroup_c (ZTC does not recognize the opcode group, and there is no application hook.)";
                    break;
                case 0xF8:
                    MessageStatus = "0xF8: gZtcOpcodeGroupIsDisabled_c (ZTC support for an opcode group is turned off by a compile option.)";
                    break;
                case 0xF9:
                    MessageStatus = "0xF9: gZtcDebugPrintFailed_c (An attempt to print a debug message ran out of buffer space.)";
                    break;
                case 0xFA:
                    MessageStatus = "0xFA: gZtcReadOnly_c (Attempt to set read-only data.)";
                    break;
                case 0xFB:
                    MessageStatus = "0xFB: gZtcUnknownIBIdentifier_c (Self explanatory.)";
                    break;
                case 0xFC:
                    MessageStatus = "0xFC: gZtcRequestIsDisabled_c (ZTC support for an opcode is turned off by a compile option.)";
                    break;
                case 0xFD:
                    MessageStatus = "0xFD: gZtcUnknownOpcode_c (Self expanatory.)";
                    break;
                case 0xFE:
                    MessageStatus = "0xFE: gZtcTooBig_c (A data item to be set or retrieved is too big for the buffer available to hold it.)";
                    break;
                case 0xFF:
                    MessageStatus = "0xFF: gZtcError_c (Non-specific, catchall error code.)";
                    break;
                default:
                    break;
                }

            }
            String logMessage = "Extracted ZTC-ERROR.Event Status:" + MessageStatus;
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix(logMessage, message);
        }

        /* ZDP-Mgmt_Nwk_Update.Notify */

        else if (_command == FreescaleConstants.ZDPMgmt_Nwk_UpdateNotify) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Nwk_Update.Notify", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NWK_UPDATE) {

                        EnergyScanResult _result = new EnergyScanResult();

                        int _address = DataManipulation.toIntFromShort((byte) message[4], (byte) message[3]);

                        short _status = message[5];
                        if (_status == GatewayConstants.SUCCESS) {
                            byte[] _scannedChannel = new byte[4];
                            _scannedChannel[0] = (byte) message[9];
                            _scannedChannel[1] = (byte) message[8];
                            _scannedChannel[2] = (byte) message[7];
                            _scannedChannel[3] = (byte) message[6];

                            int _totalTrasmission = DataManipulation.toIntFromShort((byte) message[11],
                                    (byte) message[10]);

                            int _trasmissionFailure = DataManipulation.toIntFromShort((byte) message[13],
                                    (byte) message[12]);

                            short _scannedChannelListCount = message[14];
                            for (int i = 0; i < _scannedChannelListCount; i++) {
                                ScannedChannel _sc = new ScannedChannel();
                                // _sc.setChannel(value)
                                _sc.setEnergy(message[15 + i]);

                                _result.getScannedChannel().add(_sc);
                            }
                            synchronized (pl) {
                                pl.getStatus().setCode(message[7]);
                                pl.set_objectOfResponse(_result);
                                pl.notify();
                            }
                            break;

                        }

                    }
                }
            }

        }

        /* ZDP-SimpleDescriptor.Response */
        else if (_command == FreescaleConstants.ZDPSimpleDescriptorResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-ExtendedSimpleDescriptor.Response", message);
            /* Address + EndPoint */
            Address _add = new Address();

            _add.setNetworkAddress(DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));
            byte EndPoint = (byte) message[7];
            String Key = String.format("%04X", _add.getNetworkAddress()) + String.format("%02X", EndPoint);
            // Found ZDP-SimpleDescriptor.Response. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    /* Address + EndPoint */
                    if ((pl.getType() == TypeMessage.GET_SIMPLE_DESCRIPTOR)
                            && pl.get_Key().equalsIgnoreCase(Key)) {

                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            if (pl.getStatus().getCode() == GatewayConstants.SUCCESS) {

                                SimpleDescriptor _sp = new SimpleDescriptor();
                                _sp.setApplicationProfileIdentifier(
                                        DataManipulation.toIntFromShort((byte) message[9], (byte) message[8]));
                                _sp.setApplicationDeviceIdentifier(DataManipulation
                                        .toIntFromShort((byte) message[11], (byte) message[10]));
                                _sp.setApplicationDeviceVersion(message[12]);
                                int _index = 14;
                                short _numInpCluster = message[13];
                                for (int i = 0; i < _numInpCluster; i++) {
                                    _sp.getApplicationInputCluster().add(DataManipulation.toIntFromShort(
                                            (byte) message[_index + 1], (byte) message[_index]));
                                    _index = _index + 2;
                                }

                                short _numOutCluster = message[_index++];

                                for (int i = 0; i < _numOutCluster; i++) {
                                    _sp.getApplicationOutputCluster().add(DataManipulation.toIntFromShort(
                                            (byte) message[_index + 1], (byte) message[_index]));
                                    _index = _index + 2;
                                }
                                ServiceDescriptor _toRes = new ServiceDescriptor();
                                _toRes.setAddress(_add);
                                _toRes.setEndPoint(EndPoint);
                                _toRes.setSimpleDescriptor(_sp);
                                pl.set_objectOfResponse(_toRes);
                            }
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* APS-GetEndPointIdList.Confirm */
        else if (_command == FreescaleConstants.APSGetEndPointIdListConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APS-GetEndPointIdList.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.GET_END_POINT_LIST)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            NodeServices _res = new NodeServices();
                            if (pl.getStatus().getCode() == GatewayConstants.SUCCESS) {
                                short length = message[4];
                                for (int i = 0; i < length; i++) {
                                    ActiveEndpoints _ep = new ActiveEndpoints();
                                    _ep.setEndPoint(message[5 + i]);
                                    _res.getActiveEndpoints().add(_ep);
                                }
                            }
                            pl.set_objectOfResponse(_res);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-BIND.Response */
        else if (_command == FreescaleConstants.ZDPMgmtBindResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-BIND.Response", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.ADD_BINDING)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            switch (pl.getStatus().getCode()) {
                            case GatewayConstants.SUCCESS:

                                break;

                            case 0x84:
                                pl.getStatus().setMessage("NOT_SUPPORTED (NOT SUPPORTED)");
                                break;

                            case 0x8C:
                                pl.getStatus().setMessage("TABLE_FULL (TABLE FULL)");
                                break;
                            case 0x8D:
                                pl.getStatus().setMessage("NOT_AUTHORIZED (NOT AUTHORIZED)");
                                break;
                            }
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-UNBIND.Response */
        else if (_command == FreescaleConstants.ZDPUnbindResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-UNBIND.Response", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.REMOVE_BINDING)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            switch (pl.getStatus().getCode()) {
                            case GatewayConstants.SUCCESS:

                                break;

                            case 0x84:
                                pl.getStatus().setMessage("NOT_SUPPORTED (NOT SUPPORTED)");
                                break;
                            case 0x88:
                                pl.getStatus().setMessage("No_Entry (No Entry)");
                                break;
                            case 0x8D:
                                pl.getStatus().setMessage("NOT_AUTHORIZED (NOT AUTHORIZED");
                                break;
                            }
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-Mgmt_Bind.Response */
        else if (_command == FreescaleConstants.ZDPMgmt_BindResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Bind.Response", message);

            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.GET_BINDINGS)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            BindingList _res = new BindingList();

                            if (pl.getStatus().getCode() == GatewayConstants.SUCCESS) {
                                short length = message[6];
                                int _index = 6;
                                for (int i = 0; i < length; i++) {
                                    Binding _b = new Binding();
                                    long src_longAddress = DataManipulation.toLong((byte) message[_index + 8],
                                            (byte) message[_index + 7], (byte) message[_index + 6],
                                            (byte) message[_index + 5], (byte) message[_index + 4],
                                            (byte) message[_index + 3], (byte) message[_index + 2],
                                            (byte) message[_index + 1]);
                                    short _srcEP = message[_index + 9];

                                    int _cluster = DataManipulation.toIntFromShort((byte) message[_index + 11],
                                            (byte) message[_index + 10]);

                                    short _DestinationMode = message[_index + 12];
                                    Device _dev = new Device();

                                    if (_DestinationMode == 0x03) {

                                        long dst_longAddress = DataManipulation.toLong(
                                                (byte) message[_index + 20], (byte) message[_index + 19],
                                                (byte) message[_index + 18], (byte) message[_index + 17],
                                                (byte) message[_index + 16], (byte) message[_index + 15],
                                                (byte) message[_index + 14], (byte) message[_index + 13]);

                                        short _dstEP = message[_index + 21];
                                        _dev.setAddress(BigInteger.valueOf(dst_longAddress));
                                        _dev.setEndpoint(_dstEP);
                                        _index = _index + 21;
                                    } else if (_DestinationMode == 0x01) {

                                        int _groupId = DataManipulation.toIntFromShort(
                                                (byte) message[_index + 14], (byte) message[_index + 13]);
                                        _dev.setAddress(BigInteger.valueOf(_groupId));
                                        _index = _index + 10;
                                    }
                                    _b.setClusterID(_cluster);
                                    _b.setSourceEndpoint(_srcEP);
                                    _b.setSourceIEEEAddress(BigInteger.valueOf(src_longAddress));

                                    _b.getDeviceDestination().add(_dev);
                                    _res.getBinding().add(_b);

                                }
                            }
                            pl.set_objectOfResponse(_res);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* APS-DeregisterEndPoint.Confirm */
        else if (_command == FreescaleConstants.APSDeRegisterEndPointConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APS-DeregisterEndPoint.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.DEREGISTER_END_POINT)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* APS-ZDP-Mgmt_Lqi.Response */
        else if (_command == FreescaleConstants.ZDPMgmtLqiResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix(
                        "Extracted ZDP-Mgmt_Lqi.Response... waiting the related Indication ZDO", message);

        }
        /* ZTC-ReadExtAddr.Confirm */
        else if (_command == FreescaleConstants.ZTCReadExtAddrConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZTC-ReadExtAddr.Confirm", message);
            long longAddress = DataManipulation.toLong((byte) message[11], (byte) message[10],
                    (byte) message[9], (byte) message[8], (byte) message[7], (byte) message[6],
                    (byte) message[5], (byte) message[4]);
            BigInteger _bi = BigInteger.valueOf(longAddress);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.READ_EXT_ADDRESS)) {
                        synchronized (pl) {
                            pl.set_objectOfResponse(_bi);
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }

        /* ZDP-IEEE_addr.response */
        else if (_command == FreescaleConstants.ZDPIeeeAddrResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-IEEE_addr.response", message);
            long longAddress = DataManipulation.toLong((byte) message[11], (byte) message[10],
                    (byte) message[9], (byte) message[8], (byte) message[7], (byte) message[6],
                    (byte) message[5], (byte) message[4]);
            BigInteger _bi = BigInteger.valueOf(longAddress);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if ((pl.getType() == TypeMessage.READ_IEEE_ADDRESS)) {
                        synchronized (pl) {
                            pl.set_objectOfResponse(_bi);
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        /* ZDP-Mgmt_Leave.Response */
        else if (_command == FreescaleConstants.ZDPMgmtLeaveResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Leave.Response", message);

        }
        /* ZDP-Active_EP_rsp.response */
        else if (_command == FreescaleConstants.ZDPActiveEpResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Active_EP_rsp.response", message);
            short Status = message[3];
            Address _add = new Address();

            _add.setNetworkAddress(DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]));
            String Key = String.format("%04X", _add.getNetworkAddress());
            List<Short> _toRes = null;

            NodeServices _node = new NodeServices();
            _node.setAddress(_add);

            switch (Status) {
            case 0x00:
                _toRes = new ArrayList<Short>();
                int _EPCount = message[6];

                for (int i = 0; i < _EPCount; i++) {
                    _toRes.add(message[7 + i]);
                    ActiveEndpoints _aep = new ActiveEndpoints();
                    _aep.setEndPoint(message[7 + i]);
                    _node.getActiveEndpoints().add(_aep);

                }
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:00 - Success");
                }
                break;
            case 0x80:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:80 - Inv_RequestType");
                }
                break;
            case 0x89:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:89 - No_Descriptor");
                }
                break;
            case 0x81:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("ZDP-Active_EP_rsp.response status:81 - Device_Not_found");
                }
                break;
            }
            // Found ZDP-Active_EP_rsp.response. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    /* DestAddress */
                    if ((pl.getType() == TypeMessage.ACTIVE_EP) && pl.get_Key().equalsIgnoreCase(Key)) {
                        synchronized (pl) {
                            pl.set_objectOfResponse(_toRes);
                            pl.getStatus().setCode(Status);
                            pl.notify();

                        }
                        break;
                    }
                }
            }

        }

        /* ZDP-StopNwkEx.Confirm */
        else if (_command == FreescaleConstants.ZTCStopNwkExConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-StopNwkEx.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.STOP_NETWORK) {
                        if (message[3] == 0x00) {
                            gal.get_gatewayEventManager().notifyGatewayStopResult(makeStatusObject(
                                    "The stop command has been processed byt ZDO with success.", (short) 0x00));
                            synchronized (gal) {
                                gal.setGatewayStatus(GatewayStatus.GW_STOPPING);
                            }
                        }
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        /* NLME-GET.Confirm */
        else if (_command == FreescaleConstants.NLMEGetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-GET.Confirm", message);
            String _Key = String.format("%02X", message[4]);
            // Found APSDE-DATA.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NMLE_GET && pl.get_Key().equalsIgnoreCase(_Key)) {
                        short _Length = (short) DataManipulation.toIntFromShort((byte) message[9],
                                (byte) message[8]);
                        byte[] _res = DataManipulation.subByteArray(message, 10, _Length + 9);
                        if (_Length >= 2)
                            _res = DataManipulation.reverseBytes(_res);
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.set_objectOfResponse(DataManipulation.convertBytesToString(_res));
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        /* APSME_GET.Confirm */
        else if (_command == FreescaleConstants.APSMEGetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSME_GET.Confirm", message);
            String _Key = String.format("%02X", message[4]);
            // Found APSME_GET-DATA.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.APSME_GET && pl.get_Key().equalsIgnoreCase(_Key)) {
                        short _Length = (short) DataManipulation.toIntFromShort((byte) message[9],
                                (byte) message[8]);
                        byte[] _res = DataManipulation.subByteArray(message, 10, _Length + 9);
                        if (_Length >= 2)
                            _res = DataManipulation.reverseBytes(_res);
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.set_objectOfResponse(DataManipulation.convertBytesToString(_res));
                            pl.notify();
                        }
                        break;
                    }
                }
            }

        }
        // ZDP-StartNwkEx.Confirm
        else if (_command == FreescaleConstants.ZTCStartNwkExConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-StartNwkEx.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.START_NETWORK) {
                        if (message[3] == 0x00) {
                            gal.setGatewayStatus(GatewayStatus.GW_STARTED);
                        }
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* APS-RegisterEndPoint.Confirm */
        else if (_command == FreescaleConstants.APSRegisterEndPointConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APS-RegisterEndPoint.Confirm", message);
            // Found APS-RegisterEndPoint.Confirm. Remove the lock
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CONFIGURE_END_POINT) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* ZTC-ModeSelect.Confirm */
        else if (_command == FreescaleConstants.ZTCModeSelectConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZTC-ModeSelect.Confirm", message);
            short status = message[3];
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.MODE_SELECT) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* MacGetPIBAttribute.Confirm */
        else if (_command == FreescaleConstants.MacGetPIBAttributeConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacGetPIBAttribute.Confirm", message);
        }
        /* MacBeaconNotify.Indication */
        else if (_command == FreescaleConstants.MacBeaconNotifyIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacBeaconNotify.Indication", message);
        }
        /* MacBeaconStart.Indication */
        else if (_command == FreescaleConstants.MacPollNotifyIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacBeaconStart.Indication", message);
        }
        /* NLME-NETWORK-FORMATION.Confirmn */
        else if (_command == FreescaleConstants.NLMENETWORKFORMATIONConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-FORMATION.Confirm", message);
        }
        /* NLME-START-ROUTER.Request */
        else if (_command == FreescaleConstants.NLMESTARTROUTERRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-FORMATION.Confirm", message);
        }
        /* MacStart.Request */
        else if (_command == FreescaleConstants.MacStartRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacStart.Request", message);
        }
        /* MacStart.Confirm */
        else if (_command == FreescaleConstants.MacStartConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacStart.Confirm", message);
        }
        /* NLME-START-ROUTER.Confirm */
        else if (_command == FreescaleConstants.NLMESTARTROUTERConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-START-ROUTER.Confirm", message);
        }
        /* NWK-ProcessSecureFrame.Report */
        else if (_command == FreescaleConstants.NWKProcessSecureFrameReport) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NWK-ProcessSecureFrame.Report", message);
        }
        /* ZDP-Nwk-ProcessSecureFrame.Confirm */
        else if (_command == FreescaleConstants.ZDPNwkProcessSecureFrameConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Nwk-ProcessSecureFrame.Confirm", message);
        }

        /* BlackBox.WriteSAS.Confirm */
        else if (_command == FreescaleConstants.BlackBoxWriteSASConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted BlackBox.WriteSAS.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.WRITE_SAS) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* ZTC-GetChannel.Confirm */
        else if (_command == FreescaleConstants.ZTCGetChannelConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZTC-GetChannel.Confirm", message);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CHANNEL_REQUEST) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);
                            pl.set_objectOfResponse(message[4]);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-NodeDescriptor.Response */
        else if (_command == FreescaleConstants.ZDPNodeDescriptorResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-NodeDescriptor.Response", message);
            int _NWKAddressOfInterest = DataManipulation.toIntFromShort((byte) message[5], (byte) message[4]);
            Address _addressOfInterst = new Address();
            _addressOfInterst.setNetworkAddress(_NWKAddressOfInterest);
            NodeDescriptor _node = new NodeDescriptor();

            /* First Byte */
            byte _first = (byte) message[6];
            byte _Logical_byte = (byte) (_first & 0x07);/* Bits 0,1,2 */
            byte _ComplexDescriptorAvalilable = (byte) ((_first & 0x08) >> 3);/* Bit3 */
            byte _UserDescriptorAvalilable = (byte) ((_first & 0x0A) >> 4);/* Bit4 */
            switch (_Logical_byte) {
            case FreescaleConstants.LogicalType.Coordinator:
                _node.setLogicalType(LogicalType.COORDINATOR);
                break;
            case FreescaleConstants.LogicalType.Router:
                _node.setLogicalType(LogicalType.ROUTER);
                break;
            case FreescaleConstants.LogicalType.EndDevice:
                _node.setLogicalType(LogicalType.END_DEVICE);
                break;
            default:
                throw new Exception("LogicalType is not valid value");
            }
            _node.setComplexDescriptorAvailable((_ComplexDescriptorAvalilable == 1 ? true : false));
            _node.setUserDescriptorAvailable((_UserDescriptorAvalilable == 1 ? true : false));

            /* Second Byte */
            byte _second = (byte) message[7];
            /* Aps flags bits 0,1,2 */
            byte _FrequencyBand = (byte) ((_second & 0xF8) >> 0x03);/*
                                                                    * bits
                                                                    * 3
                                                                    * ,4,5,
                                                                    * 6,7
                                                                    */
            switch (_FrequencyBand) {
            case 0x01:
                _node.setFrequencyBand("868MHz");
                break;
            case 0x04:
                _node.setFrequencyBand("900MHz");
                break;
            case 0x08:
                _node.setFrequencyBand("2400MHz");
                break;
            default:
                _node.setFrequencyBand("Reserved");
                break;
            }

            /* MACcapabilityFlags_BYTE Byte */
            byte _MACcapabilityFlags_BYTE = (byte) message[8];
            MACCapability _maccapability = new MACCapability();
            byte _AlternatePanCoordinator = (byte) (_MACcapabilityFlags_BYTE & 0x01);/* Bit0 */
            byte _DeviceIsFFD = (byte) ((_MACcapabilityFlags_BYTE & 0x02) >> 1);/* Bit1 */
            byte _MainsPowered = (byte) ((_MACcapabilityFlags_BYTE & 0x04) >> 2);/* Bit2 */
            byte _ReceiverOnWhenIdle = (byte) ((_MACcapabilityFlags_BYTE & 0x08) >> 3);/* Bit3 */
            // bit 4-5 reserved
            byte _SecuritySupported = (byte) ((_MACcapabilityFlags_BYTE & 0x40) >> 6);/* Bit6 */
            byte _AllocateAddress = (byte) ((_MACcapabilityFlags_BYTE & 0x80) >> 7);/* Bit7 */
            _maccapability.setAlternatePanCoordinator((_AlternatePanCoordinator == 1 ? true : false));
            _maccapability.setDeviceIsFFD((_DeviceIsFFD == 1 ? true : false));
            _maccapability.setMainsPowered((_MainsPowered == 1 ? true : false));
            _maccapability.setReceiverOnWhenIdle((_ReceiverOnWhenIdle == 1 ? true : false));
            _maccapability.setSecuritySupported((_SecuritySupported == 1 ? true : false));
            _maccapability.setAllocateAddress((_AllocateAddress == 1 ? true : false));
            _node.setMACCapabilityFlag(_maccapability);

            /* ManufacturerCode_BYTES */
            int _ManufacturerCode_BYTES = DataManipulation.toIntFromShort((byte) message[10],
                    (byte) message[9]);
            _node.setManufacturerCode(_ManufacturerCode_BYTES);

            /* MaximumBufferSize_BYTE */
            short _MaximumBufferSize_BYTE = message[11];
            _node.setMaximumBufferSize(_MaximumBufferSize_BYTE);

            /* MaximumTransferSize_BYTES */
            int _MaximumTransferSize_BYTES = DataManipulation.toIntFromShort((byte) message[13],
                    (byte) message[12]);
            _node.setMaximumIncomingTransferSize(_MaximumTransferSize_BYTES);

            /* ServerMask_BYTES */
            int _ServerMask_BYTES = DataManipulation.toIntFromShort((byte) message[15], (byte) message[14]);
            ServerMask _serverMask = new ServerMask();
            byte _PrimaryTrustCenter = (byte) (_ServerMask_BYTES & 0x01);/* Bit0 */
            byte _BackupTrustCenter = (byte) ((_ServerMask_BYTES & 0x02) >> 1);/* Bit1 */
            byte _PrimaryBindingTableCache = (byte) ((_ServerMask_BYTES & 0x04) >> 2);/* Bit2 */
            byte _BackupBindingTableCache = (byte) ((_ServerMask_BYTES & 0x08) >> 3);/* Bit3 */
            byte _PrimaryDiscoveryCache = (byte) ((_ServerMask_BYTES & 0x10) >> 4);/* Bit4 */
            byte _BackupDiscoveryCache = (byte) ((_ServerMask_BYTES & 0x20) >> 5);/* Bit5 */
            _serverMask.setPrimaryTrustCenter((_PrimaryTrustCenter == 1 ? true : false));
            _serverMask.setBackupTrustCenter((_BackupTrustCenter == 1 ? true : false));
            _serverMask.setPrimaryBindingTableCache((_PrimaryBindingTableCache == 1 ? true : false));
            _serverMask.setBackupBindingTableCache((_BackupBindingTableCache == 1 ? true : false));
            _serverMask.setPrimaryDiscoveryCache((_PrimaryDiscoveryCache == 1 ? true : false));
            _serverMask.setBackupDiscoveryCache((_BackupDiscoveryCache == 1 ? true : false));
            _node.setServerMask(_serverMask);

            /* MaximumOutTransferSize_BYTES */
            int _MaximumOutTransferSize_BYTES = DataManipulation.toIntFromShort((byte) message[17],
                    (byte) message[16]);
            _node.setMaximumOutgoingTransferSize(_MaximumOutTransferSize_BYTES);

            /* CapabilityField_BYTES */
            byte _CapabilityField_BYTES = (byte) message[18];
            DescriptorCapability _DescriptorCapability = new DescriptorCapability();
            byte _ExtendedActiveEndpointListAvailable = (byte) (_CapabilityField_BYTES & 0x01);/* Bit0 */
            byte _ExtendedSimpleDescriptorListAvailable = (byte) ((_CapabilityField_BYTES
                    & 0x02) >> 1);/* Bit1 */
            _DescriptorCapability.setExtendedActiveEndpointListAvailable(
                    (_ExtendedActiveEndpointListAvailable == 1 ? true : false));
            _DescriptorCapability.setExtendedSimpleDescriptorListAvailable(
                    (_ExtendedSimpleDescriptorListAvailable == 1 ? true : false));
            _node.setDescriptorCapabilityField(_DescriptorCapability);
            String _key = String.format("%04X", _NWKAddressOfInterest);
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NODE_DESCRIPTOR && pl.get_Key().equalsIgnoreCase(_key)) {
                        synchronized (pl) {
                            pl.getStatus().setCode(message[3]);/* Status */
                            pl.set_objectOfResponse(_node);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* NMLE-SET.Confirm */
        else if (_command == FreescaleConstants.NMLESETConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NMLE-SET.Confirm", message);
            short status = message[3];
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.NMLE_SET) {

                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }
        /* APSME-SET.Confirm */
        else if (_command == FreescaleConstants.APSMESetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted APSME-SET.Confirm", message);
            short status = message[3];
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.APSME_SET) {

                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.notify();
                        }
                        break;
                    }
                }
            }
        }

        /* ZDP-Mgmt_Permit_Join.response */
        else if (_command == FreescaleConstants.ZDPMgmt_Permit_JoinResponse) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted ZDP-Mgmt_Permit_Join.response", message);
            short status = message[3];
            String mess = "";

            switch (status) {
            case 0x00:

                break;
            case 0x80:
                mess = "InvRequestType";
                break;
            case 0x84:
                mess = "Not Supported";
                break;
            case 0x87:
                mess = "Table Full";
                break;
            case 0x8D:
                mess = "NOT AUTHORIZED";
                break;
            case 0xC5:
                mess = "Already present in the network";
                break;

            }
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.PERMIT_JOIN) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.getStatus().setMessage(mess);
                            pl.notify();
                        }
                        break;
                    }
                }

            }
        }

        /* APS-ClearDeviceKeyPairSet.Confirm */
        else if (_command == FreescaleConstants.APSClearDeviceKeyPairSetConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("APS-ClearDeviceKeyPairSet.Confirm", message);
            short status = message[3];
            String mess = "";
            switch (status) {
            case 0x00:

                break;
            }
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CLEAR_DEVICE_KEY_PAIR_SET) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.getStatus().setMessage(mess);
                            pl.notify();
                        }
                        break;
                    }
                }

            }

        }

        /* ZTC-ClearNeighborTableEntry.Confirm */
        else if (_command == FreescaleConstants.ZTCClearNeighborTableEntryConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("ZTC-ClearNeighborTableEntry.Confirm", message);
            short status = message[3];
            String mess = "";
            switch (status) {
            case 0x00:

                break;
            }
            synchronized (listLocker) {
                for (ParserLocker pl : listLocker) {
                    if (pl.getType() == TypeMessage.CLEAR_NEIGHBOR_TABLE_ENTRY) {
                        synchronized (pl) {
                            pl.getStatus().setCode(status);
                            pl.getStatus().setMessage(mess);
                            pl.notify();
                        }
                        break;
                    }
                }

            }

        }

        /* NLME-JOIN.Confirm */
        else if (_command == FreescaleConstants.NLMEJOINConfirm) {
            short _status = message[8];
            switch (_status) {
            case 0x00:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: SUCCESS (Joined the network)");
                }
                break;
            case 0xC2:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: INVALID_REQUEST (Not Valid Request)");
                }
                break;
            case 0xC3:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NOT_PERMITTED (Not allowed to join the network)");
                }
                break;
            case 0xCA:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NO_NETWORKS (Network not found)");
                }
                break;
            case 0x01:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: PAN_AT_CAPACITY (PAN at capacity)");
                }
                break;
            case 0x02:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: PAN_ACCESS_DENIED (PAN access denied)");
                }
                break;
            case 0xE1:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: CHANNEL_ACCESS_FAILURE (Transmission failed due to activity on the channel)");
                }
                break;
            case 0xE4:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: FAILED_SECURITY_CHECK (The received frame failed security check)");
                }
                break;
            case 0xE8:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: INVALID_PARAMETER (A parameter in the primitive is out of the valid range)");
                }
                break;
            case 0xE9:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NO_ACK (Acknowledgement was not received)");
                }
                break;
            case 0xEB:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: NO_DATA (No response data was available following a request)");
                }
                break;
            case 0xF3:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted NLME-JOIN.Confirm: UNAVAILABLE_KEY (The appropriate key is not available in the ACL)");
                }
                break;
            case 0xEA:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted NLME-JOIN.Confirm: NO_BEACON (No Networks)");
                }
                break;
            default:
                throw new Exception("Extracted NLME-JOIN.Confirm: Invalid Status - " + _status);
            }
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("NLME-JOIN.Confirm", message);
        }

        /* ZDO-NetworkState.Event */
        else if (_command == FreescaleConstants.ZDONetworkStateEvent) {
            short _status = message[3];
            String mess;
            switch (_status) {
            case 0x00:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info("Extracted ZDO-NetworkState.Event: DeviceInitialized (Device Initialized)");
                }
                break;
            case 0x01:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinNetworkDiscoveryState (Device in Network Discovery State)");
                }
                break;
            case 0x02:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceJoinNetworkstate (Device Join Network state)");
                }
                break;
            case 0x03:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinCoordinatorstartingstate (Device in Coordinator starting state)");
                }
                gal.setGatewayStatus(GatewayStatus.GW_STARTING);
                break;
            case 0x04:
                mess = "ZDO-NetworkState.Event: DeviceinRouterRunningstate (Device in Router Running state)";
                gal.get_gatewayEventManager().notifyGatewayStartResult(makeStatusObject(mess, _status));
                gal.setGatewayStatus(GatewayStatus.GW_RUNNING);
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(mess);
                }
                break;
            case 0x05:
                mess = "ZDO-NetworkState.Event: DeviceinEndDeviceRunningstate (Device in End Device Running state)";
                gal.get_gatewayEventManager().notifyGatewayStartResult(makeStatusObject(mess, _status));
                gal.setGatewayStatus(GatewayStatus.GW_RUNNING);

                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(mess);
                }
                break;
            case 0x09:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinleavenetworkstate (Device in leave network state)");
                }

                gal.setGatewayStatus(GatewayStatus.GW_STOPPING);
                break;
            case 0x0A:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinauthenticationstate (Device in authentication state)");
                }
                break;
            case 0x0B:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinstoppedstate (Device in stopped state)");
                }
                gal.setGatewayStatus(GatewayStatus.GW_STOPPED);

                break;
            case 0x0C:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinOrphanjoinstate (Device in Orphan join state)");
                }
                break;
            case 0x10:
                mess = "ZDO-NetworkState.Event: DeviceinCoordinatorRunningstate (Device is Coordinator Running state)";

                gal.get_gatewayEventManager().notifyGatewayStartResult(makeStatusObject(mess, _status));
                gal.setGatewayStatus(GatewayStatus.GW_RUNNING);
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(mess);
                }
                break;
            case 0x11:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceinKeytransferstate (Device in Key transfer state)");
                }
                break;
            case 0x12:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: Deviceinauthenticationstate (Device in authentication state)");
                }
                break;
            case 0x13:
                if (gal.getPropertiesManager().getDebugEnabled()) {
                    logger.info(
                            "Extracted ZDO-NetworkState.Event: DeviceOfftheNetwork (Device Off the Network)");
                }
                break;
            default:
                throw new Exception("ZDO-NetworkState.Event: Invalid Status - " + _status);
            }
        }
        /* MacSetPIBAttribute.Confirm */
        else if (_command == FreescaleConstants.MacSetPIBAttributeConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacSetPIBAttribute.Confirm", message);
        }
        /* NLME-ENERGY-SCAN.Request */
        else if (_command == FreescaleConstants.NLMEENERGYSCANRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-ENERGY-SCAN.Request", message);
        }
        /* MacScan.Request */
        else if (_command == FreescaleConstants.MacScanRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacScan.Request", message);
        }
        /* MacScan.Confirm */
        else if (_command == FreescaleConstants.MacScanConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacScan.Confirm", message);
        }
        /* NLME-ENERGY-SCAN.confirm */
        else if (_command == FreescaleConstants.NLMEENERGYSCANconfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-ENERGY-SCAN.confirm", message);
        }
        /* NLME-NETWORK-DISCOVERY.Request */
        else if (_command == FreescaleConstants.NLMENETWORKDISCOVERYRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-DISCOVERY.Request", message);
        }
        /* MacScan.Request */
        else if (_command == FreescaleConstants.MacScanRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted MacScan.Request", message);
        }
        /* NLME-NETWORK-DISCOVERY.Confirm */
        else if (_command == FreescaleConstants.NLMENetworkDiscoveryConfirm) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-DISCOVERY.Confirm", message);
        }
        /* NLME-NETWORK-FORMATION.Request */
        else if (_command == FreescaleConstants.NLMENETWORKFORMATIONRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-NETWORK-FORMATION.Request", message);
        }
        /* NLME-SET.Request */
        else if (_command == FreescaleConstants.NLMESetRequest) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted NLME-SET.Request", message);
        }
        /* NLME-NWK-STATUS.Indication */
        else if (_command == FreescaleConstants.NLMENwkStatusIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("NLME-NWK-STATUS.Indication", message);
        }
        /* NLME-ROUTE-DISCOVERY.confirm */
        else if (_command == FreescaleConstants.NLMENWKSTATUSIndication) {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("NLME-ROUTE-DISCOVERY.confirm", message);
        } else {
            if (gal.getPropertiesManager().getDebugEnabled())
                DataManipulation.logArrayHexRadix("Extracted a Message not in Message Management", message);
        }

        synchronized (this) {
            _size = messages.size();
        }
    }

}

From source file:ca.oson.json.Oson.java

private String bigInteger2JsonDefault(FieldData objectDTO) {
    BigInteger valueToReturn = json2BigIntegerDefault(objectDTO);

    if (valueToReturn == null) {
        return null;
    }//from   w  w  w. ja v  a  2  s.  c  om

    return valueToReturn.toString();
}