/** * Display all registered VMs on the screen with some information about each * * @param virtualBox VirtualBox instance object. */ void listVMs(IVirtualBox *virtualBox) { nsresult rc; printf("----------------------------------------------------\n"); printf("VM List:\n\n"); /* * Get the list of all registered VMs */ IMachine **machines = NULL; PRUint32 machineCnt = 0; rc = virtualBox->GetMachines(&machineCnt, &machines); if (NS_SUCCEEDED(rc)) { /* * Iterate through the collection */ for (PRUint32 i = 0; i < machineCnt; ++ i) { IMachine *machine = machines[i]; if (machine) { PRBool isAccessible = PR_FALSE; machine->GetAccessible(&isAccessible); if (isAccessible) { nsXPIDLString machineName; machine->GetName(getter_Copies(machineName)); char *machineNameAscii = ToNewCString(machineName); printf("\tName: %s\n", machineNameAscii); free(machineNameAscii); } else { printf("\tName: <inaccessible>\n"); } nsXPIDLString iid; machine->GetId(getter_Copies(iid)); const char *uuidString = ToNewCString(iid); printf("\tUUID: %s\n", uuidString); free((void*)uuidString); if (isAccessible) { nsXPIDLString configFile; machine->GetSettingsFilePath(getter_Copies(configFile)); char *configFileAscii = ToNewCString(configFile); printf("\tConfig file: %s\n", configFileAscii); free(configFileAscii); PRUint32 memorySize; machine->GetMemorySize(&memorySize); printf("\tMemory size: %uMB\n", memorySize); nsXPIDLString typeId; machine->GetOSTypeId(getter_Copies(typeId)); IGuestOSType *osType = nsnull; virtualBox->GetGuestOSType (typeId.get(), &osType); nsXPIDLString osName; osType->GetDescription(getter_Copies(osName)); char *osNameAscii = ToNewCString(osName); printf("\tGuest OS: %s\n\n", osNameAscii); free(osNameAscii); osType->Release(); } /* don't forget to release the objects in the array... */ machine->Release(); } } } printf("----------------------------------------------------\n\n"); }
// wrappers for ldap_modify_ext // nsresult nsLDAPOperation::ModifyExt(const char *base, nsIArray *mods, LDAPControl **serverctrls, LDAPControl **clientctrls) { if (mMessageListener == 0) { NS_ERROR("nsLDAPOperation::ModifyExt(): mMessageListener not set"); return NS_ERROR_NOT_INITIALIZED; } LDAPMod **attrs = 0; int retVal = 0; PRUint32 modCount = 0; nsresult rv = mods->GetLength(&modCount); NS_ENSURE_SUCCESS(rv, rv); if (modCount && mods) { attrs = static_cast<LDAPMod **>(nsMemory::Alloc((modCount + 1) * sizeof(LDAPMod *))); if (!attrs) { NS_ERROR("nsLDAPOperation::ModifyExt: out of memory "); return NS_ERROR_OUT_OF_MEMORY; } nsCAutoString type; PRUint32 index; for (index = 0; index < modCount && NS_SUCCEEDED(rv); ++index) { attrs[index] = new LDAPMod(); if (!attrs[index]) return NS_ERROR_OUT_OF_MEMORY; nsCOMPtr<nsILDAPModification> modif(do_QueryElementAt(mods, index, &rv)); if (NS_FAILED(rv)) break; PRInt32 operation; nsresult rv = modif->GetOperation(&operation); if (NS_FAILED(rv)) break; attrs[index]->mod_op = operation | LDAP_MOD_BVALUES; rv = modif->GetType(type); if (NS_FAILED(rv)) break; attrs[index]->mod_type = ToNewCString(type); rv = CopyValues(modif, &attrs[index]->mod_bvalues); if (NS_FAILED(rv)) break; } if (NS_SUCCEEDED(rv)) { attrs[modCount] = 0; retVal = ldap_modify_ext(mConnectionHandle, base, attrs, serverctrls, clientctrls, &mMsgID); } else // reset the modCount so we correctly free the array. modCount = index; } for (PRUint32 counter = 0; counter < modCount; ++counter) delete attrs[counter]; nsMemory::Free(attrs); return NS_FAILED(rv) ? rv : TranslateLDAPErrorToNSError(retVal); }
NS_INTERFACE_MAP_END //---------------------------------------------------------------------- // nsISVGValue methods: NS_IMETHODIMP nsSVGPreserveAspectRatio::SetValueString(const nsAString& aValue) { char* str = ToNewCString(aValue); if (!str) return NS_ERROR_OUT_OF_MEMORY; nsresult rv = NS_OK; char* rest = str; char* token; const char* delimiters = "\x20\x9\xD\xA"; PRUint16 align, meetOrSlice; token = nsCRT::strtok(rest, delimiters, &rest); if (token && !strcmp(token, "defer")) // Ignore: only applicable for preserveAspectRatio on 'image' elements token = nsCRT::strtok(rest, delimiters, &rest); if (token) { if (!strcmp(token, "none")) align = SVG_PRESERVEASPECTRATIO_NONE; else if (!strcmp(token, "xMinYMin")) align = SVG_PRESERVEASPECTRATIO_XMINYMIN; else if (!strcmp(token, "xMidYMin")) align = SVG_PRESERVEASPECTRATIO_XMIDYMIN; else if (!strcmp(token, "xMaxYMin")) align = SVG_PRESERVEASPECTRATIO_XMAXYMIN; else if (!strcmp(token, "xMinYMid")) align = SVG_PRESERVEASPECTRATIO_XMINYMID; else if (!strcmp(token, "xMidYMid")) align = SVG_PRESERVEASPECTRATIO_XMIDYMID; else if (!strcmp(token, "xMaxYMid")) align = SVG_PRESERVEASPECTRATIO_XMAXYMID; else if (!strcmp(token, "xMinYMax")) align = SVG_PRESERVEASPECTRATIO_XMINYMAX; else if (!strcmp(token, "xMidYMax")) align = SVG_PRESERVEASPECTRATIO_XMIDYMAX; else if (!strcmp(token, "xMaxYMax")) align = SVG_PRESERVEASPECTRATIO_XMAXYMAX; else rv = NS_ERROR_FAILURE; if (NS_SUCCEEDED(rv)) { token = nsCRT::strtok(rest, delimiters, &rest); if (token) { if (!strcmp(token, "meet")) meetOrSlice = SVG_MEETORSLICE_MEET; else if (!strcmp(token, "slice")) meetOrSlice = SVG_MEETORSLICE_SLICE; else rv = NS_ERROR_FAILURE; } else meetOrSlice = SVG_MEETORSLICE_MEET; } } else // align not specified rv = NS_ERROR_FAILURE; if (nsCRT::strtok(rest, delimiters, &rest)) // there's more rv = NS_ERROR_FAILURE; if (NS_SUCCEEDED(rv)) { WillModify(); mAlign = align; mMeetOrSlice = meetOrSlice; DidModify(); } nsMemory::Free(str); return rv; }
static char * MimeMessage_partial_message_html(const char *data, void *closure, MimeHeaders *headers) { MimeMessage *msg = (MimeMessage *)closure; nsCAutoString orig_url(data); char *uidl = MimeHeaders_get(headers, HEADER_X_UIDL, PR_FALSE, PR_FALSE); char *msgId = MimeHeaders_get(headers, HEADER_MESSAGE_ID, PR_FALSE, PR_FALSE); char *msgIdPtr = PL_strstr(msgId, "<"); int msgBase; PRInt32 pos = orig_url.Find("mailbox-message"); if (pos != -1) orig_url.Cut(pos + 7, 8); pos = orig_url.Find("#"); if (pos != -1) orig_url.Replace(pos, 1, "?number=", 8); if (msgIdPtr) msgIdPtr++; else msgIdPtr = msgId; char *gtPtr = PL_strstr(msgIdPtr, ">"); if (gtPtr) *gtPtr = 0; msgBase = (msg->bodyLength > MSG_LINEBREAK_LEN) ? MIME_MSG_PARTIAL_FMT_1 : MIME_MSG_PARTIAL_FMT2_1; nsCString partialMsgHtml; nsCString item; item.Adopt(MimeGetStringByID(msgBase)); partialMsgHtml += item; item.Adopt(MimeGetStringByID(msgBase+1)); partialMsgHtml += item; partialMsgHtml.Append(orig_url); if (msgIdPtr) { partialMsgHtml.AppendLiteral("&messageid="); MsgEscapeString(nsDependentCString(msgIdPtr), nsINetUtil::ESCAPE_URL_PATH, item); partialMsgHtml.Append(item); } if (uidl) { partialMsgHtml.AppendLiteral("&uidl="); MsgEscapeString(nsDependentCString(uidl), nsINetUtil::ESCAPE_XALPHAS, item); partialMsgHtml.Append(item); } item.Adopt(MimeGetStringByID(msgBase+2)); partialMsgHtml += item; return ToNewCString(partialMsgHtml); }
// walks the graph using a breadth-first-search algorithm which generates a discovered // verticies tree. This tree is then walked up (from destination vertex, to origin vertex) // and each link in the chain is added to an nsStringArray. A direct lookup for the given // CONTRACTID should be made prior to calling this method in an attempt to find a direct // converter rather than walking the graph. nsresult nsStreamConverterService::FindConverter(const char *aContractID, nsTArray<nsCString> **aEdgeList) { nsresult rv; if (!aEdgeList) return NS_ERROR_NULL_POINTER; *aEdgeList = nullptr; // walk the graph in search of the appropriate converter. int32_t vertexCount = mAdjacencyList->Count(); if (0 >= vertexCount) return NS_ERROR_FAILURE; // Create a corresponding color table for each vertex in the graph. nsObjectHashtable lBFSTable(nullptr, nullptr, DeleteBFSEntry, nullptr); mAdjacencyList->Enumerate(InitBFSTable, &lBFSTable); NS_ASSERTION(lBFSTable.Count() == vertexCount, "strmconv BFS table init problem"); // This is our source vertex; our starting point. nsAutoCString fromC, toC; rv = ParseFromTo(aContractID, fromC, toC); if (NS_FAILED(rv)) return rv; nsCStringKey *source = new nsCStringKey(fromC.get()); if (!source) return NS_ERROR_OUT_OF_MEMORY; SCTableData *data = (SCTableData*)lBFSTable.Get(source); if (!data) { delete source; return NS_ERROR_FAILURE; } BFSState *state = data->data.state; state->color = gray; state->distance = 0; CStreamConvDeallocator *dtorFunc = new CStreamConvDeallocator(); if (!dtorFunc) { delete source; return NS_ERROR_OUT_OF_MEMORY; } nsDeque grayQ(dtorFunc); // Now generate the shortest path tree. grayQ.Push(source); while (0 < grayQ.GetSize()) { nsCStringKey *currentHead = (nsCStringKey*)grayQ.PeekFront(); SCTableData *data2 = (SCTableData*)mAdjacencyList->Get(currentHead); if (!data2) return NS_ERROR_FAILURE; nsCOMArray<nsIAtom> *edges = data2->data.edges; NS_ASSERTION(edges, "something went wrong with BFS strmconv algorithm"); if (!edges) return NS_ERROR_FAILURE; // Get the state of the current head to calculate the distance of each // reachable vertex in the loop. data2 = (SCTableData*)lBFSTable.Get(currentHead); if (!data2) return NS_ERROR_FAILURE; BFSState *headVertexState = data2->data.state; NS_ASSERTION(headVertexState, "problem with the BFS strmconv algorithm"); if (!headVertexState) return NS_ERROR_FAILURE; int32_t edgeCount = edges->Count(); for (int32_t i = 0; i < edgeCount; i++) { nsIAtom* curVertexAtom = edges->ObjectAt(i); nsAutoString curVertexStr; curVertexAtom->ToString(curVertexStr); nsCStringKey *curVertex = new nsCStringKey(ToNewCString(curVertexStr), curVertexStr.Length(), nsCStringKey::OWN); if (!curVertex) return NS_ERROR_OUT_OF_MEMORY; SCTableData *data3 = (SCTableData*)lBFSTable.Get(curVertex); if (!data3) { delete curVertex; return NS_ERROR_FAILURE; } BFSState *curVertexState = data3->data.state; NS_ASSERTION(curVertexState, "something went wrong with the BFS strmconv algorithm"); if (!curVertexState) return NS_ERROR_FAILURE; if (white == curVertexState->color) { curVertexState->color = gray; curVertexState->distance = headVertexState->distance + 1; curVertexState->predecessor = (nsCStringKey*)currentHead->Clone(); if (!curVertexState->predecessor) { delete curVertex; return NS_ERROR_OUT_OF_MEMORY; } grayQ.Push(curVertex); } else { delete curVertex; // if this vertex has already been discovered, we don't want // to leak it. (non-discovered vertex's get cleaned up when // they're popped). } } headVertexState->color = black; nsCStringKey *cur = (nsCStringKey*)grayQ.PopFront(); delete cur; cur = nullptr; } // The shortest path (if any) has been generated and is represetned by the chain of // BFSState->predecessor keys. Start at the bottom and work our way up. // first parse out the FROM and TO MIME-types being registered. nsAutoCString fromStr, toStr; rv = ParseFromTo(aContractID, fromStr, toStr); if (NS_FAILED(rv)) return rv; // get the root CONTRACTID nsAutoCString ContractIDPrefix(NS_ISTREAMCONVERTER_KEY); nsTArray<nsCString> *shortestPath = new nsTArray<nsCString>(); if (!shortestPath) return NS_ERROR_OUT_OF_MEMORY; nsCStringKey toMIMEType(toStr); data = (SCTableData*)lBFSTable.Get(&toMIMEType); if (!data) { // If this vertex isn't in the BFSTable, then no-one has registered for it, // therefore we can't do the conversion. delete shortestPath; return NS_ERROR_FAILURE; } while (data) { BFSState *curState = data->data.state; nsCStringKey *key = data->key; if (fromStr.Equals(key->GetString())) { // found it. We're done here. *aEdgeList = shortestPath; return NS_OK; } // reconstruct the CONTRACTID. // Get the predecessor. if (!curState->predecessor) break; // no predecessor SCTableData *predecessorData = (SCTableData*)lBFSTable.Get(curState->predecessor); if (!predecessorData) break; // no predecessor, chain doesn't exist. // build out the CONTRACTID. nsAutoCString newContractID(ContractIDPrefix); newContractID.AppendLiteral("?from="); nsCStringKey *predecessorKey = predecessorData->key; newContractID.Append(predecessorKey->GetString()); newContractID.AppendLiteral("&to="); newContractID.Append(key->GetString()); // Add this CONTRACTID to the chain. rv = shortestPath->AppendElement(newContractID) ? NS_OK : NS_ERROR_FAILURE; // XXX this method incorrectly returns a bool NS_ASSERTION(NS_SUCCEEDED(rv), "AppendElement failed"); // move up the tree. data = predecessorData; } delete shortestPath; return NS_ERROR_FAILURE; // couldn't find a stream converter or chain. }
NS_IMETHODIMP nsScriptError::GetCategory(char **result) { *result = ToNewCString(mCategory); return NS_OK; }
nsresult nsOperaProfileMigrator::CopyPreferences(PRBool aReplace) { nsresult rv; nsCOMPtr<nsIFile> operaPrefs; mOperaProfile->Clone(getter_AddRefs(operaPrefs)); operaPrefs->Append(OPERA_PREFERENCES_FILE_NAME); nsCOMPtr<nsILocalFile> lf(do_QueryInterface(operaPrefs)); NS_ENSURE_TRUE(lf, NS_ERROR_UNEXPECTED); nsINIParser parser; rv = parser.Init(lf); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIPrefBranch> branch(do_GetService(NS_PREFSERVICE_CONTRACTID)); // Traverse the standard transforms PrefTransform* transform; PrefTransform* end = gTransforms + sizeof(gTransforms)/sizeof(PrefTransform); const char* lastSectionName = nsnull; for (transform = gTransforms; transform < end; ++transform) { if (transform->sectionName) lastSectionName = transform->sectionName; if (transform->type == _OPM(COLOR)) { char* colorString = nsnull; nsresult rv = ParseColor(parser, lastSectionName, &colorString); if (NS_SUCCEEDED(rv)) { transform->stringValue = colorString; transform->prefHasValue = PR_TRUE; transform->prefSetterFunc(transform, branch); } if (colorString) free(colorString); } else { nsCAutoString val; rv = parser.GetString(lastSectionName, transform->keyName, val); if (NS_SUCCEEDED(rv)) { nsresult strerr; switch (transform->type) { case _OPM(STRING): transform->stringValue = ToNewCString(val); break; case _OPM(INT): { transform->intValue = val.ToInteger(&strerr); } break; case _OPM(BOOL): { transform->boolValue = val.ToInteger(&strerr) != 0; } break; default: break; } transform->prefHasValue = PR_TRUE; transform->prefSetterFunc(transform, branch); if (transform->type == _OPM(STRING) && transform->stringValue) { NS_Free(transform->stringValue); transform->stringValue = nsnull; } } } } // Copy Proxy Settings CopyProxySettings(parser, branch); // Copy User Content Sheet if (aReplace) CopyUserContentSheet(parser); return NS_OK; }
NS_IMETHODIMP nsAbLDAPAutoCompFormatter::GetAttributes(PRUint32 *aCount, char ** *aAttrs) { if (!aCount || !aAttrs) { return NS_ERROR_INVALID_POINTER; } nsCStringArray mSearchAttrs; nsresult rv = ProcessFormat(mNameFormat, 0, 0, &mSearchAttrs); if (NS_FAILED(rv)) { NS_WARNING("nsAbLDAPAutoCompFormatter::SetNameFormat(): " "ProcessFormat() failed"); return rv; } rv = ProcessFormat(mAddressFormat, 0, 0, &mSearchAttrs); if (NS_FAILED(rv)) { NS_WARNING("nsAbLDAPAutoCompFormatter::SetNameFormat(): " "ProcessFormat() failed"); return rv; } rv = ProcessFormat(mCommentFormat, 0, 0, &mSearchAttrs); if (NS_FAILED(rv)) { NS_WARNING("nsAbLDAPAutoCompFormatter::SetNameFormat(): " "ProcessFormat() failed"); return rv; } // none of the formatting templates require any LDAP attributes // PRUint32 count = mSearchAttrs.Count(); // size of XPCOM array we'll need if (!count) { NS_ERROR("nsAbLDAPAutoCompFormatter::GetAttributes(): " "current output format (if set) requires no search " "attributes"); return NS_ERROR_NOT_INITIALIZED; } // build up the raw XPCOM array to return // PRUint32 rawSearchAttrsSize = 0; // grown as XPCOM array is built char **rawSearchAttrs = static_cast<char **>(nsMemory::Alloc(count * sizeof(char *))); if (!rawSearchAttrs) { NS_ERROR("nsAbLDAPAutoCompFormatter::GetAttributes(): out of " "memory"); return NS_ERROR_OUT_OF_MEMORY; } // Loop through the string array, and build up the C-array. // while (rawSearchAttrsSize < count) { if (!(rawSearchAttrs[rawSearchAttrsSize] = ToNewCString(*(mSearchAttrs.CStringAt(rawSearchAttrsSize))))) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(rawSearchAttrsSize, rawSearchAttrs); NS_ERROR("nsAbLDAPAutoCompFormatter::GetAttributes(): out " "of memory"); return NS_ERROR_OUT_OF_MEMORY; } rawSearchAttrsSize++; } *aCount = rawSearchAttrsSize; *aAttrs = rawSearchAttrs; return NS_OK; }
void Area::ParseCoords(const nsAString& aSpec) { char* cp = ToNewCString(aSpec); if (cp) { char *tptr; char *n_str; PRInt32 i, cnt; PRInt32 *value_list; /* * Nothing in an empty list */ mNumCoords = 0; mCoords = nsnull; if (*cp == '\0') { return; } /* * Skip beginning whitespace, all whitespace is empty list. */ n_str = cp; while (is_space(*n_str)) { n_str++; } if (*n_str == '\0') { return; } /* * Make a pass where any two numbers separated by just whitespace * are given a comma separator. Count entries while passing. */ cnt = 0; while (*n_str != '\0') { PRBool has_comma; /* * Skip to a separator */ tptr = n_str; while (!is_space(*tptr) && *tptr != ',' && *tptr != '\0') { tptr++; } n_str = tptr; /* * If no more entries, break out here */ if (*n_str == '\0') { break; } /* * Skip to the end of the separator, noting if we have a * comma. */ has_comma = PR_FALSE; while (is_space(*tptr) || *tptr == ',') { if (*tptr == ',') { if (!has_comma) { has_comma = PR_TRUE; } else { break; } } tptr++; } /* * If this was trailing whitespace we skipped, we are done. */ if ((*tptr == '\0') && !has_comma) { break; } /* * Else if the separator is all whitespace, and this is not the * end of the string, add a comma to the separator. */ else if (!has_comma) { *n_str = ','; } /* * count the entry skipped. */ cnt++; n_str = tptr; } /* * count the last entry in the list. */ cnt++; /* * Allocate space for the coordinate array. */ value_list = new nscoord[cnt]; if (!value_list) { return; } /* * Second pass to copy integer values into list. */ tptr = cp; for (i=0; i<cnt; i++) { char *ptr; ptr = strchr(tptr, ','); if (ptr) { *ptr = '\0'; } /* * Strip whitespace in front of number because I don't * trust atoi to do it on all platforms. */ while (is_space(*tptr)) { tptr++; } if (*tptr == '\0') { value_list[i] = 0; } else { value_list[i] = (nscoord) ::atoi(tptr); } if (ptr) { *ptr = ','; tptr = ptr + 1; } } mNumCoords = cnt; mCoords = value_list; NS_Free(cp); } }
/* read only attribute string name; */ NS_IMETHODIMP nsAbDirectoryQueryPropertyValue::GetName(char* *aName) { *aName = mName.IsEmpty() ? 0 : ToNewCString(mName); return NS_OK; }
nsresult writeoutto(const char* i_pURL, char** o_Result, int32_t urlFactory = URL_FACTORY_DEFAULT) { if (!o_Result || !i_pURL) return NS_ERROR_FAILURE; *o_Result = 0; nsCOMPtr<nsIURI> pURL; nsresult result = NS_OK; switch (urlFactory) { case URL_FACTORY_STDURL: { nsIURI* url; result = CallCreateInstance(kStdURLCID, &url); if (NS_FAILED(result)) { printf("CreateInstance failed\n"); return NS_ERROR_FAILURE; } pURL = url; pURL->SetSpec(nsDependentCString(i_pURL)); break; } case URL_FACTORY_DEFAULT: { nsCOMPtr<nsIIOService> pService = do_GetService(kIOServiceCID, &result); if (NS_FAILED(result)) { printf("Service failed!\n"); return NS_ERROR_FAILURE; } result = pService->NewURI(nsDependentCString(i_pURL), nullptr, nullptr, getter_AddRefs(pURL)); } } nsCString output; if (NS_SUCCEEDED(result)) { nsCOMPtr<nsIURL> tURL = do_QueryInterface(pURL); nsAutoCString temp; int32_t port; nsresult rv; #define RESULT() NS_SUCCEEDED(rv) ? temp.get() : "" rv = tURL->GetScheme(temp); output += RESULT(); output += ','; rv = tURL->GetUsername(temp); output += RESULT(); output += ','; rv = tURL->GetPassword(temp); output += RESULT(); output += ','; rv = tURL->GetHost(temp); output += RESULT(); output += ','; rv = tURL->GetPort(&port); char portbuffer[40]; snprintf_literal(portbuffer, "%d", port); output.Append(portbuffer); output += ','; rv = tURL->GetDirectory(temp); output += RESULT(); output += ','; rv = tURL->GetFileBaseName(temp); output += RESULT(); output += ','; rv = tURL->GetFileExtension(temp); output += RESULT(); output += ','; // removed with https://bugzilla.mozilla.org/show_bug.cgi?id=665706 // rv = tURL->GetParam(temp); // output += RESULT(); output += ','; rv = tURL->GetQuery(temp); output += RESULT(); output += ','; rv = tURL->GetRef(temp); output += RESULT(); output += ','; rv = tURL->GetSpec(temp); output += RESULT(); *o_Result = ToNewCString(output); } else { output = "Can not create URL"; *o_Result = ToNewCString(output); } return NS_OK; }
nsresult nsMsgI18NSaveAsCharset(const char* contentType, const char *charset, const char16_t* inString, char** outString, char **fallbackCharset, bool *isAsciiOnly) { NS_ENSURE_ARG_POINTER(contentType); NS_ENSURE_ARG_POINTER(charset); NS_ENSURE_ARG_POINTER(inString); NS_ENSURE_ARG_POINTER(outString); *outString = nullptr; if (NS_IsAscii(inString)) { if (isAsciiOnly) *isAsciiOnly = true; *outString = ToNewCString(NS_LossyConvertUTF16toASCII(inString)); return (nullptr != *outString) ? NS_OK : NS_ERROR_OUT_OF_MEMORY; } if (isAsciiOnly) *isAsciiOnly = false; bool bTEXT_HTML = false; nsresult res; if (!PL_strcasecmp(contentType, TEXT_HTML)) { bTEXT_HTML = true; } else if (PL_strcasecmp(contentType, TEXT_PLAIN)) { return NS_ERROR_ILLEGAL_VALUE; // not supported type } nsCOMPtr <nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &res); NS_ENSURE_SUCCESS(res, res); nsAutoCString charsetName; res = ccm->GetCharsetAlias(charset, charsetName); NS_ENSURE_SUCCESS(res, res); nsCOMPtr <nsISaveAsCharset> conv = do_CreateInstance(NS_SAVEASCHARSET_CONTRACTID, &res); NS_ENSURE_SUCCESS(res, res); // First try to transliterate, if that fails use '?' for "bad" chars. res = conv->Init(charsetName.get(), nsISaveAsCharset::attr_FallbackQuestionMark + nsISaveAsCharset::attr_EntityNone, nsIEntityConverter::transliterate); NS_ENSURE_SUCCESS(res, res); const char16_t *input = inString; // Convert to charset res = conv->Convert(input, outString); // If the converer cannot encode to the charset, // then fallback to pref sepcified charsets. if (NS_ERROR_UENC_NOMAPPING == res && !bTEXT_HTML && fallbackCharset) { nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &res)); NS_ENSURE_SUCCESS(res, res); nsAutoCString prefString("intl.fallbackCharsetList."); prefString.Append(charset); nsCString fallbackList; res = prefBranch->GetCharPref(prefString.get(), getter_Copies(fallbackList)); // do the fallback only if there is a pref for the charset if (NS_FAILED(res) || fallbackList.IsEmpty()) return NS_ERROR_UENC_NOMAPPING; res = conv->Init(fallbackList.get(), nsISaveAsCharset::attr_FallbackQuestionMark + nsISaveAsCharset::attr_EntityAfterCharsetConv + nsISaveAsCharset::attr_CharsetFallback, nsIEntityConverter::transliterate); NS_ENSURE_SUCCESS(res, res); // free whatever we have now PR_FREEIF(*outString); res = conv->Convert(input, outString); NS_ENSURE_SUCCESS(res, res); // get the actual charset used for the conversion if (NS_FAILED(conv->GetCharset(fallbackCharset))) *fallbackCharset = nullptr; } // Exclude stateful charset which is 7 bit but not ASCII only. else if (isAsciiOnly && *outString && !nsMsgI18Nstateful_charset(charsetName.get())) *isAsciiOnly = NS_IsAscii(*outString); return res; }
// nsIStreamListener implementation NS_IMETHODIMP nsFTPDirListingConv::OnDataAvailable(nsIRequest* request, nsISupports *ctxt, nsIInputStream *inStr, uint32_t sourceOffset, uint32_t count) { NS_ASSERTION(request, "FTP dir listing stream converter needs a request"); nsresult rv; nsCOMPtr<nsIChannel> channel = do_QueryInterface(request, &rv); NS_ENSURE_SUCCESS(rv, rv); uint32_t read, streamLen; uint64_t streamLen64; rv = inStr->Available(&streamLen64); NS_ENSURE_SUCCESS(rv, rv); streamLen = (uint32_t)NS_MIN(streamLen64, uint64_t(PR_UINT32_MAX - 1)); nsAutoArrayPtr<char> buffer(new char[streamLen + 1]); NS_ENSURE_TRUE(buffer, NS_ERROR_OUT_OF_MEMORY); rv = inStr->Read(buffer, streamLen, &read); NS_ENSURE_SUCCESS(rv, rv); // the dir listings are ascii text, null terminate this sucker. buffer[streamLen] = '\0'; PR_LOG(gFTPDirListConvLog, PR_LOG_DEBUG, ("nsFTPDirListingConv::OnData(request = %x, ctxt = %x, inStr = %x, sourceOffset = %d, count = %d)\n", request, ctxt, inStr, sourceOffset, count)); if (!mBuffer.IsEmpty()) { // we have data left over from a previous OnDataAvailable() call. // combine the buffers so we don't lose any data. mBuffer.Append(buffer); buffer = new char[mBuffer.Length()+1]; NS_ENSURE_TRUE(buffer, NS_ERROR_OUT_OF_MEMORY); strncpy(buffer, mBuffer.get(), mBuffer.Length()+1); mBuffer.Truncate(); } #ifndef DEBUG_dougt PR_LOG(gFTPDirListConvLog, PR_LOG_DEBUG, ("::OnData() received the following %d bytes...\n\n%s\n\n", streamLen, buffer.get()) ); #else printf("::OnData() received the following %d bytes...\n\n%s\n\n", streamLen, buffer); #endif // DEBUG_dougt nsCAutoString indexFormat; if (!mSentHeading) { // build up the 300: line nsCOMPtr<nsIURI> uri; rv = channel->GetURI(getter_AddRefs(uri)); NS_ENSURE_SUCCESS(rv, rv); rv = GetHeaders(indexFormat, uri); NS_ENSURE_SUCCESS(rv, rv); mSentHeading = true; } char *line = buffer; line = DigestBufferLines(line, indexFormat); #ifndef DEBUG_dougt PR_LOG(gFTPDirListConvLog, PR_LOG_DEBUG, ("::OnData() sending the following %d bytes...\n\n%s\n\n", indexFormat.Length(), indexFormat.get()) ); #else char *unescData = ToNewCString(indexFormat); NS_ENSURE_TRUE(unescData, NS_ERROR_OUT_OF_MEMORY); nsUnescape(unescData); printf("::OnData() sending the following %d bytes...\n\n%s\n\n", indexFormat.Length(), unescData); nsMemory::Free(unescData); #endif // DEBUG_dougt // if there's any data left over, buffer it. if (line && *line) { mBuffer.Append(line); PR_LOG(gFTPDirListConvLog, PR_LOG_DEBUG, ("::OnData() buffering the following %d bytes...\n\n%s\n\n", PL_strlen(line), line) ); } // send the converted data out. nsCOMPtr<nsIInputStream> inputData; rv = NS_NewCStringInputStream(getter_AddRefs(inputData), indexFormat); NS_ENSURE_SUCCESS(rv, rv); rv = mFinalListener->OnDataAvailable(request, ctxt, inputData, 0, indexFormat.Length()); return rv; }
nsresult nsFtpProtocolHandler::InsertConnection(nsIURI *aKey, nsFtpControlConnection *aConn) { NS_ASSERTION(aConn, "null pointer"); NS_ASSERTION(aKey, "null pointer"); if (aConn->mSessionId != mSessionId) return NS_ERROR_FAILURE; nsCAutoString spec; aKey->GetPrePath(spec); LOG(("FTP:inserting connection for %s\n", spec.get())); nsresult rv; nsCOMPtr<nsITimer> timer = do_CreateInstance("@mozilla.org/timer;1", &rv); if (NS_FAILED(rv)) return rv; timerStruct* ts = new timerStruct(); if (!ts) return NS_ERROR_OUT_OF_MEMORY; rv = timer->InitWithFuncCallback(nsFtpProtocolHandler::Timeout, ts, mIdleTimeout*1000, nsITimer::TYPE_REPEATING_SLACK); if (NS_FAILED(rv)) { delete ts; return rv; } ts->key = ToNewCString(spec); if (!ts->key) { delete ts; return NS_ERROR_OUT_OF_MEMORY; } NS_ADDREF(aConn); ts->conn = aConn; ts->timer = timer; // // limit number of idle connections. if limit is reached, then prune // eldest connection with matching key. if none matching, then prune // eldest connection. // if (mRootConnectionList.Length() == IDLE_CONNECTION_LIMIT) { PRUint32 i; for (i=0;i<mRootConnectionList.Length();++i) { timerStruct *candidate = mRootConnectionList[i]; if (strcmp(candidate->key, ts->key) == 0) { mRootConnectionList.RemoveElementAt(i); delete candidate; break; } } if (mRootConnectionList.Length() == IDLE_CONNECTION_LIMIT) { timerStruct *eldest = mRootConnectionList[0]; mRootConnectionList.RemoveElementAt(0); delete eldest; } } mRootConnectionList.AppendElement(ts); return NS_OK; }
/* * Class: org_mozilla_webclient_impl_wrapper_0005fnative_CurrentPageImpl * Method: nativeGetCurrentURL * Signature: ()Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_org_mozilla_webclient_impl_wrapper_1native_CurrentPageImpl_nativeGetCurrentURL (JNIEnv *env, jobject obj, jint nativeBCPtr) { JNIEnv * pEnv = env; jobject jobj = obj; char * charResult = nsnull; PRInt32 currentIndex; jstring urlString = nsnull; nsresult rv = NS_ERROR_NULL_POINTER; NativeBrowserControl* nativeBrowserControl = (NativeBrowserControl *) nativeBCPtr; if (nativeBrowserControl == nsnull) { ::util_ThrowExceptionToJava(env, "Exception: null nativeBCPtr passed to raptorWebShellGetURL"); return nsnull; } nsCOMPtr<nsISHistory> sHistory; rv = nativeBrowserControl->mNavigation->GetSessionHistory(getter_AddRefs(sHistory)); if (NS_FAILED(rv)) { ::util_ThrowExceptionToJava(env, "Exception: Can't get SessionHistory"); return nsnull; } rv = sHistory->GetIndex(¤tIndex); if (NS_FAILED(rv)) { ::util_ThrowExceptionToJava(env, "Exception: Can't get current index from SessionHistory"); return nsnull; } nsIHistoryEntry * Entry; nsIURI *URI; rv = sHistory->GetEntryAtIndex(currentIndex, PR_FALSE, &Entry); if (NS_FAILED(rv)) { ::util_ThrowExceptionToJava(env, "Exception: Can't get history entry for current index"); return nsnull; } rv = Entry->GetURI(&URI); if (NS_FAILED(rv)) { ::util_ThrowExceptionToJava(env, "Exception: Can't get URI from History Entry"); return nsnull; } nsCString urlSpecString; rv = URI->GetSpec(urlSpecString); if (NS_FAILED(rv)) { ::util_ThrowExceptionToJava(env, "Exception: Can't get url spec from URI"); return nsnull; } charResult = ToNewCString(urlSpecString); if (charResult != nsnull) { urlString = ::util_NewStringUTF(env, (const char *) charResult); } else { ::util_ThrowExceptionToJava(env, "raptorWebShellGetURL Exception: GetURL() returned NULL"); return nsnull; } nsMemory::Free(charResult); return urlString; }
// contructor for CWAB object // // pszFileName - FileName of WAB file to open // if no file name is specified, opens the default // CWAB::CWAB(nsILocalFile *file) { // Here we load the WAB Object and initialize it m_pUniBuff = NULL; m_uniBuffLen = 0; m_bInitialized = PR_FALSE; m_lpAdrBook = NULL; m_lpWABObject = NULL; m_hinstWAB = NULL; { TCHAR szWABDllPath[MAX_PATH]; DWORD dwType = 0; ULONG cbData = sizeof(szWABDllPath); HKEY hKey = NULL; *szWABDllPath = '\0'; // First we look under the default WAB DLL path location in the // Registry. // WAB_DLL_PATH_KEY is defined in wabapi.h // if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, WAB_DLL_PATH_KEY, 0, KEY_READ, &hKey)) RegQueryValueEx( hKey, "", NULL, &dwType, (LPBYTE) szWABDllPath, &cbData); if(hKey) RegCloseKey(hKey); // if the Registry came up blank, we do a loadlibrary on the wab32.dll // WAB_DLL_NAME is defined in wabapi.h // m_hinstWAB = LoadLibrary( (lstrlen(szWABDllPath)) ? szWABDllPath : WAB_DLL_NAME ); } if(m_hinstWAB) { // if we loaded the dll, get the entry point // m_lpfnWABOpen = (LPWABOPEN) GetProcAddress(m_hinstWAB, "WABOpen"); if(m_lpfnWABOpen) { char fName[2] = {0, 0}; HRESULT hr = E_FAIL; WAB_PARAM wp = {0}; wp.cbSize = sizeof(WAB_PARAM); if (file != nsnull) { nsCString path; file->GetNativePath(path); wp.szFileName = (LPTSTR) ToNewCString(path); } else wp.szFileName = (LPTSTR) fName; // if we choose not to pass in a WAB_PARAM object, // the default WAB file will be opened up // hr = m_lpfnWABOpen(&m_lpAdrBook,&m_lpWABObject,&wp,0); if(!hr) m_bInitialized = TRUE; } } }
void nsXBLPrototypeHandler::ConstructPrototype(nsIContent* aKeyElement, const PRUnichar* aEvent, const PRUnichar* aPhase, const PRUnichar* aAction, const PRUnichar* aCommand, const PRUnichar* aKeyCode, const PRUnichar* aCharCode, const PRUnichar* aModifiers, const PRUnichar* aButton, const PRUnichar* aClickCount, const PRUnichar* aGroup, const PRUnichar* aPreventDefault, const PRUnichar* aAllowUntrusted) { mType = 0; if (aKeyElement) { mType |= NS_HANDLER_TYPE_XUL; nsCOMPtr<nsIWeakReference> weak = do_GetWeakReference(aKeyElement); if (!weak) { return; } weak.swap(mHandlerElement); } else { mType |= aCommand ? NS_HANDLER_TYPE_XBL_COMMAND : NS_HANDLER_TYPE_XBL_JS; mHandlerText = nsnull; } mDetail = -1; mMisc = 0; mKeyMask = 0; mPhase = NS_PHASE_BUBBLING; if (aAction) mHandlerText = ToNewUnicode(nsDependentString(aAction)); else if (aCommand) mHandlerText = ToNewUnicode(nsDependentString(aCommand)); nsAutoString event(aEvent); if (event.IsEmpty()) { if (mType & NS_HANDLER_TYPE_XUL) GetEventType(event); if (event.IsEmpty()) return; } mEventName = do_GetAtom(event); if (aPhase) { const nsDependentString phase(aPhase); if (phase.EqualsLiteral("capturing")) mPhase = NS_PHASE_CAPTURING; else if (phase.EqualsLiteral("target")) mPhase = NS_PHASE_TARGET; } // Button and clickcount apply only to XBL handlers and don't apply to XUL key // handlers. if (aButton && *aButton) mDetail = *aButton - '0'; if (aClickCount && *aClickCount) mMisc = *aClickCount - '0'; // Modifiers are supported by both types of handlers (XUL and XBL). nsAutoString modifiers(aModifiers); if (mType & NS_HANDLER_TYPE_XUL) aKeyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::modifiers, modifiers); if (!modifiers.IsEmpty()) { mKeyMask = cAllModifiers; char* str = ToNewCString(modifiers); char* newStr; char* token = nsCRT::strtok( str, ", \t", &newStr ); while( token != NULL ) { if (PL_strcmp(token, "shift") == 0) mKeyMask |= cShift | cShiftMask; else if (PL_strcmp(token, "alt") == 0) mKeyMask |= cAlt | cAltMask; else if (PL_strcmp(token, "meta") == 0) mKeyMask |= cMeta | cMetaMask; else if (PL_strcmp(token, "control") == 0) mKeyMask |= cControl | cControlMask; else if (PL_strcmp(token, "accel") == 0) mKeyMask |= KeyToMask(kAccelKey); else if (PL_strcmp(token, "access") == 0) mKeyMask |= KeyToMask(kMenuAccessKey); else if (PL_strcmp(token, "any") == 0) mKeyMask &= ~(mKeyMask << 4); token = nsCRT::strtok( newStr, ", \t", &newStr ); } nsMemory::Free(str); } nsAutoString key(aCharCode); if (key.IsEmpty()) { if (mType & NS_HANDLER_TYPE_XUL) { aKeyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::key, key); if (key.IsEmpty()) aKeyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::charcode, key); } } if (!key.IsEmpty()) { if (mKeyMask == 0) mKeyMask = cAllModifiers; ToLowerCase(key); // We have a charcode. mMisc = 1; mDetail = key[0]; const PRUint8 GTK2Modifiers = cShift | cControl | cShiftMask | cControlMask; if ((mKeyMask & GTK2Modifiers) == GTK2Modifiers && modifiers.First() != PRUnichar(',') && (mDetail == 'u' || mDetail == 'U')) ReportKeyConflict(key.get(), modifiers.get(), aKeyElement, "GTK2Conflict"); const PRUint8 WinModifiers = cControl | cAlt | cControlMask | cAltMask; if ((mKeyMask & WinModifiers) == WinModifiers && modifiers.First() != PRUnichar(',') && (('A' <= mDetail && mDetail <= 'Z') || ('a' <= mDetail && mDetail <= 'z'))) ReportKeyConflict(key.get(), modifiers.get(), aKeyElement, "WinConflict"); } else { key.Assign(aKeyCode); if (mType & NS_HANDLER_TYPE_XUL) aKeyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::keycode, key); if (!key.IsEmpty()) { if (mKeyMask == 0) mKeyMask = cAllModifiers; mDetail = GetMatchingKeyCode(key); } } if (aGroup && nsDependentString(aGroup).EqualsLiteral("system")) mType |= NS_HANDLER_TYPE_SYSTEM; if (aPreventDefault && nsDependentString(aPreventDefault).EqualsLiteral("true")) mType |= NS_HANDLER_TYPE_PREVENTDEFAULT; if (aAllowUntrusted) { mType |= NS_HANDLER_HAS_ALLOW_UNTRUSTED_ATTR; if (nsDependentString(aAllowUntrusted).EqualsLiteral("true")) { mType |= NS_HANDLER_ALLOW_UNTRUSTED; } else { mType &= ~NS_HANDLER_ALLOW_UNTRUSTED; } } }
// moved almost verbatim from mimehdrs.cpp // char * // MimeHeaders_get_parameter (const char *header_value, const char *parm_name, // char **charset, char **language) // // The format of these header lines is // <token> [ ';' <token> '=' <token-or-quoted-string> ]* NS_IMETHODIMP nsMIMEHeaderParamImpl::GetParameterInternal(const char *aHeaderValue, const char *aParamName, char **aCharset, char **aLang, char **aResult) { if (!aHeaderValue || !*aHeaderValue || !aResult) return NS_ERROR_INVALID_ARG; *aResult = nsnull; if (aCharset) *aCharset = nsnull; if (aLang) *aLang = nsnull; const char *str = aHeaderValue; // skip leading white space. for (; *str && nsCRT::IsAsciiSpace(*str); ++str) ; const char *start = str; // aParamName is empty. return the first (possibly) _unnamed_ 'parameter' // For instance, return 'inline' in the following case: // Content-Disposition: inline; filename=..... if (!aParamName || !*aParamName) { for (; *str && *str != ';' && !nsCRT::IsAsciiSpace(*str); ++str) ; if (str == start) return NS_ERROR_UNEXPECTED; *aResult = (char *) nsMemory::Clone(start, (str - start) + 1); NS_ENSURE_TRUE(*aResult, NS_ERROR_OUT_OF_MEMORY); (*aResult)[str - start] = '\0'; // null-terminate return NS_OK; } /* Skip forward to first ';' */ for (; *str && *str != ';' && *str != ','; ++str) ; if (*str) str++; /* Skip over following whitespace */ for (; *str && nsCRT::IsAsciiSpace(*str); ++str) ; // Some broken http servers just specify parameters // like 'filename' without specifying disposition // method. Rewind to the first non-white-space // character. if (!*str) str = start; // RFC2231 - The legitimate parm format can be: // A. title=ThisIsTitle // B. title*=us-ascii'en-us'This%20is%20wierd. // C. title*0*=us-ascii'en'This%20is%20wierd.%20We // title*1*=have%20to%20support%20this. // title*2="Else..." // D. title*0="Hey, what you think you are doing?" // title*1="There is no charset and lang info." PRInt32 paramLen = strlen(aParamName); while (*str) { const char *tokenStart = str; const char *tokenEnd = 0; const char *valueStart = str; const char *valueEnd = 0; NS_ASSERTION(!nsCRT::IsAsciiSpace(*str), "should be after whitespace."); // Skip forward to the end of this token. for (; *str && !nsCRT::IsAsciiSpace(*str) && *str != '=' && *str != ';'; str++) ; tokenEnd = str; // Skip over whitespace, '=', and whitespace while (nsCRT::IsAsciiSpace(*str)) ++str; if (*str == '=') ++str; while (nsCRT::IsAsciiSpace(*str)) ++str; if (*str != '"') { // The value is a token, not a quoted string. valueStart = str; for (valueEnd = str; *valueEnd && !nsCRT::IsAsciiSpace (*valueEnd) && *valueEnd != ';'; valueEnd++) ; str = valueEnd; } else { // The value is a quoted string. ++str; valueStart = str; for (valueEnd = str; *valueEnd; ++valueEnd) { if (*valueEnd == '\\') ++valueEnd; else if (*valueEnd == '"') break; } str = valueEnd + 1; } // See if this is the simplest case (case A above), // a 'single' line value with no charset and lang. // If so, copy it and return. if (tokenEnd - tokenStart == paramLen && !nsCRT::strncasecmp(tokenStart, aParamName, paramLen)) { // if the parameter spans across multiple lines we have to strip out the // line continuation -- jht 4/29/98 nsCAutoString tempStr(valueStart, valueEnd - valueStart); tempStr.StripChars("\r\n"); *aResult = ToNewCString(tempStr); NS_ENSURE_TRUE(*aResult, NS_ERROR_OUT_OF_MEMORY); return NS_OK; } // case B, C, and D else if (tokenEnd - tokenStart > paramLen && !nsCRT::strncasecmp(tokenStart, aParamName, paramLen) && *(tokenStart + paramLen) == '*') { const char *cp = tokenStart + paramLen + 1; // 1st char pass '*' PRBool needUnescape = *(tokenEnd - 1) == '*'; // the 1st line of a multi-line parameter or a single line that needs // unescaping. ( title*0*= or title*= ) if ((*cp == '0' && needUnescape) || (tokenEnd - tokenStart == paramLen + 1)) { // look for single quotation mark(') const char *sQuote1 = PL_strchr(valueStart, 0x27); const char *sQuote2 = (char *) (sQuote1 ? PL_strchr(sQuote1 + 1, 0x27) : nsnull); // Two single quotation marks must be present even in // absence of charset and lang. if (!sQuote1 || !sQuote2) NS_WARNING("Mandatory two single quotes are missing in header parameter\n"); if (aCharset && sQuote1 > valueStart && sQuote1 < valueEnd) { *aCharset = (char *) nsMemory::Clone(valueStart, sQuote1 - valueStart + 1); if (*aCharset) *(*aCharset + (sQuote1 - valueStart)) = 0; } if (aLang && sQuote1 && sQuote2 && sQuote2 > sQuote1 + 1 && sQuote2 < valueEnd) { *aLang = (char *) nsMemory::Clone(sQuote1 + 1, sQuote2 - (sQuote1 + 1) + 1); if (*aLang) *(*aLang + (sQuote2 - (sQuote1 + 1))) = 0; } // Be generous and handle gracefully when required // single quotes are absent. if (sQuote1) { if(!sQuote2) sQuote2 = sQuote1; } else sQuote2 = valueStart - 1; if (sQuote2 && sQuote2 + 1 < valueEnd) { NS_ASSERTION(!*aResult, "This is the 1st line. result buffer should be null."); *aResult = (char *) nsMemory::Alloc(valueEnd - (sQuote2 + 1) + 1); if (*aResult) { memcpy(*aResult, sQuote2 + 1, valueEnd - (sQuote2 + 1)); *(*aResult + (valueEnd - (sQuote2 + 1))) = 0; if (needUnescape) { nsUnescape(*aResult); if (tokenEnd - tokenStart == paramLen + 1) // we're done; this is case B return NS_OK; } } } } // end of if-block : title*0*= or title*= // a line of multiline param with no need for unescaping : title*[0-9]= // or 2nd or later lines of a multiline param : title*[1-9]*= else if (nsCRT::IsAsciiDigit(PRUnichar(*cp))) { PRInt32 len = 0; if (*aResult) // 2nd or later lines of multiline parameter { len = strlen(*aResult); char *ns = (char *) nsMemory::Realloc(*aResult, len + (valueEnd - valueStart) + 1); if (!ns) { nsMemory::Free(*aResult); } *aResult = ns; } else if (*cp == '0') // must be; 1st line : title*0= { *aResult = (char *) nsMemory::Alloc(valueEnd - valueStart + 1); } // else {} something is really wrong; out of memory if (*aResult) { // append a partial value memcpy(*aResult + len, valueStart, valueEnd - valueStart); *(*aResult + len + (valueEnd - valueStart)) = 0; if (needUnescape) nsUnescape(*aResult + len); } else return NS_ERROR_OUT_OF_MEMORY; } // end of if-block : title*[0-9]= or title*[1-9]*= } // str now points after the end of the value. // skip over whitespace, ';', whitespace. while (nsCRT::IsAsciiSpace(*str)) ++str; if (*str == ';') ++str; while (nsCRT::IsAsciiSpace(*str)) ++str; } if (*aResult) return NS_OK; else return NS_ERROR_INVALID_ARG; // aParameter not found !! }
void nsMenuFrame::BuildAcceleratorText() { nsAutoString accelText; if ((GetStateBits() & NS_STATE_ACCELTEXT_IS_DERIVED) == 0) { mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, accelText); if (!accelText.IsEmpty()) return; } // accelText is definitely empty here. // Now we're going to compute the accelerator text, so remember that we did. AddStateBits(NS_STATE_ACCELTEXT_IS_DERIVED); // If anything below fails, just leave the accelerator text blank. nsWeakFrame weakFrame(this); mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, PR_FALSE); ENSURE_TRUE(weakFrame.IsAlive()); // See if we have a key node and use that instead. nsAutoString keyValue; mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::key, keyValue); if (keyValue.IsEmpty()) return; // Turn the document into a DOM document so we can use getElementById nsIDocument *document = mContent->GetDocument(); if (!document) return; nsIContent *keyElement = document->GetElementById(keyValue); if (!keyElement) { #ifdef DEBUG nsAutoString label; mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::label, label); nsAutoString msg = NS_LITERAL_STRING("Key '") + keyValue + NS_LITERAL_STRING("' of menu item '") + label + NS_LITERAL_STRING("' could not be found"); NS_WARNING(NS_ConvertUTF16toUTF8(msg).get()); #endif return; } // get the string to display as accelerator text // check the key element's attributes in this order: // |keytext|, |key|, |keycode| nsAutoString accelString; keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::keytext, accelString); if (accelString.IsEmpty()) { keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::key, accelString); if (!accelString.IsEmpty()) { ToUpperCase(accelString); } else { nsAutoString keyCode; keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::keycode, keyCode); ToUpperCase(keyCode); nsresult rv; nsCOMPtr<nsIStringBundleService> bundleService = mozilla::services::GetStringBundleService(); if (bundleService) { nsCOMPtr<nsIStringBundle> bundle; rv = bundleService->CreateBundle("chrome://global/locale/keys.properties", getter_AddRefs(bundle)); if (NS_SUCCEEDED(rv) && bundle) { nsXPIDLString keyName; rv = bundle->GetStringFromName(keyCode.get(), getter_Copies(keyName)); if (keyName) accelString = keyName; } } // nothing usable found, bail if (accelString.IsEmpty()) return; } } static PRInt32 accelKey = 0; if (!accelKey) { // Compiled-in defaults, in case we can't get LookAndFeel -- // command for mac, control for all other platforms. #ifdef XP_MACOSX accelKey = nsIDOMKeyEvent::DOM_VK_META; #else accelKey = nsIDOMKeyEvent::DOM_VK_CONTROL; #endif // Get the accelerator key value from prefs, overriding the default: accelKey = nsContentUtils::GetIntPref("ui.key.accelKey", accelKey); } nsAutoString modifiers; keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::modifiers, modifiers); char* str = ToNewCString(modifiers); char* newStr; char* token = nsCRT::strtok(str, ", \t", &newStr); while (token) { if (PL_strcmp(token, "shift") == 0) accelText += *gShiftText; else if (PL_strcmp(token, "alt") == 0) accelText += *gAltText; else if (PL_strcmp(token, "meta") == 0) accelText += *gMetaText; else if (PL_strcmp(token, "control") == 0) accelText += *gControlText; else if (PL_strcmp(token, "accel") == 0) { switch (accelKey) { case nsIDOMKeyEvent::DOM_VK_META: accelText += *gMetaText; break; case nsIDOMKeyEvent::DOM_VK_ALT: accelText += *gAltText; break; case nsIDOMKeyEvent::DOM_VK_CONTROL: default: accelText += *gControlText; break; } } accelText += *gModifierSeparator; token = nsCRT::strtok(newStr, ", \t", &newStr); } nsMemory::Free(str); accelText += accelString; mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, accelText, PR_FALSE); }
/** * Obtains all of the information currently available for this plugin. */ nsresult nsPluginFile::GetPluginInfo(nsPluginInfo& info, PRLibrary **outLibrary) { *outLibrary = nsnull; info.fVersion = nsnull; nsCAutoString fullPath; if (NS_FAILED(rv = mPlugin->GetNativePath(fullPath))) return rv; nsCAutoString fileName; if (NS_FAILED(rv = mPlugin->GetNativeLeafName(fileName))) return rv; const char *path = fullPath.get(); int i; #ifdef NS_PLUGIN_BEOS_DEBUG printf("nsPluginFile::GetPluginInfo() an attempt to load MIME String\n"); printf("path = <%s>\n", path); #endif // get supported mime types BFile file(path, B_READ_ONLY); if (file.InitCheck() != B_OK) return NS_ERROR_FAILURE; BAppFileInfo appinfo(&file); if (appinfo.InitCheck() != B_OK) return NS_ERROR_FAILURE; BMessage msg; if (appinfo.GetSupportedTypes(&msg) != B_OK) return NS_ERROR_FAILURE; uint32 type; int32 types_num; if (msg.GetInfo("types", &type, &types_num) != B_OK || type != B_STRING_TYPE) return NS_ERROR_FAILURE; // set mime types to plugin info info.fMimeTypeArray =(char **)PR_Malloc(types_num * sizeof(char *)); info.fMimeDescriptionArray =(char **)PR_Malloc(types_num * sizeof(char *)); info.fExtensionArray =(char **)PR_Malloc(types_num * sizeof(char *)); for (i = 0 ; i < types_num ; i ++) { // get mime string const char *mtype; if (msg.FindString("types", i, &mtype) != B_OK) { types_num = i; break; } // get (short)description for the mime char desc[B_MIME_TYPE_LENGTH+1] = ""; BMimeType mime(mtype) ; if (mime.InitCheck() == B_OK) mime.GetShortDescription(desc); // get file extensions for the mime char extensions[B_MIME_TYPE_LENGTH+1] = ""; GetMimeExtensions(mtype, extensions, B_MIME_TYPE_LENGTH+1); #ifdef NS_PLUGIN_BEOS_DEBUG printf(" mime = %30s | %10s | %15s |\n", mtype, extensions, desc); #endif info.fMimeTypeArray[i] = PL_strdup( mtype ? mtype : (char *)"" ) ; info.fMimeDescriptionArray[i] = PL_strdup( desc ) ; info.fExtensionArray[i] = PL_strdup( extensions ); } // get name and description of this plugin version_info vinfo; if (appinfo.GetVersionInfo(&vinfo, B_APP_VERSION_KIND) == B_OK && *vinfo.short_info) { // XXX convert UTF-8 2byte chars to 1 byte chars, to avoid string corruption info.fName = ToNewCString(NS_ConvertUTF8toUTF16(vinfo.short_info)); info.fDescription = ToNewCString(NS_ConvertUTF8toUTF16(vinfo.long_info)); } else { // use filename as its name info.fName = GetFileName(path); info.fDescription = PL_strdup(""); } info.fVariantCount = types_num; info.fFullPath = PL_strdup(fullPath.get()); info.fFileName = PL_strdup(fileName.get()); #ifdef NS_PLUGIN_BEOS_DEBUG printf("info.fFileName = %s\n", info.fFileName); printf("info.fName = %s\n", info.fName); printf("info.fDescription = %s\n", info.fDescription); #endif return NS_OK; }
nsresult nsKeygenFormProcessor::GetPublicKey(const nsAString& aValue, const nsAString& aChallenge, const nsAFlatString& aKeyType, nsAString& aOutPublicKey, const nsAString& aKeyParams) { nsNSSShutDownPreventionLock locker; if (isAlreadyShutDown()) { return NS_ERROR_NOT_AVAILABLE; } nsresult rv = NS_ERROR_FAILURE; char *keystring = nullptr; char *keyparamsString = nullptr; uint32_t keyGenMechanism; PK11SlotInfo *slot = nullptr; PK11RSAGenParams rsaParams; SECOidTag algTag; int keysize = 0; void *params = nullptr; SECKEYPrivateKey *privateKey = nullptr; SECKEYPublicKey *publicKey = nullptr; CERTSubjectPublicKeyInfo *spkInfo = nullptr; SECStatus srv = SECFailure; SECItem spkiItem; SECItem pkacItem; SECItem signedItem; CERTPublicKeyAndChallenge pkac; pkac.challenge.data = nullptr; nsIGeneratingKeypairInfoDialogs * dialogs; nsKeygenThread *KeygenRunnable = 0; nsCOMPtr<nsIKeygenThread> runnable; // permanent and sensitive flags for keygen PK11AttrFlags attrFlags = PK11_ATTR_TOKEN | PK11_ATTR_SENSITIVE | PK11_ATTR_PRIVATE; UniquePLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE)); if (!arena) { goto loser; } // Get the key size // for (size_t i = 0; i < number_of_key_size_choices; ++i) { if (aValue.Equals(mSECKeySizeChoiceList[i].name)) { keysize = mSECKeySizeChoiceList[i].size; break; } } if (!keysize) { goto loser; } // Set the keygen mechanism if (aKeyType.IsEmpty() || aKeyType.LowerCaseEqualsLiteral("rsa")) { keyGenMechanism = CKM_RSA_PKCS_KEY_PAIR_GEN; } else if (aKeyType.LowerCaseEqualsLiteral("ec")) { keyparamsString = ToNewCString(aKeyParams); if (!keyparamsString) { rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } keyGenMechanism = CKM_EC_KEY_PAIR_GEN; /* ecParams are initialized later */ } else { goto loser; } // Get the slot rv = GetSlot(keyGenMechanism, &slot); if (NS_FAILED(rv)) { goto loser; } switch (keyGenMechanism) { case CKM_RSA_PKCS_KEY_PAIR_GEN: rsaParams.keySizeInBits = keysize; rsaParams.pe = DEFAULT_RSA_KEYGEN_PE; algTag = DEFAULT_RSA_KEYGEN_ALG; params = &rsaParams; break; case CKM_EC_KEY_PAIR_GEN: /* XXX We ought to rethink how the KEYGEN tag is * displayed. The pulldown selections presented * to the user must depend on the keytype. * The displayed selection could be picked * from the keyparams attribute (this is currently called * the pqg attribute). * For now, we pick ecparams from the keyparams field * if it specifies a valid supported curve, or else * we pick one of secp384r1, secp256r1 or secp192r1 * respectively depending on the user's selection * (High, Medium, Low). * (RSA uses RSA-2048, RSA-1024 and RSA-512 for historical * reasons, while ECC choices represent a stronger mapping) * NOTE: The user's selection * is silently ignored when a valid curve is presented * in keyparams. */ if ((params = decode_ec_params(keyparamsString)) == nullptr) { /* The keyparams attribute did not specify a valid * curve name so use a curve based on the keysize. * NOTE: Here keysize is used only as an indication of * High/Medium/Low strength; elliptic curve * cryptography uses smaller keys than RSA to provide * equivalent security. */ switch (keysize) { case 2048: params = decode_ec_params("secp384r1"); break; case 1024: case 512: params = decode_ec_params("secp256r1"); break; } } /* XXX The signature algorithm ought to choose the hashing * algorithm based on key size once ECDSA variations based * on SHA256 SHA384 and SHA512 are standardized. */ algTag = SEC_OID_ANSIX962_ECDSA_SIGNATURE_WITH_SHA1_DIGEST; break; default: goto loser; } /* Make sure token is initialized. */ rv = setPassword(slot, m_ctx, locker); if (NS_FAILED(rv)) goto loser; srv = PK11_Authenticate(slot, true, m_ctx); if (srv != SECSuccess) { goto loser; } rv = getNSSDialogs((void**)&dialogs, NS_GET_IID(nsIGeneratingKeypairInfoDialogs), NS_GENERATINGKEYPAIRINFODIALOGS_CONTRACTID); if (NS_SUCCEEDED(rv)) { KeygenRunnable = new nsKeygenThread(); NS_IF_ADDREF(KeygenRunnable); } if (NS_FAILED(rv) || !KeygenRunnable) { rv = NS_OK; privateKey = PK11_GenerateKeyPairWithFlags(slot, keyGenMechanism, params, &publicKey, attrFlags, m_ctx); } else { KeygenRunnable->SetParams( slot, attrFlags, nullptr, 0, keyGenMechanism, params, m_ctx ); runnable = do_QueryInterface(KeygenRunnable); if (runnable) { rv = dialogs->DisplayGeneratingKeypairInfo(m_ctx, runnable); // We call join on the thread so we can be sure that no // simultaneous access to the passed parameters will happen. KeygenRunnable->Join(); NS_RELEASE(dialogs); if (NS_SUCCEEDED(rv)) { PK11SlotInfo *used_slot = nullptr; rv = KeygenRunnable->ConsumeResult(&used_slot, &privateKey, &publicKey); if (NS_SUCCEEDED(rv) && used_slot) { PK11_FreeSlot(used_slot); } } } } if (NS_FAILED(rv) || !privateKey) { goto loser; } // just in case we'll need to authenticate to the db -jp // privateKey->wincx = m_ctx; /* * Create a subject public key info from the public key. */ spkInfo = SECKEY_CreateSubjectPublicKeyInfo(publicKey); if ( !spkInfo ) { goto loser; } /* * Now DER encode the whole subjectPublicKeyInfo. */ srv = DER_Encode(arena.get(), &spkiItem, CERTSubjectPublicKeyInfoTemplate, spkInfo); if (srv != SECSuccess) { goto loser; } /* * set up the PublicKeyAndChallenge data structure, then DER encode it */ pkac.spki = spkiItem; pkac.challenge.len = aChallenge.Length(); pkac.challenge.data = (unsigned char *)ToNewCString(aChallenge); if (!pkac.challenge.data) { rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } srv = DER_Encode(arena.get(), &pkacItem, CERTPublicKeyAndChallengeTemplate, &pkac); if (srv != SECSuccess) { goto loser; } /* * now sign the DER encoded PublicKeyAndChallenge */ srv = SEC_DerSignData(arena.get(), &signedItem, pkacItem.data, pkacItem.len, privateKey, algTag); if (srv != SECSuccess) { goto loser; } /* * Convert the signed public key and challenge into base64/ascii. */ keystring = BTOA_DataToAscii(signedItem.data, signedItem.len); if (!keystring) { rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } CopyASCIItoUTF16(keystring, aOutPublicKey); free(keystring); rv = NS_OK; GatherKeygenTelemetry(keyGenMechanism, keysize, keyparamsString); loser: if (srv != SECSuccess) { if ( privateKey ) { PK11_DestroyTokenObject(privateKey->pkcs11Slot,privateKey->pkcs11ID); } if ( publicKey ) { PK11_DestroyTokenObject(publicKey->pkcs11Slot,publicKey->pkcs11ID); } } if ( spkInfo ) { SECKEY_DestroySubjectPublicKeyInfo(spkInfo); } if ( publicKey ) { SECKEY_DestroyPublicKey(publicKey); } if ( privateKey ) { SECKEY_DestroyPrivateKey(privateKey); } if (slot) { PK11_FreeSlot(slot); } if (KeygenRunnable) { NS_RELEASE(KeygenRunnable); } if (keyparamsString) { free(keyparamsString); } if (pkac.challenge.data) { free(pkac.challenge.data); } // If params is non-null and doesn't point to rsaParams, it was allocated // in decode_ec_params. We have to free this memory. if (params && params != &rsaParams) { SECITEM_FreeItem(static_cast<SECItem*>(params), true); params = nullptr; } return rv; }
void printString(nsString &str) { const char *cstr = ToNewCString(str); printf("%s", cstr); delete [] (char*)cstr; }
// XXX currently you can not add the same adjacency (i.e. you can't have multiple // XXX stream converters registering to handle the same from-to combination. It's // XXX not programatically prohibited, it's just that results are un-predictable // XXX right now. nsresult nsStreamConverterService::AddAdjacency(const char *aContractID) { nsresult rv; // first parse out the FROM and TO MIME-types. nsAutoCString fromStr, toStr; rv = ParseFromTo(aContractID, fromStr, toStr); if (NS_FAILED(rv)) return rv; // Each MIME-type is a vertex in the graph, so first lets make sure // each MIME-type is represented as a key in our hashtable. nsCStringKey fromKey(fromStr); SCTableData *fromEdges = (SCTableData*)mAdjacencyList->Get(&fromKey); if (!fromEdges) { // There is no fromStr vertex, create one. nsCStringKey *newFromKey = new nsCStringKey(ToNewCString(fromStr), fromStr.Length(), nsCStringKey::OWN); if (!newFromKey) return NS_ERROR_OUT_OF_MEMORY; SCTableData *data = new SCTableData(newFromKey); if (!data) { delete newFromKey; return NS_ERROR_OUT_OF_MEMORY; } nsCOMArray<nsIAtom>* edgeArray = new nsCOMArray<nsIAtom>; if (!edgeArray) { delete newFromKey; data->key = nullptr; delete data; return NS_ERROR_OUT_OF_MEMORY; } data->data.edges = edgeArray; mAdjacencyList->Put(newFromKey, data); fromEdges = data; } nsCStringKey toKey(toStr); if (!mAdjacencyList->Get(&toKey)) { // There is no toStr vertex, create one. nsCStringKey *newToKey = new nsCStringKey(ToNewCString(toStr), toStr.Length(), nsCStringKey::OWN); if (!newToKey) return NS_ERROR_OUT_OF_MEMORY; SCTableData *data = new SCTableData(newToKey); if (!data) { delete newToKey; return NS_ERROR_OUT_OF_MEMORY; } nsCOMArray<nsIAtom>* edgeArray = new nsCOMArray<nsIAtom>; if (!edgeArray) { delete newToKey; data->key = nullptr; delete data; return NS_ERROR_OUT_OF_MEMORY; } data->data.edges = edgeArray; mAdjacencyList->Put(newToKey, data); } // Now we know the FROM and TO types are represented as keys in the hashtable. // Let's "connect" the verticies, making an edge. nsCOMPtr<nsIAtom> vertex = do_GetAtom(toStr); if (!vertex) return NS_ERROR_OUT_OF_MEMORY; NS_ASSERTION(fromEdges, "something wrong in adjacency list construction"); if (!fromEdges) return NS_ERROR_FAILURE; nsCOMArray<nsIAtom> *adjacencyList = fromEdges->data.edges; return adjacencyList->AppendObject(vertex) ? NS_OK : NS_ERROR_FAILURE; }
nsresult nsMsgSearchAdapter::EncodeImapTerm (nsIMsgSearchTerm *term, bool reallyDredd, const PRUnichar *srcCharset, const PRUnichar *destCharset, char **ppOutTerm) { NS_ENSURE_ARG_POINTER(term); NS_ENSURE_ARG_POINTER(ppOutTerm); nsresult err = NS_OK; bool useNot = false; bool useQuotes = false; bool ignoreValue = false; nsCAutoString arbitraryHeader; const char *whichMnemonic = nsnull; const char *orHeaderMnemonic = nsnull; *ppOutTerm = nsnull; nsCOMPtr <nsIMsgSearchValue> searchValue; nsresult rv = term->GetValue(getter_AddRefs(searchValue)); NS_ENSURE_SUCCESS(rv,rv); nsMsgSearchOpValue op; term->GetOp(&op); if (op == nsMsgSearchOp::DoesntContain || op == nsMsgSearchOp::Isnt) useNot = true; nsMsgSearchAttribValue attrib; term->GetAttrib(&attrib); switch (attrib) { case nsMsgSearchAttrib::ToOrCC: orHeaderMnemonic = m_kImapCC; // fall through to case nsMsgSearchAttrib::To: case nsMsgSearchAttrib::To: whichMnemonic = m_kImapTo; break; case nsMsgSearchAttrib::CC: whichMnemonic = m_kImapCC; break; case nsMsgSearchAttrib::Sender: whichMnemonic = m_kImapFrom; break; case nsMsgSearchAttrib::Subject: whichMnemonic = m_kImapSubject; break; case nsMsgSearchAttrib::Body: whichMnemonic = m_kImapBody; break; case nsMsgSearchAttrib::AgeInDays: // added for searching online for age in days... // for AgeInDays, we are actually going to perform a search by date, so convert the operations for age // to the IMAP mnemonics that we would use for date! { // If we have a future date, the > and < are reversed. // e.g. ageInDays > 2 means more than 2 days old ("date before X") whereas // ageInDays > -2 should be more than 2 days in the future ("date after X") PRInt32 ageInDays; searchValue->GetAge(&ageInDays); bool dateInFuture = (ageInDays < 0); switch (op) { case nsMsgSearchOp::IsGreaterThan: whichMnemonic = (!dateInFuture) ? m_kImapBefore : m_kImapSince; break; case nsMsgSearchOp::IsLessThan: whichMnemonic = (!dateInFuture) ? m_kImapSince : m_kImapBefore; break; case nsMsgSearchOp::Is: whichMnemonic = m_kImapSentOn; break; default: NS_ASSERTION(false, "invalid search operator"); return NS_ERROR_INVALID_ARG; } } break; case nsMsgSearchAttrib::Size: switch (op) { case nsMsgSearchOp::IsGreaterThan: whichMnemonic = m_kImapSizeLarger; break; case nsMsgSearchOp::IsLessThan: whichMnemonic = m_kImapSizeSmaller; break; default: NS_ASSERTION(false, "invalid search operator"); return NS_ERROR_INVALID_ARG; } break; case nsMsgSearchAttrib::Date: switch (op) { case nsMsgSearchOp::IsBefore: whichMnemonic = m_kImapBefore; break; case nsMsgSearchOp::IsAfter: whichMnemonic = m_kImapSince; break; case nsMsgSearchOp::Isnt: /* we've already added the "Not" so just process it like it was a date is search */ case nsMsgSearchOp::Is: whichMnemonic = m_kImapSentOn; break; default: NS_ASSERTION(false, "invalid search operator"); return NS_ERROR_INVALID_ARG; } break; case nsMsgSearchAttrib::AnyText: whichMnemonic = m_kImapAnyText; break; case nsMsgSearchAttrib::Keywords: whichMnemonic = m_kImapKeyword; break; case nsMsgSearchAttrib::MsgStatus: useNot = false; // bizarrely, NOT SEEN is wrong, but UNSEEN is right. ignoreValue = true; // the mnemonic is all we need PRUint32 status; searchValue->GetStatus(&status); switch (status) { case nsMsgMessageFlags::Read: whichMnemonic = op == nsMsgSearchOp::Is ? m_kImapSeen : m_kImapNotSeen; break; case nsMsgMessageFlags::Replied: whichMnemonic = op == nsMsgSearchOp::Is ? m_kImapAnswered : m_kImapNotAnswered; break; case nsMsgMessageFlags::New: whichMnemonic = op == nsMsgSearchOp::Is ? m_kImapNew : m_kImapNotNew; break; case nsMsgMessageFlags::Marked: whichMnemonic = op == nsMsgSearchOp::Is ? m_kImapFlagged : m_kImapNotFlagged; break; default: NS_ASSERTION(false, "invalid search operator"); return NS_ERROR_INVALID_ARG; } break; default: if ( attrib > nsMsgSearchAttrib::OtherHeader && attrib < nsMsgSearchAttrib::kNumMsgSearchAttributes) { nsCString arbitraryHeaderTerm; term->GetArbitraryHeader(arbitraryHeaderTerm); if (!arbitraryHeaderTerm.IsEmpty()) { arbitraryHeader.AssignLiteral(" \""); arbitraryHeader.Append(arbitraryHeaderTerm); arbitraryHeader.AppendLiteral("\" "); whichMnemonic = arbitraryHeader.get(); } else return NS_ERROR_FAILURE; } else { NS_ASSERTION(false, "invalid search operator"); return NS_ERROR_INVALID_ARG; } } char *value = nsnull; char dateBuf[100]; dateBuf[0] = '\0'; bool valueWasAllocated = false; if (attrib == nsMsgSearchAttrib::Date) { // note that there used to be code here that encoded an RFC822 date for imap searches. // The IMAP RFC 2060 is misleading to the point that it looks like it requires an RFC822 // date but really it expects dd-mmm-yyyy, like dredd, and refers to the RFC822 date only in that the // dd-mmm-yyyy date will match the RFC822 date within the message. PRTime adjustedDate; searchValue->GetDate(&adjustedDate); if (whichMnemonic == m_kImapSince) { // it looks like the IMAP server searches on Since includes the date in question... // our UI presents Is, IsGreater and IsLessThan. For the IsGreater case (m_kImapSince) // we need to adjust the date so we get greater than and not greater than or equal to which // is what the IMAP server wants to search on // won't work on Mac. // ack, is this right? is PRTime seconds or microseconds? PRInt64 microSecondsPerSecond, secondsInDay, microSecondsInDay; LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC); LL_UI2L(secondsInDay, 60 * 60 * 24); LL_MUL(microSecondsInDay, secondsInDay, microSecondsPerSecond); LL_ADD(adjustedDate, adjustedDate, microSecondsInDay); // bump up to the day after this one... } PRExplodedTime exploded; PR_ExplodeTime(adjustedDate, PR_LocalTimeParameters, &exploded); PR_FormatTimeUSEnglish(dateBuf, sizeof(dateBuf), "%d-%b-%Y", &exploded); // strftime (dateBuf, sizeof(dateBuf), "%d-%b-%Y", localtime (/* &term->m_value.u.date */ &adjustedDate)); value = dateBuf; } else { if (attrib == nsMsgSearchAttrib::AgeInDays) { // okay, take the current date, subtract off the age in days, then do an appropriate Date search on // the resulting day. PRInt32 ageInDays; searchValue->GetAge(&ageInDays); PRTime now = PR_Now(); PRTime matchDay; PRInt64 microSecondsPerSecond, secondsInDays, microSecondsInDay; LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC); LL_I2L(secondsInDays, 60 * 60 * 24 * ageInDays); LL_MUL(microSecondsInDay, secondsInDays, microSecondsPerSecond); LL_SUB(matchDay, now, microSecondsInDay); // = now - term->m_value.u.age * 60 * 60 * 24; PRExplodedTime exploded; PR_ExplodeTime(matchDay, PR_LocalTimeParameters, &exploded); PR_FormatTimeUSEnglish(dateBuf, sizeof(dateBuf), "%d-%b-%Y", &exploded); // strftime (dateBuf, sizeof(dateBuf), "%d-%b-%Y", localtime (&matchDay)); value = dateBuf; } else if (attrib == nsMsgSearchAttrib::Size) { PRUint32 sizeValue; nsCAutoString searchTermValue; searchValue->GetSize(&sizeValue); // Multiply by 1024 to get into kb resolution sizeValue *= 1024; // Ensure that greater than is really greater than // in kb resolution. if (op == nsMsgSearchOp::IsGreaterThan) sizeValue += 1024; searchTermValue.AppendInt(sizeValue); value = ToNewCString(searchTermValue); valueWasAllocated = true; } else if (IS_STRING_ATTRIBUTE(attrib)) { PRUnichar *convertedValue; // = reallyDredd ? MSG_EscapeSearchUrl (term->m_value.u.string) : msg_EscapeImapSearchProtocol(term->m_value.u.string); nsString searchTermValue; searchValue->GetStr(searchTermValue); // Ugly switch for Korean mail/news charsets. // We want to do this here because here is where // we know what charset we want to use. #ifdef DOING_CHARSET if (reallyDredd) dest_csid = INTL_DefaultNewsCharSetID(dest_csid); else dest_csid = INTL_DefaultMailCharSetID(dest_csid); #endif // do all sorts of crazy escaping convertedValue = reallyDredd ? EscapeSearchUrl (searchTermValue.get()) : EscapeImapSearchProtocol(searchTermValue.get()); useQuotes = ((!reallyDredd || (nsDependentString(convertedValue).FindChar(PRUnichar(' ')) != -1)) && (attrib != nsMsgSearchAttrib::Keywords)); // now convert to char* and escape quoted_specials nsCAutoString valueStr; nsresult rv = ConvertFromUnicode(NS_LossyConvertUTF16toASCII(destCharset).get(), nsDependentString(convertedValue), valueStr); if (NS_SUCCEEDED(rv)) { const char *vptr = valueStr.get(); // max escaped length is one extra character for every character in the cmd. nsAutoArrayPtr<char> newValue(new char[2*strlen(vptr) + 1]); if (newValue) { char *p = newValue; while (1) { char ch = *vptr++; if (!ch) break; if ((useQuotes ? ch == '"' : 0) || ch == '\\') *p++ = '\\'; *p++ = ch; } *p = '\0'; value = strdup(newValue); // realloc down to smaller size } } else value = strdup(""); NS_Free(convertedValue); valueWasAllocated = true; } } // this should be rewritten to use nsCString int subLen = (value ? strlen(value) : 0) + (useNot ? strlen(m_kImapNot) : 0) + strlen(m_kImapHeader); int len = strlen(whichMnemonic) + subLen + (useQuotes ? 2 : 0) + (orHeaderMnemonic ? (subLen + strlen(m_kImapOr) + strlen(orHeaderMnemonic) + 2 /*""*/) : 0) + 10; // add slough for imap string literals char *encoding = new char[len]; if (encoding) { encoding[0] = '\0'; // Remember: if ToOrCC and useNot then the expression becomes NOT To AND Not CC as opposed to (NOT TO) || (NOT CC) if (orHeaderMnemonic && !useNot) PL_strcat(encoding, m_kImapOr); if (useNot) PL_strcat (encoding, m_kImapNot); if (!arbitraryHeader.IsEmpty()) PL_strcat (encoding, m_kImapHeader); PL_strcat (encoding, whichMnemonic); if (!ignoreValue) err = EncodeImapValue(encoding, value, useQuotes, reallyDredd); if (orHeaderMnemonic) { if (useNot) PL_strcat(encoding, m_kImapNot); PL_strcat (encoding, m_kImapHeader); PL_strcat (encoding, orHeaderMnemonic); if (!ignoreValue) err = EncodeImapValue(encoding, value, useQuotes, reallyDredd); } // kmcentee, don't let the encoding end with whitespace, // this throws off later url STRCMP if (*encoding && *(encoding + strlen(encoding) - 1) == ' ') *(encoding + strlen(encoding) - 1) = '\0'; } if (value && valueWasAllocated) NS_Free (value); *ppOutTerm = encoding; return err; }
NS_IMETHODIMP nsLDAPOperation::SearchExt(const nsACString& aBaseDn, PRInt32 aScope, const nsACString& aFilter, const nsACString &aAttributes, PRIntervalTime aTimeOut, PRInt32 aSizeLimit) { if (!mMessageListener) { NS_ERROR("nsLDAPOperation::SearchExt(): mMessageListener not set"); return NS_ERROR_NOT_INITIALIZED; } // XXX add control logging PR_LOG(gLDAPLogModule, PR_LOG_DEBUG, ("nsLDAPOperation::SearchExt(): called with aBaseDn = '%s'; " "aFilter = '%s'; aAttributes = %s; aSizeLimit = %d", PromiseFlatCString(aBaseDn).get(), PromiseFlatCString(aFilter).get(), PromiseFlatCString(aAttributes).get(), aSizeLimit)); LDAPControl **serverctls = 0; nsresult rv; if (mServerControls) { rv = convertControlArray(mServerControls, &serverctls); if (NS_FAILED(rv)) { PR_LOG(gLDAPLogModule, PR_LOG_ERROR, ("nsLDAPOperation::SearchExt(): error converting server " "control array: %x", rv)); return rv; } } LDAPControl **clientctls = 0; if (mClientControls) { rv = convertControlArray(mClientControls, &clientctls); if (NS_FAILED(rv)) { PR_LOG(gLDAPLogModule, PR_LOG_ERROR, ("nsLDAPOperation::SearchExt(): error converting client " "control array: %x", rv)); ldap_controls_free(serverctls); return rv; } } // Convert our comma separated string to one that the C-SDK will like, i.e. // convert to a char array and add a last NULL element. nsTArray<nsCString> attrArray; ParseString(aAttributes, ',', attrArray); char **attrs = nsnull; PRUint32 origLength = attrArray.Length(); if (origLength) { attrs = static_cast<char **> (NS_Alloc((origLength + 1) * sizeof(char *))); if (!attrs) return NS_ERROR_OUT_OF_MEMORY; for (PRUint32 i = 0; i < origLength; ++i) attrs[i] = ToNewCString(attrArray[i]); attrs[origLength] = 0; } // XXX deal with timeout here int retVal = ldap_search_ext(mConnectionHandle, PromiseFlatCString(aBaseDn).get(), aScope, PromiseFlatCString(aFilter).get(), attrs, 0, serverctls, clientctls, 0, aSizeLimit, &mMsgID); // clean up ldap_controls_free(serverctls); ldap_controls_free(clientctls); // The last entry is null, so no need to free that. NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(origLength, attrs); rv = TranslateLDAPErrorToNSError(retVal); NS_ENSURE_SUCCESS(rv, rv); // make sure the connection knows where to call back once the messages // for this operation start coming in // rv = mConnection->AddPendingOperation(mMsgID, this); if (NS_FAILED(rv)) { switch (rv) { case NS_ERROR_OUT_OF_MEMORY: (void)ldap_abandon_ext(mConnectionHandle, mMsgID, 0, 0); return NS_ERROR_OUT_OF_MEMORY; default: (void)ldap_abandon_ext(mConnectionHandle, mMsgID, 0, 0); NS_ERROR("nsLDAPOperation::SearchExt(): unexpected error in " "mConnection->AddPendingOperation"); return NS_ERROR_UNEXPECTED; } } return NS_OK; }
//------------------------------------------------------------------------- // // Show - Display the file dialog // //------------------------------------------------------------------------- NS_IMETHODIMP nsFilePicker::Show(PRInt16 *retval) { NS_ENSURE_ARG_POINTER(retval); PRBool result = PR_FALSE; nsCAutoString fileBuffer; char *converted = ConvertToFileSystemCharset(mDefault); if (nsnull == converted) { LossyCopyUTF16toASCII(mDefault, fileBuffer); } else { fileBuffer.Assign(converted); nsMemory::Free( converted ); } char *title = ConvertToFileSystemCharset(mTitle); if (nsnull == title) title = ToNewCString(mTitle); nsCAutoString initialDir; if (mDisplayDirectory) mDisplayDirectory->GetNativePath(initialDir); // If no display directory, re-use the last one. if(initialDir.IsEmpty()) initialDir = mLastUsedDirectory; mFile.Truncate(); FILEDLG filedlg; memset(&filedlg, 0, sizeof(FILEDLG)); filedlg.cbSize = sizeof(FILEDLG); filedlg.pszTitle = title; if (mMode == modeGetFolder) { PL_strncat(filedlg.szFullFile, initialDir.get(), MAX_PATH); PL_strncat(filedlg.szFullFile, "\\", 1); PL_strncat(filedlg.szFullFile, "^", 1); filedlg.fl = FDS_OPEN_DIALOG | FDS_CENTER; filedlg.pfnDlgProc = DirDialogProc; DosError(FERR_DISABLEHARDERR); WinFileDlg(HWND_DESKTOP, mWnd, &filedlg); DosError(FERR_ENABLEHARDERR); char* tempptr = strstr(filedlg.szFullFile, "^"); if (tempptr) *tempptr = '\0'; if (filedlg.lReturn == DID_OK) { result = PR_TRUE; if (!mDisplayDirectory) mDisplayDirectory = do_CreateInstance("@mozilla.org/file/local;1"); if (mDisplayDirectory) mDisplayDirectory->InitWithNativePath(nsDependentCString(filedlg.szFullFile)); mFile.Assign(filedlg.szFullFile); } } else { PL_strncpy(filedlg.szFullFile, initialDir.get(), MAX_PATH); PL_strncat(filedlg.szFullFile, "\\", 1); PL_strncat(filedlg.szFullFile, fileBuffer.get(), MAX_PATH); filedlg.fl = FDS_CENTER; if (mMode == modeSave) { filedlg.fl |= FDS_SAVEAS_DIALOG | FDS_ENABLEFILELB; } else if (mMode == modeOpenMultiple) { filedlg.fl |= FDS_MULTIPLESEL | FDS_OPEN_DIALOG; } else { filedlg.fl |= FDS_OPEN_DIALOG; } PMYDATA pmydata; pmydata = (PMYDATA)calloc(1, sizeof(MYDATA)); filedlg.ulUser = (ULONG)pmydata; filedlg.pfnDlgProc = FileDialogProc; PRUint32 i; PSZ *apszTypeList; apszTypeList = (PSZ *)malloc(mTitles.Length()*sizeof(PSZ)+1); for (i = 0; i < mTitles.Length(); i++) { const nsString& typeWide = mTitles[i]; nsAutoCharBuffer buffer; PRInt32 bufLength; WideCharToMultiByte(0, typeWide.get(), typeWide.Length(), buffer, bufLength); apszTypeList[i] = ToNewCString(nsDependentCString(buffer.Elements())); } apszTypeList[i] = 0; filedlg.papszITypeList = (PAPSZ)apszTypeList; PSZ *apszFilterList; apszFilterList = (PSZ *)malloc(mFilters.Length()*sizeof(PSZ)+1); for (i = 0; i < mFilters.Length(); i++) { const nsString& filterWide = mFilters[i]; apszFilterList[i] = ToNewCString(filterWide); } apszFilterList[i] = 0; pmydata->papszIFilterList = (PAPSZ)apszFilterList; pmydata->ulCurExt = mSelectedType; PRBool fileExists; do { DosError(FERR_DISABLEHARDERR); WinFileDlg(HWND_DESKTOP, mWnd, &filedlg); DosError(FERR_ENABLEHARDERR); if ((filedlg.lReturn == DID_OK) && (mMode == modeSave)) { PRFileInfo64 fileinfo64; PRStatus status = PR_GetFileInfo64(filedlg.szFullFile, &fileinfo64); if (status == PR_SUCCESS) { fileExists = PR_TRUE; } else { fileExists = PR_FALSE; } if (fileExists) { if (!gpszFDSaveCaption) { HMODULE hmod; char LoadError[CCHMAXPATH]; char loadedString[256]; int length; DosLoadModule(LoadError, CCHMAXPATH, "PMSDMRI", &hmod); length = WinLoadString((HAB)0, hmod, 1110, 256, loadedString); gpszFDSaveCaption = (char*)malloc(length+1); strcpy(gpszFDSaveCaption, loadedString); length = WinLoadString((HAB)0, hmod, 1135, 256, loadedString); gpszFDFileExists = (char*)malloc(length+1); strcpy(gpszFDFileExists, loadedString); length = WinLoadString((HAB)0, hmod, 1136, 256, loadedString); gpszFDFileReadOnly = (char*)malloc(length+1); strcpy(gpszFDFileReadOnly, loadedString); int i; for (i=0;i<256 && gpszFDFileExists[i];i++ ) { if (gpszFDFileExists[i] == '%') { gpszFDFileExists[i+1] = 's'; break; } } for (i=0;i<256 && gpszFDFileReadOnly[i];i++ ) { if (gpszFDFileReadOnly[i] == '%') { gpszFDFileReadOnly[i+1] = 's'; break; } } DosFreeModule(hmod); } char pszFullText[256+CCHMAXPATH]; FILESTATUS3 fsts3; ULONG ulResponse; DosQueryPathInfo( filedlg.szFullFile, FIL_STANDARD, &fsts3, sizeof(FILESTATUS3)); if (fsts3.attrFile & FILE_READONLY) { sprintf(pszFullText, gpszFDFileReadOnly, filedlg.szFullFile); ulResponse = WinMessageBox(HWND_DESKTOP, mWnd, pszFullText, gpszFDSaveCaption, 0, MB_OK | MB_MOVEABLE | MB_WARNING); } else { sprintf(pszFullText, gpszFDFileExists, filedlg.szFullFile); ulResponse = WinMessageBox(HWND_DESKTOP, mWnd, pszFullText, gpszFDSaveCaption, 0, MB_YESNO | MB_MOVEABLE | MB_WARNING); } if (ulResponse == MBID_YES) { fileExists = PR_FALSE; } } } } while (mMode == modeSave && fileExists && filedlg.lReturn == DID_OK); if (filedlg.lReturn == DID_OK) { result = PR_TRUE; if (mMode == modeOpenMultiple) { nsresult rv; if (filedlg.papszFQFilename) { for (ULONG i=0;i<filedlg.ulFQFCount;i++) { nsCOMPtr<nsILocalFile> file = do_CreateInstance("@mozilla.org/file/local;1", &rv); NS_ENSURE_SUCCESS(rv,rv); rv = file->InitWithNativePath(nsDependentCString(*(filedlg.papszFQFilename)[i])); NS_ENSURE_SUCCESS(rv,rv); rv = mFiles.AppendObject(file); NS_ENSURE_SUCCESS(rv,rv); } WinFreeFileDlgList(filedlg.papszFQFilename); } else { nsCOMPtr<nsILocalFile> file = do_CreateInstance("@mozilla.org/file/local;1", &rv); NS_ENSURE_SUCCESS(rv,rv); rv = file->InitWithNativePath(nsDependentCString(filedlg.szFullFile)); NS_ENSURE_SUCCESS(rv,rv); rv = mFiles.AppendObject(file); NS_ENSURE_SUCCESS(rv,rv); } } else { mFile.Assign(filedlg.szFullFile); } mSelectedType = (PRInt16)pmydata->ulCurExt; } for (i = 0; i < mTitles.Length(); i++) { nsMemory::Free(*(filedlg.papszITypeList[i])); } free(filedlg.papszITypeList); for (i = 0; i < mFilters.Length(); i++) { nsMemory::Free(*(pmydata->papszIFilterList[i])); } free(pmydata->papszIFilterList); free(pmydata); } if (title) nsMemory::Free( title ); if (result) { PRInt16 returnOKorReplace = returnOK; nsresult rv; // Remember last used directory. nsCOMPtr<nsILocalFile> file(do_CreateInstance("@mozilla.org/file/local;1", &rv)); NS_ENSURE_SUCCESS(rv, rv); file->InitWithNativePath(mFile); nsCOMPtr<nsIFile> dir; if (NS_SUCCEEDED(file->GetParent(getter_AddRefs(dir)))) { nsCOMPtr<nsILocalFile> localDir(do_QueryInterface(dir)); if (localDir) { nsCAutoString newDir; localDir->GetNativePath(newDir); if(!newDir.IsEmpty()) PL_strncpyz(mLastUsedDirectory, newDir.get(), MAX_PATH+1); // Update mDisplayDirectory with this directory, also. // Some callers rely on this. if (!mDisplayDirectory) mDisplayDirectory = do_CreateInstance("@mozilla.org/file/local;1"); if (mDisplayDirectory) mDisplayDirectory->InitWithNativePath( nsDependentCString(mLastUsedDirectory) ); } } if (mMode == modeSave) { // Windows does not return resultReplace, // we must check if file already exists PRBool exists = PR_FALSE; file->Exists(&exists); if (exists) returnOKorReplace = returnReplace; } *retval = returnOKorReplace; } else { *retval = returnCancel; } return NS_OK; }
int main(int argc, char* argv[]) { if (test_common_init(&argc, &argv) != 0) return -1; nsresult ret; nsCOMPtr<nsIServiceManager> servMan; NS_InitXPCOM2(getter_AddRefs(servMan), nsnull, nsnull); nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan); NS_ASSERTION(registrar, "Null nsIComponentRegistrar"); registrar->AutoRegister(nsnull); nsIInputStream* in = nsnull; nsCOMPtr<nsIIOService> service(do_GetService(kIOServiceCID, &ret)); if (NS_FAILED(ret)) return ret; nsCOMPtr<nsIEventQueueService> eventQService = do_GetService(kEventQueueServiceCID, &ret); if (NS_FAILED(ret)) return ret; nsIChannel *channel = nsnull; ret = service->NewChannel(NS_LITERAL_CSTRING(TEST_URL), nsnull, nsnull, &channel); if (NS_FAILED(ret)) return ret; nsIEventQueue *eventQ = nsnull; ret = eventQService->GetThreadEventQueue(NS_CURRENT_THREAD, &eventQ); if (NS_FAILED(ret)) return ret; ret = channel->Open(&in); if (NS_FAILED(ret)) return ret; nsIPersistentProperties* props; ret = CallCreateInstance(kPersistentPropertiesCID, &props); if (NS_FAILED(ret) || (!props)) { printf("create nsIPersistentProperties failed\n"); return 1; } ret = props->Load(in); if (NS_FAILED(ret)) { printf("cannot load properties\n"); return 1; } int i = 1; while (1) { char name[16]; name[0] = 0; sprintf(name, "%d", i); nsAutoString v; ret = props->GetStringProperty(nsDependentCString(name), v); if (NS_FAILED(ret) || (!v.Length())) { break; } char* value = ToNewCString(v); if (value) { printf("\"%d\"=\"%s\"\n", i, value); delete[] value; } else { printf("%d: ToNewCString failed\n", i); } i++; } nsCOMPtr<nsISimpleEnumerator> propEnum; ret = props->Enumerate(getter_AddRefs(propEnum)); if (NS_FAILED(ret)) { printf("cannot enumerate properties\n"); return 1; } printf("\nKey\tValue\n"); printf( "---\t-----\n"); PRBool hasMore; while (NS_SUCCEEDED(propEnum->HasMoreElements(&hasMore)) && hasMore) { nsCOMPtr<nsISupports> sup; ret = propEnum->GetNext(getter_AddRefs(sup)); nsCOMPtr<nsIPropertyElement> propElem = do_QueryInterface(sup, &ret); if (NS_FAILED(ret)) { printf("failed to get current item\n"); return 1; } nsCAutoString key; nsAutoString value; ret = propElem->GetKey(key); if (NS_FAILED(ret)) { printf("failed to get current element's key\n"); return 1; } ret = propElem->GetValue(value); if (NS_FAILED(ret)) { printf("failed to get current element's value\n"); return 1; } printf("%s\t%s\n", key.get(), NS_ConvertUTF16toUTF8(value).get()); } return 0; }
NS_CStringCloneData(const nsACString& aStr) { return ToNewCString(aStr); }
NS_IMETHODIMP nsSystemPrincipal::GetOrigin(char** aOrigin) { *aOrigin = ToNewCString(NS_LITERAL_CSTRING("[System]")); return *aOrigin ? NS_OK : NS_ERROR_OUT_OF_MEMORY; }
NS_IMETHODIMP nsMsgCompFields::GetDefaultCharacterSet(char * *aDefaultCharacterSet) { NS_ENSURE_ARG_POINTER(aDefaultCharacterSet); *aDefaultCharacterSet = ToNewCString(m_DefaultCharacterSet); return *aDefaultCharacterSet ? NS_OK : NS_ERROR_OUT_OF_MEMORY; }