NS_IMETHODIMP nsImportService::GetModuleInfo(const char *filter, PRInt32 index, PRUnichar **name, PRUnichar **moduleDescription)
{
NS_PRECONDITION(name != nsnull, "null ptr");
NS_PRECONDITION(moduleDescription != nsnull, "null ptr");
if (!name || !moduleDescription)
return NS_ERROR_NULL_POINTER;
*name = nsnull;
*moduleDescription = nsnull;
DoDiscover();
if (!m_pModules)
return NS_ERROR_FAILURE;
if ((index < 0) || (index >= m_pModules->GetCount()))
return NS_ERROR_FAILURE;
ImportModuleDesc * pDesc;
PRInt32 count = 0;
for (PRInt32 i = 0; i < m_pModules->GetCount(); i++) {
pDesc = m_pModules->GetModuleDesc(i);
if (pDesc->SupportsThings(filter)) {
if (count == index) {
*name = NS_strdup(pDesc->GetName());
*moduleDescription = NS_strdup(pDesc->GetDescription());
return NS_OK;
}
else
count++;
}
}
return NS_ERROR_FAILURE;
}
nsIMAPBodyShell::nsIMAPBodyShell(nsImapProtocol *protocolConnection,
nsIMAPBodypartMessage *message, uint32_t UID,
const char *folderName)
{
m_isValid = false;
m_isBeingGenerated = false;
m_cached = false;
m_gotAttachmentPref = false;
m_generatingWholeMessage = false;
m_generatingPart = NULL;
m_protocolConnection = protocolConnection;
m_message = message;
NS_ASSERTION(m_protocolConnection, "non null connection");
if (!m_protocolConnection)
return;
m_prefetchQueue = new nsIMAPMessagePartIDArray();
if (!m_prefetchQueue)
return;
m_UID = "";
m_UID.AppendInt(UID);
#ifdef DEBUG_chrisf
NS_ASSERTION(folderName);
#endif
if (!folderName)
return;
m_folderName = NS_strdup(folderName);
if (!m_folderName)
return;
SetContentModified(GetShowAttachmentsInline() ? IMAP_CONTENT_MODIFIED_VIEW_INLINE : IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS);
SetIsValid(m_message != nullptr);
}
NS_IMETHODIMP nsImportService::GetModuleName(const char *filter, PRInt32 index, PRUnichar **_retval)
{
NS_PRECONDITION(_retval != nsnull, "null ptr");
if (!_retval)
return NS_ERROR_NULL_POINTER;
*_retval = nsnull;
DoDiscover();
if (!m_pModules)
return NS_ERROR_FAILURE;
if ((index < 0) || (index >= m_pModules->GetCount()))
return NS_ERROR_FAILURE;
ImportModuleDesc * pDesc;
PRInt32 count = 0;
for (PRInt32 i = 0; i < m_pModules->GetCount(); i++) {
pDesc = m_pModules->GetModuleDesc(i);
if (pDesc->SupportsThings(filter)) {
if (count == index) {
*_retval = NS_strdup(pDesc->GetName());
return NS_OK;
}
else
count++;
}
}
return NS_ERROR_FAILURE;
}
/* static */
char *nsIMAPNamespaceList::AllocateServerFolderName(const char *canonicalFolderName, char delimiter)
{
if (delimiter)
return nsImapUrl::ReplaceCharsInCopiedString(canonicalFolderName, '/', delimiter);
else
return NS_strdup(canonicalFolderName);
}
nsresult nsCollationOS2::AllocateRawSortKey(int32_t strength,
const nsAString& stringIn, uint8_t** key, uint32_t* outLen)
{
nsresult res = NS_OK;
nsAutoString stringNormalized;
if (strength != kCollationCaseSensitive) {
res = mCollation->NormalizeString(stringIn, stringNormalized);
if (NS_FAILED(res))
return res;
} else {
stringNormalized = stringIn;
}
LocaleObject locObj = nullptr;
int ret = UniCreateLocaleObject(UNI_UCS_STRING_POINTER, (UniChar *)L"", &locObj);
if (ret != ULS_SUCCESS)
UniCreateLocaleObject(UNI_UCS_STRING_POINTER, (UniChar *)L"C", &locObj);
res = NS_ERROR_FAILURE; // From here on out assume failure...
int length = UniStrxfrm(locObj,
nullptr,
reinterpret_cast<const UniChar *>(stringNormalized.get()),
0);
if (length >= 0) {
length += 5; // Allow for the "extra" chars UniStrxfrm()
// will out put (overrunning the buffer if
// you let it...)
// Magic, persistent buffer. If it's not twice the size we need,
// we grow/reallocate it 4X so it doesn't grow often.
static UniChar* pLocalBuffer = nullptr;
static int iBufferLength = 100;
if (iBufferLength < length*2) {
if ( pLocalBuffer ) {
free(pLocalBuffer);
pLocalBuffer = nullptr;
}
iBufferLength = length*4;
}
if (!pLocalBuffer)
pLocalBuffer = (UniChar*) malloc(sizeof(UniChar) * iBufferLength);
if (pLocalBuffer) {
// Do the Xfrm
int uLen = UniStrxfrm(locObj, pLocalBuffer, reinterpret_cast<const UniChar *>(stringNormalized.get()), iBufferLength);
// See how big the result really is
uLen = UniStrlen(pLocalBuffer);
// make sure it will fit in the output buffer...
if (uLen < iBufferLength) {
// Success!
// Give 'em the real size in bytes...
*key = (uint8_t *)NS_strdup((char16_t*) pLocalBuffer);
*outLen = uLen * 2 + 2;
res = NS_OK;
}
}
}
UniFreeLocaleObject(locObj);
return res;
}
NS_IMETHODIMP
nsStrictTransportSecurityService::ProcessStsHeader(nsIURI* aSourceURI,
const char* aHeader,
uint64_t *aMaxAge,
bool *aIncludeSubdomains)
{
// Should be called on the main thread (or via proxy) since the permission
// manager is used and it's not threadsafe.
NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_UNEXPECTED);
if (aMaxAge != nullptr) {
*aMaxAge = 0;
}
if (aIncludeSubdomains != nullptr) {
*aIncludeSubdomains = false;
}
char * header = NS_strdup(aHeader);
if (!header) return NS_ERROR_OUT_OF_MEMORY;
nsresult rv = ProcessStsHeaderMutating(aSourceURI, header, aMaxAge,
aIncludeSubdomains);
NS_Free(header);
return rv;
}
NS_IMETHODIMP nsImportService::GetModuleDescription(const char *filter, int32_t index, char16_t **_retval)
{
NS_PRECONDITION(_retval != nullptr, "null ptr");
if (!_retval)
return NS_ERROR_NULL_POINTER;
*_retval = nullptr;
DoDiscover();
if (!m_pModules)
return NS_ERROR_FAILURE;
if ((index < 0) || (index >= m_pModules->GetCount()))
return NS_ERROR_FAILURE;
ImportModuleDesc * pDesc;
int32_t count = 0;
for (int32_t i = 0; i < m_pModules->GetCount(); i++) {
pDesc = m_pModules->GetModuleDesc(i);
if (pDesc->SupportsThings(filter)) {
if (count == index) {
*_retval = NS_strdup(pDesc->GetDescription());
return NS_OK;
}
else
count++;
}
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsMemoryCacheDeviceInfo::GetDescription(char ** result)
{
NS_ENSURE_ARG_POINTER(result);
*result = NS_strdup("Memory cache device");
if (!*result) return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
nsMsgSearchValueImpl::nsMsgSearchValueImpl(nsMsgSearchValue *aInitialValue)
{
mValue = *aInitialValue;
if (IS_STRING_ATTRIBUTE(aInitialValue->attribute) && aInitialValue->string)
mValue.string = NS_strdup(aInitialValue->string);
else
mValue.string = 0;
}
bool
nsJSID::SetName(const char* name)
{
NS_ASSERTION(!mName || mName == gNoString ,"name already set");
NS_ASSERTION(name,"null name");
mName = NS_strdup(name);
return mName ? true : false;
}
PRBool
nsJSID::SetName(const char* name)
{
NS_ASSERTION(!mName || mName == gNoString ,"name already set");
NS_ASSERTION(name,"null name");
mName = NS_strdup(name);
return mName ? PR_TRUE : PR_FALSE;
}
NS_IMETHODIMP
nsCacheEntryInfo::GetDeviceID(char ** deviceID)
{
NS_ENSURE_ARG_POINTER(deviceID);
if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE;
*deviceID = NS_strdup(mCacheEntry->GetDeviceID());
return *deviceID ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
char*
nsInt2StrHashtable::Get(uint32_t key)
{
nsPRUint32Key k(key);
const char* value = (const char*)mHashtable.Get(&k);
if (value == nullptr)
return nullptr;
return NS_strdup(value);
}
nsAtomStringList::nsAtomStringList(nsIAtom* aAtom, const PRUnichar* aString)
: mAtom(aAtom),
mString(nsnull),
mNext(nsnull)
{
MOZ_COUNT_CTOR(nsAtomStringList);
if (aString)
mString = NS_strdup(aString);
}
// Copied from toolkit/xre/nsAppData.cpp.
void SetAllocatedString(const char *&str, const char *newvalue)
{
NS_Free(const_cast<char*>(str));
if (newvalue) {
str = NS_strdup(newvalue);
}
else {
str = nullptr;
}
}
void
SetAllocatedString(const char*& aStr, const char* aNewValue)
{
NS_Free(const_cast<char*>(aStr));
if (aNewValue) {
aStr = NS_strdup(aNewValue);
} else {
aStr = nullptr;
}
}
nsPseudoClassList::nsPseudoClassList(nsCSSPseudoClasses::Type aType,
const PRUnichar* aString)
: mType(aType),
mNext(nsnull)
{
NS_ASSERTION(nsCSSPseudoClasses::HasStringArg(aType),
"unexpected pseudo-class");
NS_ASSERTION(aString, "string expected");
MOZ_COUNT_CTOR(nsPseudoClassList);
u.mString = NS_strdup(aString);
}
nsAtomStringList::nsAtomStringList(const nsString& aAtomValue,
const PRUnichar* aString)
: mAtom(nsnull),
mString(nsnull),
mNext(nsnull)
{
MOZ_COUNT_CTOR(nsAtomStringList);
mAtom = do_GetAtom(aAtomValue);
if (aString)
mString = NS_strdup(aString);
}
NS_IMETHODIMP
nsBaseDOMException::GetMessageMoz(char **aMessage)
{
if (mMessage) {
*aMessage = NS_strdup(mMessage);
} else {
*aMessage = nsnull;
}
return NS_OK;
}
NS_IMETHODIMP
FileSystemDataSource::GetURI(char **uri)
{
NS_PRECONDITION(uri != nullptr, "null ptr");
if (! uri)
return NS_ERROR_NULL_POINTER;
if ((*uri = NS_strdup("rdf:files")) == nullptr)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
nsIMAPBodypartMultipart::nsIMAPBodypartMultipart(char *partNum, nsIMAPBodypart *parentPart) :
nsIMAPBodypart(partNum, parentPart)
{
if (!m_parentPart || (m_parentPart->GetType() == IMAP_BODY_MESSAGE_RFC822))
{
// the multipart (this) will inherit the part number of its parent
PR_FREEIF(m_partNumberString);
if (!m_parentPart)
{
m_partNumberString = PR_smprintf("0");
}
else
m_partNumberString = NS_strdup(m_parentPart->GetPartNumberString());
}
m_partList = new nsVoidArray();
m_bodyType = NS_strdup("multipart");
if (m_partList && m_parentPart && m_bodyType)
SetIsValid(true);
else
SetIsValid(false);
}
nsresult
nsInt2StrHashtable::Put(uint32_t key, const char* aData)
{
char* value = NS_strdup(aData);
if (value == nullptr)
return NS_ERROR_OUT_OF_MEMORY;
nsPRUint32Key k(key);
char* oldValue = (char*)mHashtable.Put(&k, value);
if (oldValue)
NS_Free(oldValue);
return NS_OK;
}
NS_IMETHODIMP
nsJSID::GetName(char * *aName)
{
if (!aName)
return NS_ERROR_NULL_POINTER;
if (!NameIsSet())
SetNameToNoString();
NS_ASSERTION(mName, "name not set");
*aName = NS_strdup(mName);
return *aName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
NS_IMETHODIMP nsIMAPHostSessionList::SetPasswordForHost(const char *serverKey, const char *password)
{
PR_EnterMonitor(gCachedHostInfoMonitor);
nsIMAPHostInfo *host = FindHost(serverKey);
if (host)
{
PR_FREEIF(host->fCachedPassword);
if (password)
host->fCachedPassword = NS_strdup(password);
}
PR_ExitMonitor(gCachedHostInfoMonitor);
return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
}
NS_IMETHODIMP
LocalStoreImpl::GetURI(char* *aURI)
{
NS_PRECONDITION(aURI != nsnull, "null ptr");
if (! aURI)
return NS_ERROR_NULL_POINTER;
*aURI = NS_strdup("rdf:local-store");
if (! *aURI)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
NS_IMETHODIMP
nsBaseDOMException::GetName(char **aName)
{
NS_ENSURE_ARG_POINTER(aName);
if (mName) {
*aName = NS_strdup(mName);
} else {
*aName = nsnull;
}
return NS_OK;
}
/* readonly attribute string mimeType; */
NS_IMETHODIMP imgRequestProxy::GetMimeType(char **aMimeType)
{
if (!mOwner)
return NS_ERROR_FAILURE;
const char *type = mOwner->GetMimeType();
if (!type)
return NS_ERROR_FAILURE;
*aMimeType = NS_strdup(type);
return NS_OK;
}
bool test_xpidl_string()
{
nsXPIDLCString a, b;
a = b;
if (a != b)
return false;
a.Adopt(0);
if (a != b)
return false;
a.Append("foopy");
a.Assign(b);
if (a != b)
return false;
a.Insert("", 0);
a.Assign(b);
if (a != b)
return false;
const char text[] = "hello world";
*getter_Copies(a) = NS_strdup(text);
if (strcmp(a, text) != 0)
return false;
b = a;
if (strcmp(a, b) != 0)
return false;
a.Adopt(0);
nsACString::const_iterator begin, end;
a.BeginReading(begin);
a.EndReading(end);
char *r = ToNewCString(Substring(begin, end));
if (strcmp(r, "") != 0)
return false;
nsMemory::Free(r);
a.Adopt(0);
if (a != (const char*) 0)
return false;
/*
int32_t index = a.FindCharInSet("xyz");
if (index != kNotFound)
return false;
*/
return true;
}
NS_IMETHODIMP CacheEntry::GetMetaDataElement(const char * aKey, char * *aRetval)
{
NS_ENSURE_SUCCESS(mFileStatus, NS_ERROR_NOT_AVAILABLE);
const char *value;
nsresult rv = mFile->GetElement(aKey, &value);
NS_ENSURE_SUCCESS(rv, rv);
if (!value)
return NS_ERROR_NOT_AVAILABLE;
*aRetval = NS_strdup(value);
return NS_OK;
}
NS_IMETHODIMP
nsJSID::GetNumber(char * *aNumber)
{
if (!aNumber)
return NS_ERROR_NULL_POINTER;
if (!mNumber) {
if (!(mNumber = mID.ToString()))
mNumber = gNoString;
}
*aNumber = NS_strdup(mNumber);
return *aNumber ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
