static bool StringCompare(PLDHashTable *table, const PLDHashEntryHdr *entry, const void *testKey) { const void *entryKey = reinterpret_cast<const PLDHashEntryStub *>(entry)->key; return PL_strcasecmp(reinterpret_cast<const char *>(entryKey), reinterpret_cast<const char *>(testKey)) == 0; }
static void enterAttr(const char *s1, const char *s2) { const char *p1, *p2 = nullptr; p1 = lookupProp_(s1); if (s2) { VObject *a; p2 = lookupProp_(s2); a = addProp(curProp, p1); setVObjectStringZValue(a, p2); } else addProp(curProp, p1); if (PL_strcasecmp(p1, VCBase64Prop) == 0 || (s2 && PL_strcasecmp(p2, VCBase64Prop) == 0)) lexPushMode(L_BASE64); else if (PL_strcasecmp(p1, VCQuotedPrintableProp) == 0 || (s2 && PL_strcasecmp(p2, VCQuotedPrintableProp) == 0)) lexPushMode(L_QUOTED_PRINTABLE); deleteString((char *)s1); deleteString((char *)s2); }
static int parse_acct_disable(const char *theval) { int retval = ACCT_DISABLE_INVALID; if (!theval || !*theval) { return retval; } if (!PL_strcasecmp(theval, IPA_WINSYNC_ACCT_DISABLE_NONE)) { retval = ACCT_DISABLE_NONE; } else if (!PL_strcasecmp(theval, IPA_WINSYNC_ACCT_DISABLE_TO_AD)) { retval = ACCT_DISABLE_TO_AD; } else if (!PL_strcasecmp(theval, IPA_WINSYNC_ACCT_DISABLE_TO_DS)) { retval = ACCT_DISABLE_TO_DS; } else if (!PL_strcasecmp(theval, IPA_WINSYNC_ACCT_DISABLE_BOTH)) { retval = ACCT_DISABLE_BOTH; } return retval; }
CK_MECHANISM_TYPE GetKeyMechFromString(const char *keyString) { int i; for (i=0; i < keyArraySize; i++) { if (PL_strcasecmp(keyString,keyArray[i].label) == 0) { return keyArray[i].mechType; } } return (CK_MECHANISM_TYPE)-1; }
CK_KEY_TYPE GetKeyTypeFromString(const char *keyString) { int i; for (i=0; i < keyArraySize; i++) { if (PL_strcasecmp(keyString,keyArray[i].label) == 0) { return keyArray[i].keyType; } } return (CK_KEY_TYPE)-1; }
VObject* isAPropertyOf(VObject *o, const char *id) { VObjectIterator i; initPropIterator(&i,o); while (moreIteration(&i)) { VObject *each = nextVObject(&i); if (!PL_strcasecmp(id,each->id)) return each; } return (VObject*)0; }
PRBool nsPaperSizePS::Find(const char *aName) { for (int i = mCount; i--; ) { if (!PL_strcasecmp(aName, mList[i].name)) { mCurrent = i; return PR_TRUE; } } return PR_FALSE; }
eFontPrefLang gfxPlatform::GetFontPrefLangFor(const char* aLang) { if (!aLang || !aLang[0]) return eFontPrefLang_Others; for (PRUint32 i = 0; i < PRUint32(eFontPrefLang_LangCount); ++i) { if (!PL_strcasecmp(gPrefLangNames[i], aLang)) return eFontPrefLang(i); } return eFontPrefLang_Others; }
// static xptiFileType::Type xptiFileType::GetType(const char* name) { NS_ASSERTION(name, "loser!"); int len = PL_strlen(name); for(const xptiFileTypeEntry* p = g_Entries; p->name; p++) { if(len > p->len && 0 == PL_strcasecmp(p->name, &(name[len - p->len]))) return p->type; } return UNKNOWN; }
// Ok, if we are here, and we have a aCharset passed in that is not // UTF-8 or US-ASCII, then we should tag the mChannel member with this // charset. This is because replying to messages with specified charset's // need to be tagged as that charset by default. // NS_IMETHODIMP nsMimeBaseEmitter::UpdateCharacterSet(const char *aCharset) { if ( (aCharset) && (PL_strcasecmp(aCharset, "US-ASCII")) && (PL_strcasecmp(aCharset, "ISO-8859-1")) && (PL_strcasecmp(aCharset, "UTF-8")) ) { nsAutoCString contentType; if (NS_SUCCEEDED(mChannel->GetContentType(contentType)) && !contentType.IsEmpty()) { char *cBegin = contentType.BeginWriting(); const char *cPtr = PL_strcasestr(cBegin, "charset="); if (cPtr) { char *ptr = cBegin; while (*ptr) { if ( (*ptr == ' ') || (*ptr == ';') ) { if ((ptr + 1) >= cPtr) { *ptr = '\0'; break; } } ++ptr; } } // have to set content-type since it could have an embedded null byte mChannel->SetContentType(nsDependentCString(cBegin)); mChannel->SetContentCharset(nsDependentCString(aCharset)); } } return NS_OK; }
nsIMAPHostInfo *nsIMAPHostSessionList::FindHost(const char *serverKey) { nsIMAPHostInfo *host; // ### should also check userName here, if NON NULL for (host = fHostInfoList; host; host = host->fNextHost) { if (!PL_strcasecmp(serverKey, host->fServerKey)) return host; } return host; }
static struct PreDefProp* lookupPropInfo(const char* str) { /* brute force for now, could use a hash table here. */ int i; for (i = 0; propNames[i].name; i++) if (PL_strcasecmp(str, propNames[i].name) == 0) { return &propNames[i]; } return 0; }
NS_IMETHODIMP nsImportGenericMail::GetStatus(const char *statusKind, int32_t *_retval) { NS_PRECONDITION(statusKind != nullptr, "null ptr"); NS_PRECONDITION(_retval != nullptr, "null ptr"); if (!statusKind || !_retval) return NS_ERROR_NULL_POINTER; *_retval = 0; if (!PL_strcasecmp(statusKind, "isInstalled")) { GetDefaultLocation(); *_retval = (int32_t) m_found; } if (!PL_strcasecmp(statusKind, "canUserSetLocation")) { GetDefaultLocation(); *_retval = (int32_t) m_userVerify; } return NS_OK; }
const char* lookupProp_(const char* str) { int i; for (i = 0; propNames[i].name; i++) if (PL_strcasecmp(str, propNames[i].name) == 0) { const char* s; s = propNames[i].alias?propNames[i].alias:propNames[i].name; return lookupStr(s); } return lookupStr(str); }
NS_IMETHODIMP nsImportGenericAddressBooks::GetStatus(const char *statusKind, int32_t *_retval) { NS_PRECONDITION(statusKind != nullptr, "null ptr"); NS_PRECONDITION(_retval != nullptr, "null ptr"); if (!statusKind || !_retval) return NS_ERROR_NULL_POINTER; *_retval = 0; if (!PL_strcasecmp(statusKind, "isInstalled")) { GetDefaultLocation(); *_retval = (int32_t) m_found; } if (!PL_strcasecmp(statusKind, "canUserSetLocation")) { GetDefaultLocation(); *_retval = (int32_t) m_userVerify; } if (!PL_strcasecmp(statusKind, "autoFind")) { GetDefaultLocation(); *_retval = (int32_t) m_autoFind; } if (!PL_strcasecmp(statusKind, "supportsMultiple")) { bool multi = false; if (m_pInterface) m_pInterface->GetSupportsMultiple(&multi); *_retval = (int32_t) multi; } if (!PL_strcasecmp(statusKind, "needsFieldMap")) { bool needs = false; if (m_pInterface && m_pLocation) m_pInterface->GetNeedsFieldMap(m_pLocation, &needs); *_retval = (int32_t) needs; } return NS_OK; }
// Finds the part with given part number // Returns a nsIMAPBodystructure of the matched part if it is this // or one of its children. Returns NULL otherwise. nsIMAPBodypart *nsIMAPBodypart::FindPartWithNumber(const char *partNum) { // either brute force, or do it the smart way - look at the number. // (the parts should be ordered, and hopefully indexed by their number) if (m_partNumberString && !PL_strcasecmp(partNum, m_partNumberString)) return this; //if (!m_partNumberString && !PL_strcasecmp(partNum, "1")) // return this; return NULL; }
/* * Finds a named ACL in an input list. * * Input: * acl_list a list of ACLs to search * acl_name the name of the ACL to find * flags e.g. ACL_CASE_INSENSITIVE * Returns: * NULL No ACL found * acl A pointer to an ACL with named acl_name */ NSAPI_PUBLIC ACLHandle_t * ACL_ListFind (NSErr_t *errp, ACLListHandle_t *acl_list, char *acl_name, int flags ) { ACLHandle_t *result = NULL; ACLWrapper_t *wrapper; Symbol_t *sym; if ( acl_list == NULL || acl_name == NULL ) return NULL; /* * right now the symbol table exists if there hasn't been * any collisions based on using case insensitive names. * if there are any collisions then the table will be * deleted and we will look up using list search. * * we should probably create two hash tables, one for case * sensitive lookups and the other for insensitive. */ if ( acl_list->acl_sym_table ) { if ( symTableFindSym(acl_list->acl_sym_table, acl_name, ACLSYMACL, (void **) &sym) >= 0 ) { result = (ACLHandle_t *) sym->sym_data; if ( result && (flags & ACL_CASE_SENSITIVE) && strcmp(result->tag, acl_name) ) { result = NULL; /* case doesn't match */ } } return( result ); } // // if there's no symbol table, we search in a linear fashion. // if ( flags & ACL_CASE_INSENSITIVE ) { for ( wrapper = acl_list->acl_list_head; wrapper != NULL; wrapper = wrapper->wrap_next ) { if ( wrapper->acl->tag && PL_strcasecmp( wrapper->acl->tag, acl_name ) == 0 ) { result = wrapper->acl; break; } } } else { for ( wrapper = acl_list->acl_list_head; wrapper != NULL; wrapper = wrapper->wrap_next ) { if ( wrapper->acl->tag && strcmp( wrapper->acl->tag, acl_name ) == 0 ) { result = wrapper->acl; break; } } } return( result ); }
int32_t nsIMAPBodypartMessage::Generate(nsIMAPBodyShell *aShell, bool stream, bool prefetch) { if (!GetIsValid()) return 0; m_contentLength = 0; if (stream && !prefetch) aShell->GetConnection()->Log("SHELL","GENERATE-MessageRFC822",m_partNumberString); if (!m_topLevelMessage && !aShell->GetPseudoInterrupted()) // not the top-level message - we need the MIME header as well as the message header { // but we don't need the MIME headers of a message/rfc822 part if this content // type is in (part of) the main msg header. In other words, we still need // these MIME headers if this message/rfc822 body part is enclosed in the msg // body (most likely as a body part of a multipart/mixed msg). // Don't fetch (bug 128888) Do fetch (bug 168097) // ---------------------------------- ----------------------------------- // message/rfc822 (parent part) message/rfc822 // message/rfc822 <<<--- multipart/mixed (parent part) // multipart/mixed message/rfc822 <<<--- // text/html (body text) multipart/mixed // text/plain (attachment) text/html (body text) // application/msword (attachment) text/plain (attachment) // application/msword (attachment) // "<<<---" points to the part we're examining here. if ( PL_strcasecmp(m_bodyType, "message") || PL_strcasecmp(m_bodySubType, "rfc822") || PL_strcasecmp(m_parentPart->GetBodyType(), "message") || PL_strcasecmp(m_parentPart->GetBodySubType(), "rfc822") ) m_contentLength += GenerateMIMEHeader(aShell, stream, prefetch); } if (!aShell->GetPseudoInterrupted()) m_contentLength += m_headers->Generate(aShell, stream, prefetch); if (!aShell->GetPseudoInterrupted()) m_contentLength += m_body->Generate(aShell, stream, prefetch); return m_contentLength; }
NPError NPP_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc, char* argn[], char* argv[], NPSavedData* saved) { PluginInstance* This; if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; instance->pdata = NPN_MemAlloc(sizeof(PluginInstance)); This = (PluginInstance*) instance->pdata; if (This == NULL) { return NPERR_OUT_OF_MEMORY_ERROR; } memset(This, 0, sizeof(PluginInstance)); /* mode is NP_EMBED, NP_FULL, or NP_BACKGROUND (see npapi.h) */ This->mode = mode; This->type = dupMimeType(pluginType); This->instance = instance; This->pluginsPageUrl = NULL; This->exists = FALSE; /* Parse argument list passed to plugin instance */ /* We are interested in these arguments * PLUGINSPAGE = <url> */ while (argc > 0) { argc --; if (argv[argc] != NULL) { if (!PL_strcasecmp(argn[argc], "PLUGINSPAGE")) This->pluginsPageUrl = strdup(argv[argc]); else if (!PL_strcasecmp(argn[argc], "PLUGINURL")) This->pluginsFileUrl = strdup(argv[argc]); else if (!PL_strcasecmp(argn[argc], "CODEBASE")) This->pluginsPageUrl = strdup(argv[argc]); else if (!PL_strcasecmp(argn[argc], "CLASSID")) This->pluginsFileUrl = strdup(argv[argc]); else if (!PL_strcasecmp(argn[argc], "HIDDEN")) This->pluginsHidden = (!PL_strcasecmp(argv[argc], "TRUE")); } } return NPERR_NO_ERROR; }
NS_IMETHODIMP nsURLFetcher::CanHandleContent(const char * aContentType, bool aIsContentPreferred, char ** aDesiredContentType, bool * aCanHandleContent) { if (!mIsFile && PL_strcasecmp(aContentType, MESSAGE_RFC822) == 0) *aDesiredContentType = strdup("text/html"); // since we explicilty loaded the url, we always want to handle it! *aCanHandleContent = true; return NS_OK; }
const char* lookupProp(const char* str) { int i; for (i = 0; propNames[i].name; i++) if (PL_strcasecmp(str, propNames[i].name) == 0) { const char *s; fieldedProp = (char **)propNames[i].fields; s = propNames[i].alias?propNames[i].alias:propNames[i].name; return lookupStr(s); } fieldedProp = 0; return lookupStr(str); }
NS_IMETHODIMP nsMimeHtmlDisplayEmitter::WriteHTMLHeaders(const nsACString &name) { // if we aren't broadcasting headers OR printing...just do whatever // our base class does... if (mFormat == nsMimeOutput::nsMimeMessagePrintOutput) { return nsMimeBaseEmitter::WriteHTMLHeaders(name); } else if (!BroadCastHeadersAndAttachments() || !mDocHeader) { // This needs to be here to correct the output format if we are // not going to broadcast headers to the XUL document. if (mFormat == nsMimeOutput::nsMimeMessageBodyDisplay) mFormat = nsMimeOutput::nsMimeMessagePrintOutput; return nsMimeBaseEmitter::WriteHTMLHeaders(name); } else mFirstHeaders = false; bool bFromNewsgroups = false; for (int32_t j=0; j < mHeaderArray->Count(); j++) { headerInfoType *headerInfo = (headerInfoType *)mHeaderArray->ElementAt(j); if (!(headerInfo && headerInfo->name && *headerInfo->name)) continue; if (!PL_strcasecmp("Newsgroups", headerInfo->name)) { bFromNewsgroups = true; break; } } // try to get a header sink if there is one.... nsCOMPtr<nsIMsgHeaderSink> headerSink; nsresult rv = GetHeaderSink(getter_AddRefs(headerSink)); if (headerSink) { int32_t viewMode = 0; nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); if (pPrefBranch) rv = pPrefBranch->GetIntPref("mail.show_headers", &viewMode); rv = BroadcastHeaders(headerSink, viewMode, bFromNewsgroups); } // if header Sink return NS_OK; }
nsresult nsAbQueryStringToExpression::CreateBooleanExpression( const char* operation, nsIAbBooleanExpression** expression) { nsAbBooleanOperationType op; if (PL_strcasecmp (operation, "and") == 0) op = nsIAbBooleanOperationTypes::AND; else if (PL_strcasecmp (operation, "or") == 0) op = nsIAbBooleanOperationTypes::OR; else if (PL_strcasecmp (operation, "not") == 0) op = nsIAbBooleanOperationTypes::NOT; else return NS_ERROR_FAILURE; nsresult rv; nsCOMPtr <nsIAbBooleanExpression> expr = do_CreateInstance(NS_BOOLEANEXPRESSION_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); NS_IF_ADDREF(*expression = expr); rv = expr->SetOperation (op); return rv; }
NS_IMETHODIMP nsImportGenericMail::GetData(const char *dataId, nsISupports **_retval) { nsresult rv = NS_OK; NS_PRECONDITION(_retval != nullptr, "null ptr"); if (!_retval) return NS_ERROR_NULL_POINTER; *_retval = nullptr; if (!PL_strcasecmp(dataId, "mailInterface")) { *_retval = m_pInterface; NS_IF_ADDREF(m_pInterface); } if (!PL_strcasecmp(dataId, "mailBoxes")) { if (!m_pMailboxes) GetDefaultMailboxes(); *_retval = m_pMailboxes; NS_IF_ADDREF(m_pMailboxes); } if (!PL_strcasecmp(dataId, "mailLocation")) { if (!m_pSrcLocation) GetDefaultLocation(); NS_IF_ADDREF(*_retval = m_pSrcLocation); } if (!PL_strcasecmp(dataId, "mailDestination")) { if (!m_pDestFolder) GetDefaultDestination(); NS_IF_ADDREF(*_retval = m_pDestFolder); } if (!PL_strcasecmp(dataId, "migration")) { nsCOMPtr<nsISupportsPRBool> migrationString = do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); migrationString->SetData(m_performingMigration); NS_IF_ADDREF(*_retval = migrationString); } if (!PL_strcasecmp(dataId, "currentMailbox")) { // create an nsISupportsString, get the current mailbox // name being imported and put it in the string nsCOMPtr<nsISupportsString> data = do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv); if (NS_FAILED(rv)) return rv; if (m_pThreadData) { GetMailboxName(m_pThreadData->currentMailbox, data); } NS_ADDREF(*_retval = data); } return rv; }
NS_IMETHODIMP nsMozIconURI::Equals(nsIURI *other, PRBool *result) { NS_ENSURE_ARG_POINTER(other); NS_PRECONDITION(result, "null pointer"); nsCAutoString spec1; nsCAutoString spec2; other->GetSpec(spec2); GetSpec(spec1); if (!PL_strcasecmp(spec1.get(), spec2.get())) *result = PR_TRUE; else *result = PR_FALSE; return NS_OK; }
static int MimeDummy_parse_begin(MimeObject *obj) { fprintf(stderr, "MimeDummy_parse_begin:\n"); MimeObject *parent = obj->parent; MimeContainer* container = (MimeContainer *) parent; if (container) { PRInt32 nchildren = container->nchildren; fprintf(stderr, "MimeDummy_parse_begin: nchildren=%d\n",nchildren ); if (nchildren == 2) { MimeObject* sibling = *(container->children); MimeObjectClass *clazz = sibling->clazz; fprintf(stderr, "MimeDummy_parse_begin: sibling class_name=%s\n", clazz->class_name); MimeObjectClass *superclazz = clazz->superclass; if (superclazz) { fprintf(stderr, "MimeDummy_parse_begin: sibling superclass_name=%s\n", superclazz->class_name); if (!PL_strcasecmp(superclazz->class_name, "MimeEncrypted")) { // mimeEncryptedClass fprintf(stderr, "MimeDummy_parse_begin: found MimeEncrypted\n"); mimeEncryptedClassP = (MimeEncryptedClass *) superclazz; MimeObjectClass* objClass = (MimeObjectClass*) &mimeEncryptedEnigClass; objClass->superclass = (MimeObjectClass *) superclazz; nsresult rv; nsCOMPtr<nsIEnigMimeService> enigMimeService = do_GetService(NS_ENIGMIMESERVICE_CONTRACTID, &rv); if (NS_SUCCEEDED(rv)) { enigMimeService->Init(); } } } } } return 0; }
NS_IMETHODIMP nsImportGenericMail::SetData(const char *dataId, nsISupports *item) { nsresult rv = NS_OK; NS_PRECONDITION(dataId != nullptr, "null ptr"); if (!dataId) return NS_ERROR_NULL_POINTER; if (!PL_strcasecmp(dataId, "mailInterface")) { NS_IF_RELEASE(m_pInterface); if (item) item->QueryInterface(NS_GET_IID(nsIImportMail), (void **) &m_pInterface); } if (!PL_strcasecmp(dataId, "mailBoxes")) { NS_IF_RELEASE(m_pMailboxes); if (item) item->QueryInterface(NS_GET_IID(nsISupportsArray), (void **) &m_pMailboxes); } if (!PL_strcasecmp(dataId, "mailLocation")) { NS_IF_RELEASE(m_pMailboxes); m_pSrcLocation = nullptr; if (item) { nsresult rv; nsCOMPtr <nsIFile> location = do_QueryInterface(item, &rv); NS_ENSURE_SUCCESS(rv,rv); m_pSrcLocation = location; } } if (!PL_strcasecmp(dataId, "mailDestination")) { NS_IF_RELEASE(m_pDestFolder); if (item) item->QueryInterface(NS_GET_IID(nsIMsgFolder), (void **) &m_pDestFolder); m_deleteDestFolder = false; } if (!PL_strcasecmp(dataId, "name")) { nsCOMPtr<nsISupportsString> nameString; if (item) { item->QueryInterface(NS_GET_IID(nsISupportsString), getter_AddRefs(nameString)); rv = nameString->GetData(m_pName); } } if (!PL_strcasecmp(dataId, "migration")) { nsCOMPtr<nsISupportsPRBool> migrationString; if (item) { item->QueryInterface(NS_GET_IID(nsISupportsPRBool), getter_AddRefs(migrationString)); rv = migrationString->GetData(&m_performingMigration); } } return rv; }
void IPC_InitModuleReg(const char *exePath) { if (!(exePath && *exePath)) return; // // register plug-in modules // char *p = PL_strrchr(exePath, IPC_PATH_SEP_CHAR); if (p == NULL) { LOG(("unexpected exe path\n")); return; } int baseLen = p - exePath; int finalLen = baseLen + 1 + sizeof(IPC_MODULES_DIR); // build full path to ipc modules char *modulesDir = (char*) malloc(finalLen); memcpy(modulesDir, exePath, baseLen); modulesDir[baseLen] = IPC_PATH_SEP_CHAR; memcpy(modulesDir + baseLen + 1, IPC_MODULES_DIR, sizeof(IPC_MODULES_DIR)); LOG(("loading libraries in %s\n", modulesDir)); // // scan directory for IPC modules // PRDir *dir = PR_OpenDir(modulesDir); if (dir) { PRDirEntry *ent; while ((ent = PR_ReadDir(dir, PR_SKIP_BOTH)) != NULL) { // // locate extension, and check if dynamic library // const char *p = strrchr(ent->name, '.'); if (p && PL_strcasecmp(p, MOZ_DLL_SUFFIX) == 0) InitModuleFromLib(modulesDir, ent->name); } PR_CloseDir(dir); } free(modulesDir); }
VObject* addPropValue(VObject *o, const char *p, const char *v) { VObject *prop; prop = addProp(o,p); if (v) { setVObjectUStringZValue_(prop, fakeUnicode(v,0)); if (needsQuotedPrintable (v)) { if (PL_strcasecmp (VCCardProp, vObjectName(o)) == 0) addProp (prop, VCQuotedPrintableProp); else addProp (o, VCQuotedPrintableProp); } } else setVObjectUStringZValue_(prop, fakeUnicode("",0)); return prop; }
static void RunTests(const char *exePath) { if (!(exePath && *exePath)) return; // // load test modules // char *p = strrchr(exePath, kPathSep); if (p == NULL) { LOG(("unexpected exe path\n")); return; } int baseLen = p - exePath; int finalLen = baseLen + 1 + sizeof(kTestsDirectory); // build full path to ipc modules char *modulesDir = (char*) malloc(finalLen); memcpy(modulesDir, exePath, baseLen); modulesDir[baseLen] = kPathSep; memcpy(modulesDir + baseLen + 1, kTestsDirectory, sizeof(kTestsDirectory)); LOG(("loading libraries in %s\n", modulesDir)); // // scan directory for IPC modules // PRDir *dir = PR_OpenDir(modulesDir); if (dir) { PRDirEntry *ent; while ((ent = PR_ReadDir(dir, PR_SKIP_BOTH)) != NULL) { // // locate extension, and check if dynamic library // char *p = strrchr(ent->name, '.'); if (p && PL_strcasecmp(p, MOZ_DLL_SUFFIX) == 0) ProcessModule(modulesDir, ent->name); } PR_CloseDir(dir); } free(modulesDir); }