// The file name must be in the form "np*.dll"
PRBool nsPluginsDir::IsPluginFile(nsIFile* file)
{
nsCAutoString path;
if (NS_FAILED(file->GetNativePath(path)))
return PR_FALSE;
const char *cPath = path.get();
// this is most likely a path, so skip to the filename
const char* filename = PL_strrchr(cPath, '\\');
if (filename)
++filename;
else
filename = cPath;
char* extension = PL_strrchr(filename, '.');
if (extension)
++extension;
PRUint32 fullLength = PL_strlen(filename);
PRUint32 extLength = PL_strlen(extension);
if (fullLength >= 7 && extLength == 3) {
if (!PL_strncasecmp(filename, "np", 2) && !PL_strncasecmp(extension, "dll", 3)) {
// don't load OJI-based Java plugins
if (!PL_strncasecmp(filename, "npoji", 5) ||
!PL_strncasecmp(filename, "npjava", 6))
return PR_FALSE;
return PR_TRUE;
}
}
return PR_FALSE;
}
/* Will only work if the original input to url encoding was
* a base64 encoded buffer. Will only decode the sequences used
* for encoding the special base64 characters, and fail if any
* other encoded chars are found.
* Will return SECSuccess if input could be processed.
* Coversion is done in place.
*/
static SECStatus
urldecode_base64chars_inplace(char *buf)
{
char *walk;
size_t remaining_bytes;
if (!buf || !*buf)
return SECFailure;
walk = buf;
remaining_bytes = strlen(buf) + 1; /* include terminator */
while (*walk) {
if (*walk == '%') {
if (!PL_strncasecmp(walk, "%2B", 3)) {
*walk = '+';
} else if (!PL_strncasecmp(walk, "%2F", 3)) {
*walk = '/';
} else if (!PL_strncasecmp(walk, "%3D", 3)) {
*walk = '=';
} else {
return SECFailure;
}
remaining_bytes -= 3;
++walk;
memmove(walk, walk + 2, remaining_bytes);
} else {
++walk;
--remaining_bytes;
}
}
return SECSuccess;
}
nsresult
nsEnigMimeDecrypt::ProcessPlainData(char* buf, PRUint32 readCount)
{
DEBUG_LOG(("nsEnigMimeDecrypt::ProcessPlainData: readCount=%d\n", readCount));
int status;
++mIterations;
// Read synchronously
if (mIterations == 1 && readCount > 25) {
// add mime boundaries around text/plain message (bug 6627)
if (PL_strncasecmp("content-type:", buf, 13)==0) {
PRUint32 whitespace=13;
while((whitespace<readCount) && buf[whitespace] &&
((buf[whitespace]==' ') || (buf[whitespace]=='\t'))) { whitespace++; }
if (buf[whitespace] && (whitespace<readCount)) {
mCtFound = PL_strncasecmp(buf + whitespace, "text/plain", 10);
if (mCtFound != 0) {
mCtFound=PL_strncasecmp(buf + whitespace, "text/html", 9);
}
}
if (mCtFound == 0) {
char* header = PR_smprintf(
"Content-Type: multipart/mixed; boundary=\"enigDummy\""
"\n\n--enigDummy\n");
PR_SetError(0,0);
status = mOutputFun(header, strlen(header), mOutputClosure);
if (status < 0) {
PR_SetError(status, 0);
mOutputFun = NULL;
mOutputClosure = NULL;
return NS_ERROR_FAILURE;
}
mOutputLen += strlen(header);
}
}
}
if (readCount < kCharMax) {
// make sure we can continue to write later
if (buf[readCount-1]==0) --readCount;
}
PR_SetError(0,0);
status = mOutputFun(buf, readCount, mOutputClosure);
if (status < 0) {
PR_SetError(status, 0);
mOutputFun = NULL;
mOutputClosure = NULL;
return NS_ERROR_FAILURE;
}
mOutputLen += readCount;
return NS_OK;
} // loop end
PRBool nsPluginNativeWindowGtk2::CanGetValueFromPlugin(nsCOMPtr<nsIPluginInstance> &aPluginInstance)
{
#ifdef OJI
if(aPluginInstance) {
nsresult rv;
nsCOMPtr<nsIPluginInstancePeer> peer;
rv = aPluginInstance->GetPeer(getter_AddRefs(peer));
if (NS_SUCCEEDED(rv) && peer) {
const char *aMimeType = nsnull;
peer->GetMIMEType((nsMIMEType*)&aMimeType);
if (aMimeType &&
(PL_strncasecmp(aMimeType, "application/x-java-vm", 21) == 0 ||
PL_strncasecmp(aMimeType, "application/x-java-applet", 25) == 0)) {
nsCOMPtr<nsIPluginHost> pluginHost = do_GetService(kPluginManagerCID, &rv);
if (NS_SUCCEEDED(rv) && pluginHost) {
nsIPlugin* pluginFactory = NULL;
rv = pluginHost->GetPluginFactory("application/x-java-vm", &pluginFactory);
if (NS_SUCCEEDED(rv) && pluginFactory) {
const char * jpiDescription;
pluginFactory->GetValue(nsPluginVariable_DescriptionString, (void*)&jpiDescription);
/**
* "Java(TM) Plug-in" is Sun's Java Plugin Trademark,
* so we are sure that this is Sun 's Java Plugin if
* the description start with "Java(TM) Plug-in"
**/
if (PL_strncasecmp(jpiDescription, "Java(TM) Plug-in", 16) == 0) {
// Java Plugin support Xembed from JRE 1.5
if (PL_strcasecmp(jpiDescription + 17, "1.5") < 0)
return PR_FALSE;
}
if (PL_strncasecmp(jpiDescription, "<a href=\"http://www.blackdown.org/java-linux.html\">", 51) == 0) {
// Java Plugin support Xembed from JRE 1.5
if (PL_strcasecmp(jpiDescription + 92, "1.5") < 0)
return PR_FALSE;
}
if (PL_strncasecmp(jpiDescription, "IBM Java(TM) Plug-in", 20) == 0) {
// Java Plugin support Xembed from JRE 1.5
if (PL_strcasecmp(jpiDescription + 27, "1.5") < 0)
return PR_FALSE;
}
}
}
}
}
}
#endif
return PR_TRUE;
}
void
nsHttpResponseHead::ParseVersion(const char *str)
{
// Parse HTTP-Version:: "HTTP" "/" 1*DIGIT "." 1*DIGIT
LOG(("nsHttpResponseHead::ParseVersion [version=%s]\n", str));
// make sure we have HTTP at the beginning
if (PL_strncasecmp(str, "HTTP", 4) != 0) {
if (PL_strncasecmp(str, "ICY ", 4) == 0) {
// ShoutCast ICY is HTTP/1.0-like. Assume it is HTTP/1.0.
LOG(("Treating ICY as HTTP 1.0\n"));
mVersion = NS_HTTP_VERSION_1_0;
return;
}
LOG(("looks like a HTTP/0.9 response\n"));
mVersion = NS_HTTP_VERSION_0_9;
return;
}
str += 4;
if (*str != '/') {
LOG(("server did not send a version number; assuming HTTP/1.0\n"));
// NCSA/1.5.2 has a bug in which it fails to send a version number
// if the request version is HTTP/1.1, so we fall back on HTTP/1.0
mVersion = NS_HTTP_VERSION_1_0;
return;
}
char *p = PL_strchr(str, '.');
if (p == nullptr) {
LOG(("mal-formed server version; assuming HTTP/1.0\n"));
mVersion = NS_HTTP_VERSION_1_0;
return;
}
++p; // let b point to the minor version
int major = atoi(str + 1);
int minor = atoi(p);
if ((major > 1) || ((major == 1) && (minor >= 1)))
// at least HTTP/1.1
mVersion = NS_HTTP_VERSION_1_1;
else
// treat anything else as version 1.0
mVersion = NS_HTTP_VERSION_1_0;
}
/* void asyncConvertData (in string aFromType, in string aToType,
* in nsIStreamListener aListener,
* in nsISupports aCtxt); */
NS_IMETHODIMP nsDeflateConverter::AsyncConvertData(const char *aFromType,
const char *aToType,
nsIStreamListener *aListener,
nsISupports *aCtxt)
{
if (mListener)
return NS_ERROR_ALREADY_INITIALIZED;
NS_ENSURE_ARG_POINTER(aListener);
if (!PL_strncasecmp(aToType, ZLIB_TYPE, sizeof(ZLIB_TYPE)-1))
mWrapMode = WRAP_ZLIB;
else if (!PL_strcasecmp(aFromType, GZIP_TYPE) ||
!PL_strcasecmp(aFromType, X_GZIP_TYPE))
mWrapMode = WRAP_GZIP;
else
mWrapMode = WRAP_NONE;
nsresult rv = Init();
NS_ENSURE_SUCCESS(rv, rv);
mListener = aListener;
mContext = aCtxt;
return rv;
}
const char *
nsHttp::FindToken(const char *input, const char *token, const char *seps)
{
if (!input)
return nsnull;
int inputLen = strlen(input);
int tokenLen = strlen(token);
if (inputLen < tokenLen)
return nsnull;
const char *inputTop = input;
const char *inputEnd = input + inputLen - tokenLen;
for (; input <= inputEnd; ++input) {
if (PL_strncasecmp(input, token, tokenLen) == 0) {
if (input > inputTop && !strchr(seps, *(input - 1)))
continue;
if (input < inputEnd && !strchr(seps, *(input + tokenLen)))
continue;
return input;
}
}
return nsnull;
}
int nsEudoraMailbox::IsMonthStr(const char *pStr)
{
for (int i = 0; i < 12; i++) {
if (!PL_strncasecmp(pStr, eudoraMonths[i], 3))
return i + 1;
}
return 0;
}
int nsEudoraMailbox::IsWeekDayStr(const char *pStr)
{
for (int i = 0; i < 7; i++) {
if (!PL_strncasecmp(pStr, eudoraWeekDays[i], 3))
return i + 1;
}
return 0;
}
static char *
LocateHttpStart(char *buf, PRUint32 len)
{
// if we have received less than 4 bytes of data, then we'll have to
// just accept a partial match, which may not be correct.
if (len < 4)
return (PL_strncasecmp(buf, "HTTP", len) == 0) ? buf : 0;
// PL_strncasestr would be perfect for this, but unfortunately bug 96571
// prevents its use here.
while (len >= 4) {
if (PL_strncasecmp(buf, "HTTP", 4) == 0)
return buf;
buf++;
len--;
}
return 0;
}
/* Writes the headers as text/plain.
This writes out a blank line after the headers, unless
dont_write_content_type is true, in which case the header-block
is not closed off, and none of the Content- headers are written.
*/
int
MimeHeaders_write_raw_headers (MimeHeaders *hdrs, MimeDisplayOptions *opt,
bool dont_write_content_type)
{
int status;
if (hdrs && !hdrs->done_p)
{
hdrs->done_p = true;
status = MimeHeaders_build_heads_list(hdrs);
if (status < 0) return 0;
}
nsCString name;
name.Adopt(MimeHeaders_get_name(hdrs, opt));
MimeHeaders_convert_header_value(opt, name, false);
if (!dont_write_content_type)
{
char nl[] = MSG_LINEBREAK;
if (hdrs)
{
status = MimeHeaders_write(opt, name, hdrs->all_headers,
hdrs->all_headers_fp);
if (status < 0) return status;
}
status = MimeHeaders_write(opt, name, nl, strlen(nl));
if (status < 0) return status;
}
else if (hdrs)
{
int32_t i;
for (i = 0; i < hdrs->heads_size; i++)
{
char *head = hdrs->heads[i];
char *end = (i == hdrs->heads_size-1
? hdrs->all_headers + hdrs->all_headers_fp
: hdrs->heads[i+1]);
NS_ASSERTION(head, "1.22 <*****@*****.**> 22 Aug 1999 08:48");
if (!head) continue;
/* Don't write out any Content- header. */
if (!PL_strncasecmp(head, "Content-", 8))
continue;
/* Write out this (possibly multi-line) header. */
status = MimeHeaders_write(opt, name, head, end - head);
if (status < 0) return status;
}
}
if (hdrs)
MimeHeaders_compact(hdrs);
return 0;
}
static bool
MimeMultipartAlternative_display_part_p(MimeObject *self,
MimeHeaders *sub_hdrs)
{
char *ct = MimeHeaders_get (sub_hdrs, HEADER_CONTENT_TYPE, true, false);
if (!ct)
return false;
/* RFC 1521 says:
Receiving user agents should pick and display the last format
they are capable of displaying. In the case where one of the
alternatives is itself of type "multipart" and contains unrecognized
sub-parts, the user agent may choose either to show that alternative,
an earlier alternative, or both.
Ugh. If there is a multipart subtype of alternative, we simply show
that, without descending into it to determine if any of its sub-parts
are themselves unknown.
*/
// prefer_plaintext pref
nsIPrefBranch *prefBranch = GetPrefBranch(self->options);
bool prefer_plaintext = false;
if (prefBranch)
prefBranch->GetBoolPref("mailnews.display.prefer_plaintext",
&prefer_plaintext);
if (prefer_plaintext
&& self->options->format_out != nsMimeOutput::nsMimeMessageSaveAs
&& (!PL_strncasecmp(ct, "text/html", 9) ||
!PL_strncasecmp(ct, "text/enriched", 13) ||
!PL_strncasecmp(ct, "text/richtext", 13))
)
// if the user prefers plaintext and this is the "rich" (e.g. HTML) part...
{
return false;
}
MimeObjectClass *clazz = mime_find_class (ct, sub_hdrs, self->options, true);
bool result = (clazz
? clazz->displayable_inline_p(clazz, sub_hdrs)
: false);
PR_FREEIF(ct);
return result;
}
int
nsCaseInsensitiveCStringComparator::operator()( const char_type* lhs, const char_type* rhs, PRUint32 aLength ) const
{
PRInt32 result=PRInt32(PL_strncasecmp(lhs, rhs, aLength));
//Egads. PL_strncasecmp is returning *very* negative numbers.
//Some folks expect -1,0,1, so let's temper its enthusiasm.
if (result<0)
result=-1;
return result;
}
bool
nsHttpNegotiateAuth::MatchesBaseURI(const nsCSubstring &matchScheme,
const nsCSubstring &matchHost,
PRInt32 matchPort,
const char *baseStart,
const char *baseEnd)
{
// check if scheme://host:port matches baseURI
// parse the base URI
const char *hostStart, *schemeEnd = strstr(baseStart, "://");
if (schemeEnd) {
// the given scheme must match the parsed scheme exactly
if (!matchScheme.Equals(Substring(baseStart, schemeEnd)))
return false;
hostStart = schemeEnd + 3;
}
else
hostStart = baseStart;
// XXX this does not work for IPv6-literals
const char *hostEnd = strchr(hostStart, ':');
if (hostEnd && hostEnd < baseEnd) {
// the given port must match the parsed port exactly
int port = atoi(hostEnd + 1);
if (matchPort != (PRInt32) port)
return false;
}
else
hostEnd = baseEnd;
// if we didn't parse out a host, then assume we got a match.
if (hostStart == hostEnd)
return true;
PRUint32 hostLen = hostEnd - hostStart;
// matchHost must either equal host or be a subdomain of host
if (matchHost.Length() < hostLen)
return false;
const char *end = matchHost.EndReading();
if (PL_strncasecmp(end - hostLen, hostStart, hostLen) == 0) {
// if matchHost ends with host from the base URI, then make sure it is
// either an exact match, or prefixed with a dot. we don't want
// "foobar.com" to match "bar.com"
if (matchHost.Length() == hostLen ||
*(end - hostLen) == '.' ||
*(end - hostLen - 1) == '.')
return true;
}
return false;
}
PRUint16
nsDNSService::GetAFForLookup(const nsACString &host)
{
if (mDisableIPv6)
return PR_AF_INET;
nsAutoLock lock(mLock);
PRUint16 af = PR_AF_UNSPEC;
if (!mIPv4OnlyDomains.IsEmpty()) {
const char *domain, *domainEnd, *end;
PRUint32 hostLen, domainLen;
// see if host is in one of the IPv4-only domains
domain = mIPv4OnlyDomains.BeginReading();
domainEnd = mIPv4OnlyDomains.EndReading();
nsACString::const_iterator hostStart;
host.BeginReading(hostStart);
hostLen = host.Length();
do {
// skip any whitespace
while (*domain == ' ' || *domain == '\t')
++domain;
// find end of this domain in the string
end = strchr(domain, ',');
if (!end)
end = domainEnd;
// to see if the hostname is in the domain, check if the domain
// matches the end of the hostname.
domainLen = end - domain;
if (domainLen && hostLen >= domainLen) {
const char *hostTail = hostStart.get() + hostLen - domainLen;
if (PL_strncasecmp(domain, hostTail, domainLen) == 0) {
// now, make sure either that the hostname is a direct match or
// that the hostname begins with a dot.
if (hostLen == domainLen ||
*hostTail == '.' || *(hostTail - 1) == '.') {
af = PR_AF_INET;
break;
}
}
}
domain = end + 1;
} while (*end);
}
return af;
}
// CreateNilString return either NULL (for "NIL") or a string
// Call with fNextToken pointing to the thing which we think is the nilstring.
// This function leaves us off with fCurrentTokenPlaceHolder immediately after
// the end of the string.
// Regardless of type, call AdvanceToNextToken() to get the token after it.
// RFC3501: nstring = string / nil
// nil = "NIL"
char *nsIMAPGenericParser::CreateNilString()
{
if (!PL_strncasecmp(fNextToken, "NIL", 3))
{
// check if there is text after "NIL" in fNextToken,
// equivalent handling as in CreateQuoted
if (fNextToken[3])
AdvanceTokenizerStartingPoint((fNextToken - fLineOfTokens) + 3);
return NULL;
}
else
return CreateString();
}
static int
meth_to_int(char **map_method, int *err)
{
char *end;
int len;
int ret = PAMPT_MAP_METHOD_NONE;
*err = 0;
if (!map_method || !*map_method) {
return ret;
}
end = strchr(*map_method, ' ');
if (!end) {
len = strlen(*map_method);
} else {
len = end - *map_method;
}
if (!PL_strncasecmp(*map_method, PAMPT_MAP_METHOD_DN_STRING, len)) {
ret = PAMPT_MAP_METHOD_DN;
} else if (!PL_strncasecmp(*map_method, PAMPT_MAP_METHOD_RDN_STRING, len)) {
ret = PAMPT_MAP_METHOD_RDN;
} else if (!PL_strncasecmp(*map_method, PAMPT_MAP_METHOD_ENTRY_STRING, len)) {
ret = PAMPT_MAP_METHOD_ENTRY;
} else {
*err = 1;
}
if (!*err) {
if (end && *end) {
*map_method = end + 1;
} else {
*map_method = NULL;
}
}
return ret;
}
int
nsCaseInsensitiveCStringComparator::operator()( const char_type* lhs,
const char_type* rhs,
uint32_t lLength,
uint32_t rLength ) const
{
if (lLength != rLength)
return (lLength > rLength) ? 1 : -1;
int32_t result=int32_t(PL_strncasecmp(lhs, rhs, lLength));
//Egads. PL_strncasecmp is returning *very* negative numbers.
//Some folks expect -1,0,1, so let's temper its enthusiasm.
if (result<0)
result=-1;
return result;
}
NS_IMETHODIMP
nsHTTPCompressConv::AsyncConvertData(const char *aFromType,
const char *aToType,
nsIStreamListener *aListener,
nsISupports *aCtxt)
{
if (!PL_strncasecmp(aFromType, HTTP_COMPRESS_TYPE, sizeof(HTTP_COMPRESS_TYPE)-1) ||
!PL_strncasecmp(aFromType, HTTP_X_COMPRESS_TYPE, sizeof(HTTP_X_COMPRESS_TYPE)-1))
mMode = HTTP_COMPRESS_COMPRESS;
else if (!PL_strncasecmp(aFromType, HTTP_GZIP_TYPE, sizeof(HTTP_GZIP_TYPE)-1) ||
!PL_strncasecmp(aFromType, HTTP_X_GZIP_TYPE, sizeof(HTTP_X_GZIP_TYPE)-1))
mMode = HTTP_COMPRESS_GZIP;
else if (!PL_strncasecmp(aFromType, HTTP_DEFLATE_TYPE, sizeof(HTTP_DEFLATE_TYPE)-1))
mMode = HTTP_COMPRESS_DEFLATE;
// hook ourself up with the receiving listener.
mListener = aListener;
NS_ADDREF(mListener);
mAsyncConvContext = aCtxt;
return NS_OK;
}
PL_strcasestr(const char *big, const char *little)
{
PRUint32 ll;
if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
ll = PL_strlen(little);
for( ; *big; big++ )
/* obvious improvement available here */
if( 0 == PL_strncasecmp(big, little, ll) )
return (char *)big;
return (char *)0;
}
/*
* adjust_idl_switch
* if the current nsslapd-idl-switch is different from ldbmversion,
* update the value of nsslapd-idl-switch (in LDBM_CONFIG_ENTRY)
*/
int
adjust_idl_switch(char *ldbmversion, struct ldbminfo *li)
{
int rval = 0;
li->li_flags |= LI_FORCE_MOD_CONFIG;
if ((0 == PL_strncasecmp(ldbmversion, BDB_IMPL, strlen(BDB_IMPL))) ||
(0 == PL_strcmp(ldbmversion, LDBM_VERSION))) /* db: new idl */
{
if (!idl_get_idl_new()) /* config: old idl */
{
replace_ldbm_config_value(CONFIG_IDL_SWITCH, "new", li);
LDAPDebug(LDAP_DEBUG_ANY,
"Warning: Dbversion %s does not meet nsslapd-idl-switch: \"old\"; "
"nsslapd-idl-switch is updated to \"new\"\n",
ldbmversion, 0, 0);
}
}
else if ((0 == strcmp(ldbmversion, LDBM_VERSION_OLD)) ||
(0 == PL_strcmp(ldbmversion, LDBM_VERSION_61)) ||
(0 == PL_strcmp(ldbmversion, LDBM_VERSION_62)) ||
(0 == strcmp(ldbmversion, LDBM_VERSION_60))) /* db: old */
{
if (idl_get_idl_new()) /* config: new */
{
replace_ldbm_config_value(CONFIG_IDL_SWITCH, "old", li);
LDAPDebug(LDAP_DEBUG_ANY,
"Warning: Dbversion %s does not meet nsslapd-idl-switch: \"new\"; "
"nsslapd-idl-switch is updated to \"old\"\n",
ldbmversion, 0, 0);
}
}
else
{
LDAPDebug(LDAP_DEBUG_ANY,
"Warning: Dbversion %s is not supported\n",
ldbmversion, 0, 0);
rval = 1;
}
/* ldbminfo is a common resource; should clean up when the job is done */
li->li_flags &= ~LI_FORCE_MOD_CONFIG;
return rval;
}
// Verify that nsCRT versions of string comparison routines get the
// same answers as the native non-unicode versions. We only pass in
// iso-latin-1 strings, so the comparison must be valid.
static void Check(const char* s1, const char* s2, PRIntn n)
{
PRIntn clib = PL_strcmp(s1, s2);
PRIntn clib_n = PL_strncmp(s1, s2, n);
PRIntn clib_case = PL_strcasecmp(s1, s2);
PRIntn clib_case_n = PL_strncasecmp(s1, s2, n);
nsAutoString t1,t2;
t1.AssignWithConversion(s1);
t2.AssignWithConversion(s2);
const PRUnichar* us1 = t1.get();
const PRUnichar* us2 = t2.get();
PRIntn u2 = nsCRT::strcmp(us1, us2);
PRIntn u2_n = nsCRT::strncmp(us1, us2, n);
NS_ASSERTION(sign(clib) == sign(u2), "strcmp");
NS_ASSERTION(sign(clib_n) == sign(u2_n), "strncmp");
}
PL_strncasestr(const char *big, const char *little, PRUint32 max)
{
PRUint32 ll;
if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
ll = PL_strlen(little);
if( ll > max ) return (char *)0;
max -= ll;
max++;
for( ; max && *big; big++, max-- )
/* obvious improvement available here */
if( 0 == PL_strncasecmp(big, little, ll) )
return (char *)big;
return (char *)0;
}
PL_strcaserstr(const char *big, const char *little)
{
const char *p;
PRUint32 ll;
if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
ll = PL_strlen(little);
p = &big[ PL_strlen(big) - ll ];
if( p < big ) return (char *)0;
for( ; p >= big; p-- )
/* obvious improvement available here */
if( 0 == PL_strncasecmp(p, little, ll) )
return (char *)p;
return (char *)0;
}
/**
* This method compares the data in one buffer with another
* @update gess 01/04/99
* @param aStr1 is the first buffer to be compared
* @param aStr2 is the 2nd buffer to be compared
* @param aCount is the number of chars to compare
* @param aIgnoreCase tells us whether to use a case-sensitive comparison
* @return -1,0,1 depending on <,==,>
*/
static
#ifdef __SUNPRO_CC
inline
#endif /* __SUNPRO_CC */
PRInt32
Compare1To1(const char* aStr1,const char* aStr2,PRUint32 aCount,bool aIgnoreCase){
PRInt32 result=0;
if(aIgnoreCase)
result=PRInt32(PL_strncasecmp(aStr1, aStr2, aCount));
else
result=nsCharTraits<char>::compare(aStr1,aStr2,aCount);
// alien comparisons may return out-of-bound answers
// instead of the -1, 0, 1 expected by most clients
if ( result < -1 )
result = -1;
else if ( result > 1 )
result = 1;
return result;
}
NS_IMETHODIMP
nsHttpBasicAuth::GenerateCredentials(nsIHttpAuthenticableChannel *authChannel,
const char *challenge,
bool isProxyAuth,
const PRUnichar *domain,
const PRUnichar *user,
const PRUnichar *password,
nsISupports **sessionState,
nsISupports **continuationState,
uint32_t *aFlags,
char **creds)
{
LOG(("nsHttpBasicAuth::GenerateCredentials [challenge=%s]\n", challenge));
NS_ENSURE_ARG_POINTER(creds);
*aFlags = 0;
// we only know how to deal with Basic auth for http.
bool isBasicAuth = !PL_strncasecmp(challenge, "basic", 5);
NS_ENSURE_TRUE(isBasicAuth, NS_ERROR_UNEXPECTED);
// we work with ASCII around here
nsAutoCString userpass;
LossyCopyUTF16toASCII(user, userpass);
userpass.Append(':'); // always send a ':' (see bug 129565)
if (password)
LossyAppendUTF16toASCII(password, userpass);
// plbase64.h provides this worst-case output buffer size calculation.
// use calloc, since PL_Base64Encode does not null terminate.
*creds = (char *) calloc(6 + ((userpass.Length() + 2)/3)*4 + 1, 1);
if (!*creds)
return NS_ERROR_OUT_OF_MEMORY;
memcpy(*creds, "Basic ", 6);
PL_Base64Encode(userpass.get(), userpass.Length(), *creds + 6);
return NS_OK;
}
PRBool nsMsgMdnGenerator::MailAddrMatch(const char *addr1, const char *addr2)
{
// Comparing two email addresses returns true if matched; local/account
// part comparison is case sensitive; domain part comparison is case
// insensitive
DEBUG_MDN("nsMsgMdnGenerator::MailAddrMatch");
PRBool isMatched = PR_TRUE;
const char *atSign1 = nsnull, *atSign2 = nsnull;
const char *lt = nsnull, *local1 = nsnull, *local2 = nsnull;
const char *end1 = nsnull, *end2 = nsnull;
if (!addr1 || !addr2)
return PR_FALSE;
lt = strchr(addr1, '<');
local1 = !lt ? addr1 : lt+1;
lt = strchr(addr2, '<');
local2 = !lt ? addr2 : lt+1;
end1 = strchr(local1, '>');
if (!end1)
end1 = addr1 + strlen(addr1);
end2 = strchr(local2, '>');
if (!end2)
end2 = addr2 + strlen(addr2);
atSign1 = strchr(local1, '@');
atSign2 = strchr(local2, '@');
if (!atSign1 || !atSign2 // ill formed addr spec
|| (atSign1 - local1) != (atSign2 - local2))
isMatched = PR_FALSE;
else if (strncmp(local1, local2, (atSign1-local1))) // case sensitive
// compare for local part
isMatched = PR_FALSE;
else if ((end1 - atSign1) != (end2 - atSign2) ||
PL_strncasecmp(atSign1, atSign2, (end1-atSign1))) // case
// insensitive compare for domain part
isMatched = PR_FALSE;
return isMatched;
}
PL_strncaserstr(const char *big, const char *little, PRUint32 max)
{
const char *p;
PRUint32 ll;
if( ((const char *)0 == big) || ((const char *)0 == little) ) return (char *)0;
if( ((char)0 == *big) || ((char)0 == *little) ) return (char *)0;
ll = PL_strlen(little);
for( p = big; max && *p; p++, max-- )
;
p -= ll;
if( p < big ) return (char *)0;
for( ; p >= big; p-- )
/* obvious improvement available here */
if( 0 == PL_strncasecmp(p, little, ll) )
return (char *)p;
return (char *)0;
}
//
// GenerateCredentials
//
// This routine is responsible for creating the correct authentication
// blob to pass to the server that requested "Negotiate" authentication.
//
NS_IMETHODIMP
nsHttpNegotiateAuth::GenerateCredentials(nsIHttpAuthenticableChannel *authChannel,
const char *challenge,
bool isProxyAuth,
const PRUnichar *domain,
const PRUnichar *username,
const PRUnichar *password,
nsISupports **sessionState,
nsISupports **continuationState,
PRUint32 *flags,
char **creds)
{
// ChallengeReceived must have been called previously.
nsIAuthModule *module = (nsIAuthModule *) *continuationState;
NS_ENSURE_TRUE(module, NS_ERROR_NOT_INITIALIZED);
*flags = USING_INTERNAL_IDENTITY;
LOG(("nsHttpNegotiateAuth::GenerateCredentials() [challenge=%s]\n", challenge));
NS_ASSERTION(creds, "null param");
#ifdef DEBUG
bool isGssapiAuth =
!PL_strncasecmp(challenge, kNegotiate, kNegotiateLen);
NS_ASSERTION(isGssapiAuth, "Unexpected challenge");
#endif
//
// If the "Negotiate:" header had some data associated with it,
// that data should be used as the input to this call. This may
// be a continuation of an earlier call because GSSAPI authentication
// often takes multiple round-trips to complete depending on the
// context flags given. We want to use MUTUAL_AUTHENTICATION which
// generally *does* require multiple round-trips. Don't assume
// auth can be completed in just 1 call.
//
unsigned int len = strlen(challenge);
void *inToken, *outToken;
PRUint32 inTokenLen, outTokenLen;
if (len > kNegotiateLen) {
challenge += kNegotiateLen;
while (*challenge == ' ')
challenge++;
len = strlen(challenge);
// strip off any padding (see bug 230351)
while (challenge[len - 1] == '=')
len--;
inTokenLen = (len * 3)/4;
inToken = malloc(inTokenLen);
if (!inToken)
return (NS_ERROR_OUT_OF_MEMORY);
//
// Decode the response that followed the "Negotiate" token
//
if (PL_Base64Decode(challenge, len, (char *) inToken) == NULL) {
free(inToken);
return(NS_ERROR_UNEXPECTED);
}
}
else {
//
// Initializing, don't use an input token.
//
inToken = nullptr;
inTokenLen = 0;
}
nsresult rv = module->GetNextToken(inToken, inTokenLen, &outToken, &outTokenLen);
free(inToken);
if (NS_FAILED(rv))
return rv;
if (outTokenLen == 0) {
LOG((" No output token to send, exiting"));
return NS_ERROR_FAILURE;
}
//
// base64 encode the output token.
//
char *encoded_token = PL_Base64Encode((char *)outToken, outTokenLen, nullptr);
nsMemory::Free(outToken);
if (!encoded_token)
return NS_ERROR_OUT_OF_MEMORY;
LOG((" Sending a token of length %d\n", outTokenLen));
// allocate a buffer sizeof("Negotiate" + " " + b64output_token + "\0")
*creds = (char *) nsMemory::Alloc(kNegotiateLen + 1 + strlen(encoded_token) + 1);
if (NS_UNLIKELY(!*creds))
rv = NS_ERROR_OUT_OF_MEMORY;
else
sprintf(*creds, "%s %s", kNegotiate, encoded_token);
PR_Free(encoded_token);
return rv;
}
// this is used to convert non Unicode data and then populate comp fields
nsresult nsMapiHook::PopulateCompFieldsWithConversion(lpnsMapiMessage aMessage,
nsIMsgCompFields * aCompFields)
{
nsresult rv = NS_OK;
if (aMessage->lpOriginator)
{
nsAutoString From;
From.Append(NS_ConvertASCIItoUTF16((char *) aMessage->lpOriginator->lpszAddress));
aCompFields->SetFrom (From);
}
nsAutoString To;
nsAutoString Cc;
nsAutoString Bcc;
NS_NAMED_LITERAL_STRING(Comma, ",");
if (aMessage->lpRecips)
{
for (int i=0 ; i < (int) aMessage->nRecipCount ; i++)
{
if (aMessage->lpRecips[i].lpszAddress || aMessage->lpRecips[i].lpszName)
{
const char *addressWithoutType = (aMessage->lpRecips[i].lpszAddress)
? aMessage->lpRecips[i].lpszAddress : aMessage->lpRecips[i].lpszName;
if (!PL_strncasecmp(addressWithoutType, "SMTP:", 5))
addressWithoutType += 5;
switch (aMessage->lpRecips[i].ulRecipClass)
{
case MAPI_TO :
if (!To.IsEmpty())
To += Comma ;
To.Append(NS_ConvertASCIItoUTF16(addressWithoutType));
break ;
case MAPI_CC :
if (!Cc.IsEmpty())
Cc += Comma ;
Cc.Append(NS_ConvertASCIItoUTF16(addressWithoutType));
break ;
case MAPI_BCC :
if (!Bcc.IsEmpty())
Bcc += Comma ;
Bcc.Append(NS_ConvertASCIItoUTF16(addressWithoutType));
break ;
}
}
}
}
// set To, Cc, Bcc
aCompFields->SetTo (To) ;
aCompFields->SetCc (Cc) ;
aCompFields->SetBcc (Bcc) ;
PR_LOG(MAPI, PR_LOG_DEBUG, ("to: %s cc: %s bcc: %s \n", NS_ConvertUTF16toUTF8(To).get(), NS_ConvertUTF16toUTF8(Cc).get(), NS_ConvertUTF16toUTF8(Bcc).get()));
nsCAutoString platformCharSet;
// set subject
if (aMessage->lpszSubject)
{
nsAutoString Subject ;
if (platformCharSet.IsEmpty())
platformCharSet.Assign(nsMsgI18NFileSystemCharset());
rv = ConvertToUnicode(platformCharSet.get(), (char *) aMessage->lpszSubject, Subject);
if (NS_FAILED(rv)) return rv;
aCompFields->SetSubject(Subject);
}
// handle attachments as File URL
rv = HandleAttachments (aCompFields, aMessage->nFileCount, aMessage->lpFiles, PR_FALSE) ;
if (NS_FAILED(rv)) return rv ;
// set body
if (aMessage->lpszNoteText)
{
nsAutoString Body ;
if (platformCharSet.IsEmpty())
platformCharSet.Assign(nsMsgI18NFileSystemCharset());
rv = ConvertToUnicode(platformCharSet.get(), (char *) aMessage->lpszNoteText, Body);
if (NS_FAILED(rv)) return rv ;
if (Body.Last() != '\n')
Body.AppendLiteral(CRLF);
if (Body.Find("<html>") == kNotFound)
aCompFields->SetForcePlainText(PR_TRUE);
rv = aCompFields->SetBody(Body) ;
}
#ifdef RAJIV_DEBUG
// testing what all was set in CompFields
printf ("To : %S \n", To.get()) ;
printf ("CC : %S \n", Cc.get() ) ;
printf ("BCC : %S \n", Bcc.get() ) ;
#endif
return rv ;
}
