Boolean IconPackHelper::IsComposedIconComponent(
/* [in] */ const String& tag)
{
return tag.EqualsIgnoreCase(ICON_MASK_TAG) ||
tag.EqualsIgnoreCase(ICON_BACK_TAG) ||
tag.EqualsIgnoreCase(ICON_UPON_TAG);
}
ECode CHttpAuthHeader::ParseScheme(
/* [in] */ const String& header,
/* [out] */ String* scheme)
{
if (header != NULL) {
Int32 i = header.IndexOf(' ');
if (i >= 0) {
String localScheme = header.Substring(0, i).Trim();
if (localScheme.EqualsIgnoreCase(DIGEST_TOKEN)) {
mScheme = DIGEST;
// md5 is the default algorithm!!!
mAlgorithm = String("md5");
} else {
if (localScheme.EqualsIgnoreCase(BASIC_TOKEN)) {
mScheme = BASIC;
}
}
*scheme = header.Substring(i + 1);
}
}
*scheme = String(NULL);
return NOERROR;
}
ECode CHttpAuthHeader::ParseParameter(
/* [in] */ const String& token,
/* [in] */ const String& value)
{
if (token != NULL && value != NULL) {
if (token.EqualsIgnoreCase(NONCE_TOKEN)) {
mNonce = value;
return NOERROR;
}
if (token.EqualsIgnoreCase(STALE_TOKEN)) {
ParseStale(value);
return NOERROR;
}
if (token.EqualsIgnoreCase(OPAQUE_TOKEN)) {
mOpaque = value;
return NOERROR;
}
if (token.EqualsIgnoreCase(QOP_TOKEN)) {
mQop = value.ToLowerCase();
return NOERROR;
}
if (token.EqualsIgnoreCase(ALGORITHM_TOKEN)) {
mAlgorithm = value.ToLowerCase();
return NOERROR;
}
}
return NOERROR;
}
ECode CJDBCResultSetMetaData::FindColByName(
/* [in] */ const String& columnName,
/* [out] */ Int32 * value)
{
String c = String(NULL);
if (r != NULL && ((CJDBCResultSet *)r.Get())->tr != NULL) {
for (Int32 i = 0; i < ((CJDBCResultSet *)r.Get())->tr->mNcolumns; i++) {
c = (*((CJDBCResultSet *)r.Get())->tr->mColumn)[i];
if (c != NULL) {
if (c.EqualsIgnoreCase(columnName) == 0) {
*value = i + 1;
} else {
Int32 k = c.IndexOf('.');
if (k > 0) {
c = c.Substring(k + 1);
if (c.EqualsIgnoreCase(columnName) == 0) {
*value = i + 1;
}
}
}
}
}
} else {
return E_SQL_EXCEPTION;
}
return NOERROR;
}
Boolean CMediaHTTPConnection::IsLocalHost(
/* [in] */ IURL* url)
{
if (url == NULL) {
return FALSE;
}
String host;
url->GetHost(&host);
if (host == NULL) {
return FALSE;
}
// try {
if (host.EqualsIgnoreCase("localhost")) {
return TRUE;
}
AutoPtr<IInetAddress> addr;
NetworkUtils::NumericToInetAddress(host, (IInetAddress**)&addr);
Boolean b;
if ((addr->IsLoopbackAddress(&b), b)) {
return TRUE;
}
// } catch (IllegalArgumentException iex) {
// }
return FALSE;
}
ECode BasicHeaderElement::GetParameterByName(
/* [in] */ const String& name,
/* [out] */ INameValuePair** parameter)
{
VALIDATE_NOT_NULL(parameter)
*parameter = NULL;
if (name.IsNull()) {
Logger::E("BasicHeaderElement", "Name may not be null");
return E_ILLEGAL_ARGUMENT_EXCEPTION;
}
AutoPtr<INameValuePair> found;
Int32 len;
mParameters->GetLength(&len);
for (Int32 i = 0; i < len; i++) {
AutoPtr<IInterface> value;
mParameters->Get(i, (IInterface**)&value);
AutoPtr<INameValuePair> current = INameValuePair::Probe(value);
String n;
current->GetName(&n);
if (n.EqualsIgnoreCase(name)) {
found = current;
break;
}
}
*parameter = found;
REFCOUNT_ADD(*parameter)
return NOERROR;
}
ECode ProfileManagerService::NotificationGroupExistsByName(
/* [in] */ const String& notificationGroupName,
/* [out] */ Boolean* result)
{
VALIDATE_NOT_NULL(result);
AutoPtr<ICollection> values;
mGroups->GetValues((ICollection**)&values);
AutoPtr<IIterator> it;
values->GetIterator((IIterator**)&it);
Boolean bHasNxt = FALSE;
while ((it->HasNext(&bHasNxt), bHasNxt)) {
AutoPtr<IInterface> p;
it->GetNext((IInterface**)&p);
AutoPtr<INotificationGroup> group = INotificationGroup::Probe(p);
String name;
group->GetName(&name);
if (name.EqualsIgnoreCase(notificationGroupName)) {
*result = TRUE;
return NOERROR;
}
it = IIterator::Probe(p);
}
*result = FALSE;
return NOERROR;
}
ECode ProfileManagerService::ProfileExistsByName(
/* [in] */ const String& profileName,
/* [out] */ Boolean* result)
{
VALIDATE_NOT_NULL(result);
AutoPtr<ISet> entrySet;
mProfileNames->GetEntrySet((ISet**)&entrySet);
AutoPtr<IIterator> it;
entrySet->GetIterator((IIterator**)&it);
Boolean bHasNxt = FALSE;
while ((it->HasNext(&bHasNxt), bHasNxt)) {
AutoPtr<IInterface> p;
it->GetNext((IInterface**)&p);
AutoPtr<IMapEntry> entry = IMapEntry::Probe(p);
AutoPtr<IInterface> k;
entry->GetKey((IInterface**)&k);
AutoPtr<ICharSequence> cs = ICharSequence::Probe(k);
String str;
cs->ToString(&str);
if (str.EqualsIgnoreCase(profileName)) {
*result = TRUE;
return NOERROR;
}
}
*result = FALSE;
return NOERROR;
}
ECode CHttpAuthHeader::ParseParameter(
/* [in] */ const String& parameter)
{
if (parameter != NULL) {
// here, we are looking for the 1st occurence of '=' only!!!
Int32 i = parameter.IndexOf('=');
if (i >= 0) {
String token = parameter.Substring(0, i).Trim();
String value =
TrimDoubleQuotesIfAny(parameter.Substring(i + 1).Trim());
if (HttpLog::LOGV) {
HttpLog::V(String("HttpAuthHeader.parseParameter(): token: ") + token
+ String(" value: ") + value);
}
if (token.EqualsIgnoreCase(REALM_TOKEN)) {
mRealm = value;
} else {
if (mScheme == DIGEST) {
ParseParameter(token, value);
}
}
}
}
return NOERROR;
}
Boolean IconPackHelper::ParseComposedIconComponent(
/* [in] */ IXmlPullParser* parser,
/* [in] */ IMap* iconPackResources)
{
String icon;
String tag;
parser->GetName(&tag);
if (!IsComposedIconComponent(tag)) {
return FALSE;
}
Int32 count;
if (parser->GetAttributeCount(&count), count >= 1) {
if (tag.EqualsIgnoreCase(ICON_BACK_TAG)) {
parser->GetAttributeCount(&mIconBackCount);
for (Int32 i = 0; i < mIconBackCount; i++) {
tag = "";
tag.AppendFormat(ICON_BACK_FORMAT.string(), i);
parser->GetAttributeValue(i, &icon);
AutoPtr<IComponentName> component;
CComponentName::New(tag, String(""), (IComponentName**)&component);
iconPackResources->Put(component, CoreUtils::Convert(icon));
}
}
else {
parser->GetAttributeValue(0, &icon);
AutoPtr<IComponentName> component;
CComponentName::New(tag, String(""), (IComponentName**)&component);
iconPackResources->Put(component, CoreUtils::Convert(icon));
}
return TRUE;
}
return FALSE;
}
Boolean CInstrumentationTestRunner::GetBooleanArgument(
/* [in] */ IBundle* arguments,
/* [in] */ const String& tag)
{
String tagString;
arguments->GetString(tag, &tagString);
return !tagString.IsNull() && tagString.EqualsIgnoreCase("TRUE");
}
ECode CHttpAuthHeader::ParseStale(
/* [in] */ const String& value)
{
if (value != NULL) {
if (value.EqualsIgnoreCase("true")) {
mStale = true;
}
}
return NOERROR;
}
Boolean Provider::CheckAttribute(
/* [in] */ const String& servAlg,
/* [in] */ const String& attribute,
/* [in] */ const String& val)
{
String attributeValue = GetPropertyIgnoreCase(servAlg + String(" ") + attribute);
if (!attributeValue.IsNull()) {
if (attribute.EqualsIgnoreCase("KeySize")) {
if (StringUtils::ParseInt32(attributeValue) >= StringUtils::ParseInt32(val)) {
return TRUE;
}
}
else { // other attributes
if (attributeValue.EqualsIgnoreCase(val)) {
return TRUE;
}
}
}
return FALSE;
}
ECode Provider::GetService(
/* [in] */ const String& type,
/* [in] */ const String& algorithm,
/* [out] */ IProviderService** service)
{
VALIDATE_NOT_NULL(service);
*service = NULL;
AutoLock lock(this);
if (type.IsNull()) {
Logger::E("Provider", "type == null");
return E_NULL_POINTER_EXCEPTION;
}
else if (algorithm.IsNull()) {
Logger::E("Provider", "algorithm == null");
return E_NULL_POINTER_EXCEPTION;
}
if (type.Equals(mLastServiceName) && algorithm.EqualsIgnoreCase(mLastAlgorithm)) {
*service = mReturnedService;
return NOERROR;
}
String key = Key(type, algorithm);
AutoPtr<ICharSequence> keyObj;
CString::New(key, (ICharSequence**)&keyObj);
AutoPtr<IInterface> o;
if (mServiceTable != NULL) {
mServiceTable->Get(keyObj, (IInterface**)&o);
}
if (o == NULL && mAliasTable != NULL) {
mAliasTable->Get(keyObj, (IInterface**)&o);
}
if (o == NULL) {
UpdatePropertyServiceTable();
}
if (o == NULL && mPropertyServiceTable != NULL) {
mPropertyServiceTable->Get(keyObj, (IInterface**)&o);
}
if (o == NULL && mPropertyAliasTable != NULL) {
mPropertyAliasTable->Get(keyObj, (IInterface**)&o);
}
if (o != NULL) {
mLastServiceName = type;
mLastAlgorithm = algorithm;
mReturnedService = IProviderService::Probe(o);
*service = mReturnedService;
REFCOUNT_ADD(*service);
return NOERROR;
}
*service = NULL;
return NOERROR;
}
Xml::Encoding Xml::FindEncodingByName(
/* [in] */ const String& encodingName)
{
if (encodingName.IsNull()) {
return Encoding::UTF_8;
}
if (encodingName.EqualsIgnoreCase(Encoding::US_ASCII.mExpatName)) {
return Encoding::US_ASCII;
}
else if (encodingName.EqualsIgnoreCase(Encoding::UTF_8.mExpatName)) {
return Encoding::UTF_8;
}
else if (encodingName.EqualsIgnoreCase(Encoding::UTF_16.mExpatName)) {
return Encoding::UTF_16;
}
else if (encodingName.EqualsIgnoreCase(Encoding::ISO_8859_1.mExpatName)) {
return Encoding::ISO_8859_1;
}
assert(0 && "UnsupportedEncodingException");
return Encoding::UTF_8;
}
Boolean Request::CanResponseHaveBody(
/* [in] */ IHttpRequest* request,
/* [in] */ Int32 status)
{
AutoPtr<IRequestLine> line;
request->GetRequestLine((IRequestLine**)&line);
String str;
line->GetMethod(&str);
if (str.EqualsIgnoreCase("HEAD")) {
return FALSE;
}
return status >= IHttpStatus::SC_OK
&& status != IHttpStatus::SC_NO_CONTENT
&& status != IHttpStatus::SC_NOT_MODIFIED;
}
Boolean Proxy::IsLocalHost(
/* [in] */ const String& host)
{
if (host.IsNull()) {
return FALSE;
}
if (!(host.IsNull())) {
if (host.EqualsIgnoreCase("localhost")) {
return TRUE;
}
AutoPtr<IInetAddress> address;
NetworkUtils::NumericToInetAddress(host, (IInetAddress**)&address);
Boolean isLoopback;
address->IsLoopbackAddress(&isLoopback);
if (isLoopback == TRUE) {
return TRUE;
}
}
return FALSE;
}
String Provider::GetPropertyIgnoreCase(
/* [in] */ const String& key)
{
String res;
GetProperty(key, &res);
if (!res.IsNull()) {
return res;
}
AutoPtr<IEnumeration> names;
PropertyNames((IEnumeration**)&names);
Boolean hasMore;
while (names->HasMoreElements(&hasMore), hasMore) {
AutoPtr<IInterface> nameObj;
names->GetNextElement((IInterface**)&nameObj);
String propertyName;
ICharSequence::Probe(nameObj)->ToString(&propertyName);
if (key.EqualsIgnoreCase(propertyName)) {
GetProperty(propertyName, &res);
return res;
}
}
return String(NULL);
}
ECode IconPackHelper::LoadResourcesFromXmlParser(
/* [in] */ IXmlPullParser* parser,
/* [in] */ IMap* iconPackResources)
{
mIconBackCount = 0;
Int32 eventType;
parser->GetEventType(&eventType);
do {
if (eventType != IXmlPullParser::START_TAG) {
continue;
}
if (ParseComposedIconComponent(parser, iconPackResources)) {
continue;
}
Boolean result;
FAIL_RETURN(ColorFilterUtils::ParseIconFilter(parser, mFilterBuilder, &result));
if (result) {
continue;
}
String strName;
if (parser->GetName(&strName), strName.EqualsIgnoreCase(ICON_SCALE_TAG)) {
String factor;
parser->GetAttributeValue(String(NULL), String("factor"), &factor);
if (factor.IsNull()) {
Int32 count;
if (parser->GetAttributeCount(&count), count == 1) {
parser->GetAttributeValue(0, &factor);
}
}
iconPackResources->Put(ICON_SCALE_COMPONENT, CoreUtils::Convert(factor));
continue;
}
if (parser->GetName(&strName), !strName.EqualsIgnoreCase("item")) {
continue;
}
String component;
parser->GetAttributeValue(String(NULL), String("component"), &component);
String drawable;
parser->GetAttributeValue(String(NULL), String("drawable"), &drawable);
// Validate component/drawable exist
if (TextUtils::IsEmpty(component) || TextUtils::IsEmpty(drawable)) {
continue;
}
// Validate format/length of component
if (!component.StartWith("ComponentInfo{") || !component.EndWith("}")
|| component.GetLength() < 16 || drawable.GetLength() == 0) {
continue;
}
// Sanitize stored value
component = component.Substring(14, component.GetLength() - 1).ToLowerCase();
AutoPtr<IComponentName> name;
if (!component.Contains("/")) {
// Package icon reference
CComponentName::New(component.ToLowerCase(), String(""), (IComponentName**)&name);
}
else {
CComponentName::UnflattenFromString(component, (IComponentName**)&name);
}
if (name != NULL) {
iconPackResources->Put(name, CoreUtils::Convert(drawable));
}
} while (parser->Next(&eventType), eventType != IXmlPullParser::END_DOCUMENT);
return NOERROR;
}
ECode Request::ReadResponse(
/* [in] */ IElastosHttpClientConnection* httpClientConnection)
{
if (mCancelled){
return NOERROR; // don't send cancelled requests
}
AutoPtr<IStatusLine> statusLine;
Boolean hasBody = FALSE;
httpClientConnection->Flush();
Int32 statusCode = 0;
AutoPtr<IHeaders> header;
CHeaders::New((IHeaders**)&header);
do {
statusLine = NULL;
FAIL_RETURN(httpClientConnection->ParseResponseHeader(header, (IStatusLine**)&statusLine));
statusLine->GetStatusCode(&statusCode);
} while (statusCode < IHttpStatus::SC_OK);
if (HttpLog::LOGV) {
String str;
IObject::Probe(statusLine)->ToString(&str);
HttpLog::V(String("Request.readResponseStatus() ") +
StringUtils::ToString(str.GetLength()) + String(" ") + str);
}
AutoPtr<IProtocolVersion> v;
statusLine->GetProtocolVersion((IProtocolVersion**)&v);
Int32 major;
Int32 minor;
v->GetMajor(&major);
v->GetMinor(&minor);
String phrase;
statusLine->GetReasonPhrase(&phrase);
mEventHandler->Status(major, minor, statusCode, phrase);
mEventHandler->Headers(header);
AutoPtr<IHttpEntity> entity;
AutoPtr<IHttpRequest> req = IHttpRequest::Probe(mHttpRequest);
hasBody = CanResponseHaveBody(req, statusCode);
if (hasBody) {
httpClientConnection->ReceiveResponseEntity(header, (IHttpEntity**)&entity);
}
// restrict the range request to the servers claiming that they are
// accepting ranges in bytes
String ranges;
header->GetAcceptRanges(&ranges);
Boolean supportPartialContent = ranges.EqualsIgnoreCase("bytes");
if (entity != NULL) {
AutoPtr<IInputStream> is;
entity->GetContent((IInputStream**)&is);
// process gzip content encoding
AutoPtr<IHeader> contentEncoding;
entity->GetContentEncoding((IHeader**)&contentEncoding);
AutoPtr<IInputStream> nis;
AutoPtr<ArrayOf<Byte> > buf;
Int32 count = 0;
String value;
if (contentEncoding != NULL &&
(contentEncoding->GetValue(&value), value).Equals("gzip")) {
ECode ec = CGZIPInputStream::New(is, (IInputStream**)&nis);
if(FAILED(ec)) {
// don't throw if we have a non-OK status code
if (statusCode == IHttpStatus::SC_OK
|| statusCode == IHttpStatus::SC_PARTIAL_CONTENT) {
if (supportPartialContent && count > 0) {
// if there is uncommited content, we should commit them
// as we will continue the request
mEventHandler->Data(buf, count);
}
if (nis != NULL) {
nis->Close();
}
return ec;
}
}
} else {
nis = is;
}
/* accumulate enough data to make it worth pushing it
* up the stack */
((Connection*)mConnection.Get())->GetBuf((ArrayOf<Byte>**)&buf);
Int32 len = 0;
Int32 lowWater = buf->GetLength() / 2;
while (len != -1) {
{
AutoLock syncLock(mClientResource);
while (mLoadingPaused) {
// Put this (network loading) thread to sleep if WebCore
// has asked us to. This can happen with plugins for
// example, if we are streaming data but the plugin has
// filled its internal buffers.
if(FAILED(Wait())) {
HttpLog::E(String("Interrupted exception whilst network thread paused at WebCore's request."));
}
}
}
ECode ec;
ec = nis->Read(buf, count, buf->GetLength() - count, &len);
if(FAILED(ec)) {
/* InflaterInputStream throws an EOFException when the
server truncates gzipped content. Handle this case
as we do truncated non-gzipped content: no error */
if (count > 0) {
// if there is uncommited content, we should commit them
mEventHandler->Data(buf, count);
}
if (HttpLog::LOGV) HttpLog::V(String("readResponse() handling "));
}
if (len != -1) {
count += len;
if (supportPartialContent) mReceivedBytes += len;
}
if (len == -1 || count >= lowWater) {
if (HttpLog::LOGV) {
HttpLog::V(String("Request.readResponse() ") + StringUtils::ToString(count));
}
mEventHandler->Data(buf, count);
count = 0;
}
}
if (nis != NULL) {
nis->Close();
}
}
AutoPtr<IProtocolVersion> ver;
statusLine->GetProtocolVersion((IProtocolVersion**)&ver);
Int32 type;
header->GetConnectionType(&type);
((Connection*)mConnection.Get())->SetCanPersist(entity, ver, type);
mEventHandler->EndData();
Complete();
if (HttpLog::LOGV) {
String name;
mHost->GetSchemeName(&name);
String port;
GetHostPort(&port);
HttpLog::V("Request.readResponse(): done %s://%s%s",
name.string(), port.string(), mPath.string());
}
return NOERROR;
}
String URLUtil::GuessFileName(
/* [in] */ const String& url,
/* [in] */ const String& contentDisposition,
/* [in] */ const String& _mimeType)
{
String filename;
String extension;
String mimeType = _mimeType;
// If we couldn't do anything with the hint, move toward the content disposition
if (filename.IsNull() && !contentDisposition.IsNull()) {
filename = ParseContentDisposition(contentDisposition);
if (!filename.IsNull()) {
Int32 index = filename.LastIndexOf('/') + 1;
if (index > 0) {
filename = filename.Substring(index);
}
}
}
// If all the other http-related approaches failed, use the plain uri
if (filename.IsNull()) {
String decodedUrl;
Uri::Decode(url, &decodedUrl);
if (!decodedUrl.IsNull()) {
Int32 queryIndex = decodedUrl.IndexOf('?');
// If there is a query string strip it, same as desktop browsers
if (queryIndex > 0) {
decodedUrl = decodedUrl.Substring(0, queryIndex);
}
if (!decodedUrl.EndWith("/")) {
Int32 index = decodedUrl.LastIndexOf('/') + 1;
if (index > 0) {
filename = decodedUrl.Substring(index);
}
}
}
}
// Finally, if couldn't get filename from URI, get a generic filename
if (filename.IsNull()) {
filename = "downloadfile";
}
// Split filename between base and extension
// Add an extension if filename does not have one
Int32 dotIndex = filename.IndexOf('.');
if (dotIndex < 0) {
if (!mimeType.IsNull()) {
AutoPtr<MimeTypeMap> mimeTypeMap = MimeTypeMap::GetSingleton();
mimeTypeMap->GetExtensionFromMimeType(mimeType, &extension);
if (!extension.IsNull()) {
extension = String(".") + extension;
}
}
if (extension.IsNull()) {
if (!mimeType.IsNull() && mimeType.StartWithIgnoreCase("text/")) {
if (mimeType.EqualsIgnoreCase("text/html")) {
extension = ".html";
}
else {
extension = ".txt";
}
}
else {
extension = ".bin";
}
}
}
else {
if (!mimeType.IsNull()) {
// Compare the last segment of the extension against the mime type.
// If there's a mismatch, discard the entire extension.
Int32 lastDotIndex = filename.LastIndexOf('.');
AutoPtr<MimeTypeMap> mimeTypeMap = MimeTypeMap::GetSingleton();
String typeFromExt;
mimeTypeMap->GetMimeTypeFromExtension(
filename.Substring(lastDotIndex + 1), &typeFromExt);
if (!typeFromExt.IsNull() && !typeFromExt.EqualsIgnoreCase(mimeType)) {
mimeTypeMap->GetExtensionFromMimeType(mimeType, &extension);
if (!extension.IsNull()) {
extension = String(".") + extension;
}
}
}
if (extension.IsNull()) {
extension = filename.Substring(dotIndex);
}
filename = filename.Substring(0, dotIndex);
}
return filename + extension;
}