/**
* Given two strings, compute a score representing whether the internal
* boundary falls on logical boundaries.
* Scores range from 5 (best) to 0 (worst).
* @param one First CFStringRef.
* @param two Second CFStringRef.
* @return The score.
*/
CFIndex diff_cleanupSemanticScore(CFStringRef one, CFStringRef two) {
static Boolean firstRun = true;
static CFCharacterSetRef alphaNumericSet = NULL;
static CFCharacterSetRef whiteSpaceSet = NULL;
static CFCharacterSetRef controlSet = NULL;
static regex_t blankLineEndRegEx;
static regex_t blankLineStartRegEx;
if (firstRun) {
alphaNumericSet = CFCharacterSetGetPredefined(kCFCharacterSetAlphaNumeric);
whiteSpaceSet = CFCharacterSetGetPredefined(kCFCharacterSetWhitespaceAndNewline);
controlSet = CFCharacterSetGetPredefined(kCFCharacterSetControl);
int status;
status = regcomp(&blankLineEndRegEx, "\n\r?\n$", REG_EXTENDED | REG_NOSUB);
check(status == 0);
status = regcomp(&blankLineStartRegEx, "^\r?\n\r?\n", REG_EXTENDED | REG_NOSUB);
check(status == 0);
firstRun = false;
}
if (CFStringGetLength(one) == 0 || CFStringGetLength(two) == 0) {
// Edges are the best.
return 5;
}
// Each port of this function behaves slightly differently due to
// subtle differences in each language's definition of things like
// 'whitespace'. Since this function's purpose is largely cosmetic,
// the choice has been made to use each language's native features
// rather than force total conformity.
CFIndex score = 0;
UniChar lastCharOfStringOne = CFStringGetCharacterAtIndex(one, (CFStringGetLength(one) - 1));
UniChar firstCharOfStringTwo = CFStringGetCharacterAtIndex(two, 0);
// One point for non-alphanumeric.
if (!CFCharacterSetIsCharacterMember(alphaNumericSet, lastCharOfStringOne)
|| !CFCharacterSetIsCharacterMember(alphaNumericSet, firstCharOfStringTwo)) {
score++;
// Two points for whitespace.
if (CFCharacterSetIsCharacterMember(whiteSpaceSet, lastCharOfStringOne)
|| CFCharacterSetIsCharacterMember(whiteSpaceSet, firstCharOfStringTwo)) {
score++;
// Three points for line breaks.
if (CFCharacterSetIsCharacterMember(controlSet, lastCharOfStringOne)
|| CFCharacterSetIsCharacterMember(controlSet, firstCharOfStringTwo)) {
score++;
// Four points for blank lines.
if (diff_regExMatch(one, &blankLineEndRegEx)
|| diff_regExMatch(two, &blankLineStartRegEx)) {
score++;
}
}
}
}
return score;
}
void SendString(CFStringRef str, unsigned delayMS)
{
//virtual keycodes copied from 10.6 SDK. Could not find them in 10.4 SDK
enum { VK_RETURN = 0x24 /*KVK_Return*/, VK_TAB = 0x30 /*kVK_Tab*/, VK_SPACE = 0x31/*kVK_Space*/};
//A list of chars for which we must specify the virtual keycode
static const CFStringRef specialChars = CFSTR("\n\t ");
static const UniChar verticalTab = CFStringGetCharacterAtIndex(CFSTR("\v"), 0);
//each keycode must correspond to the correct char in 'specialChars'
CGKeyCode specialKeyCodes[] = {VK_RETURN, VK_TAB, VK_SPACE };
assert(CFStringGetLength(specialChars) == NumberOf(specialKeyCodes));
for (unsigned i = 0, len = CFStringGetLength(str); i < len; ++i) {
//The next char to send
UniChar c = CFStringGetCharacterAtIndex(str, i);
//throw away 'vertical tab' chars which are only used on Windows to send a shift+tab
//as a workaround for some issues with IE
if (verticalTab == c)
continue;
//see if we need to specify the virtual keycode for this char
CGKeyCode vKey = 0; //0 = kVK_ANSI_A, but I don't know of a more appropriate default value
for (size_t j = 0; j < NumberOf(specialKeyCodes); ++j) {
if ( CFStringGetCharacterAtIndex(specialChars, j) == c) {
vKey = specialKeyCodes[j];
break;
}
}
CGEventRef keyDown = CGEventCreateKeyboardEvent(NULL, vKey, true);
CGEventRef keyUp = CGEventCreateKeyboardEvent(NULL, vKey, false);
if (keyDown && keyUp) {
//may be we should not do this if we found the virtual keycode?
CGEventKeyboardSetUnicodeString(keyDown, 1, &c);
CGEventKeyboardSetUnicodeString(keyUp, 1, &c);
CGEventPost(kCGSessionEventTap, keyDown);
CGEventPost(kCGSessionEventTap, keyUp);
pws_os::sleep_ms(delayMS);
CFRelease(keyDown);
CFRelease(keyUp);
}
else {
if (keyDown) CFRelease(keyDown);
if (keyUp) CFRelease(keyUp);
pws_os::IssueError(_T("Out of memory trying to allocate CGEventRef"));
return;
}
}
}
static Boolean _hasNet(CFStringRef path) {
if (CFStringGetLength(path) >= 2) {
UniChar firstCharacters[2];
firstCharacters[0] = CFStringGetCharacterAtIndex(path, 0);
firstCharacters[1] = CFStringGetCharacterAtIndex(path, 1);
if (firstCharacters[0] == '\\' && firstCharacters[1] == '\\') return true;
}
return false;
}
static int16_t handleEventCocoa(NPP instance, PluginObject* obj, NPCocoaEvent* event)
{
switch (event->type) {
case NPCocoaEventWindowFocusChanged:
case NPCocoaEventFocusChanged:
if (event->data.focus.hasFocus)
pluginLog(instance, "getFocusEvent");
else
pluginLog(instance, "loseFocusEvent");
return 1;
case NPCocoaEventDrawRect:
return 1;
case NPCocoaEventKeyDown:
if (event->data.key.characters)
pluginLog(instance, "keyDown '%c'", CFStringGetCharacterAtIndex(reinterpret_cast<CFStringRef>(event->data.key.characters), 0));
return 1;
case NPCocoaEventKeyUp:
if (event->data.key.characters) {
pluginLog(instance, "keyUp '%c'", CFStringGetCharacterAtIndex(reinterpret_cast<CFStringRef>(event->data.key.characters), 0));
if (obj->testKeyboardFocusForPlugins) {
obj->eventLogging = false;
obj->testKeyboardFocusForPlugins = FALSE;
executeScript(obj, "layoutTestController.notifyDone();");
}
}
return 1;
case NPCocoaEventFlagsChanged:
return 1;
case NPCocoaEventMouseDown:
pluginLog(instance, "mouseDown at (%d, %d)",
(int)event->data.mouse.pluginX,
(int)event->data.mouse.pluginY);
return 1;
case NPCocoaEventMouseUp:
pluginLog(instance, "mouseUp at (%d, %d)",
(int)event->data.mouse.pluginX,
(int)event->data.mouse.pluginY);
return 1;
case NPCocoaEventMouseMoved:
case NPCocoaEventMouseEntered:
case NPCocoaEventMouseExited:
case NPCocoaEventMouseDragged:
case NPCocoaEventScrollWheel:
case NPCocoaEventTextInput:
return 1;
}
return 0;
}
static UChar32 _CFStringTransformChar32At(const UReplaceable *rep, int32_t offset) {
CFMutableStringRef string = (CFMutableStringRef)rep;
UniChar ch = CFStringGetCharacterAtIndex(string, offset);
if (CFStringIsSurrogateHighCharacter(ch)) {
UniChar low = CFStringGetCharacterAtIndex(string, offset + 1);
return CFStringGetLongCharacterForSurrogatePair(ch, low);
} else {
return (UChar32)ch;
}
}
CF_PRIVATE Boolean _CFAppendPathExtension2(CFMutableStringRef path, CFStringRef extension) {
if (!path) {
return false;
}
if (0 < CFStringGetLength(extension) && IS_SLASH(CFStringGetCharacterAtIndex(extension, 0))) {
return false;
}
if (1 < CFStringGetLength(extension)) {
if (_hasDrive(extension)) return false;
}
Boolean destHasDrive = (1 < CFStringGetLength(path)) && _hasDrive(path);
while (((destHasDrive && 3 < CFStringGetLength(path)) || (!destHasDrive && 1 < CFStringGetLength(path))) && IS_SLASH(CFStringGetCharacterAtIndex(path, CFStringGetLength(path) - 1))) {
CFStringDelete(path, CFRangeMake(CFStringGetLength(path) - 1, 1));
}
if (CFStringGetLength(path) == 0) {
return false;
}
UniChar firstChar = CFStringGetCharacterAtIndex(path, 0);
CFIndex newLength = CFStringGetLength(path);
switch (newLength) {
case 0:
return false;
case 1:
if (IS_SLASH(firstChar) || firstChar == '~') {
return false;
}
break;
case 2:
if (_hasDrive(path) || _hasNet(path)) {
return false;
}
break;
case 3:
if (IS_SLASH(CFStringGetCharacterAtIndex(path, 2)) && _hasDrive(path)) {
return false;
}
break;
}
if (0 < newLength && firstChar == '~') {
// Make sure we have a slash in the string
if (!CFStringFindWithOptions(path, CFPreferredSlashStr, CFRangeMake(1, newLength - 1), 0, NULL)) {
return false;
}
}
static const UniChar dotChar = '.';
CFStringAppendCharacters(path, &dotChar, 1);
CFStringAppend(path, extension);
return true;
}
static Boolean _hasDrive(CFStringRef path) {
if (CFStringGetLength(path) >= 2) {
UniChar firstCharacters[2];
firstCharacters[0] = CFStringGetCharacterAtIndex(path, 0);
firstCharacters[1] = CFStringGetCharacterAtIndex(path, 1);
if (firstCharacters[1] == ':' &&
(('A' <= (firstCharacters)[0] && (firstCharacters)[0] <= 'Z') ||
('a' <= (firstCharacters)[0] && (firstCharacters)[0] <= 'z'))
) {
return true;
}
}
return false;
}
CString TextCodecMac::encode(const UChar* characters, size_t length, UnencodableHandling handling)
{
// FIXME: We should really use TEC here instead of CFString for consistency with the other direction.
// FIXME: Since there's no "force ASCII range" mode in CFString, we change the backslash into a yen sign.
// Encoding will change the yen sign back into a backslash.
String copy(characters, length);
copy.replace('\\', m_backslashAsCurrencySymbol);
CFStringRef cfs = copy.createCFString();
CFIndex startPos = 0;
CFIndex charactersLeft = CFStringGetLength(cfs);
Vector<char> result;
size_t size = 0;
UInt8 lossByte = handling == QuestionMarksForUnencodables ? '?' : 0;
while (charactersLeft > 0) {
CFRange range = CFRangeMake(startPos, charactersLeft);
CFIndex bufferLength;
CFStringGetBytes(cfs, range, m_encoding, lossByte, false, NULL, 0x7FFFFFFF, &bufferLength);
result.grow(size + bufferLength);
unsigned char* buffer = reinterpret_cast<unsigned char*>(result.data() + size);
CFIndex charactersConverted = CFStringGetBytes(cfs, range, m_encoding, lossByte, false, buffer, bufferLength, &bufferLength);
size += bufferLength;
if (charactersConverted != charactersLeft) {
unsigned badChar = CFStringGetCharacterAtIndex(cfs, startPos + charactersConverted);
++charactersConverted;
if ((badChar & 0xFC00) == 0xD800 && charactersConverted != charactersLeft) { // is high surrogate
UniChar low = CFStringGetCharacterAtIndex(cfs, startPos + charactersConverted);
if ((low & 0xFC00) == 0xDC00) { // is low surrogate
badChar <<= 10;
badChar += low;
badChar += 0x10000 - (0xD800 << 10) - 0xDC00;
++charactersConverted;
}
}
UnencodableReplacementArray entity;
int entityLength = getUnencodableReplacement(badChar, handling, entity);
result.grow(size + entityLength);
memcpy(result.data() + size, entity, entityLength);
size += entityLength;
}
startPos += charactersConverted;
charactersLeft -= charactersConverted;
}
CFRelease(cfs);
return CString(result.data(), size);
}
UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
{
if (!srcString.IsEmpty())
{
UString resultString;
const char * path = &srcString[0];
CFStringRef cfpath = CFStringCreateWithCString(NULL,path,kCFStringEncodingUTF8);
if (cfpath)
{
CFMutableStringRef cfpath2 = CFStringCreateMutableCopy(NULL,0,cfpath);
CFRelease(cfpath);
CFStringNormalize(cfpath2,kCFStringNormalizationFormC);
size_t n = CFStringGetLength(cfpath2);
for(size_t i = 0 ; i< n ;i++) {
UniChar uc = CFStringGetCharacterAtIndex(cfpath2,i);
resultString += (wchar_t)uc; // FIXME
}
CFRelease(cfpath2);
return resultString;
}
}
UString resultString;
for (int i = 0; i < srcString.Len(); i++)
resultString += wchar_t(srcString[i] & 255);
return resultString;
}
CF_PRIVATE CFStringRef _CFCreateLastPathComponent(CFAllocatorRef alloc, CFStringRef path, CFIndex *slashIndex) {
CFIndex len = CFStringGetLength(path);
if (len < 2) {
// Can't be any path components in a string this short
if (slashIndex) *slashIndex = -1;
return (CFStringRef)CFRetain(path);
}
// Find the last slash
for (CFIndex i = len - 1; i >= 0; i--) {
if (IS_SLASH(CFStringGetCharacterAtIndex(path, i))) {
if (slashIndex) *slashIndex = i;
return CFStringCreateWithSubstring(alloc, path, CFRangeMake(i + 1, len - i - 1));
}
}
// Strip any drive if we have one
if (len > 2 && _hasDrive(path)) {
if (slashIndex) *slashIndex = -1;
return CFStringCreateWithSubstring(alloc, path, CFRangeMake(2, len - 2));
}
// No slash, so just return the same string
if (slashIndex) *slashIndex = -1;
return (CFStringRef)CFRetain(path);
}
CFStringRef find_path(CFStringRef rootPath, CFStringRef namePattern, CFStringRef expression) {
FILE *fpipe = NULL;
CFStringRef quotedRootPath = rootPath;
if (CFStringGetCharacterAtIndex(rootPath, 0) != '`') {
quotedRootPath = CFStringCreateWithFormat(NULL, NULL, CFSTR("'%@'"), rootPath);
}
CFStringRef cf_command = CFStringCreateWithFormat(NULL, NULL, CFSTR("find %@ -name '%@' %@ 2>/dev/null | sort | tail -n 1"), quotedRootPath, namePattern, expression);
if (quotedRootPath != rootPath) {
CFRelease(quotedRootPath);
}
char command[1024] = { '\0' };
CFStringGetCString(cf_command, command, sizeof(command), kCFStringEncodingUTF8);
CFRelease(cf_command);
if (!(fpipe = (FILE *)popen(command, "r")))
{
perror("Error encountered while opening pipe");
exit(EXIT_FAILURE);
}
char buffer[256] = { '\0' };
fgets(buffer, sizeof(buffer), fpipe);
pclose(fpipe);
strtok(buffer, "\n");
return CFStringCreateWithCString(NULL, buffer, kCFStringEncodingUTF8);
}
CF_PRIVATE void _CFAppendConditionalTrailingPathSlash2(CFMutableStringRef path) {
static const UniChar slash[1] = { CFPreferredSlash };
UniChar character = CFStringGetCharacterAtIndex((CFStringRef)path, CFStringGetLength(path) - 1);
if (!IS_SLASH(character)) {
CFStringAppendCharacters(path, slash, 1);
}
}
/* There seems to be a bug with MacFUSE such that the CFString that
* it returns for kFUSEMountPath in the dictionary accompanying the
* com.google.filesystems.fusefs.unotifications.mounted notification
* is represented as UTF-8 within the internal representation.
* Probably UTF-8 encoded text represented as UTF-16 values. This
* function transforms it to a true null terminated UTF-8 string.
* This function assumes that the target buffer out is at least
* CFStringGetLength(in) bytes long. */
static void GetCorruptedMacFUSEStringAsUTF8(CFStringRef in, char* out, int outsize) {
int inLength = CFStringGetLength(in);
int bytesToWrite = MIN(inLength, outsize-1);
int i;
for(i = 0; i < bytesToWrite; ++i)
out[i] = (char)CFStringGetCharacterAtIndex(in, i);
out[i] = '\0';
}
JNIEXPORT jchar JNICALL WebKit_win32_NATIVE(CFStringGetCharacterAtIndex)
(JNIEnv *env, jclass that, jintLong arg0, jint arg1)
{
jchar rc = 0;
WebKit_win32_NATIVE_ENTER(env, that, CFStringGetCharacterAtIndex_FUNC);
rc = (jchar)CFStringGetCharacterAtIndex((CFStringRef)arg0, (CFIndex)arg1);
WebKit_win32_NATIVE_EXIT(env, that, CFStringGetCharacterAtIndex_FUNC);
return rc;
}
static void
CFStringTruncateToUTF8Length(CFMutableStringRef str, ssize_t utf8LengthLimit)
// Truncates a CFString such that it's UTF-8 representation will have
// utf8LengthLimit or less characters (not including the terminating
// null character). Handles UTF-16 surrogates and trims whitespace
// from the end of the resulting string.
{
CFIndex shortLen;
CFIndex convertedLen;
CFIndex originalLen;
CFIndex utf8Length;
CFCharacterSetRef whiteCharSet;
UniChar thisChar;
CFIndex trailingCharsToDelete;
// Keep converting successively smaller strings until the UTF-8 string is suitably
// short. Note that utf8LengthLimit must be non-negative, so this loop will
// always terminate before we run off the front of the string.
originalLen = CFStringGetLength(str);
shortLen = originalLen;
do {
// Because the buffer parameter is NULL, CFStringGetBytes returns the size of
// buffer required for the range of characters. This doesn't include the
// trailing null byte traditionally associated with UTF-8 C strings, which
// is cool because that's what our caller is expecting.
convertedLen = CFStringGetBytes(str, CFRangeMake(0, shortLen), kCFStringEncodingUTF8, 0, false, NULL, 0, &utf8Length);
assert( (convertedLen == shortLen) || (convertedLen == (shortLen - 1)) );
shortLen = convertedLen;
if (utf8Length <= utf8LengthLimit) {
break;
}
shortLen -= 1;
} while (true);
whiteCharSet = CFCharacterSetGetPredefined(kCFCharacterSetWhitespaceAndNewline);
assert(whiteCharSet != NULL);
do {
if ( shortLen == 0 ) {
break;
}
thisChar = CFStringGetCharacterAtIndex(str, shortLen - 1);
if ( ! CFCharacterSetIsCharacterMember(whiteCharSet, thisChar) ) {
break;
}
shortLen -= 1;
} while (true);
trailingCharsToDelete = originalLen - shortLen;
CFStringDelete(str, CFRangeMake(originalLen - trailingCharsToDelete, trailingCharsToDelete));
}
Tcl_UniChar Tcl_UniCharToTitle(Tcl_UniChar c)
{
if (c < 0x7f)
return toupper(c);
CFMutableStringRef str = CFStringCreateMutableWithExternalCharactersNoCopy(kCFAllocatorDefault,&c, 1,0, kCFAllocatorNull);
CFStringCapitalize(str,NULL);
Tcl_UniChar retval = c;
if (CFStringGetLength(str)) { // make sure one exists
retval = CFStringGetCharacterAtIndex(str, 0);
}
CFRelease(str);
return retval;
}
/*++
Function:
PAL_towupper
See MSDN
--*/
wchar_16
__cdecl
PAL_towupper( wchar_16 c )
{
#if HAVE_COREFOUNDATION
PERF_ENTRY(towupper);
ENTRY("towupper (c=%d)\n", c);
if (!PAL_iswupper(c))
{
CFMutableStringRef cfString = CFStringCreateMutable(
kCFAllocatorDefault, 1);
if (cfString != NULL)
{
CFStringAppendCharacters(cfString, (const UniChar*)&c, 1);
CFStringUppercase(cfString, NULL);
c = CFStringGetCharacterAtIndex(cfString, 0);
CFRelease(cfString);
}
}
LOGEXIT("towupper returns int %d\n", c );
PERF_EXIT(towupper);
return c;
#else /* HAVE_COREFOUNDATION */
UnicodeDataRec dataRec;
PERF_ENTRY(towupper);
ENTRY("towupper (c=%d)\n", c);
if (!GetUnicodeData(c, &dataRec))
{
TRACE( "Unable to retrieve unicode data for the character %c.\n", c );
LOGEXIT("towupper returns int %d\n", c );
PERF_EXIT(towupper);
return c;
}
if ( (dataRec.C1_TYPE_FLAGS & C1_UPPER) || (dataRec.nOpposingCase == 0 ))
{
LOGEXIT("towupper returns int %d\n", c );
PERF_EXIT(towupper);
return c;
}
else
{
LOGEXIT("towupper returns int %d\n", dataRec.nOpposingCase );
PERF_EXIT(towupper);
return dataRec.nOpposingCase;
}
#endif /* HAVE_COREFOUNDATION */
}
/* HasDirectoryPath returns true if pathString ends with a '/' character */
static Boolean HasDirectoryPath(
CFStringRef pathString, // input: the path string
CFURLPathStyle pathStyle) // input: the path style
{
Boolean result;
switch ( pathStyle )
{
case kCFURLPOSIXPathStyle:
result = CFStringGetCharacterAtIndex(pathString, CFStringGetLength(pathString)) == (UniChar)'/';
break;
case kCFURLHFSPathStyle:
result = CFStringGetCharacterAtIndex(pathString, CFStringGetLength(pathString)) == (UniChar)':';
break;
case kCFURLWindowsPathStyle:
result = CFStringGetCharacterAtIndex(pathString, CFStringGetLength(pathString)) == (UniChar)'\\';
break;
default:
result = FALSE;
break;
}
return ( result );
}
wchar_t* convert_CFString_to_wchar(const CFStringRef str)
{
wchar_t *prov = malloc(sizeof(wchar_t) * (CFStringGetLength(str)+1));
CFIndex i;
if(prov)
{
for(i = 0 ; i<CFStringGetLength(str) ; i++)
prov[i] = CFStringGetCharacterAtIndex(str, i);
prov[i] = L'\0';
}
return prov;
}
wchar_t
towlower (wchar_t wc)
{
CFMutableStringRef strRef = CFStringCreateMutable (NULL, 0);
UniChar c = (UniChar) wc;
wchar_t wcs;
CFStringAppendCharacters (strRef, &c, 1);
CFStringLowercase (strRef, NULL);
wcs = CFStringGetCharacterAtIndex (strRef, 0);
CFRelease (strRef);
return wcs;
}
CF_PRIVATE CFIndex _CFStartOfLastPathComponent2(CFStringRef path) {
CFIndex length = CFStringGetLength(path);
if (length < 2) {
return 0;
}
for (CFIndex idx = length - 1; idx; idx--) {
if (IS_SLASH(CFStringGetCharacterAtIndex(path, idx - 1))) {
return idx;
}
}
if ((2 < length && _hasDrive(path))) {
return 2;
}
return 0;
}
CF_PRIVATE void _CFAppendTrailingPathSlash2(CFMutableStringRef path) {
static const UniChar slash[1] = { CFPreferredSlash };
CFIndex len = CFStringGetLength(path);
if (len == 0) {
// Do nothing for this case
} else if (len == 1) {
UniChar character = CFStringGetCharacterAtIndex((CFStringRef)path, 0);
if (!IS_SLASH(character)) {
CFStringAppendCharacters(path, slash, 1);
}
} else if (len == 2) {
if (!_hasDrive(path) && !_hasNet(path)) {
CFStringAppendCharacters(path, slash, 1);
}
} else {
CFStringAppendCharacters(path, slash, 1);
}
}
/*
* Convert CFString to little-endian unicode.
*/
void ntlmStringToLE(
CFStringRef pwd,
unsigned char **ucode, // mallocd and RETURNED
unsigned *ucodeLen) // RETURNED
{
CFIndex len = CFStringGetLength(pwd);
unsigned char *data = (unsigned char *)malloc(len * 2);
unsigned char *cp = data;
CFIndex dex;
for(dex=0; dex<len; dex++) {
UniChar uc = CFStringGetCharacterAtIndex(pwd, dex);
*cp++ = uc & 0xff;
*cp++ = uc >> 8;
}
*ucode = data;
*ucodeLen = (unsigned)(len * 2);
}
/*++
Function:
PAL_towlower
See MSDN
--*/
wchar_16
__cdecl
PAL_towlower( wchar_16 c )
{
#if HAVE_CFSTRING
ENTRY("towlower (c=%d)\n", c);
if (!PAL_iswlower(c))
{
CFMutableStringRef cfString = CFStringCreateMutable(
kCFAllocatorDefault, 1);
if (cfString != NULL)
{
CFStringAppendCharacters(cfString, &c, 1);
CFStringLowercase(cfString, NULL);
c = CFStringGetCharacterAtIndex(cfString, 0);
CFRelease(cfString);
}
}
ENTRY("towlower returns int %d\n", c );
return c;
#else /* HAVE_CFSTRING */
UnicodeDataRec dataRec;
ENTRY("towlower (c=%d)\n", c);
if (!GetUnicodeData(c, &dataRec))
{
TRACE( "Unable to retrive unicode data for the character %c.\n", c );
LOGEXIT("towlower returns int %d\n", c );
return c;
}
if ( (dataRec.C1_TYPE_FLAGS & C1_LOWER) || (dataRec.nOpposingCase == 0 ))
{
LOGEXIT("towlower returns int %d\n", c );
return c;
}
else
{
LOGEXIT("towlower returns int %d\n", dataRec.nOpposingCase );
return dataRec.nOpposingCase;
}
#endif /* HAVE_CFSTRING */
}
void P12ParseInfo::pwdToUcode(
CFStringRef str,
CSSM_DATA &pwd)
{
if(str == NULL) {
pwd.Data = NULL;
pwd.Length = 0;
return;
}
CFIndex len = CFStringGetLength(str);
mCoder.allocItem(pwd, (len * sizeof(UniChar)) + 2);
uint8 *cp = pwd.Data;
for(CFIndex dex=0; dex<len; dex++) {
UniChar uc = CFStringGetCharacterAtIndex(str, dex);
*cp++ = uc >> 8;
*cp++ = uc & 0xff;
}
*cp++ = 0;
*cp++ = 0;
}
CF_PRIVATE CFIndex _CFStartOfPathExtension2(CFStringRef path) {
if (CFStringGetLength(path) < 2) {
return 0;
}
Boolean hasDrive = _hasDrive(path);
for (CFIndex idx = CFStringGetLength(path) - 1; idx; idx--) {
UniChar thisCharacter = CFStringGetCharacterAtIndex(path, idx);
if (IS_SLASH(thisCharacter)) {
return 0;
}
if (thisCharacter != '.') {
continue;
}
if (idx == 2 && hasDrive) {
return 0;
}
return idx;
}
return 0;
}
void HP_IOCycleTelemetry::Initialize(CFStringRef /*inName*/)
{
// get the device's UID
CACFString theUID(mDevice->CopyDeviceUID());
// get the CFHash of the UID
UInt32 theHashCode = ToUInt32(CFHash(theUID.GetCFString()));
// sum all the characters in the UID
UInt64 theSum = 0;
UInt32 theNumberCharacters = ToUInt32(CFStringGetLength(theUID.GetCFString()));
for(UInt32 theCharacterIndex = 0; theCharacterIndex < theNumberCharacters; ++theCharacterIndex)
{
UniChar theCharacter = CFStringGetCharacterAtIndex(theUID.GetCFString(), theCharacterIndex);
theSum += theCharacter;
}
// build a string out of the hash code and character sum
CFStringRef thePortName = CFStringCreateWithFormat(NULL, NULL, CFSTR(kHALIOCycleTelemetryServerPortNameFormat), CAProcess::GetPID(), theHashCode, theSum);
// initialize the super class (who releases the port name too)
HP_TelemetryServer::Initialize(thePortName);
}
/* There has got to be an easier way to do this. For now we based this code
on CFNetwork/Connection/URLResponse.cpp. */
static CFStringRef copyParseMaxAge(CFStringRef cacheControlHeader) {
/* The format of the cache control header is a comma-separated list, but
each list element could be a key-value pair, with the value quoted and
possibly containing a comma. */
CFStringInlineBuffer inlineBuf;
CFRange componentRange;
CFIndex length = CFStringGetLength(cacheControlHeader);
bool done = false;
CFCharacterSetRef whitespaceSet = CFCharacterSetGetPredefined(kCFCharacterSetWhitespace);
CFStringRef maxAgeValue = NULL;
CFStringInitInlineBuffer(cacheControlHeader, &inlineBuf, CFRangeMake(0, length));
componentRange.location = 0;
while (!done) {
bool inQuotes = false;
bool foundComponentStart = false;
CFIndex charIndex = componentRange.location;
CFIndex componentEnd = -1;
CFRange maxAgeRg;
componentRange.length = 0;
while (charIndex < length) {
UniChar ch = CFStringGetCharacterFromInlineBuffer(&inlineBuf, charIndex);
if (!inQuotes && ch == ',') {
componentRange.length = charIndex - componentRange.location;
break;
}
if (!CFCharacterSetIsCharacterMember(whitespaceSet, ch)) {
if (!foundComponentStart) {
foundComponentStart = true;
componentRange.location = charIndex;
} else {
componentEnd = charIndex;
}
if (ch == '\"') {
inQuotes = (inQuotes == false);
}
}
charIndex ++;
}
if (componentEnd == -1) {
componentRange.length = charIndex - componentRange.location;
} else {
componentRange.length = componentEnd - componentRange.location + 1;
}
if (charIndex == length) {
/* Fell off the end; this is the last component. */
done = true;
}
/* componentRange should now contain the range of the current
component; trimmed of any whitespace. */
/* We want to look for a max-age value. */
if (!maxAgeValue && CFStringFindWithOptions(cacheControlHeader, CFSTR("max-age"), componentRange, kCFCompareCaseInsensitive | kCFCompareAnchored, &maxAgeRg)) {
CFIndex equalIdx;
CFIndex maxCompRg = componentRange.location + componentRange.length;
for (equalIdx = maxAgeRg.location + maxAgeRg.length; equalIdx < maxCompRg; equalIdx ++) {
UniChar equalCh = CFStringGetCharacterFromInlineBuffer(&inlineBuf, equalIdx);
if (equalCh == '=') {
// Parse out max-age value
equalIdx ++;
while (equalIdx < maxCompRg && CFCharacterSetIsCharacterMember(whitespaceSet, CFStringGetCharacterAtIndex(cacheControlHeader, equalIdx))) {
equalIdx ++;
}
if (equalIdx < maxCompRg) {
maxAgeValue = CFStringCreateWithSubstring(kCFAllocatorDefault, cacheControlHeader, CFRangeMake(equalIdx, maxCompRg-equalIdx));
}
} else if (!CFCharacterSetIsCharacterMember(whitespaceSet, equalCh)) {
// Not a valid max-age header; break out doing nothing
break;
}
}
}
if (!done && maxAgeValue) {
done = true;
}
if (!done) {
/* Advance to the next component; + 1 to get past the comma. */
componentRange.location = charIndex + 1;
}
}
return maxAgeValue;
}
static void cb(am_device_notification_callback_info * info, void *foo)
{
struct am_device *dev;
if (info->msg == ADNCI_MSG_CONNECTED) {
dev = info->dev;
AMDeviceConnect(dev);
assert(AMDeviceIsPaired(dev));
assert(!AMDeviceValidatePairing(dev));
assert(!AMDeviceStartSession(dev));
CFStringRef product =
AMDeviceCopyValue(dev, 0, CFSTR("ProductVersion"));
assert(product);
UniChar first = CFStringGetCharacterAtIndex(product, 0);
int epoch = first - '0';
Retry: {}
printf("Attempting to mount image...\n");
service_conn_t afc_socket = 0;
struct afc_connection *afc = NULL;
assert(!AMDeviceStartService(dev, CFSTR("com.apple.afc"), &afc_socket, NULL));
assert(!AFCConnectionOpen(afc_socket, 0, &afc));
assert(!AFCDirectoryCreate(afc, "PublicStaging"));
AFCRemovePath(afc, "PublicStaging/staging.dimage");
qwrite(afc, real_dmg, "PublicStaging/staging.dimage");
qwrite(afc, ddi_dmg, "PublicStaging/ddi.dimage");
service_conn_t mim_socket1 = 0;
service_conn_t mim_socket2 = 0;
assert(!AMDeviceStartService(dev, CFSTR("com.apple.mobile.mobile_image_mounter"), &mim_socket1, NULL));
assert(mim_socket1);
CFPropertyListRef result = NULL;
CFMutableDictionaryRef dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(dict, CFSTR("Command"), CFSTR("MountImage"));
CFDictionarySetValue(dict, CFSTR("ImageType"), CFSTR("Developer"));
CFDictionarySetValue(dict, CFSTR("ImagePath"), CFSTR("/var/mobile/Media/PublicStaging/staging.dimage"));
int fd = open(real_dmg_signature, O_RDONLY);
assert(fd != -1);
uint8_t sig[128];
assert(read(fd, sig, sizeof(sig)) == sizeof(sig));
close(fd);
CFDictionarySetValue(dict, CFSTR("ImageSignature"), CFDataCreateWithBytesNoCopy(NULL, sig, sizeof(sig), kCFAllocatorNull));
send_message(mim_socket1, dict);
usleep(timesl);
assert(!AFCRenamePath(afc, "PublicStaging/ddi.dimage", "PublicStaging/staging.dimage"));
result = receive_message(mim_socket1);
int len = CFDataGetLength(CFPropertyListCreateXMLData(NULL, result));
char* bytes = CFDataGetBytePtr(CFPropertyListCreateXMLData(NULL, result));
if(strstr(bytes, "Complete")) {
char* the_service = "CopyIt";
service_conn_t socket = 0;
sleep(2);
printf("Image mounted, running helper...\n");
assert(!AMDeviceStartService(dev, CFStringCreateWithCStringNoCopy(NULL, the_service, kCFStringEncodingUTF8, kCFAllocatorNull),
&socket, NULL));
assert(!fcntl(socket, F_SETFL, O_NONBLOCK));
assert(!fcntl(0, F_SETFL, O_NONBLOCK));
} else {
printf("Failed to inject image, trying again... (if it fails, try a different time), delay ... %dus\n", timesl);
timesl += 1000;
goto Retry;
}
exit(0);
}
}
/*
* See if this is a BTMM address
*/
int isBTMMAddress(CFStringRef serverNameRef)
{
boolean_t foundBTMM;
CFStringRef btmmRef;
CFStringRef serverNameQual;
CFIndex serverNameLen, btmmCount, serverCount, btmmIndex, srvIndex;
CFArrayRef btmmArrRef, serverArrRef;
CFStringRef btmmTmpRef, serverTmpRef;
CFComparisonResult res;
foundBTMM = TRUE;
btmmRef = NULL;
serverNameQual = NULL;
btmmArrRef = NULL;
serverArrRef = NULL;
if (serverNameRef == NULL) {
smb_log_info("%s: serverNameRef is NULL!", ASL_LEVEL_DEBUG, __FUNCTION__);
foundBTMM = FALSE;
goto out;
}
serverNameLen = CFStringGetLength(serverNameRef);
if (serverNameLen == 0) {
smb_log_info("%s: serverNameRef len is 0!", ASL_LEVEL_DEBUG, __FUNCTION__);
foundBTMM = FALSE;
goto out;
}
/* Create a copy of the server name, add a trailing '.' */
/* if it doesn't already have one. */
if (CFStringGetCharacterAtIndex(serverNameRef, serverNameLen - 1) == (UniChar)'.') {
serverNameQual = CFStringCreateCopy(kCFAllocatorDefault, serverNameRef);
} else {
serverNameQual = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@."), serverNameRef);
}
if (serverNameQual == NULL) {
foundBTMM = FALSE;
goto out;
}
/* Fetch BTMM domain from DynamicStore */
btmmRef = _CSBackToMyMacCopyDomain();
if (btmmRef == NULL) {
foundBTMM = FALSE;
goto out;
}
/* Split them into component string arrays */
btmmArrRef = CFStringCreateArrayBySeparatingStrings(kCFAllocatorDefault, btmmRef, CFSTR("."));
btmmCount = CFArrayGetCount(btmmArrRef);
serverArrRef = CFStringCreateArrayBySeparatingStrings(kCFAllocatorDefault, serverNameQual, CFSTR("."));
serverCount = CFArrayGetCount(serverArrRef);
if (btmmCount == 0 || serverCount == 0) {
foundBTMM = FALSE;
goto out;
}
if (btmmCount > serverCount) {
/* Not a BTMM domain */
foundBTMM = FALSE;
goto out;
}
for (btmmIndex = btmmCount - 1, srvIndex = serverCount - 1; btmmIndex >= 0; btmmIndex--, srvIndex--) {
btmmTmpRef = CFArrayGetValueAtIndex(btmmArrRef, btmmIndex);
serverTmpRef = CFArrayGetValueAtIndex(serverArrRef, srvIndex);
res = CFStringCompare(btmmTmpRef, serverTmpRef, kCFCompareCaseInsensitive);
if (res != kCFCompareEqualTo) {
/* Not a BTMM domain */
foundBTMM = FALSE;
break;
}
}
if (foundBTMM == TRUE) {
smb_log_info("%s: found a btmm address", ASL_LEVEL_DEBUG, __FUNCTION__);
}
out:
// Clean up mem
if (btmmArrRef != NULL) {
CFRelease(btmmArrRef);
}
if (serverArrRef != NULL) {
CFRelease(serverArrRef);
}
if (btmmRef != NULL) {
CFRelease(btmmRef);
}
if (serverNameQual !=NULL) {
CFRelease(serverNameQual);
}
return (foundBTMM);
}
