PRInt32 _PR_MD_GETFILEINFO(const char *fn, PRFileInfo *info) { struct stat sb; PRInt32 rv; PRInt64 s, s2us; if ( (rv = _PR_MD_STAT(fn, &sb)) == 0 ) { if (info) { if (S_IFREG & sb.st_mode) info->type = PR_FILE_FILE ; else if (S_IFDIR & sb.st_mode) info->type = PR_FILE_DIRECTORY; else info->type = PR_FILE_OTHER; info->size = sb.st_size; LL_I2L(s2us, PR_USEC_PER_SEC); LL_I2L(s, sb.st_mtime); LL_MUL(s, s, s2us); info->modifyTime = s; LL_I2L(s, sb.st_ctime); LL_MUL(s, s, s2us); info->creationTime = s; } } return rv; }
PR_Now(void) { PRInt64 s, ms, ms2us, s2us; struct timeb b; ftime(&b); LL_I2L(ms2us, PR_USEC_PER_MSEC); LL_I2L(s2us, PR_USEC_PER_SEC); LL_I2L(s, b.time); LL_I2L(ms, b.millitm); LL_MUL(ms, ms, ms2us); LL_MUL(s, s, s2us); LL_ADD(s, s, ms); return s; }
PRStatus TimelineInit(void) { char *timeStr; char *fileName; PRInt32 secs, msecs; PRFileDesc *fd; PRInt64 tmp1, tmp2; PRStatus status = PR_NewThreadPrivateIndex( &gTLSIndex, ThreadDestruct ); NS_WARN_IF_FALSE(status==0, "TimelineService could not allocate TLS storage."); timeStr = PR_GetEnv("NS_TIMELINE_INIT_TIME"); #ifdef XP_MAC initInterval = PR_IntervalNow(); #endif // NS_TIMELINE_INIT_TIME only makes sense for the main thread, so if it // exists, set it there. If not, let normal thread management code take // care of setting the init time. if (timeStr != NULL && 2 == PR_sscanf(timeStr, "%d.%d", &secs, &msecs)) { PRTime &initTime = GetThisThreadData()->initTime; LL_MUL(tmp1, (PRInt64)secs, 1000000); LL_MUL(tmp2, (PRInt64)msecs, 1000); LL_ADD(initTime, tmp1, tmp2); #ifdef XP_MAC initInterval -= PR_MicrosecondsToInterval( (PRUint32)(PR_Now() - initTime)); #endif } // Get the log file. #ifdef XP_MAC fileName = "timeline.txt"; #else fileName = PR_GetEnv("NS_TIMELINE_LOG_FILE"); #endif if (fileName != NULL && (fd = PR_Open(fileName, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 0666)) != NULL) { timelineFD = fd; PR_fprintf(fd, "NOTE: due to asynchrony, the indentation that you see does" " not necessarily correspond to nesting in the code.\n\n"); } // Runtime disable of timeline if (PR_GetEnv("NS_TIMELINE_ENABLE")) gTimelineDisabled = PR_FALSE; return PR_SUCCESS; }
PRMJ_ToExtendedTime(PRInt32 time) { PRInt64 exttime; PRInt64 g1970GMTMicroSeconds; PRInt64 low; time_t diff; PRInt64 tmp; PRInt64 tmp1; diff = PRMJ_LocalGMTDifference(); LL_UI2L(tmp, PRMJ_USEC_PER_SEC); LL_I2L(tmp1,diff); LL_MUL(tmp,tmp,tmp1); LL_UI2L(g1970GMTMicroSeconds,G1970GMTMICROHI); LL_UI2L(low,G1970GMTMICROLOW); #ifndef HAVE_LONG_LONG LL_SHL(g1970GMTMicroSeconds,g1970GMTMicroSeconds,16); LL_SHL(g1970GMTMicroSeconds,g1970GMTMicroSeconds,16); #else LL_SHL(g1970GMTMicroSeconds,g1970GMTMicroSeconds,32); #endif LL_ADD(g1970GMTMicroSeconds,g1970GMTMicroSeconds,low); LL_I2L(exttime,time); LL_ADD(exttime,exttime,g1970GMTMicroSeconds); LL_SUB(exttime,exttime,tmp); return exttime; }
static SECCertTimeValidity _NSSCPY_CheckCrlTimes(CERTCrl *crl, PRTime t) { PRTime notBefore, notAfter, llPendingSlop, tmp1; SECStatus rv; PRInt32 pSlop = CERT_GetSlopTime(); rv = _NSSCPY_GetCrlTimes(crl, ¬Before, ¬After); if (rv) { return(secCertTimeExpired); } LL_I2L(llPendingSlop, pSlop); /* convert to micro seconds */ LL_I2L(tmp1, PR_USEC_PER_SEC); LL_MUL(llPendingSlop, llPendingSlop, tmp1); LL_SUB(notBefore, notBefore, llPendingSlop); if ( LL_CMP( t, <, notBefore ) ) { return(secCertTimeNotValidYet); } /* If next update is omitted and the test for notBefore passes, then * we assume that the crl is up to date. */ if ( LL_IS_ZERO(notAfter) ) { return(secCertTimeValid); } if ( LL_CMP( t, >, notAfter) ) { return(secCertTimeExpired); } return(secCertTimeValid); }
static PRTime SecondsToPRTime(PRUint32 t_sec) { PRTime t_usec, usec_per_sec; LL_I2L(t_usec, t_sec); LL_I2L(usec_per_sec, PR_USEC_PER_SEC); LL_MUL(t_usec, t_usec, usec_per_sec); return t_usec; }
static void testParseTimeString(PRTime t) { PRExplodedTime et; PRTime t2; char timeString[128]; char buf[128]; PRInt32 totalOffset; PRInt32 hourOffset, minOffset; const char *sign; PRInt64 usec_per_sec; /* Truncate the microsecond part of PRTime */ LL_I2L(usec_per_sec, PR_USEC_PER_SEC); LL_DIV(t, t, usec_per_sec); LL_MUL(t, t, usec_per_sec); PR_ExplodeTime(t, PR_LocalTimeParameters, &et); /* Print day of the week, month, day, hour, minute, and second */ PR_snprintf(timeString, 128, "%s %s %ld %02ld:%02ld:%02ld ", dayOfWeek[et.tm_wday], month[et.tm_month], et.tm_mday, et.tm_hour, et.tm_min, et.tm_sec); /* Print time zone */ totalOffset = et.tm_params.tp_gmt_offset + et.tm_params.tp_dst_offset; if (totalOffset == 0) { strcat(timeString, "GMT "); /* I wanted to use "UTC" here, but * PR_ParseTimeString doesn't * understand "UTC". */ } else { sign = "+"; if (totalOffset < 0) { totalOffset = -totalOffset; sign = "-"; } hourOffset = totalOffset / 3600; minOffset = (totalOffset % 3600) / 60; PR_snprintf(buf, 128, "%s%02ld%02ld ", sign, hourOffset, minOffset); strcat(timeString, buf); } /* Print year */ PR_snprintf(buf, 128, "%hd", et.tm_year); strcat(timeString, buf); if (PR_ParseTimeString(timeString, PR_FALSE, &t2) == PR_FAILURE) { fprintf(stderr, "PR_ParseTimeString() failed\n"); exit(1); } if (LL_NE(t, t2)) { fprintf(stderr, "PR_ParseTimeString() incorrect\n"); PR_snprintf(buf, 128, "t is %lld, t2 is %lld, time string is %s\n", t, t2, timeString); fprintf(stderr, "%s\n", buf); exit(1); } }
nsresult nsSafariProfileMigrator::CopyHistoryBatched(bool aReplace) { nsCOMPtr<nsIProperties> fileLocator(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID)); nsCOMPtr<nsILocalFile> safariHistoryFile; fileLocator->Get(NS_MAC_USER_LIB_DIR, NS_GET_IID(nsILocalFile), getter_AddRefs(safariHistoryFile)); safariHistoryFile->Append(NS_LITERAL_STRING("Safari")); safariHistoryFile->Append(SAFARI_HISTORY_FILE_NAME); CFDictionaryRef safariHistory = static_cast<CFDictionaryRef>(CopyPListFromFile(safariHistoryFile)); if (!safariHistory) return NS_OK; if (!::CFDictionaryContainsKey(safariHistory, CFSTR("WebHistoryDates"))) { ::CFRelease(safariHistory); return NS_OK; } nsCOMPtr<nsIBrowserHistory> history(do_GetService(NS_GLOBALHISTORY2_CONTRACTID)); CFArrayRef children = (CFArrayRef) ::CFDictionaryGetValue(safariHistory, CFSTR("WebHistoryDates")); if (children) { CFIndex count = ::CFArrayGetCount(children); for (PRInt32 i = 0; i < count; ++i) { CFDictionaryRef entry = (CFDictionaryRef)::CFArrayGetValueAtIndex(children, i); CFStringRef lastVisitedDate = (CFStringRef) ::CFDictionaryGetValue(entry, CFSTR("lastVisitedDate")); nsAutoString url, title; if (GetDictionaryStringValue(entry, CFSTR(""), url) && GetDictionaryStringValue(entry, CFSTR("title"), title) && lastVisitedDate) { double lvd = ::CFStringGetDoubleValue(lastVisitedDate) + SAFARI_DATE_OFFSET; PRTime lastVisitTime; PRInt64 temp, million; LL_D2L(temp, lvd); LL_I2L(million, PR_USEC_PER_SEC); LL_MUL(lastVisitTime, temp, million); nsCOMPtr<nsIURI> uri; NS_NewURI(getter_AddRefs(uri), url); if (uri) history->AddPageWithDetails(uri, title.get(), lastVisitTime); } } } ::CFRelease(safariHistory); return NS_OK; }
PRInt32 _PR_MD_GETOPENFILEINFO(const PRFileDesc *fd, PRFileInfo *info) { /* For once, the VAC compiler/library did a nice thing. * The file handle used by the C runtime is the same one * returned by the OS when you call DosOpen(). This means * that you can take an OS HFILE and use it with C file * functions. The only caveat is that you have to call * _setmode() first to initialize some junk. This is * immensely useful because I did not have a clue how to * implement this function otherwise. The windows folks * took the source from the Microsoft C library source, but * IBM wasn't kind enough to ship the source with VAC. * On second thought, the needed function could probably * be gotten from the OS/2 GNU library source, but the * point is now moot. */ struct stat hinfo; PRInt64 s, s2us; _setmode(fd->secret->md.osfd, O_BINARY); if(fstat((int)fd->secret->md.osfd, &hinfo) != NO_ERROR) { _PR_MD_MAP_FSTAT_ERROR(errno); return -1; } if (hinfo.st_mode & S_IFDIR) info->type = PR_FILE_DIRECTORY; else info->type = PR_FILE_FILE; info->size = hinfo.st_size; LL_I2L(s2us, PR_USEC_PER_SEC); LL_I2L(s, hinfo.st_mtime); LL_MUL(s, s, s2us); info->modifyTime = s; LL_I2L(s, hinfo.st_ctime); LL_MUL(s, s, s2us); info->creationTime = s; return 0; }
// This should use NSPR but NSPR isn't exporting its PR_strtoll function // Until then... PRInt64 nsCRT::atoll(const char *str) { if (!str) return LL_Zero(); PRInt64 ll = LL_Zero(), digitll = LL_Zero(); while (*str && *str >= '0' && *str <= '9') { LL_MUL(ll, ll, 10); LL_UI2L(digitll, (*str - '0')); LL_ADD(ll, ll, digitll); str++; } return ll; }
//---------------------------------------------------------------------------------------- PRInt64 nsFileSpec::GetDiskSpaceAvailable() const //---------------------------------------------------------------------------------------- { PRInt64 bytes; /* XXX dougt needs to fix this */ LL_I2L(bytes , LONG_MAX); // initialize to all the space in the world? #if defined(HAVE_SYS_STATFS_H) || defined(HAVE_SYS_STATVFS_H) char curdir [MAXPATHLEN]; if (mPath.IsEmpty()) { (void) getcwd(curdir, MAXPATHLEN); if (!curdir) return bytes; /* hope for the best as we did in cheddar */ } else sprintf(curdir, "%.200s", (const char*)mPath); struct STATFS fs_buf; #if defined(__QNX__) && !defined(HAVE_STATVFS) /* Maybe this should be handled differently? */ if (STATFS(curdir, &fs_buf, 0, 0) < 0) #else if (STATFS(curdir, &fs_buf) < 0) #endif return bytes; /* hope for the best as we did in cheddar */ #ifdef DEBUG_DISK_SPACE printf("DiskSpaceAvailable: %d bytes\n", fs_buf.f_bsize * (fs_buf.f_bavail - 1)); #endif PRInt64 bsize,bavail; LL_I2L( bsize, fs_buf.f_bsize ); LL_I2L( bavail, fs_buf.f_bavail - 1 ); LL_MUL( bytes, bsize, bavail ); return bytes; #else /* ** This platform doesn't have statfs or statvfs, so we don't have much ** choice but to "hope for the best as we did in cheddar". */ return bytes; #endif /* HAVE_SYS_STATFS_H or HAVE_SYS_STATVFS_H */ } // nsFileSpec::GetDiskSpace()
void addVariance(VarianceState* inVariance, unsigned inValue) /* ** Add a value to a variance state. */ { PRUint64 squared; PRUint64 bigValue; LL_UI2L(bigValue, inValue); LL_ADD(inVariance->mSum, inVariance->mSum, bigValue); LL_MUL(squared, bigValue, bigValue); LL_ADD(inVariance->mSquaredSum, inVariance->mSquaredSum, squared); inVariance->mCount++; }
/* * Determine if the token is logged in. We have to actually query the token, * because it's state can change without intervention from us. */ PRBool PK11_IsLoggedIn(PK11SlotInfo *slot,void *wincx) { CK_SESSION_INFO sessionInfo; int askpw = slot->askpw; int timeout = slot->timeout; CK_RV crv; PRIntervalTime curTime; static PRIntervalTime login_delay_time = 0; if (login_delay_time == 0) { login_delay_time = PR_SecondsToInterval(1); } /* If we don't have our own password default values, use the system * ones */ if ((slot->defaultFlags & PK11_OWN_PW_DEFAULTS) == 0) { PK11SlotInfo *def_slot = PK11_GetInternalKeySlot(); if (def_slot) { askpw = def_slot->askpw; timeout = def_slot->timeout; PK11_FreeSlot(def_slot); } } if ((wincx != NULL) && (PK11_Global.isLoggedIn != NULL) && (*PK11_Global.isLoggedIn)(slot, wincx) == PR_FALSE) { return PR_FALSE; } /* forget the password if we've been inactive too long */ if (askpw == 1) { int64 currtime = PR_Now(); int64 result; int64 mult; LL_I2L(result, timeout); LL_I2L(mult, 60*1000*1000); LL_MUL(result,result,mult); LL_ADD(result, result, slot->authTime); if (LL_CMP(result, <, currtime) ) { PK11_EnterSlotMonitor(slot); PK11_GETTAB(slot)->C_Logout(slot->session); slot->lastLoginCheck = 0; PK11_ExitSlotMonitor(slot); } else {
PRUint32 ticks2xsec(tmreader* aReader, PRUint32 aTicks, PRUint32 aResolution) /* ** Convert platform specific ticks to second units ** Returns 0 on success. */ { PRUint32 retval = 0; PRUint64 bigone; PRUint64 tmp64; LL_UI2L(bigone, aResolution); LL_UI2L(tmp64, aTicks); LL_MUL(bigone, bigone, tmp64); LL_UI2L(tmp64, aReader->ticksPerSec); LL_DIV(bigone, bigone, tmp64); LL_L2UI(retval, bigone); return retval; }
static void TestNowOverhead(void) { PRTime timeout, timein; PRInt32 overhead, loops = 1000000; PRInt64 elapsed, per_call, ten23rd, ten26th; LL_I2L(ten23rd, 1000); LL_I2L(ten26th, 1000000); timein = PR_Now(); while (--loops > 0) timeout = PR_Now(); LL_SUB(elapsed, timeout, timein); LL_MUL(elapsed, elapsed, ten23rd); LL_DIV(per_call, elapsed, ten26th); LL_L2I(overhead, per_call); PR_fprintf( output, "Overhead of 'PR_Now()' is %u nsecs\n\n", overhead); } /* TestNowOverhead */
PRMJ_DSTOffset(PRInt64 time) { PRInt64 us2s; #ifdef XP_MAC MachineLocation machineLocation; PRInt64 dlsOffset; /* Get the information about the local machine, including * its GMT offset and its daylight savings time info. * Convert each into wides that we can add to * startupTimeMicroSeconds. */ MyReadLocation(&machineLocation); /* Is Daylight Savings On? If so, we need to add an hour to the offset. */ if (machineLocation.u.dlsDelta != 0) { LL_UI2L(us2s, PRMJ_USEC_PER_SEC); /* seconds in a microseconds */ LL_UI2L(dlsOffset, PRMJ_HOUR_SECONDS); /* seconds in one hour */ LL_MUL(dlsOffset, dlsOffset, us2s); } else LL_I2L(dlsOffset, 0); return(dlsOffset); #else time_t local; PRInt32 diff; PRInt64 maxtimet; struct tm tm; #if defined( XP_PC ) || defined( FREEBSD ) struct tm *ptm; #endif PRMJTime prtm; LL_UI2L(us2s, PRMJ_USEC_PER_SEC); LL_DIV(time, time, us2s); /* get the maximum of time_t value */ LL_UI2L(maxtimet,PRMJ_MAX_UNIX_TIMET); if(LL_CMP(time,>,maxtimet)){ LL_UI2L(time,PRMJ_MAX_UNIX_TIMET); } else if(!LL_GE_ZERO(time)){
/* bool setProperty (in nsIXPConnectWrappedNative wrapper, in JSContextPtr cx, in JSObjectPtr obj, in jsid id, in JSValPtr vp); */ NS_IMETHODIMP calDateTime::SetProperty(nsIXPConnectWrappedNative *wrapper, JSContext * cx, JSObject * obj, jsid id, jsval * vp, bool *_retval) { NS_ENSURE_ARG_POINTER(_retval); if (JSID_IS_STRING(id)) { size_t length; JSString *idString = JSID_TO_STRING(id); const jschar *str = JS_GetStringCharsAndLength(cx, idString, &length); nsDependentString const val(reinterpret_cast<PRUnichar const*>(str), length); if (val.EqualsLiteral("jsDate") && vp) { JSObject *dobj; if (!JSVAL_IS_OBJECT(*vp) || !js_DateIsValid(cx, (dobj = JSVAL_TO_OBJECT(*vp)))) { mIsValid = PR_FALSE; } else { jsdouble utcMsec = js_DateGetMsecSinceEpoch(cx, dobj); PRTime utcTime, thousands; LL_F2L(utcTime, utcMsec); LL_I2L(thousands, 1000); LL_MUL(utcTime, utcTime, thousands); nsresult rv = SetNativeTime(utcTime); if (NS_SUCCEEDED(rv)) { mIsValid = PR_TRUE; } else { mIsValid = PR_FALSE; } } *_retval = PR_TRUE; return NS_SUCCESS_I_DID_SOMETHING; } } *_retval = PR_TRUE; return NS_OK; }
void nsNetscapeProfileMigratorBase::CopyNextFolder() { if (mFileCopyTransactionIndex < mFileCopyTransactions.Length()) { PRUint32 percentage = 0; fileTransactionEntry fileTransaction = mFileCopyTransactions.ElementAt(mFileCopyTransactionIndex++); // copy the file fileTransaction.srcFile->CopyTo(fileTransaction.destFile, fileTransaction.newName); // add to our current progress PRInt64 fileSize; fileTransaction.srcFile->GetFileSize(&fileSize); LL_ADD(mCurrentProgress, mCurrentProgress, fileSize); PRInt64 percentDone; LL_MUL(percentDone, mCurrentProgress, 100); LL_DIV(percentDone, percentDone, mMaxProgress); LL_L2UI(percentage, percentDone); nsAutoString index; index.AppendInt(percentage); NOTIFY_OBSERVERS(MIGRATION_PROGRESS, index.get()); // fire a timer to handle the next one. mFileIOTimer = do_CreateInstance("@mozilla.org/timer;1"); if (mFileIOTimer) mFileIOTimer->InitWithCallback(static_cast<nsITimerCallback *>(this), percentage == 100 ? 500 : 0, nsITimer::TYPE_ONE_SHOT); } else EndCopyFolders(); return; }
nsresult nsOperaProfileMigrator::CopyHistoryBatched(PRBool aReplace) { nsCOMPtr<nsIBrowserHistory> hist(do_GetService(NS_GLOBALHISTORY2_CONTRACTID)); nsCOMPtr<nsIFile> temp; mOperaProfile->Clone(getter_AddRefs(temp)); nsCOMPtr<nsILocalFile> historyFile(do_QueryInterface(temp)); historyFile->Append(OPERA_HISTORY_FILE_NAME); nsCOMPtr<nsIInputStream> fileStream; NS_NewLocalFileInputStream(getter_AddRefs(fileStream), historyFile); if (!fileStream) return NS_ERROR_OUT_OF_MEMORY; nsCOMPtr<nsILineInputStream> lineStream = do_QueryInterface(fileStream); nsCAutoString buffer, url; nsAutoString title; PRTime lastVisitDate; PRBool moreData = PR_FALSE; enum { TITLE, URL, LASTVISIT } state = TITLE; // Format is "title\nurl\nlastvisitdate" do { nsresult rv = lineStream->ReadLine(buffer, &moreData); if (NS_FAILED(rv)) return rv; switch (state) { case TITLE: CopyUTF8toUTF16(buffer, title); state = URL; break; case URL: url = buffer; state = LASTVISIT; break; case LASTVISIT: // Opera time format is a second offset, PRTime is a microsecond offset nsresult err; lastVisitDate = buffer.ToInteger(&err); PRInt64 temp, million; LL_I2L(temp, lastVisitDate); LL_I2L(million, PR_USEC_PER_SEC); LL_MUL(lastVisitDate, temp, million); nsCOMPtr<nsIURI> uri; NS_NewURI(getter_AddRefs(uri), url); if (uri) hist->AddPageWithDetails(uri, title.get(), lastVisitDate); state = TITLE; break; } } while (moreData); return NS_OK; }
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; }
PRMJ_Now(void) { #ifdef XP_PC PRInt64 s, us, ms2us, s2us; struct timeb b; #endif /* XP_PC */ #ifdef XP_UNIX struct timeval tv; PRInt64 s, us, s2us; #endif /* XP_UNIX */ #ifdef XP_MAC UnsignedWide upTime; PRInt64 localTime; PRInt64 gmtOffset; PRInt64 dstOffset; time_t gmtDiff; PRInt64 s2us; #endif /* XP_MAC */ #ifdef XP_PC ftime(&b); LL_UI2L(ms2us, PRMJ_USEC_PER_MSEC); LL_UI2L(s2us, PRMJ_USEC_PER_SEC); LL_UI2L(s, b.time); LL_UI2L(us, b.millitm); LL_MUL(us, us, ms2us); LL_MUL(s, s, s2us); LL_ADD(s, s, us); return s; #endif #ifdef XP_UNIX #if defined(SOLARIS) gettimeofday(&tv); #else gettimeofday(&tv, 0); #endif /* SOLARIS */ LL_UI2L(s2us, PRMJ_USEC_PER_SEC); LL_UI2L(s, tv.tv_sec); LL_UI2L(us, tv.tv_usec); LL_MUL(s, s, s2us); LL_ADD(s, s, us); return s; #endif /* XP_UNIX */ #ifdef XP_MAC LL_UI2L(localTime,0); gmtDiff = PRMJ_LocalGMTDifference(); LL_I2L(gmtOffset,gmtDiff); LL_UI2L(s2us, PRMJ_USEC_PER_SEC); LL_MUL(gmtOffset,gmtOffset,s2us); LL_UI2L(dstOffset,0); dstOffset = PRMJ_DSTOffset(dstOffset); LL_SUB(gmtOffset,gmtOffset,dstOffset); /* don't adjust for DST since it sets ctime and gmtime off on the MAC */ Microseconds(&upTime); LL_ADD(localTime,localTime,gmtOffset); LL_ADD(localTime,localTime, *((PRUint64 *)&dstLocalBaseMicroseconds)); LL_ADD(localTime,localTime, *((PRUint64 *)&upTime)); return *((PRUint64 *)&localTime); #endif /* XP_MAC */ }
NS_IMETHODIMP InvokeTestTarget::MultTwoLLs(PRInt64 p1, PRInt64 p2, PRInt64* retval) { LL_MUL(*retval, p1, p2); return NS_OK; }
static PRUint64 _pr_strtoull(const char *str, char **endptr, int base) { static const int BASE_MAX = 16; static const char digits[] = "0123456789abcdef"; char *digitPtr; PRUint64 x; /* return value */ PRInt64 base64; const char *cPtr; PRBool negative; const char *digitStart; PR_ASSERT(base == 0 || base == 8 || base == 10 || base == 16); if (base < 0 || base == 1 || base > BASE_MAX) { if (endptr) { *endptr = (char *) str; return LL_ZERO; } } cPtr = str; while (isspace(*cPtr)) { ++cPtr; } negative = PR_FALSE; if (*cPtr == '-') { negative = PR_TRUE; cPtr++; } else if (*cPtr == '+') { cPtr++; } if (base == 16) { if (*cPtr == '0' && (cPtr[1] == 'x' || cPtr[1] == 'X')) { cPtr += 2; } } else if (base == 0) { if (*cPtr != '0') { base = 10; } else if (cPtr[1] == 'x' || cPtr[1] == 'X') { base = 16; cPtr += 2; } else { base = 8; } } PR_ASSERT(base != 0); LL_I2L(base64, base); digitStart = cPtr; /* Skip leading zeros */ while (*cPtr == '0') { cPtr++; } LL_I2L(x, 0); while ((digitPtr = (char*)memchr(digits, tolower(*cPtr), base)) != NULL) { PRUint64 d; LL_I2L(d, (digitPtr - digits)); LL_MUL(x, x, base64); LL_ADD(x, x, d); cPtr++; } if (cPtr == digitStart) { if (endptr) { *endptr = (char *) str; } return LL_ZERO; } if (negative) { #ifdef HAVE_LONG_LONG /* The cast to a signed type is to avoid a compiler warning */ x = -(PRInt64)x; #else LL_NEG(x, x); #endif } if (endptr) { *endptr = (char *) cPtr; } return x; }
// Set rcvDate to true to get the Received: date instead of the Date: date. nsresult nsMsgGroupView::GetAgeBucketValue(nsIMsgDBHdr *aMsgHdr, PRUint32 * aAgeBucket, bool rcvDate) { NS_ENSURE_ARG_POINTER(aMsgHdr); NS_ENSURE_ARG_POINTER(aAgeBucket); PRTime dateOfMsg; nsresult rv; if (!rcvDate) rv = aMsgHdr->GetDate(&dateOfMsg); else { PRUint32 rcvDateSecs; rv = aMsgHdr->GetUint32Property("dateReceived", &rcvDateSecs); Seconds2PRTime(rcvDateSecs, &dateOfMsg); } NS_ENSURE_SUCCESS(rv, rv); PRTime currentTime = PR_Now(); PRExplodedTime currentExplodedTime; PR_ExplodeTime(currentTime, PR_LocalTimeParameters, ¤tExplodedTime); PRExplodedTime explodedMsgTime; PR_ExplodeTime(dateOfMsg, PR_LocalTimeParameters, &explodedMsgTime); if (m_lastCurExplodedTime.tm_mday && m_lastCurExplodedTime.tm_mday != currentExplodedTime.tm_mday) m_dayChanged = true; // this will cause us to rebuild the view. m_lastCurExplodedTime = currentExplodedTime; if (currentExplodedTime.tm_year == explodedMsgTime.tm_year && currentExplodedTime.tm_month == explodedMsgTime.tm_month && currentExplodedTime.tm_mday == explodedMsgTime.tm_mday) { // same day... *aAgeBucket = 1; } // figure out how many days ago this msg arrived else if (LL_CMP(currentTime, >, dateOfMsg)) { // some constants for calculation static PRInt64 microSecondsPerSecond; static PRInt64 microSecondsPerDay; static PRInt64 secondsPerDay; static PRInt64 microSecondsPer6Days; static PRInt64 microSecondsPer13Days; static bool bGotConstants = false; if ( !bGotConstants ) { // seeds LL_I2L ( microSecondsPerSecond, PR_USEC_PER_SEC ); LL_UI2L ( secondsPerDay, 60 * 60 * 24 ); // derivees LL_MUL( microSecondsPerDay, secondsPerDay, microSecondsPerSecond ); LL_MUL( microSecondsPer6Days, microSecondsPerDay, 6 ); LL_MUL( microSecondsPer13Days, microSecondsPerDay, 13 ); bGotConstants = true; } // setting the time variables to local time PRInt64 GMTLocalTimeShift; LL_ADD( GMTLocalTimeShift, currentExplodedTime.tm_params.tp_gmt_offset, currentExplodedTime.tm_params.tp_dst_offset ); LL_MUL( GMTLocalTimeShift, GMTLocalTimeShift, microSecondsPerSecond ); LL_ADD( currentTime, currentTime, GMTLocalTimeShift ); LL_ADD( dateOfMsg, dateOfMsg, GMTLocalTimeShift ); // the most recent midnight, counting from current time PRInt64 todaysMicroSeconds, mostRecentMidnight; LL_MOD( todaysMicroSeconds, currentTime, microSecondsPerDay ); LL_SUB( mostRecentMidnight, currentTime, todaysMicroSeconds ); PRInt64 yesterday; LL_SUB( yesterday, mostRecentMidnight, microSecondsPerDay ); // most recent midnight minus 6 days PRInt64 mostRecentWeek; LL_SUB( mostRecentWeek, mostRecentMidnight, microSecondsPer6Days ); // was the message sent yesterday? if ( LL_CMP( dateOfMsg, >=, yesterday ) ) // yes .... *aAgeBucket = 2; else if ( LL_CMP(dateOfMsg, >=, mostRecentWeek) ) *aAgeBucket = 3; else {