// This is the helper function to extract the strings from WebPluginExtensions
// in mimetype_dictionary_applier.
// value CFString containing a single file extension
// context char ** of the current extension list.
static void extension_array_applier(const void *value, void *context)
{
CFIndex ext_length;
char **extension_list;
extension_list = context;
ext_length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(value),
kCFStringEncodingUTF8);
*extension_list = realloc(*extension_list, strlen(*extension_list)
+ ext_length
+ 1
+ 1);
// If I'm not the first extension, append a comma delimiter.
if (strlen(*extension_list)) {
strcat(*extension_list, ",");
}
// Append this string to the list.
CFStringGetCString(value,
*extension_list + strlen(*extension_list),
ext_length + 1,
kCFStringEncodingUTF8);
return;
}
CFIndex
CFStringGetMaximumSizeOfFileSystemRepresentation (CFStringRef string)
{
CFIndex length = CFStringGetLength (string);
return
CFStringGetMaximumSizeForEncoding (length, CFStringGetSystemEncoding ());
}
ST_FUNC ST_Error ST_ID3v2_TextFrame_setTextStr(ST_TextFrame *f, CFStringRef s) {
CFIndex slen;
CFIndex l;
uint8_t *buf;
void *tmp;
if(!f || !s)
return ST_Error_InvalidArgument;
/* Make space for it */
slen = CFStringGetLength(s);
l = CFStringGetMaximumSizeForEncoding(slen, encs[f->encoding]);
if(!(buf = (uint8_t *)malloc(l)))
return ST_Error_errno;
CFStringGetBytes(s, CFRangeMake(0, slen), encs[f->encoding], 0,
f->encoding == ST_TextEncoding_UTF16, buf, l, &slen);
/* Attempt to make it smaller */
if(slen != l) {
if((tmp = realloc(buf, slen)))
buf = (uint8_t *)tmp;
}
free(f->string);
f->size = slen;
f->string = buf;
return ST_Error_None;
}
/**
* Increment iterator of a #PLIST_DICT node.
*
* @param node the node of type #PLIST_DICT
* @param iter iterator of the dictionary
* @param key a location to store the key, or NULL.
* @param val a location to store the value, or NULL.
*/
void plist_dict_next_item(plist_t node, plist_dict_iter iter, char **key, plist_t *val)
{
assert(CFGetTypeID(node) == CFDictionaryGetTypeID());
struct {
CFIndex index;
CFIndex count;
const void * pairs[][2];
} * myiter;
myiter = iter;
if (myiter->index < myiter->count) {
if (key) {
CFStringRef keyRef = myiter->pairs[myiter->index][0];
CFIndex maxSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(keyRef), kCFStringEncodingUTF8);
char *keyData = malloc(++maxSize);
CFStringGetCString(keyRef, keyData, maxSize, kCFStringEncodingUTF8);
*key = keyData;
}
if (val)
*val = myiter->pairs[myiter->index][1];
myiter->index += 1;
}
else {
if (key) *key = NULL;
if (val) *val = NULL;
}
}
SecPolicyRef SecPolicyCreateAppleSSLService(CFStringRef hostname)
{
// SSL server, pinned to an Apple intermediate
SecPolicyRef policy = SecPolicyCreateSSL(true, hostname);
if (policy) {
// change options for policy evaluation
char *strbuf = NULL;
const char *hostnamestr = NULL;
if (hostname) {
hostnamestr = CFStringGetCStringPtr(hostname, kCFStringEncodingUTF8);
if (hostnamestr == NULL) {
CFIndex maxLen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(hostname), kCFStringEncodingUTF8) + 1;
strbuf = (char *)malloc(maxLen);
if (CFStringGetCString(hostname, strbuf, maxLen, kCFStringEncodingUTF8)) {
hostnamestr = strbuf;
}
}
}
uint32 hostnamelen = (hostnamestr) ? (uint32)strlen(hostnamestr) : 0;
uint32 flags = 0x00000002; // 2nd-lowest bit set to require Apple intermediate pin
CSSM_APPLE_TP_SSL_OPTIONS opts = {CSSM_APPLE_TP_SSL_OPTS_VERSION, hostnamelen, hostnamestr, flags};
CSSM_DATA data = {sizeof(opts), (uint8*)&opts};
SecPolicySetValue(policy, &data);
}
return policy;
}
void ARRAY_TEXT::convertToUTF8(const CUTF16String* fromString, CUTF8String* toString)
{
#ifdef _WIN32
int len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, (LPCWSTR)fromString->c_str(), fromString->length(), NULL, 0, NULL, NULL);
if(len){
std::vector<uint8_t> buf(len + 1);
if(WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, (LPCWSTR)fromString->c_str(), fromString->length(), (LPSTR)&buf[0], len, NULL, NULL)){
*toString = CUTF8String((const uint8_t *)&buf[0]);
}
}
#else
CFStringRef str = CFStringCreateWithCharacters(kCFAllocatorDefault, (const UniChar *)fromString->c_str(), fromString->length());
if(str){
size_t size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8) + sizeof(uint8_t);
std::vector<uint8_t> buf(size);
CFIndex len = 0;
CFStringGetBytes(str, CFRangeMake(0, CFStringGetLength(str)), kCFStringEncodingUTF8, 0, true, (UInt8 *)&buf[0], size, &len);
*toString = CUTF8String((const uint8_t *)&buf[0], len);
CFRelease(str);
}
#endif
}
char *
_mongoc_cfstringref_to_cstring (CFStringRef str)
{
CFIndex length;
CFStringEncoding encoding;
CFIndex max_size;
char *cs;
if (!str) {
return NULL;
}
if (CFGetTypeID (str) != CFStringGetTypeID ()) {
return NULL;
}
length = CFStringGetLength (str);
encoding = kCFStringEncodingASCII;
max_size = CFStringGetMaximumSizeForEncoding (length, encoding) + 1;
cs = bson_malloc ((size_t) max_size);
if (CFStringGetCString (str, cs, max_size, encoding)) {
return cs;
}
bson_free (cs);
return NULL;
}
static OSStatus GetAudioPropertyString(AudioObjectID id,
AudioObjectPropertySelector selector,
char **outData)
{
OSStatus err;
AudioObjectPropertyAddress property_address;
UInt32 i_param_size;
CFStringRef string;
CFIndex string_length;
property_address.mSelector = selector;
property_address.mScope = kAudioObjectPropertyScopeGlobal;
property_address.mElement = kAudioObjectPropertyElementMaster;
i_param_size = sizeof(CFStringRef);
err = AudioObjectGetPropertyData(id, &property_address, 0, NULL, &i_param_size, &string);
if (err != noErr)
return err;
string_length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(string),
kCFStringEncodingASCII);
*outData = malloc(string_length + 1);
CFStringGetCString(string, *outData, string_length + 1, kCFStringEncodingASCII);
CFRelease(string);
return err;
}
int
cfstring_to_cstring(const CFStringRef val, char **buffer)
{
CFIndex maxlen = 0;
int retval = PAM_BUF_ERR;
if (NULL == val || NULL == buffer) {
openpam_log(PAM_LOG_DEBUG, "NULL argument passed");
retval = PAM_SERVICE_ERR;
goto cleanup;
}
maxlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(val), kCFStringEncodingUTF8);
*buffer = calloc(maxlen + 1, sizeof(char));
if (NULL == *buffer) {
openpam_log(PAM_LOG_DEBUG, "malloc() failed");
retval = PAM_BUF_ERR;
goto cleanup;
}
if (CFStringGetCString(val, *buffer, maxlen + 1, kCFStringEncodingUTF8)) {
retval = PAM_SUCCESS;
} else {
openpam_log(PAM_LOG_DEBUG, "CFStringGetCString failed.");
free(*buffer);
*buffer = NULL;
}
cleanup:
if (PAM_SUCCESS != retval)
openpam_log(PAM_LOG_ERROR, "failed: %d", retval);
return retval;
}
OSG_BEGIN_NAMESPACE
/********************** OS X **************************/
#ifdef __APPLE__
std::string FSRef2String(const FSRef& foundRef)
{
std::string Result("");
CFURLRef tURL;
tURL = CFURLCreateFromFSRef(kCFAllocatorDefault, &foundRef);
CFStringRef tCFString = CFURLCopyFileSystemPath(tURL,
kCFURLPOSIXPathStyle);
CFIndex buf_len = 1 + CFStringGetMaximumSizeForEncoding(CFStringGetLength(tCFString),
kCFStringEncodingUTF8);
char *buffer = new char[buf_len];
CFStringGetCString(tCFString, buffer, buf_len,
kCFStringEncodingUTF8);
Result = std::string(buffer);
delete[] buffer;
CFRelease(tCFString);
CFRelease(tURL);
return Result;
}
CFDataRef WebApiClientDataCreateWithHexEncodedString(CFStringRef string) {
CFIndex len = CFStringGetLength(string);
CFMutableDataRef result = CFDataCreateMutable(kCFAllocatorDefault, len / 2);
bool allocated = false;
char *str = (char *)CFStringGetCStringPtr(string, kCFStringEncodingUTF8);
if ( str == NULL ) {
CFIndex bufferSize = CFStringGetMaximumSizeForEncoding(len, kCFStringEncodingUTF8) + 1;
str = malloc(bufferSize);
if ( !str ) {
return result;
}
if ( !CFStringGetCString(string, str, bufferSize, kCFStringEncodingUTF8) ) {
free(str);
return result;
}
allocated = true;
}
CFIndex i;
unsigned char byte = 0;
size_t slen = strnlen(str, len);
slen -= (slen % 2); // if odd # of characters, truncate down
for ( i = 0; i < slen; i += 2 ) {
if ( sscanf(&str[i], "%2hhx", &byte) ) {
CFDataAppendBytes(result, &byte, 1);
} else {
break;
}
}
if ( allocated ) {
free(str);
}
return result;
}
/* http://stackoverflow.com/a/12535482 */
static CFDataRef APCopyDataFromHexString(CFStringRef string)
{
CFIndex length = CFStringGetLength(string);
CFIndex maxSize =CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8);
char *cString = (char *)malloc(maxSize);
CFStringGetCString(string, cString, maxSize, kCFStringEncodingUTF8);
/* allocate the buffer */
UInt8 * buffer = malloc((strlen(cString) / 2));
char *h = cString; /* this will walk through the hex string */
UInt8 *b = buffer; /* point inside the buffer */
/* offset into this string is the numeric value */
char translate[] = "0123456789abcdef";
for ( ; *h; h += 2, ++b) /* go by twos through the hex string */
*b = ((strchr(translate, *h) - translate) * 16) /* multiply leading digit by 16 */
+ ((strchr(translate, *(h+1)) - translate));
CFDataRef data = CFDataCreate(kCFAllocatorDefault, buffer, (strlen(cString) / 2));
free(cString);
free(buffer);
return data;
}
FILE* fopen (const char *filename, const char *mode) {
#ifdef HX_MACOS
FILE *result = ::fopen (filename, "rb");
if (!result) {
CFStringRef str = CFStringCreateWithCString (NULL, filename, kCFStringEncodingUTF8);
CFURLRef path = CFBundleCopyResourceURL (CFBundleGetMainBundle (), str, NULL, NULL);
CFRelease (str);
if (path) {
str = CFURLCopyPath (path);
CFIndex maxSize = CFStringGetMaximumSizeForEncoding (CFStringGetLength (str), kCFStringEncodingUTF8);
char *buffer = (char *)malloc (maxSize);
if (CFStringGetCString (str, buffer, maxSize, kCFStringEncodingUTF8)) {
result = ::fopen (buffer,"rb");
free (buffer);
}
CFRelease (str);
CFRelease (path);
}
}
return result;
#else
return ::fopen (filename, mode);
#endif
}
char *create_cstr_from_cfstring(CFStringRef cfstring)
{
CFIndex str_len = CFStringGetLength(cfstring);
if (str_len < 0)
{
return NULL;
}
CFIndex buf_len = CFStringGetMaximumSizeForEncoding(str_len, kCFStringEncodingUTF8) + 1;
if (buf_len < 1)
{
return NULL;
}
char *cstr = (char *)malloc(buf_len);
if (cstr == NULL)
{
return NULL;
}
if (CFStringGetCString(cfstring, cstr, buf_len, kCFStringEncodingUTF8))
{
return cstr;
}
return NULL;
}
void MDSAttrParser::parseFile(CFURLRef infoUrl, CFStringRef subdir)
{
CFStringRef infoType = NULL;
/* Get contents of mdsinfo file as dictionary */
MDSDictionary mdsDict(infoUrl, subdir, mPath);
/* Make sure we set all possible MDS values before checking for GUID */
mdsDict.setDefaults(mDefaults);
if (mGuid == NULL) {
CFStringRef guid = (CFStringRef)mdsDict.lookup("ModuleID", true, CFStringGetTypeID());
if (guid) {
CFIndex copylen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(guid), kCFStringEncodingUTF8) + 1/*nul terminator*/;
mGuid = new char[copylen];
if (false == CFStringGetCString(guid, mGuid, copylen, kCFStringEncodingUTF8)) {
logFileError("Error copying GUID", infoUrl, NULL, NULL);
delete [] mGuid;
mGuid = NULL;
CssmError::throwMe(CSSM_ERRCODE_MDS_ERROR);
}
}
else {
logFileError("No GUID associated with plugin?", infoUrl, NULL, NULL);
CssmError::throwMe(CSSM_ERRCODE_MDS_ERROR);
}
}
MPDebug("Parsing mdsinfo file %s", mdsDict.fileDesc());
/* Determine what kind of info file this is and dispatch accordingly */
infoType = (CFStringRef)mdsDict.lookup(CFSTR(MDS_INFO_FILE_TYPE),
true, CFStringGetTypeID());
if(infoType == NULL) {
logFileError("Malformed MDS Info file", infoUrl, NULL, NULL);
CssmError::throwMe(CSSM_ERRCODE_MDS_ERROR);
}
/* be robust here, errors in these low-level routines do not affect
* the rest of our task */
try {
if(CFStringCompare(infoType, CFSTR(MDS_INFO_FILE_TYPE_CSSM), 0)
== kCFCompareEqualTo) {
parseCssmInfo(&mdsDict);
}
else if(CFStringCompare(infoType, CFSTR(MDS_INFO_FILE_TYPE_PLUGIN), 0)
== kCFCompareEqualTo) {
parsePluginCommon(&mdsDict);
}
else if(CFStringCompare(infoType, CFSTR(MDS_INFO_FILE_TYPE_RECORD), 0)
== kCFCompareEqualTo) {
parsePluginSpecific(&mdsDict);
}
else {
logFileError("Malformed MDS Info file", infoUrl, NULL, NULL);
}
}
catch(...) {
}
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if USE(CF) && !OS(WINDOWS)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
#if COMPILER(CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
#if COMPILER(CLANG)
#pragma clang diagnostic pop
#endif
CFIndex length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
logToStderr(buffer);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
return;
}
#if USE(APPLE_SYSTEM_LOG)
va_list copyOfArgs;
va_copy(copyOfArgs, args);
asl_vlog(0, 0, ASL_LEVEL_NOTICE, format, copyOfArgs);
va_end(copyOfArgs);
#endif
// Fall through to write to stderr in the same manner as other platforms.
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (vsnprintf(buffer, size, format, args) != -1) {
OutputDebugStringA(buffer);
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
vfprintf(stderr, format, args);
}
/*
* Get the server name out of the URL. CFURLCopyHostName will escape out the
* server name for us. So just convert it to the correct code page encoding.
*
* Note: Currently we put the server name into a c-style string. In the future
* it would be nice to keep this as a CFString.
*/
static int SetServerFromURL(struct smb_ctx *ctx, CFURLRef url)
{
CFIndex maxlen;
CFStringRef serverNameRef = CFURLCopyHostName(url);
char *ipV6Name = NULL;
ipV6Name = CStringCreateWithCFString(serverNameRef);
if (ipV6Name && isIPv6NumericName(ipV6Name)) {
/* CFURLCopyHostName removed the [] so put them back in */
CFMutableStringRef newServer = CFStringCreateMutableCopy(NULL, 1024, CFSTR("["));
if (newServer) {
CFStringAppend(newServer, serverNameRef);
CFStringAppend(newServer, CFSTR("]"));
CFRelease(serverNameRef);
serverNameRef = newServer;
}
}
/* Free up the buffer we allocated */
if (ipV6Name) {
free(ipV6Name);
}
/*
* Every time we parse the URL we end up replacing the server name. In the
* future we should skip replacing the server name if we already have one and
* the one return CFURLCopyHostName matches it.
*
* Not going to make that big of a change in an update, so lets limit to the
* case were we are dealing with using a domain controller.
*/
if (serverNameRef && ctx->serverNameRef && ctx->serverName &&
(ctx->serverIsDomainController) &&
(ctx->ct_flags & SMBCF_CONNECTED) &&
(CFStringCompare(serverNameRef, ctx->serverNameRef, 0) == kCFCompareEqualTo)) {
CFRelease(serverNameRef);
return 0; /* Same name nothing to do here */
}
if (ctx->serverNameRef) {
CFRelease(ctx->serverNameRef);
}
/* The serverNameRef should always contain the URL host name or the Bonjour Name */
ctx->serverNameRef = serverNameRef;
if (ctx->serverNameRef == NULL)
return EINVAL;
DebugLogCFString(ctx->serverNameRef, "Server", __FUNCTION__, __LINE__);
maxlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(ctx->serverNameRef), kCFStringEncodingUTF8) + 1;
if (ctx->serverName)
free(ctx->serverName);
ctx->serverName = malloc(maxlen);
if (!ctx->serverName) {
CFRelease(ctx->serverNameRef);
ctx->serverNameRef = NULL;
return ENOMEM;
}
CFStringGetCString(ctx->serverNameRef, ctx->serverName, maxlen, kCFStringEncodingUTF8);
return 0;
}
char *cfstr_get_cstr(CFStringRef cfstr)
{
CFIndex size =
CFStringGetMaximumSizeForEncoding(
CFStringGetLength(cfstr), CA_CFSTR_ENCODING) + 1;
char *buffer = talloc_zero_size(NULL, size);
CFStringGetCString(cfstr, buffer, size, CA_CFSTR_ENCODING);
return buffer;
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if PLATFORM(MAC)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
int length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
return;
}
#elif PLATFORM(BLACKBERRY)
BlackBerry::Platform::logV(BlackBerry::Platform::LogLevelInfo, format, args);
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
#if OS(WINCE)
// WinCE only supports wide chars
wchar_t* wideBuffer = (wchar_t*)malloc(size * sizeof(wchar_t));
if (wideBuffer == NULL)
break;
for (unsigned int i = 0; i < size; ++i) {
if (!(wideBuffer[i] = buffer[i]))
break;
}
OutputDebugStringW(wideBuffer);
free(wideBuffer);
#else
OutputDebugStringA(buffer);
#endif
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
vfprintf(stderr, format, args);
}
Array AudioDriverCoreAudio::_get_device_list(bool capture) {
Array list;
list.push_back("Default");
AudioObjectPropertyAddress prop;
prop.mSelector = kAudioHardwarePropertyDevices;
prop.mScope = kAudioObjectPropertyScopeGlobal;
prop.mElement = kAudioObjectPropertyElementMaster;
UInt32 size = 0;
AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &prop, 0, NULL, &size);
AudioDeviceID *audioDevices = (AudioDeviceID *)malloc(size);
AudioObjectGetPropertyData(kAudioObjectSystemObject, &prop, 0, NULL, &size, audioDevices);
UInt32 deviceCount = size / sizeof(AudioDeviceID);
for (UInt32 i = 0; i < deviceCount; i++) {
prop.mScope = capture ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;
prop.mSelector = kAudioDevicePropertyStreamConfiguration;
AudioObjectGetPropertyDataSize(audioDevices[i], &prop, 0, NULL, &size);
AudioBufferList *bufferList = (AudioBufferList *)malloc(size);
AudioObjectGetPropertyData(audioDevices[i], &prop, 0, NULL, &size, bufferList);
UInt32 channelCount = 0;
for (UInt32 j = 0; j < bufferList->mNumberBuffers; j++)
channelCount += bufferList->mBuffers[j].mNumberChannels;
free(bufferList);
if (channelCount >= 1) {
CFStringRef cfname;
size = sizeof(CFStringRef);
prop.mSelector = kAudioObjectPropertyName;
AudioObjectGetPropertyData(audioDevices[i], &prop, 0, NULL, &size, &cfname);
CFIndex length = CFStringGetLength(cfname);
CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;
char *buffer = (char *)malloc(maxSize);
if (CFStringGetCString(cfname, buffer, maxSize, kCFStringEncodingUTF8)) {
// Append the ID to the name in case we have devices with duplicate name
list.push_back(String(buffer) + " (" + itos(audioDevices[i]) + ")");
}
free(buffer);
}
}
free(audioDevices);
return list;
}
size_t der_sizeof_string(CFStringRef str, CFErrorRef *error)
{
const CFIndex str_length = CFStringGetLength(str);
const CFIndex maximum = CFStringGetMaximumSizeForEncoding(str_length, kCFStringEncodingUTF8);
CFIndex encodedLen = 0;
CFIndex converted = CFStringGetBytes(str, CFRangeMake(0, str_length), kCFStringEncodingUTF8, 0, false, NULL, maximum, &encodedLen);
return ccder_sizeof(CCDER_UTF8_STRING, (converted == str_length) ? encodedLen : 0);
}
char *
CFStringToCString(CFStringRef input)
{
if (input == NULL)
return NULL;
int strlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(input), kCFStringEncodingUTF8);
char *output = NewPtr(strlen+1);
CFStringGetCString(input, output, strlen+1, kCFStringEncodingUTF8);
return output;
}
bool
SetXiphCommentFromMetadata(const AudioMetadata& metadata, TagLib::Ogg::XiphComment *tag)
{
assert(NULL != tag);
// Standard tags
SetXiphComment(tag, "ALBUM", metadata.GetAlbumTitle());
SetXiphComment(tag, "ARTIST", metadata.GetArtist());
SetXiphComment(tag, "ALBUMARTIST", metadata.GetAlbumArtist());
SetXiphComment(tag, "COMPOSER", metadata.GetComposer());
SetXiphComment(tag, "GENRE", metadata.GetGenre());
SetXiphComment(tag, "DATE", metadata.GetReleaseDate());
SetXiphComment(tag, "DESCRIPTION", metadata.GetComment());
SetXiphComment(tag, "TITLE", metadata.GetTitle());
SetXiphCommentNumber(tag, "TRACKNUMBER", metadata.GetTrackNumber());
SetXiphCommentNumber(tag, "TRACKTOTAL", metadata.GetTrackTotal());
SetXiphCommentBoolean(tag, "COMPILATION", metadata.GetCompilation());
SetXiphCommentNumber(tag, "DISCNUMBER", metadata.GetDiscNumber());
SetXiphCommentNumber(tag, "DISCTOTAL", metadata.GetDiscTotal());
SetXiphComment(tag, "ISRC", metadata.GetISRC());
SetXiphComment(tag, "MCN", metadata.GetMCN());
// Additional metadata
CFDictionaryRef additionalMetadata = metadata.GetAdditionalMetadata();
if(NULL != additionalMetadata) {
CFIndex count = CFDictionaryGetCount(additionalMetadata);
const void * keys [count];
const void * values [count];
CFDictionaryGetKeysAndValues(additionalMetadata, reinterpret_cast<const void **>(keys), reinterpret_cast<const void **>(values));
for(CFIndex i = 0; i < count; ++i) {
CFIndex keySize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(reinterpret_cast<CFStringRef>(keys[i])), kCFStringEncodingASCII);
char key [keySize + 1];
if(!CFStringGetCString(reinterpret_cast<CFStringRef>(keys[i]), key, keySize + 1, kCFStringEncodingASCII)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine");
LOG4CXX_ERROR(logger, "CFStringGetCString failed");
continue;
}
SetXiphComment(tag, key, reinterpret_cast<CFStringRef>(values[i]));
}
}
// ReplayGain info
SetXiphCommentDouble(tag, "REPLAYGAIN_REFERENCE_LOUDNESS", metadata.GetReplayGainReferenceLoudness(), CFSTR("%2.1f dB"));
SetXiphCommentDouble(tag, "REPLAYGAIN_TRACK_GAIN", metadata.GetReplayGainReferenceLoudness(), CFSTR("%+2.2f dB"));
SetXiphCommentDouble(tag, "REPLAYGAIN_TRACK_PEAK", metadata.GetReplayGainTrackGain(), CFSTR("%1.8f"));
SetXiphCommentDouble(tag, "REPLAYGAIN_ALBUM_GAIN", metadata.GetReplayGainAlbumGain(), CFSTR("%+2.2f dB"));
SetXiphCommentDouble(tag, "REPLAYGAIN_ALBUM_PEAK", metadata.GetReplayGainAlbumPeak(), CFSTR("%1.8f"));
return true;
}
/*
* We need to separate the share name and any path component from the URL.
* URL "smb://*****:*****@server" no share name or path.
* URL "smb://*****:*****@server/"no share name or path.
* URL "smb://*****:*****@server/share" just a share name.
* URL "smb://*****:*****@server/share/path" share name and path.
*
* The Share name and Path name will not begin with a slash.
* smb://server/ntfs share = ntfs path = NULL
* smb://ntfs/dir1/dir2 share = ntfs path = dir1/dir2
*/
static int SetShareAndPathFromURL(struct smb_ctx *ctx, CFURLRef url)
{
CFStringRef share = NULL;
CFStringRef path = NULL;
CFIndex maxlen;
int error;
error = GetShareAndPathFromURL(url, &share, &path);
if (error) {
return error;
}
/* Since there is no share name we have nothing left to do. */
if (share == NULL) {
if (path != NULL) {
CFRelease(path);
}
return 0;
}
DebugLogCFString(share, "Share", __FUNCTION__, __LINE__);
CreateStringByReplacingPercentEscapesUTF8(&share, CFSTR(""));
if (ctx->ct_origshare) {
free(ctx->ct_origshare);
}
if (ctx->mountPath) {
CFRelease(ctx->mountPath);
}
ctx->mountPath = NULL;
maxlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(share), kCFStringEncodingUTF8) + 1;
ctx->ct_origshare = malloc(maxlen);
if (!ctx->ct_origshare) {
CFRelease(share);
if (path != NULL) {
CFRelease(path);
}
return ENOMEM;
}
CFStringGetCString(share, ctx->ct_origshare, maxlen, kCFStringEncodingUTF8);
str_upper(ctx->ct_sh.ioc_share, sizeof(ctx->ct_sh.ioc_share), share);
CFRelease(share);
ctx->mountPath = path;
return 0;
}
char *PortBurn_CStringFromCFString(CFStringRef cfname) {
char *name;
CFIndex len;
len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfname),
kCFStringEncodingASCII);
name = (char *)malloc(len + 1);
name[0] = 0;
CFStringGetCString(cfname, name, len + 1, kCFStringEncodingASCII);
return name;
}
char * CFStringCopyUTF8String(CFStringRef aString) {
if (aString == NULL) { return NULL; }
CFIndex length = CFStringGetLength(aString);
CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8);
char *buffer = (char *)malloc(maxSize);
if (CFStringGetCString(aString, buffer, maxSize, kCFStringEncodingUTF8)) {
return buffer;
}
return "";
}
char *secCopyCString(CFStringRef theString)
{
CFIndex maxLength = CFStringGetMaximumSizeForEncoding(CFStringGetLength(theString), kCFStringEncodingUTF8) + 1;
char* buffer = (char*) malloc(maxLength);
Boolean converted = CFStringGetCString(theString, buffer, maxLength, kCFStringEncodingUTF8);
if (!converted) {
free(buffer);
buffer = NULL;
}
return buffer;
}
CFRunLoopSourceRef CreateIPCRunLoopSource(CFStringRef aPortName, StartupContext aStartupContext)
{
CFRunLoopSourceRef aSource = NULL;
CFMachPortRef aMachPort = NULL;
CFMachPortContext aContext;
kern_return_t aKernReturn = KERN_FAILURE;
aContext.version = 0;
aContext.info = (void*) aStartupContext;
aContext.retain = 0;
aContext.release = 0;
aContext.copyDescription = 0;
aMachPort = CFMachPortCreate(NULL, NULL, &aContext, NULL);
if (aMachPort && aPortName)
{
CFIndex aPortNameLength = CFStringGetLength(aPortName);
CFIndex aPortNameSize = CFStringGetMaximumSizeForEncoding(aPortNameLength, kCFStringEncodingUTF8) + 1;
uint8_t *aBuffer = CFAllocatorAllocate(NULL, aPortNameSize, 0);
if (aBuffer && CFStringGetCString(aPortName,
aBuffer,
aPortNameSize,
kCFStringEncodingUTF8))
{
mach_port_t aBootstrapPort;
task_get_bootstrap_port(mach_task_self(), &aBootstrapPort);
aKernReturn = bootstrap_register(aBootstrapPort, aBuffer, CFMachPortGetPort(aMachPort));
}
if (aBuffer) CFAllocatorDeallocate(NULL, aBuffer);
}
if (aMachPort && aKernReturn == KERN_SUCCESS)
{
CFRunLoopSourceContext1 aSourceContext;
aSourceContext.version = 1;
aSourceContext.info = aMachPort;
aSourceContext.retain = CFRetain;
aSourceContext.release = CFRelease;
aSourceContext.copyDescription = CFCopyDescription;
aSourceContext.equal = CFEqual;
aSourceContext.hash = CFHash;
aSourceContext.getPort = getIPCPort;
aSourceContext.perform = (void*)handleIPCMessage;
aSource = CFRunLoopSourceCreate(NULL, 0, (CFRunLoopSourceContext*)&aSourceContext);
}
if (aMachPort && (!aSource || aKernReturn != KERN_SUCCESS))
{
CFMachPortInvalidate(aMachPort);
CFRelease(aMachPort);
aMachPort = NULL;
}
return aSource;
}
void MDSAttrParser::parseAttrs(CFStringRef subdir)
{
/* get all *.mdsinfo files */
CFArrayRef bundleInfoFiles = CFBundleCopyResourceURLsOfType(mBundle,
CFSTR(MDS_INFO_TYPE),
subdir);
if(bundleInfoFiles == NULL) {
Syslog::alert("MDSAttrParser: no mdsattr files for %s", mPath);
return;
}
assert(CFGetTypeID(bundleInfoFiles) == CFArrayGetTypeID());
/* process each .mdsinfo file */
CFIndex numFiles = CFArrayGetCount(bundleInfoFiles);
for(CFIndex i=0; i<numFiles; i++) {
/* get filename as CFURL */
CFURLRef infoUrl = NULL;
infoUrl = reinterpret_cast<CFURLRef>(
CFArrayGetValueAtIndex(bundleInfoFiles, i));
if(infoUrl == NULL) {
MPDebug("MDSAttrParser: CFBundleCopyResourceURLsOfType screwup 1");
continue;
}
if(CFGetTypeID(infoUrl) != CFURLGetTypeID()) {
MPDebug("MDSAttrParser: CFBundleCopyResourceURLsOfType screwup 2");
continue;
}
// @@@ Workaround for 4234967: skip any filename beginning with "._"
CFStringRef lastComponent = CFURLCopyLastPathComponent(infoUrl);
if (lastComponent) {
CFStringRef resFilePfx = CFSTR("._");
// setting the search length and location like this permits,
// e.g., ".foo.mdsinfo" to be valid
CFIndex resFilePfxLen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(resFilePfx), kCFStringEncodingUTF8);
CFRange range = CFRangeMake(0, resFilePfxLen);
Boolean skip = CFStringFindWithOptions(lastComponent,
resFilePfx,
range,
0/*options*/,
NULL/*returned substr*/);
CFRelease(lastComponent);
if (skip == true) {
Syslog::warning("MDSAttrParser: ignoring resource file");
continue;
}
}
parseFile(infoUrl, subdir);
} /* for each mdsinfo */
CF_RELEASE(bundleInfoFiles);
}
WB_INLINE
UTF8Char *__WBCFStringCopyUTF8Characters(CFStringRef string) {
CFIndex length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(string), kCFStringEncodingUTF8);
UTF8Char *characters = calloc(length, sizeof(UTF8Char));
if (!characters) return NULL;
if (!CFStringGetCString(string, (char *)characters, length, kCFStringEncodingUTF8)) {
free(characters);
return NULL;
}
return characters;
}