--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javaextensions/bluetooth/bluetoothcommons/src.s60/bturlparams.cpp Mon May 03 12:27:20 2010 +0300
@@ -0,0 +1,491 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include <cctype> // tolower
+#include <locale>
+
+#include "logger.h"
+#include "bturlparams.h"
+#include "javacommonutils.h"
+#include "s60commonutils.h"
+#include "exceptionbase.h"
+#include "bluetoothconsts.h"
+
+using namespace std;
+using namespace java::util;
+using namespace java::bluetooth;
+
+OS_EXPORT BtUrlParams::BtUrlParams(std::wstring aUrl, std::wstring aFilter) :
+ mMaster(false), mAuthorize(false), mAuthenticate(false), mEncrypt(false),
+ mTransmitMtu(0), mReceiveMtu(0),mUrl(aUrl),mFilter(aFilter)
+{
+ JELOG2(EJavaBluetooth);
+
+ if (!mUrl.empty())
+ {
+ extractUrlParams(mUrl);
+ }
+
+ if (!mFilter.empty())
+ {
+ extractFilterParams(mFilter);
+ }
+}
+
+BtUrlParams::BtUrlParams()
+{
+}
+
+OS_EXPORT BtUrlParams::~BtUrlParams()
+{
+ std::list<HBufC*>::const_iterator it;
+ for (it = mBlockedSenders.begin(); it != mBlockedSenders.end(); it++)
+ {
+ delete *it;
+ }
+}
+
+OS_EXPORT std::wstring BtUrlParams::getProtocol()
+{
+ return mProtocol;
+}
+
+OS_EXPORT std::wstring BtUrlParams::getServiceUuid()
+{
+ return validLongUuid(mServiceUuid);
+}
+
+OS_EXPORT std::wstring BtUrlParams::getParamName()
+{
+ return mName;
+}
+
+OS_EXPORT bool BtUrlParams::getParamMaster()
+{
+ return mMaster;
+}
+
+OS_EXPORT bool BtUrlParams::getParamAuthorize()
+{
+ return mAuthorize;
+}
+
+OS_EXPORT bool BtUrlParams::getParamAuthenticate()
+{
+ return mAuthenticate;
+}
+
+OS_EXPORT bool BtUrlParams::getParamEncrypt()
+{
+ return mEncrypt;
+}
+
+OS_EXPORT int BtUrlParams::getParamReceiveMtu()
+{
+ return mReceiveMtu;
+}
+
+OS_EXPORT int BtUrlParams::getParamTransmitMtu()
+{
+ return mTransmitMtu;
+}
+
+std::wstring BtUrlParams::validLongUuid(std::wstring &aStr)
+{
+ int length = aStr.length();
+ std::wstring validUuid(aStr);
+
+ // Only if it is shorter than 8 bytes,
+ // Then it will be added with the SHORT_BASE_UUID_STRING
+ // Otherwise simply prepend zeros to the given uuid.
+ if (length < 8)
+ {
+ std::wstring zeros = L"00000000";
+ validUuid = zeros.substr(length);
+ validUuid += aStr;
+ validUuid += SHORT_UUID_BASE_STRING;
+ }
+ else if (length < 32)
+ {
+ std::wstring zeros=L"00000000000000000000000000000000";
+ validUuid = zeros.substr(length);
+ validUuid += aStr;
+ }
+ return validUuid;
+}
+
+std::wstring &BtUrlParams::ToLower(std::wstring &aStr)
+{
+ JELOG2(EJavaBluetooth);
+ for (size_t i = 0; i < aStr.length(); ++i)
+ aStr[i] = std::tolower(aStr[i]);
+ return aStr;
+}
+
+/**
+ * extractUrlParams: Function to extract parameters from Server URL
+ */
+
+void BtUrlParams::extractUrlParams(std::wstring aUrl)
+{
+ JELOG2(EJavaBluetooth);
+ LOG1(EJavaBluetooth, EInfo, "+ BtUrlParams::extractUrlParams %S",
+ aUrl.c_str());
+
+ int index = std::string::npos;
+
+ // Extracting protocol
+ index = aUrl.find(PROTOCOL_SEPERATOR);
+
+ if (std::string::npos != index)
+ {
+ mProtocol = aUrl.substr(0, index);
+ aUrl = aUrl.substr(index + wcslen(PROTOCOL_SEPERATOR));
+ LOG1(EJavaBluetooth, EInfo,
+ " BtUrlParams::extractUrlParams Protocol=%S",
+ mProtocol.c_str());
+ }
+
+ std::wstring tempUrl = aUrl.substr(0, wcslen(LOCALHOST));
+ if (0 == ToLower(tempUrl).compare(LOCALHOST))
+ {
+ aUrl = aUrl.substr(wcslen(LOCALHOST));
+ }
+
+ LOG1(EJavaBluetooth, EInfo, " BtUrlParams::extractUrlParams url=%S",
+ aUrl.c_str());
+
+ // Extracting Service UUID
+ index = aUrl.find(SEMICOLON);
+ if (std::string::npos != index)
+ {
+ mServiceUuid = aUrl.substr(0, index);
+ aUrl = aUrl.substr(index);
+ }
+ else
+ {
+ mServiceUuid = aUrl;
+ }
+
+ if (aUrl.length() <= 1)
+ {
+ return;
+ }
+
+ // Extracting other parameters
+ index = aUrl.find(SEMICOLON, 1);
+
+ int eqLength = wcslen(EQUAL);
+ while (std::string::npos != index)
+ {
+ int eqIndex = std::string::npos;
+
+ eqIndex = aUrl.find(EQUAL);
+ if (std::string::npos != eqIndex && eqIndex < index)
+ {
+ setUrlParamsValue(aUrl.substr(0, eqIndex + eqLength),
+ aUrl.substr(eqIndex + eqLength, index - (eqIndex
+ + eqLength)));
+ }
+ else
+ { // Actually erroneous URL !!
+ break;
+ }
+ aUrl = aUrl.substr(index);
+ LOG1(EJavaBluetooth, EInfo,
+ " BtUrlParams::extractUrlParams In while: %S", aUrl.c_str());
+
+ if (aUrl.length() <= 1)
+ {
+ break;
+ }
+ index = aUrl.find(SEMICOLON, 1);
+ }
+
+ // Extracting last parameter: In case URL is not ended with ";"
+ if (!aUrl.empty())
+ {
+ LOG1(EJavaBluetooth, EInfo,
+ " BtUrlParams::extractUrlParams After while loop: %S",
+ aUrl.c_str());
+ int eqIndex = std::string::npos;
+
+ eqIndex = aUrl.find(EQUAL);
+ if (std::string::npos != eqIndex)
+ {
+ setUrlParamsValue(aUrl.substr(0, eqIndex + eqLength),
+ aUrl.substr(eqIndex + eqLength, index - (eqIndex
+ + eqLength)));
+ }
+ }
+}
+
+void BtUrlParams::setUrlParamsValue(std::wstring aParam, std::wstring aVal)
+{
+ JELOG2(EJavaBluetooth);
+ LOG2(EJavaBluetooth, EInfo,
+ "+ BtUrlParams::setUrlParamsValue Param:%S Val:%S", aParam.c_str(),
+ aVal.c_str());
+ ToLower(aParam);
+ if (0 == aParam.compare(URL_PARAM_AUTHENTICATE))
+ {
+ mAuthenticate = ToLower(aVal).compare(L"false");
+ }
+ else if (0 == aParam.compare(URL_PARAM_AUTHORIZE))
+ {
+ mAuthorize = ToLower(aVal).compare(L"false");
+ }
+ else if (0 == aParam.compare(URL_PARAM_ENCRYPT))
+ {
+ mEncrypt = ToLower(aVal).compare(L"false");
+ }
+ else if (0 == aParam.compare(URL_PARAM_MASTER))
+ {
+ mMaster = ToLower(aVal).compare(L"false");
+ }
+ else if (0 == aParam.compare(URL_PARAM_NAME))
+ {
+ mName = aVal;
+ }
+ else if (0 == aParam.compare(URL_PARAM_RECEIVE_MTU))
+ {
+ try
+ {
+ LOG2(EJavaBluetooth, EInfo,
+ "+ BtUrlParams::setUrlParamsValue URL_PARAM_RECEIVE_MTU:%S Val:%S",
+ aParam.c_str(), aVal.c_str());
+ mReceiveMtu = JavaCommonUtils::wstringToInt(aVal);
+ }
+ catch (ExceptionBase ex)
+ {
+ ELOG1(EJavaBluetooth,
+ "- ServiceRecord::setUrlParamsValue URL_PARAM_RECEIVE_MTU exception Caught: %S",
+ ex.toString().c_str());
+ }
+ }
+ else if (0 == aParam.compare(URL_PARAM_TRANSMIT_MTU))
+ {
+ try
+ {
+ LOG2(EJavaBluetooth, EInfo,
+ "+ BtUrlParams::setUrlParamsValue URL_PARAM_TRANSMIT_MTU:%S Val:%S",
+ aParam.c_str(), aVal.c_str());
+ mTransmitMtu = JavaCommonUtils::wstringToInt(aVal);
+ }
+ catch (ExceptionBase ex)
+ {
+ ELOG1(EJavaBluetooth,
+ "- ServiceRecord::setUrlParamsValue URL_PARAM_TRANSMIT_MTU exception Caught: %S",
+ ex.toString().c_str());
+ }
+ }
+ else
+ {
+ // Nothing to do
+ }
+}
+
+/**
+ * extractUrlParams: Function to extract parameters from Push Filter
+ */
+
+void BtUrlParams::extractFilterParams(std::wstring aFilter)
+{
+ JELOG2(EJavaBluetooth);
+ LOG1(EJavaBluetooth, EInfo, "+ BtUrlParams::extractFilterParams %S",
+ aFilter.c_str());
+ int index = std::string::npos;
+
+ // Extracting black list items (if any)
+ index = aFilter.find(FILTER_PARAM_BLACKLIST);
+
+ if (std::string::npos != index)
+ {
+ fillBlackList(aFilter.substr(index + wcslen(FILTER_PARAM_BLACKLIST)));
+ aFilter = aFilter.substr(0, index);
+ }
+
+ LOG2(EJavaBluetooth, EInfo,
+ "+ BtUrlParams::extractFilterParams Allowed List:(%d)%S", index,
+ aFilter.c_str());
+
+ // Extracting Allowed list
+ index = aFilter.find(SEMICOLON);
+ LOG2(EJavaBluetooth, EInfo,
+ "+ BtUrlParams::extractFilterParams Allowed List \";\" (%d)%S",
+ index, aFilter.c_str());
+
+ if (std::string::npos != index)
+ {
+ mAllowedSenders.mPattern = aFilter.substr(0, index - wcslen(SEMICOLON));
+ LOG1(EJavaBluetooth, EInfo,
+ " BtUrlParams::extractFilterParams AllowedSender Pattern:%S",
+ mAllowedSenders.mPattern.c_str());
+ }
+ else
+ {
+ mAllowedSenders.mPattern = aFilter;
+ LOG1(EJavaBluetooth, EInfo,
+ " BtUrlParams::extractFilterParams AllowedSender Pattern:%S",
+ mAllowedSenders.mPattern.c_str());
+ }
+
+ // Extracting Authenticated
+ index = aFilter.find(FILTER_PARAM_AUTHENTICATED);
+ LOG2(
+ EJavaBluetooth,
+ EInfo,
+ "+ BtUrlParams::extractFilterParams Allowed List \"authenticated\" (%d)%S",
+ index, aFilter.c_str());
+ if (std::string::npos != index)
+ {
+ mAllowedSenders.mAuthenticated = true;
+ LOG(EJavaBluetooth, EInfo,
+ " BtUrlParams::extractFilterParams Authenticated");
+ }
+ else
+ {
+ mAllowedSenders.mAuthenticated = false;
+ }
+
+ // Extracting Authorized
+ index = aFilter.find(FILTER_PARAM_AUTHORIZED);
+ LOG2(
+ EJavaBluetooth,
+ EInfo,
+ "+ BtUrlParams::extractFilterParams Allowed List \"authorized\" (%d)%S",
+ index, aFilter.c_str());
+ if (std::string::npos != index)
+ {
+ mAllowedSenders.mAuthorized = true;
+ LOG(EJavaBluetooth, EInfo,
+ " BtUrlParams::extractFilterParams Authorized");
+ }
+ else
+ {
+ mAllowedSenders.mAuthorized = false;
+ }
+}
+
+void BtUrlParams::fillBlackList(std::wstring aBlackList)
+{
+ JELOG2(EJavaBluetooth);
+ int index = std::string::npos;
+
+ index = aBlackList.find(SEMICOLON);
+
+ while (std::string::npos != index)
+ {
+ std::wstring pattern;
+
+ pattern = aBlackList.substr(0, index - wcslen(SEMICOLON));
+ aBlackList = aBlackList.substr(index + wcslen(SEMICOLON));
+ LOG1(EJavaBluetooth, EInfo,
+ " BtUrlParams::fillBlackList Adding Pattern:%S",
+ pattern.c_str());
+ try
+ {
+ HBufC *blackPattern = S60CommonUtils::wstringToDes(
+ pattern.c_str());
+ mBlockedSenders.push_back(blackPattern);
+ index = aBlackList.find(SEMICOLON);
+ }
+ catch (ExceptionBase ex)
+ {
+ // Nothing to handle here.
+ }
+ }
+
+ // Extracting last parameter: In case URL is not ended with ";"
+ if (!aBlackList.empty())
+ {
+ LOG1(EJavaBluetooth, EInfo,
+ " BtUrlParams::fillBlackList Adding Last Pattern:%S",
+ aBlackList.c_str());
+ try
+ {
+ HBufC *blackPattern = S60CommonUtils::wstringToDes(
+ aBlackList.c_str());
+ mBlockedSenders.push_back(blackPattern);
+ }
+ catch (ExceptionBase ex)
+ {
+ // Nothing to handle here.
+ }
+ }
+}
+
+OS_EXPORT bool BtUrlParams::isAllowedSender(HBufC& aDevAddr, bool &aAuthorized,
+ bool &aAuthenticated)
+{
+ JELOG2(EJavaBluetooth);
+ int matchFlag = false;
+
+ LOG2(EJavaBluetooth, EInfo,
+ " BtUrlParams::isAllowedSender Device:%S Pattern:%S",
+ aDevAddr.Des().PtrZ(), mAllowedSenders.mPattern.c_str());
+
+ matchFlag = matchWS(aDevAddr, mAllowedSenders.mPattern);
+
+ if (matchFlag == true)
+ {
+ aAuthorized = mAllowedSenders.mAuthorized;
+ aAuthenticated = mAllowedSenders.mAuthenticated;
+ }
+ return matchFlag;
+}
+
+OS_EXPORT bool BtUrlParams::isBlockedSender(HBufC& aDevAddr)
+{
+ JELOG2(EJavaBluetooth);
+ int matchFlag = false;
+ std::list<HBufC*>::const_iterator cii;
+
+ for (cii = mBlockedSenders.end(); cii != mBlockedSenders.begin();)
+ {
+ if (matchHB(aDevAddr, **(--cii)))
+ return true;
+ }
+ return matchFlag;
+}
+
+bool BtUrlParams::matchWS(HBufC& aDevAddr, std::wstring aPattern)
+{
+ JELOG2(EJavaBluetooth);
+ HBufC *pattern;
+ try
+ {
+ pattern = S60CommonUtils::wstringToDes(aPattern.c_str());
+ }
+ catch (ExceptionBase ex)
+ {
+ return true;
+ }
+
+ bool ret = matchHB(aDevAddr, *pattern);
+ delete pattern;
+ return ret;
+}
+
+bool BtUrlParams::matchHB(HBufC &aDevAddr, HBufC &aPattern)
+{
+ JELOG2(EJavaBluetooth);
+
+ if (aDevAddr.MatchF(aPattern) >= 0)
+ return true;
+ return false;
+}