/// data() is re-implemented from QStandardItemModel to return the widget window title and icon for the Qt::DecorationRole and Qt::DisplayRole/Qt::EditRole
QVariant AMWindowPaneModel::data(const QModelIndex &index, int role) const {
switch(role) {
case Qt::DisplayRole:
case Qt::EditRole:
// alias items can have separate descriptions, but for normal items, the DisplayRole and EditRole should be the window title
if(!isAlias(index) && internalPane(index))
return internalPane(index)->windowTitle();
else
return AMDragDropItemModel::data(index, role);
break;
case Qt::DecorationRole:
if(!isAlias(index) && internalPane(index))
return internalPane(index)->windowIcon();
else
return AMDragDropItemModel::data(index, role);
break;
// read-only property, defined as being (a) NOT an alias, AND (b) having no valid window pane widget set
case AMWindowPaneModel::IsHeadingRole:
return (index.isValid() && !isAlias(index) && internalPane(index) == 0);
break;
// Dock state: alias items should return the dock state of their target. Other items simply return their dock state, as stored in the AMWindowPaneModel::DockStateRole.
case AMWindowPaneModel::DockStateRole:
if(isAlias(index)) {
QStandardItem* target = aliasTarget(index);
if(target)
return data(target->index(), role);
else
return true;
}
else
return AMDragDropItemModel::data(index, role);
break;
case AMWindowPaneModel::UndockResizeRole:
return AMDragDropItemModel::data(index, role);
break;
case AMWindowPaneModel::IsVisibleRole:
if (AMDragDropItemModel::data(index, role).isValid())
return AMDragDropItemModel::data(index, role);
else
return true;
break;
default:
return AMDragDropItemModel::data(index, role);
}
}
U_CFUNC const char *
ucnv_io_getConverterName(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) {
const char *aliasTmp = alias;
int32_t i = 0;
for (i = 0; i < 2; i++) {
if (i == 1) {
/*
* After the first unsuccess converter lookup, check to see if
* the name begins with 'x-'. If it does, strip it off and try
* again. This behaviour is similar to how ICU4J does it.
*/
if (aliasTmp[0] == 'x' || aliasTmp[1] == '-') {
aliasTmp = aliasTmp+2;
} else {
break;
}
}
if(haveAliasData(pErrorCode) && isAlias(aliasTmp, pErrorCode)) {
uint32_t convNum = findConverter(aliasTmp, containsOption, pErrorCode);
if (convNum < gMainTable.converterListSize) {
return GET_STRING(gMainTable.converterList[convNum]);
}
/* else converter not found */
} else {
break;
}
}
return NULL;
}
U_CAPI UEnumeration * U_EXPORT2
ucnv_openStandardNames(const char *convName,
const char *standard,
UErrorCode *pErrorCode)
{
UEnumeration *myEnum = NULL;
if (haveAliasData(pErrorCode) && isAlias(convName, pErrorCode)) {
uint32_t listOffset = findTaggedAliasListsOffset(convName, standard, pErrorCode);
/* When listOffset == 0, we want to acknowledge that the
converter name and standard are okay, but there
is nothing to enumerate. */
if (listOffset < gMainTable.taggedAliasListsSize) {
UAliasContext *myContext;
myEnum = reinterpret_cast<UEnumeration *>(uprv_malloc(sizeof(UEnumeration)));
if (myEnum == NULL) {
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
uprv_memcpy(myEnum, &gEnumAliases, sizeof(UEnumeration));
myContext = reinterpret_cast<UAliasContext *>(uprv_malloc(sizeof(UAliasContext)));
if (myContext == NULL) {
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
uprv_free(myEnum);
return NULL;
}
myContext->listOffset = listOffset;
myContext->listIdx = 0;
myEnum->context = myContext;
}
/* else converter or tag not found */
}
return myEnum;
}
static uint16_t
ucnv_io_getAliases(const char* alias, uint16_t start, const char** aliases, UErrorCode* pErrorCode) {
if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
uint32_t currAlias;
uint32_t convNum = findConverter(alias, NULL, pErrorCode);
if (convNum < gMainTable.converterListSize) {
/* tagListNum - 1 is the ALL tag */
int32_t listOffset = gMainTable.taggedAliasArray[
(gMainTable.tagListSize - 1) * gMainTable.converterListSize + convNum];
if (listOffset) {
uint32_t listCount = gMainTable.taggedAliasLists[listOffset];
/* +1 to skip listCount */
const uint16_t* currList = gMainTable.taggedAliasLists + listOffset + 1;
for (currAlias = start; currAlias < listCount; currAlias++) {
aliases[currAlias] = GET_STRING(currList[currAlias]);
}
}
/* else this shouldn't happen. internal program error */
}
/* else converter not found */
}
return 0;
}
static const char*
ucnv_io_getAlias(const char* alias, uint16_t n, UErrorCode* pErrorCode) {
if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
uint32_t convNum = findConverter(alias, NULL, pErrorCode);
if (convNum < gMainTable.converterListSize) {
/* tagListNum - 1 is the ALL tag */
int32_t listOffset = gMainTable.taggedAliasArray[
(gMainTable.tagListSize - 1) * gMainTable.converterListSize + convNum];
if (listOffset) {
uint32_t listCount = gMainTable.taggedAliasLists[listOffset];
/* +1 to skip listCount */
const uint16_t* currList = gMainTable.taggedAliasLists + listOffset + 1;
if (n < listCount) {
return GET_STRING(currList[n]);
}
*pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
}
/* else this shouldn't happen. internal program error */
}
/* else converter not found */
}
return NULL;
}
/// Convenience function to retrieve an alias item's target item. Returns 0 if the item at this \c index is not an alias.
QStandardItem* AMWindowPaneModel::aliasTarget(const QModelIndex& index) const {
if(!index.isValid() || !isAlias(index))
return 0;
QVariant itemPointer = data(index, AMWindowPaneModel::AliasTargetRole);
if(itemPointer.isValid())
return itemPointer.value<QStandardItem*>();
else
return 0;
}
U_CFUNC const char *
ucnv_io_getConverterName(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) {
if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
uint32_t convNum = findConverter(alias, containsOption, pErrorCode);
if (convNum < gMainTable.converterListSize) {
return GET_STRING(gMainTable.converterList[convNum]);
}
/* else converter not found */
}
return NULL;
}
U_CAPI const char * U_EXPORT2
ucnv_getCanonicalName(const char *alias, const char *standard, UErrorCode *pErrorCode) {
if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
uint32_t convNum = findTaggedConverterNum(alias, standard, pErrorCode);
if (convNum < gMainTable.converterListSize) {
return GET_STRING(gMainTable.converterList[convNum]);
}
}
return NULL;
}
void AMWindowPaneModel::onRowsInserted(const QModelIndex &parent, int first, int last) {
// for each item inserted: install event filter on the widget, and add to the widget lookup hash.
for(int row=first; row<=last; row++) {
QModelIndex i = index(row, 0, parent);
if(!isAlias(i)) {
QWidget* widget = internalPane(i);
if(widget) {
widget2item_.insert(widget, itemFromIndex(i));
widget->installEventFilter(this);
}
}
}
}
void AMWindowPaneModel::onRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last) {
for(int row=first; row<=last; row++) {
QModelIndex i = index(row, 0, parent);
if(!isAlias(i)) {
QWidget* w = internalPane(i);
if(w) {
widget2item_.remove(w);
w->removeEventFilter(this);
}
}
}
}
/// Convenience function to return a pointer to an item's QWidget window pane. For alias items, will return the window pane of the target. \warning Might be 0 if an invalid item has been added to the model, or if this index is a heading item.
QWidget* AMWindowPaneModel::pane(const QModelIndex& index) const {
if(!index.isValid())
return 0;
if(isAlias(index)) {
QStandardItem* target = aliasTarget(index);
if(target)
return internalPane(target->index());
else
return 0;
}
else {
return internalPane(index);
}
}
static uint16_t
ucnv_io_countAliases(const char *alias, UErrorCode *pErrorCode) {
if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
uint32_t convNum = findConverter(alias, NULL, pErrorCode);
if (convNum < gMainTable.converterListSize) {
/* tagListNum - 1 is the ALL tag */
int32_t listOffset = gMainTable.taggedAliasArray[(gMainTable.tagListSize - 1)*gMainTable.converterListSize + convNum];
if (listOffset) {
return gMainTable.taggedAliasLists[listOffset];
}
/* else this shouldn't happen. internal program error */
}
/* else converter not found */
}
return 0;
}
U_CAPI const char * U_EXPORT2
ucnv_getStandardName(const char *alias, const char *standard, UErrorCode *pErrorCode) {
if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
uint32_t listOffset = findTaggedAliasListsOffset(alias, standard, pErrorCode);
if (0 < listOffset && listOffset < gMainTable.taggedAliasListsSize) {
const uint16_t *currList = gMainTable.taggedAliasLists + listOffset + 1;
/* Get the preferred name from this list */
if (currList[0]) {
return GET_STRING(currList[0]);
}
/* else someone screwed up the alias table. */
/* *pErrorCode = U_INVALID_FORMAT_ERROR */
}
}
return NULL;
}
const AST::Alias& Value::alias() const {
assert(isAlias());
return *(impl_->union_.alias);
}
/// setData() is re-implemented from QStandardItemModel to set the widget window title and icon for the Qt::DecorationRole and Qt::DisplayRole/Qt::EditRole
bool AMWindowPaneModel::setData(const QModelIndex &index, const QVariant &value, int role) {
if(!index.isValid())
return false;
switch(role) {
case Qt::DisplayRole:
case Qt::EditRole:
// alias items and heading items can have separate descriptions, but for normal items, the DisplayRole and EditRole should be the window title
if(isAlias(index) || isHeading(index))
return AMDragDropItemModel::setData(index, value, role);
if(internalPane(index)) {
internalPane(index)->setWindowTitle(value.toString());
return true;
}
else
return false;
break;
case Qt::DecorationRole:
// alias items and heading items can have separate icons, but for normal items, the Decoration role should be the window icon
if(isAlias(index) || isHeading(index))
return AMDragDropItemModel::setData(index, value, role);
if(internalPane(index)) {
internalPane(index)->setWindowIcon(value.value<QIcon>());
return true;
}
else
return false;
break;
case AMWindowPaneModel::DockStateRole:
{
// docking an alias? dock the target instead.
if(isAlias(index)) {
QStandardItem* target = aliasTarget(index);
if(target)
return setData(target->index(), value, role);
else
return false;
}
bool nowDocked = value.toBool();
bool wasDocked = isDocked(index);
// set dock state like normal, but emit special signal dockStateChanged() if it's changing.
if(AMDragDropItemModel::setData(index, value, role)) {
QWidget* w = internalPane(index);
if(wasDocked && !nowDocked)
emit dockStateChanged(w, false, index.data(AMWindowPaneModel::UndockResizeRole).toBool());
else if(!wasDocked && nowDocked)
emit dockStateChanged(w, true, index.data(AMWindowPaneModel::UndockResizeRole).toBool());
return true;
}
else
return false;
break;
}
case AMWindowPaneModel::UndockResizeRole:
return AMDragDropItemModel::setData(index, value, role);
break;
default:
return AMDragDropItemModel::setData(index, value, role);
}
}
/// Convenience function to check if this item is a header item. This is defined as being true when (a) the item is NOT an alias, AND (b) that the AM::Widget role is 0/unset.
bool AMWindowPaneModel::isHeading(const QModelIndex &index) const {
return (index.isValid() && !isAlias(index) && internalPane(index) == 0);
}
///-------------------------------------------------------------------------------------------------
/// Scan a single file. Everything that applies to ms_scan also applies to this function. If
/// you know the type of the file, set the type paramter to one of TYPE_AUDIO, TYPE_VIDEO, or
/// TYPE_IMAGE. Set it to TYPE_UNKNOWN to have it determined automatically.
///
/// @author Andy Grundman
/// @date 03/15/2011
///
/// @param [in,out] s If non-null, the.
/// @param full_path Full pathname of the full file.
///
/// ### remarks .
///-------------------------------------------------------------------------------------------------
void ms_scan_file(MediaScan *s, const char *full_path, enum media_type type) {
MediaScanError *e = NULL;
MediaScanResult *r = NULL;
int ret;
uint32_t hash;
int mtime = 0;
uint64_t size = 0;
DBT key, data;
char tmp_full_path[MAX_PATH_STR_LEN];
#ifdef WIN32
char *ext = strrchr(full_path, '.');
#endif
if (s == NULL) {
ms_errno = MSENO_NULLSCANOBJ;
LOG_ERROR("MediaScan = NULL, aborting scan\n");
return;
}
if (s->on_result == NULL) {
ms_errno = MSENO_NORESULTCALLBACK;
LOG_ERROR("Result callback not set, aborting scan\n");
return;
}
#if (defined(__APPLE__) && defined(__MACH__))
if (isAlias(full_path)) {
LOG_INFO("File %s is a mac alias\n", full_path);
// Check if this file is a shortcut and if so resolve it
if (!CheckMacAlias(full_path, tmp_full_path)) {
LOG_ERROR("Failure to follow symlink or alias, skipping file\n");
return;
}
}
else {
strcpy(tmp_full_path, full_path);
}
#elif defined(__unix__) || defined(__unix)
if (isAlias(full_path)) {
LOG_INFO("File %s is a unix symlink\n", full_path);
// Check if this file is a shortcut and if so resolve it
FollowLink(full_path, tmp_full_path);
}
else {
strcpy(tmp_full_path, full_path);
}
#elif defined(WIN32)
if (strcasecmp(ext, ".lnk") == 0) {
// Check if this file is a shortcut and if so resolve it
parse_lnk(full_path, tmp_full_path, MAX_PATH_STR_LEN);
if (PathIsDirectory(tmp_full_path))
return;
}
else {
strcpy(tmp_full_path, full_path);
}
#endif
// Check if the file has been recently scanned
hash = HashFile(tmp_full_path, &mtime, &size);
// Skip 0-byte files
if (unlikely(size == 0)) {
LOG_WARN("Skipping 0-byte file: %s\n", tmp_full_path);
return;
}
// Setup DBT values
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
key.data = (char *)full_path;
key.size = strlen(full_path) + 1;
data.data = &hash;
data.size = sizeof(uint32_t);
if ((s->flags & MS_RESCAN) || (s->flags & MS_FULL_SCAN)) {
// s->dbp will be null if this function is called directly, if not check if this file is
// already scanned.
if (s->dbp != NULL) {
// DB_GET_BOTH will only return OK if both key and data match, this avoids the need to check
// the returned data against hash
int ret = s->dbp->get(s->dbp, NULL, &key, &data, DB_GET_BOTH);
if (ret != DB_NOTFOUND) {
// LOG_INFO("File %s already scanned, skipping\n", tmp_full_path);
return;
}
}
}
LOG_INFO("Scanning file %s\n", tmp_full_path);
if (type == TYPE_UNKNOWN || type == TYPE_LNK) {
// auto-detect type
type = _should_scan(s, tmp_full_path);
if (!type) {
if (s->on_error) {
ms_errno = MSENO_SCANERROR;
e = error_create(tmp_full_path, MS_ERROR_TYPE_UNKNOWN, "Unrecognized file extension");
send_error(s, e);
return;
}
}
}
r = result_create(s);
if (r == NULL)
return;
r->type = type;
r->path = strdup(full_path);
if (result_scan(r)) {
// These were determined by HashFile
r->mtime = mtime;
r->size = size;
r->hash = hash;
// Store path -> hash data in cache
if (s->dbp != NULL) {
memset(&data, 0, sizeof(DBT));
data.data = &hash;
data.size = sizeof(uint32_t);
ret = s->dbp->put(s->dbp, NULL, &key, &data, 0);
if (ret != 0) {
s->dbp->err(s->dbp, ret, "Cache store failed: %s", db_strerror(ret));
}
}
send_result(s, r);
}
else {
if (s->on_error && r->error) {
// Copy the error, because the original will be cleaned up by result_destroy below
MediaScanError *ecopy = error_copy(r->error);
send_error(s, ecopy);
}
result_destroy(r);
}
} /* ms_scan_file() */
const ValueArray& Value::aliasTemplateArguments() const {
assert(isAlias());
return impl_->valueArray;
}
// ---------------------------------------------------------------------------
// Win32TransService: Constructors and Destructor
// ---------------------------------------------------------------------------
Win32TransService::Win32TransService(MemoryManager* manager) :
fCPMap(NULL)
, fManager(manager)
{
// Figure out if we are on XP or later and save that flag for later use.
// We need this because of certain code page conversion calls.
OSVERSIONINFO OSVer;
OSVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
::GetVersionEx(&OSVer);
if ((OSVer.dwPlatformId == VER_PLATFORM_WIN32_NT) &&
((OSVer.dwMajorVersion == 5) && (OSVer.dwMinorVersion > 0)))
{
onXPOrLater = true;
}
fCPMap = new RefHashTableOf<CPMapEntry>(109);
//
// Open up the registry key that contains the info we want. Note that,
// if this key does not exist, then we just return. It will just mean
// that we don't have any support except for intrinsic encodings supported
// by the parser itself (and the LCP support of course.
//
HKEY charsetKey;
if (::RegOpenKeyExA
(
HKEY_CLASSES_ROOT
, "MIME\\Database\\Charset"
, 0
, KEY_READ
, &charsetKey))
{
return;
}
//
// Read in the registry keys that hold the code page ids. Skip for now
// those entries which indicate that they are aliases for some other
// encodings. We'll come back and do a second round for those and look
// up the original name and get the code page id.
//
// Note that we have to use A versions here so that this will run on
// 98, and transcode the strings to Unicode.
//
const unsigned int nameBufSz = 1024;
char nameBuf[nameBufSz + 1];
unsigned int subIndex;
unsigned long theSize;
for (subIndex = 0;;++subIndex)
{
// Get the name of the next key
theSize = nameBufSz;
if (::RegEnumKeyExA
(
charsetKey
, subIndex
, nameBuf
, &theSize
, 0, 0, 0, 0) == ERROR_NO_MORE_ITEMS)
{
break;
}
// Open this subkey
HKEY encodingKey;
if (::RegOpenKeyExA
(
charsetKey
, nameBuf
, 0
, KEY_READ
, &encodingKey))
{
continue;
}
//
// Lts see if its an alias. If so, then ignore it in this first
// loop. Else, we'll add a new entry for this one.
//
if (!isAlias(encodingKey))
{
//
// Lets get the two values out of this key that we are
// interested in. There should be a code page entry and an
// IE entry.
//
// The Codepage entry is the default code page for a computer using that charset
// while the InternetEncoding holds the code page that represents that charset
//
unsigned long theType;
unsigned int CPId;
unsigned int IEId;
theSize = sizeof(unsigned int);
if (::RegQueryValueExA
(
encodingKey
, "Codepage"
, 0
, &theType
, (unsigned char*)&CPId
, &theSize) != ERROR_SUCCESS)
{
::RegCloseKey(encodingKey);
continue;
}
//
// If this is not a valid Id, and it might not be because its
// not loaded on this system, then don't take it.
//
if (::IsValidCodePage(CPId))
{
theSize = sizeof(unsigned int);
if (::RegQueryValueExA
(
encodingKey
, "InternetEncoding"
, 0
, &theType
, (unsigned char*)&IEId
, &theSize) != ERROR_SUCCESS)
{
::RegCloseKey(encodingKey);
continue;
}
CPMapEntry* newEntry = new (fManager) CPMapEntry(nameBuf, IEId, fManager);
fCPMap->put((void*)newEntry->getEncodingName(), newEntry);
}
}
// And close the subkey handle
::RegCloseKey(encodingKey);
}
//
// Now loop one more time and this time we do just the aliases. For
// each one we find, we look up that name in the map we've already
// built and add a new entry with this new name and the same id
// values we stored for the original.
//
char aliasBuf[nameBufSz + 1];
for (subIndex = 0;;++subIndex)
{
// Get the name of the next key
theSize = nameBufSz;
if (::RegEnumKeyExA
(
charsetKey
, subIndex
, nameBuf
, &theSize
, 0, 0, 0, 0) == ERROR_NO_MORE_ITEMS)
{
break;
}
// Open this subkey
HKEY encodingKey;
if (::RegOpenKeyExA
(
charsetKey
, nameBuf
, 0
, KEY_READ
, &encodingKey))
{
continue;
}
//
// If its an alias, look up the name in the map. If we find it,
// then construct a new one with the new name and the aliased
// ids.
//
if (isAlias(encodingKey, aliasBuf, nameBufSz))
{
int targetLen = ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, aliasBuf, -1, NULL, 0);
if(targetLen!=0)
{
XMLCh* uniAlias = (XMLCh*) fManager->allocate
(
(targetLen + 1) * sizeof(XMLCh)
);//new XMLCh[targetLen + 1];
::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, aliasBuf, -1, (LPWSTR)uniAlias, targetLen);
uniAlias[targetLen] = 0;
_wcsupr(uniAlias);
// Look up the alias name
CPMapEntry* aliasedEntry = fCPMap->get(uniAlias);
if (aliasedEntry)
{
int targetLen = ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, nameBuf, -1, NULL, 0);
if(targetLen!=0)
{
XMLCh* uniName = (XMLCh*) fManager->allocate
(
(targetLen + 1) * sizeof(XMLCh)
);//new XMLCh[targetLen + 1];
::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, nameBuf, -1, (LPWSTR)uniName, targetLen);
uniName[targetLen] = 0;
_wcsupr(uniName);
//
// If the name is actually different, then take it.
// Otherwise, don't take it. They map aliases that are
// just different case.
//
if (!XMLString::equals(uniName, aliasedEntry->getEncodingName()))
{
CPMapEntry* newEntry = new (fManager) CPMapEntry(uniName, aliasedEntry->getIEEncoding(), fManager);
fCPMap->put((void*)newEntry->getEncodingName(), newEntry);
}
fManager->deallocate(uniName);//delete [] uniName;
}
}
fManager->deallocate(uniAlias);//delete [] uniAlias;
}
}
// And close the subkey handle
::RegCloseKey(encodingKey);
}
// And close the main key handle
::RegCloseKey(charsetKey);
}
void recurse_dir(MediaScan *s, const char *path, int recurse_count) {
char *dir, *p;
char tmp_full_path[MAX_PATH_STR_LEN];
DIR *dirp;
struct dirent *dp;
struct dirq *subdirq; // list of subdirs of the current directory
struct dirq_entry *parent_entry = NULL; // entry for current dir in s->_dirq
char redirect_dir[MAX_PATH_STR_LEN];
if (recurse_count > RECURSE_LIMIT) {
LOG_ERROR("Hit recurse limit of %d scanning path %s\n", RECURSE_LIMIT, path);
return;
}
if (path[0] != '/') { // XXX Win32
// Get full path
char *buf = (char *)malloc((size_t)MAX_PATH_STR_LEN);
if (buf == NULL) {
FATAL("Out of memory for directory scan\n");
return;
}
dir = getcwd(buf, (size_t)MAX_PATH_STR_LEN);
strcat(dir, "/");
strcat(dir, path);
}
else {
#ifdef USING_TCMALLOC
// strdup will cause tcmalloc to crash on free
dir = (char *)malloc((size_t)MAX_PATH_STR_LEN);
strcpy(dir, path);
#else
dir = strdup(path);
#endif
}
// Strip trailing slash if any
p = &dir[0];
while (*p != 0) {
if (p[1] == 0 && *p == '/')
*p = 0;
p++;
}
LOG_INFO("Recursed into %s\n", dir);
#if defined(__APPLE__)
if (isAlias(dir)) {
if (CheckMacAlias(dir, redirect_dir)) {
LOG_INFO("Resolving Alias %s to %s\n", dir, redirect_dir);
strcpy(dir, redirect_dir);
}
else {
LOG_ERROR("Failure to follow symlink or alias, skipping directory\n");
goto out;
}
}
#elif defined(__linux__)
if (isAlias(dir)) {
FollowLink(dir, redirect_dir);
LOG_INFO("Resolving symlink %s to %s\n", dir, redirect_dir);
strcpy(dir, redirect_dir);
}
#endif
if ((dirp = opendir(dir)) == NULL) {
LOG_ERROR("Unable to open directory %s: %s\n", dir, strerror(errno));
goto out;
}
subdirq = malloc(sizeof(struct dirq));
SIMPLEQ_INIT(subdirq);
while ((dp = readdir(dirp)) != NULL) {
char *name = dp->d_name;
// skip all dot files
if (name[0] != '.') {
// Check if scan should be aborted
if (unlikely(s->_want_abort))
break;
// XXX some platforms may be missing d_type/DT_DIR
if (dp->d_type == DT_DIR) {
// Add to list of subdirectories we need to recurse into
struct dirq_entry *subdir_entry = malloc(sizeof(struct dirq_entry));
// Construct full path
//*tmp_full_path = 0;
strcpy(tmp_full_path, dir);
strcat(tmp_full_path, "/");
strcat(tmp_full_path, name);
if (_should_scan_dir(s, tmp_full_path)) {
subdir_entry->dir = strdup(tmp_full_path);
SIMPLEQ_INSERT_TAIL(subdirq, subdir_entry, entries);
LOG_INFO(" subdir: %s\n", tmp_full_path);
}
else {
LOG_INFO(" skipping subdir: %s\n", tmp_full_path);
}
}
else {
enum media_type type = _should_scan(s, name);
LOG_INFO("name %s = type %d\n", name, type);
if (type) {
struct fileq_entry *entry;
// Check if this file is a shortcut and if so resolve it
#if defined(__APPLE__)
if (isAlias(name)) {
char full_name[MAX_PATH_STR_LEN];
LOG_INFO("Mac Alias detected\n");
strcpy(full_name, dir);
strcat(full_name, "\\");
strcat(full_name, name);
parse_lnk(full_name, redirect_dir, MAX_PATH_STR_LEN);
if (PathIsDirectory(redirect_dir)) {
struct dirq_entry *subdir_entry = malloc(sizeof(struct dirq_entry));
subdir_entry->dir = strdup(redirect_dir);
SIMPLEQ_INSERT_TAIL(subdirq, subdir_entry, entries);
LOG_INFO(" subdir: %s\n", tmp_full_path);
type = 0;
}
}
#elif defined(__linux__)
if (isAlias(name)) {
char full_name[MAX_PATH_STR_LEN];
printf("Linux Alias detected\n");
strcpy(full_name, dir);
strcat(full_name, "\\");
strcat(full_name, name);
FollowLink(full_name, redirect_dir);
if (PathIsDirectory(redirect_dir)) {
struct dirq_entry *subdir_entry = malloc(sizeof(struct dirq_entry));
subdir_entry->dir = strdup(redirect_dir);
SIMPLEQ_INSERT_TAIL(subdirq, subdir_entry, entries);
LOG_INFO(" subdir: %s\n", tmp_full_path);
type = 0;
}
}
#endif
if (parent_entry == NULL) {
// Add parent directory to list of dirs with files
parent_entry = malloc(sizeof(struct dirq_entry));
parent_entry->dir = strdup(dir);
parent_entry->files = malloc(sizeof(struct fileq));
SIMPLEQ_INIT(parent_entry->files);
SIMPLEQ_INSERT_TAIL((struct dirq *)s->_dirq, parent_entry, entries);
}
// Add scannable file to this directory list
entry = malloc(sizeof(struct fileq_entry));
entry->file = strdup(name);
entry->type = type;
SIMPLEQ_INSERT_TAIL(parent_entry->files, entry, entries);
s->progress->total++;
LOG_INFO(" [%5d] file: %s\n", s->progress->total, entry->file);
}
}
}
}
closedir(dirp);
// Send progress update
if (s->on_progress && !s->_want_abort)
if (progress_update(s->progress, dir))
send_progress(s);
// process subdirs
while (!SIMPLEQ_EMPTY(subdirq)) {
struct dirq_entry *subdir_entry = SIMPLEQ_FIRST(subdirq);
SIMPLEQ_REMOVE_HEAD(subdirq, entries);
if (!s->_want_abort)
recurse_dir(s, subdir_entry->dir, recurse_count);
free(subdir_entry);
}
free(subdirq);
out:
free(dir);
}
// ---------------------------------------------------------------------------
// CygwinTransService: Constructors and Destructor
// ---------------------------------------------------------------------------
CygwinTransService::CygwinTransService()
{
fCPMap = new RefHashTableOf<CPMapEntry>(109);
//
// Open up the registry key that contains the info we want. Note that,
// if this key does not exist, then we just return. It will just mean
// that we don't have any support except for intrinsic encodings supported
// by the parser itself (and the LCP support of course.
//
HKEY charsetKey;
if (::RegOpenKeyExA
(
HKEY_CLASSES_ROOT
, "MIME\\Database\\Charset"
, 0
, KEY_READ
, &charsetKey))
{
return;
}
//
// Read in the registry keys that hold the code page ids. Skip for now
// those entries which indicate that they are aliases for some other
// encodings. We'll come back and do a second round for those and look
// up the original name and get the code page id.
//
// Note that we have to use A versions here so that this will run on
// 98, and transcode the strings to Unicode.
//
const unsigned int nameBufSz = 1024;
char nameBuf[nameBufSz + 1];
unsigned int subIndex = 0;
unsigned long theSize;
while (true)
{
// Get the name of the next key
theSize = nameBufSz;
if (::RegEnumKeyExA
(
charsetKey
, subIndex
, nameBuf
, &theSize
, 0, 0, 0, 0) == ERROR_NO_MORE_ITEMS)
{
break;
}
// Open this subkey
HKEY encodingKey;
if (::RegOpenKeyExA
(
charsetKey
, nameBuf
, 0
, KEY_READ
, &encodingKey))
{
XMLPlatformUtils::panic(PanicHandler::Panic_NoTransService);
}
//
// Lts see if its an alias. If so, then ignore it in this first
// loop. Else, we'll add a new entry for this one.
//
if (!isAlias(encodingKey))
{
//
// Lets get the two values out of this key that we are
// interested in. There should be a code page entry and an
// IE entry.
//
unsigned long theType;
unsigned int CPId;
unsigned int IEId;
theSize = sizeof(unsigned int);
if (::RegQueryValueExA
(
encodingKey
, "Codepage"
, 0
, &theType
, (unsigned char*)&CPId
, &theSize) != ERROR_SUCCESS)
{
XMLPlatformUtils::panic(PanicHandler::Panic_NoTransService);
}
//
// If this is not a valid Id, and it might not be because its
// not loaded on this system, then don't take it.
//
if (::IsValidCodePage(CPId))
{
theSize = sizeof(unsigned int);
if (::RegQueryValueExA
(
encodingKey
, "InternetEncoding"
, 0
, &theType
, (unsigned char*)&IEId
, &theSize) != ERROR_SUCCESS)
{
XMLPlatformUtils::panic(PanicHandler::Panic_NoTransService);
}
CPMapEntry* newEntry = new CPMapEntry(nameBuf, CPId, IEId);
fCPMap->put((void*)newEntry->getEncodingName(), newEntry);
}
}
// And now close the subkey handle and bump the subkey index
::RegCloseKey(encodingKey);
subIndex++;
}
//
// Now loop one more time and this time we do just the aliases. For
// each one we find, we look up that name in the map we've already
// built and add a new entry with this new name and the same id
// values we stored for the original.
//
subIndex = 0;
char aliasBuf[nameBufSz + 1];
while (true)
{
// Get the name of the next key
theSize = nameBufSz;
if (::RegEnumKeyExA
(
charsetKey
, subIndex
, nameBuf
, &theSize
, 0, 0, 0, 0) == ERROR_NO_MORE_ITEMS)
{
break;
}
// Open this subkey
HKEY encodingKey;
if (::RegOpenKeyExA
(
charsetKey
, nameBuf
, 0
, KEY_READ
, &encodingKey))
{
XMLPlatformUtils::panic(PanicHandler::Panic_NoTransService);
}
//
// If its an alias, look up the name in the map. If we find it,
// then construct a new one with the new name and the aliased
// ids.
//
if (isAlias(encodingKey, aliasBuf, nameBufSz))
{
const unsigned int srcLen = strlen(aliasBuf);
const unsigned int targetLen = ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, aliasBuf, srcLen, NULL, 0);
XMLCh* uniAlias = (XMLCh*) XMLPlatformUtils::fgMemoryManager->allocate
(
(targetLen + 1) * sizeof(XMLCh)
);//new XMLCh[targetLen + 1];
::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, aliasBuf, srcLen, (LPWSTR)uniAlias, targetLen);
uniAlias[targetLen] = 0;
::LCMapStringW( gLocaleId, LCMAP_UPPERCASE, (LPCWSTR)uniAlias, targetLen, (LPWSTR)uniAlias, targetLen);
// Look up the alias name
CPMapEntry* aliasedEntry = fCPMap->get(uniAlias);
if (aliasedEntry)
{
//
// If the name is actually different, then take it.
// Otherwise, don't take it. They map aliases that are
// just different case.
//
if (auxCompareString(uniAlias, aliasedEntry->getEncodingName(), -1L, false))
{
CPMapEntry* newEntry = new CPMapEntry(uniAlias, aliasedEntry->getWinCP(), aliasedEntry->getIEEncoding());
fCPMap->put((void*)newEntry->getEncodingName(), newEntry);
}
}
XMLPlatformUtils::fgMemoryManager->deallocate(uniAlias);//delete [] uniAlias;
}
// And now close the subkey handle and bump the subkey index
::RegCloseKey(encodingKey);
subIndex++;
}
// And close the main key handle
::RegCloseKey(charsetKey);
}
/*
* getCommand
*
* arguments:
* char *cmdLine: pointer to the command line string
*
* returns: commandT*: pointer to the commandT struct generated by
* parsing the cmdLine string
*
* This parses the command line string, and returns a commandT struct,
* as defined in runtime.h. You must free the memory used by commandT
* using the freeCommand function after you are finished.
*
* This function tokenizes the input, preserving quoted strings. It
* supports escaping quotes and the escape character, '\'.
*/
commandT*
getCommand(char* cmdLine)
{
//printf("here");
char* restOfLine = (char*)malloc(sizeof(char)*BUFSIZE);
//char* restCmdLine = (char*)malloc(sizeof(char)*BUFSIZE);
commandT* cmd = malloc(sizeof(commandT) + sizeof(char*) * MAXARGS);
cmd->argv[0] = 0;
cmd->name = 0;
cmd->argc = 0;
cmd->piped = FALSE;
cmd->next=NULL;
int i, inArg = 0;
char quote = 0;
char escape = 0;
// Set up the initial empty argument
char* tmp = malloc(sizeof(char*) * BUFSIZE);
int tmpLen = 0;
tmp[0] = 0;
//For aliasing:
//aliasL* alias;
char* keptString = 0;
//printf("parsing:%s\n", cmdLine);
for (i = 0; cmdLine[i] != 0; i++)
{
//printf("\tindex %d, char %c\n", i, cmdLine[i]);
// Check for whitespace
if (cmdLine[i] == ' ')
{
if (inArg == 0)
continue;
if (quote == 0)
{
// End of an argument
cmd->argv[cmd->argc] = malloc(sizeof(char) * (tmpLen + 1));
strcpy(cmd->argv[cmd->argc], tmp);
//Get rest of command to add on to expanded command of alias
if(cmd->argc==0){
if(isAlias(cmd->argv[0])){
alias=getAlias(cmd->argv[0]);
if(alias->found == FALSE){
keptString = splitCmd(cmdLine, i, restOfLine);
//printf("The rest of the string is: %s\n", keptString);
}
}
}
inArg = 0;
tmp[0] = 0;
tmpLen = 0;
cmd->argc++;
cmd->argv[cmd->argc] = 0;
continue;
}
}
// If we get here, we're in text or a quoted string
inArg = 1;
// Start or end quoting.
if (cmdLine[i] == '\'' || cmdLine[i] == '"')
{
if (escape != 0 && quote != 0 && cmdLine[i] == quote)
{
// Escaped quote. Add it to the argument.
tmp[tmpLen++] = cmdLine[i];
tmp[tmpLen] = 0;
escape = 0;
continue;
}
if (quote == 0)
{
//printf("\t\tstarting quote around %c\n", cmdLine[i]);
quote = cmdLine[i];
continue;
}
else
{
if (cmdLine[i] == quote)
{
//printf("\t\tfound end quote %c\n", quote);
quote = 0;
continue;
}
}
}
// Handle escape character repeat
if (cmdLine[i] == '\\' && escape == '\\')
{
escape = 0;
tmp[tmpLen++] = '\\';
tmp[tmpLen] = 0;
continue;
}
// Handle single escape character followed by a non-backslash or quote character
if (escape == '\\')
{
if (quote != 0)
{
tmp[tmpLen++] = '\\';
tmp[tmpLen] = 0;
}
escape = 0;
}
// Set the escape flag if we have a new escape character sequence.
if (cmdLine[i] == '\\')
{
escape = '\\';
continue;
}
if(cmdLine[i] =='|'){
cmd->piped =TRUE;
i+=2;
char* nextCmd = splitCmd(cmdLine, i, restOfLine);
pipeSeq(nextCmd, cmd);
//printf("%s\n",nextCmd);
//cmd->piped =TRUE;
//printf("Piped is %b\n", cmd->piped);
break;
}
tmp[tmpLen++] = cmdLine[i];
tmp[tmpLen] = 0;
}
// End the final argument, if any.
if (tmpLen > 0)
{
//printf("\t\tend of argument %d, got:%s\n", cmd.argc, tmp);
cmd->argv[cmd->argc] = malloc(sizeof(char) * (tmpLen + 1));
strcpy(cmd->argv[cmd->argc], tmp);
//cmd->next=0;
inArg = 0;
tmp[0] = 0;
tmpLen = 0;
cmd->argc++;
cmd->argv[cmd->argc] = 0;
//If input is an alias call expanded command
if(isAlias(cmd->argv[0])){
alias=getAlias(cmd->argv[0]);
if(alias->found == FALSE){
char* concat = concatCmd(alias->origName, keptString);
alias->found=TRUE;
cmd = getCommand(concat);
alias->found=FALSE;
//free(concat);
}
// alias->found=FALSE;
}
}
free(tmp);
//TODO Maybe we Need the cmd Line?
free(restOfLine);
//free(restCmdLine);
cmd->name = cmd->argv[0];
return cmd;
} /* getCommand */
