void KURLCompletion::adjustMatch(QString &match) const
{
if(match.at(match.length() - 1) != '/')
{
QString copy;
if(match.startsWith(QString("file:")))
copy = KURL(match).path();
else
copy = match;
expandTilde(copy);
expandEnv(copy);
if(QDir::isRelativePath(copy))
copy.prepend(d->cwd + '/');
// kdDebug() << "postProcess: stating " << copy << endl;
KDE_struct_stat sbuff;
QCString file = QFile::encodeName(copy);
if(KDE_stat((const char *)file, &sbuff) == 0)
{
if(S_ISDIR(sbuff.st_mode))
match.append('/');
}
else
{
kdDebug() << "Could not stat file " << copy << endl;
}
}
}
QString KStandardDirs::saveLocation(const char *type,
const QString& suffix,
bool create) const
{
checkConfig();
QString *pPath = savelocations.find(type);
if (!pPath)
{
QStringList *dirs = relatives.find(type);
if (!dirs && (
(strcmp(type, "socket") == 0) ||
(strcmp(type, "tmp") == 0) ||
(strcmp(type, "cache") == 0) ))
{
(void) resourceDirs(type); // Generate socket|tmp|cache resource.
dirs = relatives.find(type); // Search again.
}
if (dirs)
{
// Check for existence of typed directory + suffix
if (strncmp(type, "xdgdata-", 8) == 0)
pPath = new QString(realPath(localxdgdatadir() + dirs->last()));
else if (strncmp(type, "xdgconf-", 8) == 0)
pPath = new QString(realPath(localxdgconfdir() + dirs->last()));
else
pPath = new QString(realPath(localkdedir() + dirs->last()));
}
else {
dirs = absolutes.find(type);
if (!dirs)
qFatal("KStandardDirs: The resource type %s is not registered", type);
pPath = new QString(realPath(dirs->last()));
}
savelocations.insert(type, pPath);
}
QString fullPath = *pPath + (pPath->endsWith("/") ? "" : "/") + suffix;
KDE_struct_stat st;
if (KDE_stat(QFile::encodeName(fullPath), &st) != 0 || !(S_ISDIR(st.st_mode))) {
if(!create) {
#ifndef NDEBUG
kdDebug() << QString("save location %1 doesn't exist").arg(fullPath) << endl;
#endif
return fullPath;
}
if(!makeDir(fullPath, 0700)) {
return fullPath;
}
dircache.remove(type);
}
if (!fullPath.endsWith("/"))
fullPath += "/";
return fullPath;
}
static Q_UINT32 updateHash(const QString &file, Q_UINT32 hash)
{
QCString cFile = QFile::encodeName(file);
KDE_struct_stat buff;
if((access(cFile, R_OK) == 0) && (KDE_stat(cFile, &buff) == 0) && (S_ISREG(buff.st_mode)))
{
hash = hash + (Q_UINT32)buff.st_ctime;
}
return hash;
}
bool KStandardDirs::exists(const QString &fullPath)
{
KDE_struct_stat buff;
if (access(QFile::encodeName(fullPath), R_OK) == 0 && KDE_stat( QFile::encodeName(fullPath), &buff ) == 0)
if (fullPath.at(fullPath.length() - 1) != '/') {
if (S_ISREG( buff.st_mode ))
return true;
} else
if (S_ISDIR( buff.st_mode ))
return true;
return false;
}
bool TrashProtocol::createUDSEntry(const QString &physicalPath, const QString &fileName, const QString &url, KIO::UDSEntry &entry,
const TrashedFileInfo &info)
{
QCString physicalPath_c = QFile::encodeName(physicalPath);
KDE_struct_stat buff;
if(KDE_lstat(physicalPath_c, &buff) == -1)
{
kdWarning() << "couldn't stat " << physicalPath << endl;
return false;
}
if(S_ISLNK(buff.st_mode))
{
char buffer2[1000];
int n = readlink(physicalPath_c, buffer2, 1000);
if(n != -1)
{
buffer2[n] = 0;
}
addAtom(entry, KIO::UDS_LINK_DEST, 0, QFile::decodeName(buffer2));
// Follow symlink
// That makes sense in kio_file, but not in the trash, especially for the size
// #136876
#if 0
if ( KDE_stat( physicalPath_c, &buff ) == -1 ) {
// It is a link pointing to nowhere
buff.st_mode = S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
buff.st_mtime = 0;
buff.st_atime = 0;
buff.st_size = 0;
}
#endif
}
mode_t type = buff.st_mode & S_IFMT; // extract file type
mode_t access = buff.st_mode & 07777; // extract permissions
access &= 07555; // make it readonly, since it's in the trashcan
addAtom(entry, KIO::UDS_NAME, 0, fileName);
addAtom(entry, KIO::UDS_FILE_TYPE, type);
if(!url.isEmpty())
addAtom(entry, KIO::UDS_URL, 0, url);
KMimeType::Ptr mt = KMimeType::findByPath(physicalPath, buff.st_mode);
addAtom(entry, KIO::UDS_MIME_TYPE, 0, mt->name());
addAtom(entry, KIO::UDS_ACCESS, access);
addAtom(entry, KIO::UDS_SIZE, buff.st_size);
addAtom(entry, KIO::UDS_USER, 0, m_userName); // assumption
addAtom(entry, KIO::UDS_GROUP, 0, m_groupName); // assumption
addAtom(entry, KIO::UDS_MODIFICATION_TIME, buff.st_mtime);
addAtom(entry, KIO::UDS_ACCESS_TIME, buff.st_atime); // ## or use it for deletion time?
addAtom(entry, KIO::UDS_EXTRA, 0, info.origPath);
addAtom(entry, KIO::UDS_EXTRA, 0, info.deletionDate.toString(Qt::ISODate));
return true;
}
bool TrashProtocol::createUDSEntry( const QString& physicalPath, const QString& displayFileName, const QString& internalFileName, KIO::UDSEntry& entry, const TrashedFileInfo& info )
{
QByteArray physicalPath_c = QFile::encodeName( physicalPath );
KDE_struct_stat buff;
if ( KDE_lstat( physicalPath_c, &buff ) == -1 ) {
kWarning() << "couldn't stat " << physicalPath ;
return false;
}
if (S_ISLNK(buff.st_mode)) {
char buffer2[ 1000 ];
int n = readlink( physicalPath_c, buffer2, 999 );
if ( n != -1 ) {
buffer2[ n ] = 0;
}
entry.insert( KIO::UDSEntry::UDS_LINK_DEST, QFile::decodeName( buffer2 ) );
// Follow symlink
// That makes sense in kio_file, but not in the trash, especially for the size
// #136876
#if 0
if ( KDE_stat( physicalPath_c, &buff ) == -1 ) {
// It is a link pointing to nowhere
buff.st_mode = S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
buff.st_mtime = 0;
buff.st_atime = 0;
buff.st_size = 0;
}
#endif
}
mode_t type = buff.st_mode & S_IFMT; // extract file type
mode_t access = buff.st_mode & 07777; // extract permissions
access &= 07555; // make it readonly, since it's in the trashcan
Q_ASSERT(!internalFileName.isEmpty());
entry.insert( KIO::UDSEntry::UDS_NAME, internalFileName ); // internal filename, like "0-foo"
entry.insert( KIO::UDSEntry::UDS_DISPLAY_NAME, displayFileName ); // user-visible filename, like "foo"
entry.insert( KIO::UDSEntry::UDS_FILE_TYPE, type );
//if ( !url.isEmpty() )
// entry.insert( KIO::UDSEntry::UDS_URL, url );
KMimeType::Ptr mt = KMimeType::findByPath( physicalPath, buff.st_mode );
if ( mt )
entry.insert( KIO::UDSEntry::UDS_MIME_TYPE, mt->name() );
entry.insert( KIO::UDSEntry::UDS_ACCESS, access );
entry.insert( KIO::UDSEntry::UDS_SIZE, buff.st_size );
entry.insert( KIO::UDSEntry::UDS_USER, m_userName ); // assumption
entry.insert( KIO::UDSEntry::UDS_GROUP, m_groupName ); // assumption
entry.insert( KIO::UDSEntry::UDS_MODIFICATION_TIME, buff.st_mtime );
entry.insert( KIO::UDSEntry::UDS_ACCESS_TIME, buff.st_atime ); // ## or use it for deletion time?
entry.insert( KIO::UDSEntry::UDS_EXTRA, info.origPath );
entry.insert( KIO::UDSEntry::UDS_EXTRA + 1, info.deletionDate.toString( Qt::ISODate ) );
return true;
}
time_t KFileItem::time( unsigned int which, bool &hasTime ) const
{
hasTime = true;
unsigned int mappedWhich = 0;
switch( which ) {
case KIO::UDS_MODIFICATION_TIME:
mappedWhich = Modification;
break;
case KIO::UDS_ACCESS_TIME:
mappedWhich = Access;
break;
case KIO::UDS_CREATION_TIME:
mappedWhich = Creation;
break;
}
if ( m_time[mappedWhich] != (time_t) -1 )
return m_time[mappedWhich];
// Extract it from the KIO::UDSEntry
KIO::UDSEntry::ConstIterator it = m_entry.begin();
for( ; it != m_entry.end(); ++it )
if ( (*it).m_uds == which ) {
m_time[mappedWhich] = static_cast<time_t>((*it).m_long);
return m_time[mappedWhich];
}
// If not in the KIO::UDSEntry, or if UDSEntry empty, use stat() [if local URL]
if ( m_bIsLocalURL )
{
KDE_struct_stat buf;
if ( KDE_stat( QFile::encodeName(m_url.path(-1)), &buf ) == 0 )
{
if(which == KIO::UDS_CREATION_TIME) {
// We can't determine creation time for local files
hasTime = false;
m_time[mappedWhich] = static_cast<time_t>(0);
return m_time[mappedWhich];
}
m_time[mappedWhich] = (which == KIO::UDS_MODIFICATION_TIME) ?
buf.st_mtime :
/* which == KIO::UDS_ACCESS_TIME)*/
buf.st_atime;
return m_time[mappedWhich];
}
}
hasTime = false;
return static_cast<time_t>(0);
}
bool KDEsuClient::isServerSGID()
{
if(d->daemon.isEmpty())
d->daemon = findDaemon();
if(d->daemon.isEmpty())
return false;
KDE_struct_stat sbuf;
if(KDE_stat(QFile::encodeName(d->daemon), &sbuf) < 0)
{
kdWarning(900) << k_lineinfo << "stat(): " << perror << "\n";
return false;
}
return (sbuf.st_mode & S_ISGID);
}
TDEIO::filesize_t
ArkUtils::getSizes(TQStringList *list)
{
TDEIO::filesize_t sum = 0;
TQString str;
KDE_struct_stat st;
for ( TQStringList::Iterator it = list->begin(); it != list->end(); ++it)
{
str = *it;
str = str.right(str.length()-5);
if (KDE_stat(TQFile::encodeName(str), &st ) < 0)
continue;
sum += st.st_size;
}
return sum;
}
bool KStandardDirs::makeDir(const QString &dir, int mode)
{
// we want an absolute path
if(QDir::isRelativePath(dir))
return false;
QString target = dir;
uint len = target.length();
// append trailing slash if missing
if(dir.at(len - 1) != '/')
target += '/';
QString base("");
uint i = 1;
while(i < len)
{
KDE_struct_stat st;
int pos = target.find('/', i);
base += target.mid(i - 1, pos - i + 1);
QCString baseEncoded = QFile::encodeName(base);
// bail out if we encountered a problem
if(KDE_stat(baseEncoded, &st) != 0)
{
// Directory does not exist....
// Or maybe a dangling symlink ?
if(KDE_lstat(baseEncoded, &st) == 0)
(void)unlink(baseEncoded); // try removing
if(KDE_mkdir(baseEncoded, (mode_t)mode) != 0)
{
baseEncoded.prepend("trying to create local folder ");
perror(baseEncoded.data());
return false; // Couldn't create it :-(
}
}
i = pos + 1;
}
return true;
}
bool MultiSegmentCopyJob::checkLocalFile()
{
QString dest_orig = m_dest.path();
QString dest_part( dest_orig );
dest_part += QLatin1String(".part");
QByteArray _dest_part( QFile::encodeName(dest_part));
KDE_struct_stat buff_part;
bool bPartExists = (KDE_stat( _dest_part.data(), &buff_part ) != -1);
if(!bPartExists)
{
QByteArray _dest = QFile::encodeName(dest_part);
int fd = -1;
mode_t initialMode;
if (m_permissions != -1)
initialMode = m_permissions | S_IWUSR | S_IRUSR;
else
initialMode = 0666;
fd = KDE_open(_dest.data(), O_CREAT | O_TRUNC | O_WRONLY, initialMode);
if ( fd < 0 )
{
kDebug(5001) << " error";
/* if ( errno == EACCES )
error( ERR_WRITE_ACCESS_DENIED, dest_part );
else
error( ERR_CANNOT_OPEN_FOR_WRITING, dest_part );*/
return false;
}
else
{
close(fd);
}
}
m_dest_part = m_dest;
m_dest_part.setPath(dest_part);
kDebug(5001) << "success";
return true;
}
KIO::filesize_t KFileItem::size(bool &exists) const
{
exists = true;
if ( m_size != (KIO::filesize_t) -1 )
return m_size;
// Extract it from the KIO::UDSEntry
KIO::UDSEntry::ConstIterator it = m_entry.begin();
for( ; it != m_entry.end(); ++it )
if ( (*it).m_uds == KIO::UDS_SIZE ) {
m_size = (*it).m_long;
return m_size;
}
// If not in the KIO::UDSEntry, or if UDSEntry empty, use stat() [if local URL]
if ( m_bIsLocalURL )
{
KDE_struct_stat buf;
if ( KDE_stat( QFile::encodeName(m_url.path( -1 )), &buf ) == 0 )
return buf.st_size;
}
exists = false;
return 0L;
}
bool PakProtocol::checkNewFile(const KURL &url, QString &path, KIO::Error &errorNum) {
QString fullPath = url.path();
kdDebug(PAK_DEBUG_ID) << "Entering checkNewFile() - " << fullPath << endl;
// Are we already looking at that file ?
if ( _pakFile && _pakFileName == fullPath.left(_pakFileName.length()) )
{
// Has it changed ?
KDE_struct_stat statbuf;
if ( KDE_stat( QFile::encodeName( _pakFileName ), &statbuf ) == 0 )
{
if ( _pakFileTime == statbuf.st_mtime )
{
// It hasn't changed, so just return
path = fullPath.mid( _pakFileName.length() );
kdDebug(PAK_DEBUG_ID) << "checkNewFile() returning " << path << endl;
return true;
}
}
}
kdDebug(PAK_DEBUG_ID) << "Need to open a new file or check if dir" << endl;
// Close previous file
if ( _pakFile )
{
_pakFile->close();
delete _pakFile;
_pakFile = NULL;
}
kdDebug(PAK_DEBUG_ID) << "Going to find full path" << endl;
// Find where the tar file is in the full path
int pos = 0;
QString archiveFile;
path = QString::null;
int len = fullPath.length();
if ( len != 0 && fullPath[ len - 1 ] != '/' )
fullPath += '/';
kdDebug(PAK_DEBUG_ID) << "the full path is " << fullPath << endl;
KDE_struct_stat statbuf;
statbuf.st_mode = 0; // be sure to clear the directory bit
while ( (pos=fullPath.find( '/', pos+1 )) != -1 )
{
QString tryPath = fullPath.left( pos );
kdDebug(PAK_DEBUG_ID) << fullPath << " trying " << tryPath << endl;
if ( KDE_stat( QFile::encodeName(tryPath), &statbuf ) == -1 )
{
// We are not in the file system anymore, either we have already enough data or we will never get any useful data anymore
break;
}
if ( !S_ISDIR(statbuf.st_mode) )
{
archiveFile = tryPath;
_pakFileTime = statbuf.st_mtime;
path = fullPath.mid( pos + 1 );
kdDebug(PAK_DEBUG_ID) << "fullPath=" << fullPath << " path=" << path << endl;
len = path.length();
if ( len > 1 )
{
if ( path[ len - 1 ] == '/' )
path.truncate( len - 1 );
}
else
path = QString::fromLatin1("/");
kdDebug(PAK_DEBUG_ID) << "Found. archiveFile=" << archiveFile << " path=" << path << endl;
break;
}
}
if ( archiveFile.isEmpty() )
{
kdDebug(PAK_DEBUG_ID) << "checkNewFile(): not found" << endl;
if ( S_ISDIR(statbuf.st_mode) ) // Was the last stat about a directory?
{
// Too bad, it is a directory, not an archive.
kdDebug(PAK_DEBUG_ID) << "Path is a directory, not an archive." << endl;
errorNum = KIO::ERR_IS_DIRECTORY;
}
else
errorNum = KIO::ERR_DOES_NOT_EXIST;
return false;
}
if (url.protocol() == "pak") {
kdDebug(PAK_DEBUG_ID) << "Creating a KPak object on " << archiveFile << endl;
_pakFile = new KPak(archiveFile);
} else {
kdWarning(PAK_DEBUG_ID) << "Protocol " << url.protocol() << " not supported by this IOSlave" << endl;
errorNum = KIO::ERR_UNSUPPORTED_PROTOCOL;
return false;
}
if ( !_pakFile->open(IO_ReadOnly) )
{
kdDebug(PAK_DEBUG_ID) << "Opening " << archiveFile << "failed." << endl;
delete _pakFile;
_pakFile = NULL;
errorNum = KIO::ERR_CANNOT_OPEN_FOR_READING;
return false;
}
_pakFileName = archiveFile;
return true;
}
bool KPty::open()
{
Q_D(KPty);
if (d->masterFd >= 0)
return true;
d->ownMaster = true;
QByteArray ptyName;
// Find a master pty that we can open ////////////////////////////////
// Because not all the pty animals are created equal, they want to
// be opened by several different methods.
// We try, as we know them, one by one.
#ifdef HAVE_OPENPTY
char ptsn[PATH_MAX];
if (::openpty( &d->masterFd, &d->slaveFd, ptsn, 0, 0))
{
d->masterFd = -1;
d->slaveFd = -1;
kWarning(175) << "Can't open a pseudo teletype";
return false;
}
d->ttyName = ptsn;
#else
#ifdef HAVE__GETPTY // irix
char *ptsn = _getpty(&d->masterFd, O_RDWR|O_NOCTTY, S_IRUSR|S_IWUSR, 0);
if (ptsn) {
d->ttyName = ptsn;
goto grantedpt;
}
#elif defined(HAVE_PTSNAME) || defined(TIOCGPTN)
#ifdef HAVE_POSIX_OPENPT
d->masterFd = ::posix_openpt(O_RDWR|O_NOCTTY);
#elif defined(HAVE_GETPT)
d->masterFd = ::getpt();
#elif defined(PTM_DEVICE)
d->masterFd = KDE_open(PTM_DEVICE, O_RDWR|O_NOCTTY);
#else
# error No method to open a PTY master detected.
#endif
if (d->masterFd >= 0)
{
#ifdef HAVE_PTSNAME
char *ptsn = ptsname(d->masterFd);
if (ptsn) {
d->ttyName = ptsn;
#else
int ptyno;
if (!ioctl(d->masterFd, TIOCGPTN, &ptyno)) {
char buf[32];
sprintf(buf, "/dev/pts/%d", ptyno);
d->ttyName = buf;
#endif
#ifdef HAVE_GRANTPT
if (!grantpt(d->masterFd))
goto grantedpt;
#else
goto gotpty;
#endif
}
::close(d->masterFd);
d->masterFd = -1;
}
#endif // HAVE_PTSNAME || TIOCGPTN
// Linux device names, FIXME: Trouble on other systems?
for (const char* s3 = "pqrstuvwxyzabcde"; *s3; s3++)
{
for (const char* s4 = "0123456789abcdef"; *s4; s4++)
{
ptyName = QString().sprintf("/dev/pty%c%c", *s3, *s4).toAscii();
d->ttyName = QString().sprintf("/dev/tty%c%c", *s3, *s4).toAscii();
d->masterFd = KDE_open(ptyName.data(), O_RDWR);
if (d->masterFd >= 0)
{
#ifdef Q_OS_SOLARIS
/* Need to check the process group of the pty.
* If it exists, then the slave pty is in use,
* and we need to get another one.
*/
int pgrp_rtn;
if (ioctl(d->masterFd, TIOCGPGRP, &pgrp_rtn) == 0 || errno != EIO) {
::close(d->masterFd);
d->masterFd = -1;
continue;
}
#endif /* Q_OS_SOLARIS */
if (!access(d->ttyName.data(),R_OK|W_OK)) // checks availability based on permission bits
{
if (!geteuid())
{
struct group* p = getgrnam(TTY_GROUP);
if (!p)
p = getgrnam("wheel");
gid_t gid = p ? p->gr_gid : getgid ();
chown(d->ttyName.data(), getuid(), gid);
chmod(d->ttyName.data(), S_IRUSR|S_IWUSR|S_IWGRP);
}
goto gotpty;
}
::close(d->masterFd);
d->masterFd = -1;
}
}
}
kWarning(175) << "Can't open a pseudo teletype";
return false;
gotpty:
KDE_struct_stat st;
if (KDE_stat(d->ttyName.data(), &st))
return false; // this just cannot happen ... *cough* Yeah right, I just
// had it happen when pty #349 was allocated. I guess
// there was some sort of leak? I only had a few open.
if (((st.st_uid != getuid()) ||
(st.st_mode & (S_IRGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH))) &&
!d->chownpty(true))
{
kWarning(175)
<< "chownpty failed for device " << ptyName << "::" << d->ttyName
<< "\nThis means the communication can be eavesdropped." << endl;
}
grantedpt:
#ifdef HAVE_REVOKE
revoke(d->ttyName.data());
#endif
#ifdef HAVE_UNLOCKPT
unlockpt(d->masterFd);
#elif defined(TIOCSPTLCK)
int flag = 0;
ioctl(d->masterFd, TIOCSPTLCK, &flag);
#endif
d->slaveFd = KDE_open(d->ttyName.data(), O_RDWR | O_NOCTTY);
if (d->slaveFd < 0)
{
kWarning(175) << "Can't open slave pseudo teletype";
::close(d->masterFd);
d->masterFd = -1;
return false;
}
#if (defined(__svr4__) || defined(__sgi__) || defined(Q_OS_SOLARIS))
// Solaris uses STREAMS for terminal handling. It is possible
// for the pty handling modules to be left off the stream; in that
// case push them on. ioctl(fd, I_FIND, ...) is documented to return
// 1 if the module is on the stream already.
{
static const char *pt = "ptem";
static const char *ld = "ldterm";
if (ioctl(d->slaveFd, I_FIND, pt) == 0)
ioctl(d->slaveFd, I_PUSH, pt);
if (ioctl(d->slaveFd, I_FIND, ld) == 0)
ioctl(d->slaveFd, I_PUSH, ld);
}
#endif
#endif /* HAVE_OPENPTY */
fcntl(d->masterFd, F_SETFD, FD_CLOEXEC);
fcntl(d->slaveFd, F_SETFD, FD_CLOEXEC);
return true;
}
bool KPty::open(int fd)
{
#if !defined(HAVE_PTSNAME) && !defined(TIOCGPTN)
kWarning(175) << "Unsupported attempt to open pty with fd" << fd;
return false;
#else
Q_D(KPty);
if (d->masterFd >= 0) {
kWarning(175) << "Attempting to open an already open pty";
return false;
}
d->ownMaster = false;
# ifdef HAVE_PTSNAME
char *ptsn = ptsname(fd);
if (ptsn) {
d->ttyName = ptsn;
# else
int ptyno;
if (!ioctl(fd, TIOCGPTN, &ptyno)) {
char buf[32];
sprintf(buf, "/dev/pts/%d", ptyno);
d->ttyName = buf;
# endif
} else {
kWarning(175) << "Failed to determine pty slave device for fd" << fd;
return false;
}
d->masterFd = fd;
if (!openSlave()) {
d->masterFd = -1;
return false;
}
return true;
#endif
}
void KPty::closeSlave()
{
Q_D(KPty);
if (d->slaveFd < 0)
return;
::close(d->slaveFd);
d->slaveFd = -1;
}
void KFileTreeBranch::addItems( const KFileItemList& list )
{
KFileItemListIterator it( list );
kdDebug(250) << "Adding " << list.count() << " items !" << endl;
KFileItem *currItem;
KFileTreeViewItemList treeViewItList;
KFileTreeViewItem *parentItem = 0;
while ( (currItem = it.current()) != 0 )
{
parentItem = parentKFTVItem( currItem );
/* Only create a new KFileTreeViewItem if it does not yet exist */
KFileTreeViewItem *newKFTVI =
static_cast<KFileTreeViewItem *>(currItem->extraData( this ));
if( ! newKFTVI )
{
newKFTVI = createTreeViewItem( parentItem, currItem );
if (!newKFTVI)
{
// TODO: Don't fail if parentItem == 0
++it;
continue;
}
currItem->setExtraData( this, newKFTVI );
/* Cut off the file extension in case it is not a directory */
if( !m_showExtensions && !currItem->isDir() ) /* Need to cut the extension */
{
TQString name = currItem->text();
int mPoint = name.findRev( '.' );
if( mPoint > 0 )
name = name.left( mPoint );
newKFTVI->setText( 0, name );
}
}
/* Now try to find out if there are children for dirs in the treeview */
/* This stats a directory on the local file system and checks the */
/* hardlink entry in the stat-buf. This works only for local directories. */
if( dirOnlyMode() && !m_recurseChildren && currItem->isLocalFile( ) && currItem->isDir() )
{
KURL url = currItem->url();
TQString filename = url.directory( false, true ) + url.fileName();
/* do the stat trick of Carsten. The problem is, that the hardlink
* count only contains directory links. Thus, this method only seem
* to work in dir-only mode */
kdDebug(250) << "Doing stat on " << filename << endl;
KDE_struct_stat statBuf;
if( KDE_stat( TQFile::encodeName( filename ), &statBuf ) == 0 )
{
int hardLinks = statBuf.st_nlink; /* Count of dirs */
kdDebug(250) << "stat succeeded, hardlinks: " << hardLinks << endl;
// If the link count is > 2, the directory likely has subdirs. If it's < 2
// it's something weird like a mounted SMB share. In that case we don't know
// if there are subdirs, thus show it as expandable.
if( hardLinks != 2 )
{
newKFTVI->setExpandable(true);
}
else
{
newKFTVI->setExpandable(false);
}
if( hardLinks >= 2 ) // "Normal" directory with subdirs
{
kdDebug(250) << "Emitting for " << url.prettyURL() << endl;
emit( directoryChildCount( newKFTVI, hardLinks-2)); // parentItem, hardLinks-1 ));
}
}
else
{
kdDebug(250) << "stat of " << filename << " failed !" << endl;
}
}
++it;
treeViewItList.append( newKFTVI );
}
emit newTreeViewItems( this, treeViewItList );
}
/* antlarr: KDE 4.0: make the first parameter "const QString &" */
bool KConfigINIBackEnd::writeConfigFile(QString filename, bool bGlobal, bool bMerge)
{
// is the config object read-only?
if(pConfig->isReadOnly())
return true; // pretend we wrote it
KEntryMap aTempMap;
QFile *mergeFile = (bMerge ? new QFile(filename) : 0);
bool bEntriesLeft = getEntryMap(aTempMap, bGlobal, mergeFile);
delete mergeFile;
if(bFileImmutable)
return true; // pretend we wrote it
// OK now the temporary map should be full of ALL entries.
// write it out to disk.
// Check if file exists:
int fileMode = -1;
bool createNew = true;
KDE_struct_stat buf;
if(KDE_stat(QFile::encodeName(filename), &buf) == 0)
{
if(buf.st_uid == getuid())
{
// Preserve file mode if file exists and is owned by user.
fileMode = buf.st_mode & 0777;
}
else
{
// File is not owned by user:
// Don't create new file but write to existing file instead.
createNew = false;
}
}
KSaveFile *pConfigFile = 0;
FILE *pStream = 0;
if(createNew)
{
pConfigFile = new KSaveFile(filename, 0600);
if(pConfigFile->status() != 0)
{
delete pConfigFile;
return bEntriesLeft;
}
if(!bGlobal && (fileMode == -1))
fileMode = mFileMode;
if(fileMode != -1)
{
fchmod(pConfigFile->handle(), fileMode);
}
pStream = pConfigFile->fstream();
}
else
{
// Open existing file.
// We use open() to ensure that we call without O_CREAT.
int fd = KDE_open(QFile::encodeName(filename), O_WRONLY | O_TRUNC);
if(fd < 0)
{
return bEntriesLeft;
}
pStream = KDE_fdopen(fd, "w");
if(!pStream)
{
close(fd);
return bEntriesLeft;
}
}
writeEntries(pStream, aTempMap);
if(pConfigFile)
{
bool bEmptyFile = (ftell(pStream) == 0);
if(bEmptyFile && ((fileMode == -1) || (fileMode == 0600)))
{
// File is empty and doesn't have special permissions: delete it.
::unlink(QFile::encodeName(filename));
pConfigFile->abort();
}
else
{
// Normal case: Close the file
pConfigFile->close();
}
delete pConfigFile;
}
else
{
fclose(pStream);
}
return bEntriesLeft;
}
static void lookupDirectory(const QString& path, const QString &relPart,
const QRegExp ®exp,
QStringList& list,
QStringList& relList,
bool recursive, bool unique)
{
QString pattern = regexp.pattern();
if (recursive || pattern.contains('?') || pattern.contains('*'))
{
if (path.isEmpty()) //for sanity
return;
// We look for a set of files.
DIR *dp = opendir( QFile::encodeName(path));
if (!dp)
return;
#ifdef Q_WS_WIN
assert(path.at(path.length() - 1) == '/' || path.at(path.length() - 1) == '\\');
#else
assert(path.at(path.length() - 1) == '/');
#endif
struct dirent *ep;
KDE_struct_stat buff;
QString _dot(".");
QString _dotdot("..");
while( ( ep = readdir( dp ) ) != 0L )
{
QString fn( QFile::decodeName(ep->d_name));
if (fn == _dot || fn == _dotdot || fn.at(fn.length() - 1).latin1() == '~')
continue;
if (!recursive && !regexp.exactMatch(fn))
continue; // No match
QString pathfn = path + fn;
if ( KDE_stat( QFile::encodeName(pathfn), &buff ) != 0 ) {
kdDebug() << "Error stat'ing " << pathfn << " : " << perror << endl;
continue; // Couldn't stat (e.g. no read permissions)
}
if ( recursive ) {
if ( S_ISDIR( buff.st_mode )) {
lookupDirectory(pathfn + '/', relPart + fn + '/', regexp, list, relList, recursive, unique);
}
if (!regexp.exactMatch(fn))
continue; // No match
}
if ( S_ISREG( buff.st_mode))
{
if (!unique || !relList.contains(relPart + fn))
{
list.append( pathfn );
relList.append( relPart + fn );
}
}
}
closedir( dp );
}
else
{
// We look for a single file.
QString fn = pattern;
QString pathfn = path + fn;
KDE_struct_stat buff;
if ( KDE_stat( QFile::encodeName(pathfn), &buff ) != 0 )
return; // File not found
if ( S_ISREG( buff.st_mode))
{
if (!unique || !relList.contains(relPart + fn))
{
list.append( pathfn );
relList.append( relPart + fn );
}
}
}
}
void PakProtocol::stat(const KURL &url) {
kdDebug(PAK_DEBUG_ID) << "Entering stat()" << endl;
QString path;
KIO::UDSEntry entry;
KIO::Error errorNum;
if ( !checkNewFile( url, path, errorNum ) )
{
// We may be looking at a real directory - this happens
// when pressing up after being in the root of an archive
if ( errorNum == KIO::ERR_CANNOT_OPEN_FOR_READING )
{
// If we cannot open, it might be a problem with the archive header (e.g. unsupported format)
// Therefore give a more specific error message
error( KIO::ERR_SLAVE_DEFINED,
i18n( "Could not open the file, probably due to an unsupported file format.\n%1")
.arg( url.prettyURL() ) );
return;
}
else if ( errorNum != KIO::ERR_IS_DIRECTORY )
{
// We have any other error
error( errorNum, url.prettyURL() );
return;
}
// Real directory. Return just enough information for KRun to work
KIO::UDSAtom atom;
atom.m_uds = KIO::UDS_NAME;
atom.m_str = url.fileName();
entry.append( atom );
kdDebug( PAK_DEBUG_ID ) << "ArchiveProtocol::stat returning name=" << url.fileName() << endl;
KDE_struct_stat buff;
if ( KDE_stat( QFile::encodeName( url.path() ), &buff ) == -1 )
{
// Should not happen, as the file was already stated by checkNewFile
error( KIO::ERR_COULD_NOT_STAT, url.prettyURL() );
return;
}
atom.m_uds = KIO::UDS_FILE_TYPE;
atom.m_long = buff.st_mode & S_IFMT;
entry.append( atom );
statEntry( entry );
finished();
// And let go of the tar file - for people who want to unmount a cdrom after that
delete _pakFile;
_pakFile = 0L;
return;
}
const KArchiveDirectory* root = _pakFile->directory();
const KArchiveEntry* archiveEntry;
if ( path.isEmpty() )
{
path = QString::fromLatin1( "/" );
archiveEntry = root;
} else {
path = QString::fromLocal8Bit(remoteEncoding()->encode(path));
archiveEntry = root->entry( path );
}
if ( !archiveEntry )
{
error( KIO::ERR_DOES_NOT_EXIST, url.prettyURL() );
return;
}
createUDSEntry( archiveEntry, entry );
statEntry( entry );
finished();
/*kdDebug(PAK_DEBUG_ID) << "Entering stat()" << endl;
KIO::UDSEntry entry;
createUDSEntry(NULL, entry);
kdDebug(PAK_DEBUG_ID) << "Giving file away" << endl;
statEntry(entry);
finished();
kdDebug(PAK_DEBUG_ID) << "-<> Exiting stat()" << endl;*/
}
static void lookupPrefix(const QString& prefix, const QString& relpath,
const QString& relPart,
const QRegExp ®exp,
QStringList& list,
QStringList& relList,
bool recursive, bool unique)
{
if (relpath.isEmpty()) {
lookupDirectory(prefix, relPart, regexp, list,
relList, recursive, unique);
return;
}
QString path;
QString rest;
if (relpath.length())
{
int slash = relpath.find('/');
if (slash < 0)
rest = relpath.left(relpath.length() - 1);
else {
path = relpath.left(slash);
rest = relpath.mid(slash + 1);
}
}
if (prefix.isEmpty()) //for sanity
return;
#ifdef Q_WS_WIN
assert(prefix.at(prefix.length() - 1) == '/' || prefix.at(prefix.length() - 1) == '\\');
#else
assert(prefix.at(prefix.length() - 1) == '/');
#endif
KDE_struct_stat buff;
if (path.contains('*') || path.contains('?')) {
QRegExp pathExp(path, true, true);
DIR *dp = opendir( QFile::encodeName(prefix) );
if (!dp) {
return;
}
struct dirent *ep;
QString _dot(".");
QString _dotdot("..");
while( ( ep = readdir( dp ) ) != 0L )
{
QString fn( QFile::decodeName(ep->d_name));
if (fn == _dot || fn == _dotdot || fn.at(fn.length() - 1) == '~')
continue;
if ( !pathExp.exactMatch(fn) )
continue; // No match
QString rfn = relPart+fn;
fn = prefix + fn;
if ( KDE_stat( QFile::encodeName(fn), &buff ) != 0 ) {
kdDebug() << "Error statting " << fn << " : " << perror << endl;
continue; // Couldn't stat (e.g. no permissions)
}
if ( S_ISDIR( buff.st_mode ))
lookupPrefix(fn + '/', rest, rfn + '/', regexp, list, relList, recursive, unique);
}
closedir( dp );
} else {
// Don't stat, if the dir doesn't exist we will find out
// when we try to open it.
lookupPrefix(prefix + path + '/', rest,
relPart + path + '/', regexp, list,
relList, recursive, unique);
}
}
void DirectoryListThread::run()
{
// Thread safety notes:
//
// There very possibly may be thread safety issues here, but I've done a check
// of all of the things that would seem to be problematic. Here are a few
// things that I have checked to be safe here (some used indirectly):
//
// QDir::currentDirPath(), QDir::setCurrent(), QFile::decodeName(), QFile::encodeName()
// QString::fromLocal8Bit(), QString::local8Bit(), QTextCodec::codecForLocale()
//
// Also see (for POSIX functions):
// http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_09.html
DIR *dir = 0;
for(QStringList::ConstIterator it = m_dirList.begin(); it != m_dirList.end() && !terminationRequested(); ++it)
{
// Open the next directory
if(!dir)
{
dir = ::opendir(QFile::encodeName(*it));
if(!dir)
{
kdDebug() << "Failed to open dir: " << *it << endl;
done();
return;
}
}
// A trick from KIO that helps performance by a little bit:
// chdir to the directroy so we won't have to deal with full paths
// with stat()
QString path = QDir::currentDirPath();
QDir::setCurrent(*it);
// Loop through all directory entries
// Solaris and IRIX dirent structures do not allocate space for d_name. On
// systems that do (HP-UX, Linux, Tru64 UNIX), we overallocate space but
// that's ok.
#ifndef HAVE_READDIR_R
struct dirent *dirEntry = 0;
while(!terminationRequested() && (dirEntry = ::readdir(dir)))
#else
struct dirent *dirPosition = (struct dirent *)malloc(sizeof(struct dirent) + MAXPATHLEN + 1);
struct dirent *dirEntry = 0;
while(!terminationRequested() && ::readdir_r(dir, dirPosition, &dirEntry) == 0 && dirEntry)
#endif
{
// Skip hidden files if m_noHidden is true
if(dirEntry->d_name[0] == '.' && m_noHidden)
continue;
// Skip "."
if(dirEntry->d_name[0] == '.' && dirEntry->d_name[1] == '\0')
continue;
// Skip ".."
if(dirEntry->d_name[0] == '.' && dirEntry->d_name[1] == '.' && dirEntry->d_name[2] == '\0')
continue;
QString file = QFile::decodeName(dirEntry->d_name);
if(m_filter.isEmpty() || file.startsWith(m_filter))
{
if(m_onlyExe || m_onlyDir || m_appendSlashToDir)
{
KDE_struct_stat sbuff;
if(KDE_stat(dirEntry->d_name, &sbuff) == 0)
{
// Verify executable
if(m_onlyExe && (sbuff.st_mode & MODE_EXE) == 0)
continue;
// Verify directory
if(m_onlyDir && !S_ISDIR(sbuff.st_mode))
continue;
// Add '/' to directories
if(m_appendSlashToDir && S_ISDIR(sbuff.st_mode))
file.append('/');
}
else
{
kdDebug() << "Could not stat file " << file << endl;
continue;
}
}
addMatch(file);
}
}
// chdir to the original directory
QDir::setCurrent(path);
::closedir(dir);
dir = 0;
#ifdef HAVE_READDIR_R
free(dirPosition);
#endif
}
done();
}
void RenameImagesWidget::slotNext()
{
QTreeWidgetItem* it = ui->m_listView->selectedItems().first();
if (!it)
{
slotAbort();
return;
}
BatchProcessImagesItem* item = static_cast<BatchProcessImagesItem*>(it);
KUrl src;
src.setPath(item->pathSrc());
KUrl dst = src.upUrl();
dst.addPath(item->text(2));
bool skip = false;
bool overwrite = false;
if (!m_overwriteAll)
{
KDE_struct_stat info;
while (KDE_stat(QFile::encodeName(dst.toLocalFile()), &info) == 0)
{
if (m_autoSkip)
{
skip = true;
break;
}
QPointer<KIO::RenameDialog> dlg = new KIO::RenameDialog(this, i18n("Rename File"),
src.path(), dst.path(),
KIO::RenameDialog_Mode(KIO::M_MULTI | KIO::M_OVERWRITE | KIO::M_SKIP));
int result = dlg->exec();
dst = dlg->newDestUrl();
delete dlg;
switch (result)
{
case KIO::R_CANCEL:
{
slotAbort();
return;
}
case KIO::R_SKIP:
{
skip = true;
break;
}
case KIO::R_AUTO_SKIP:
{
m_autoSkip = true;
skip = true;
break;
}
case KIO::R_OVERWRITE:
{
overwrite = true;
break;
}
case KIO::R_OVERWRITE_ALL:
{
m_overwriteAll = true;
overwrite = true;
break;
}
default:
break;
}
if (skip || overwrite)
break;
}
}
if (skip)
{
item->changeResult(i18nc("batch process result", "Skipped"));
}
else
{
// Get the src info
KIPIPlugins::KPImageInfo srcInfo(src);
if (KDE_rename(QFile::encodeName(src.toLocalFile()),
QFile::encodeName(dst.toLocalFile())) == 0)
{
// Rename XMP sidecar file
KIPIPlugins::KPMetadata::moveSidecar(src, dst);
srcInfo.setName(dst.fileName());
item->changeResult(i18nc("batch process result", "OK"));
}
else
{
item->changeResult(i18nc("batch process result", "Failed"));
}
}
m_progress->progressBar()->setValue(m_progress->progressBar()->value() + 1);
it = ui->m_listView->itemBelow(it);
if (it)
{
ui->m_listView->setCurrentItem(it);
ui->m_listView->scrollToItem(it);
m_timer->setSingleShot(true);
m_timer->start(0);
}
}
void KFileItem::init( bool _determineMimeTypeOnDemand )
{
m_access = QString::null;
m_size = (KIO::filesize_t) -1;
// metaInfo = KFileMetaInfo();
for ( int i = 0; i < NumFlags; i++ )
m_time[i] = (time_t) -1;
// determine mode and/or permissions if unknown
if ( m_fileMode == KFileItem::Unknown || m_permissions == KFileItem::Unknown )
{
mode_t mode = 0;
if ( m_url.isLocalFile() )
{
/* directories may not have a slash at the end if
* we want to stat() them; it requires that we
* change into it .. which may not be allowed
* stat("/is/unaccessible") -> rwx------
* stat("/is/unaccessible/") -> EPERM H.Z.
* This is the reason for the -1
*/
KDE_struct_stat buf;
QCString path = QFile::encodeName(m_url.path( -1 ));
if ( KDE_lstat( path.data(), &buf ) == 0 )
{
mode = buf.st_mode;
if ( S_ISLNK( mode ) )
{
m_bLink = true;
if ( KDE_stat( path.data(), &buf ) == 0 )
mode = buf.st_mode;
else // link pointing to nowhere (see kio/file/file.cc)
mode = (S_IFMT-1) | S_IRWXU | S_IRWXG | S_IRWXO;
}
// While we're at it, store the times
m_time[ Modification ] = buf.st_mtime;
m_time[ Access ] = buf.st_atime;
if ( m_fileMode == KFileItem::Unknown )
m_fileMode = mode & S_IFMT; // extract file type
if ( m_permissions == KFileItem::Unknown )
m_permissions = mode & 07777; // extract permissions
}
}
}
// determine the mimetype
if (!m_pMimeType && !m_url.isEmpty())
{
bool accurate = false;
bool isLocalURL;
KURL url = mostLocalURL(isLocalURL);
m_pMimeType = KMimeType::findByURL( url, m_fileMode, isLocalURL,
// use fast mode if not mimetype on demand
_determineMimeTypeOnDemand, &accurate );
//kdDebug() << "finding mimetype for " << url.url() << " : " << m_pMimeType->name() << endl;
// if we didn't use fast mode, or if we got a result, then this is the mimetype
// otherwise, determineMimeType will be able to do better.
m_bMimeTypeKnown = (!_determineMimeTypeOnDemand) || accurate;
}
}
