bool
KShred::shred()
{
unsigned char p[6][3] = {{'\222', '\111', '\044'}, {'\111', '\044', '\222'},
{'\044', '\222', '\111'}, {'\155', '\266', '\333'},
{'\266', '\333', '\155'}, {'\333', '\155', '\266'}};
TQString msg = i18n("Shredding: pass %1 of 35");
emit processedSize(0);
// thirty-five times writing the entire file size
totalBytes = fileSize * 35;
int iteration = 1;
for (int ctr = 0; ctr < 4; ctr++)
if (!fillrandom())
return false;
else
{
emit infoMessage(msg.arg(iteration));
}
if (!fillbyte((unsigned int) 0x55)) // '0x55' is 01010101
return false;
emit infoMessage(msg.arg(iteration));
if (!fillbyte((unsigned int) 0xAA)) // '0xAA' is 10101010
return false;
emit infoMessage(msg.arg(iteration));
for (unsigned int ctr = 0; ctr < 3; ctr++)
if (!fillpattern(p[ctr], 3)) // '0x92', '0x49', '0x24'
return false;
else
{
emit infoMessage(msg.arg(iteration));
}
for (unsigned int ctr = 0; ctr <= 255 ; ctr += 17)
if (!fillbyte(ctr)) // sequence of '0x00', '0x11', ..., '0xFF'
return false;
else
{
emit infoMessage(msg.arg(iteration));
}
for (unsigned int ctr = 0; ctr < 6; ctr++)
if (!fillpattern(p[ctr], 3)) // '0x92', '0x49', '0x24'
return false;
else
{
emit infoMessage(msg.arg(iteration));
}
for (int ctr = 0; ctr < 4; ctr++)
if (!fillrandom())
return false;
else
{
emit infoMessage(msg.arg(iteration));
}
if (!file->remove())
return false;
file = 0L;
emit processedSize(fileSize);
return true;
}
void SMBSlave::smbCopyPut(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags)
{
qCDebug(KIO_SMB) << "src = " << ksrc << ", dest = " << kdst;
QFile srcFile (ksrc.toLocalFile());
const QFileInfo srcInfo (srcFile);
if (srcInfo.exists()) {
if (srcInfo.isDir()) {
error(KIO::ERR_IS_DIRECTORY, ksrc.toDisplayString());
return;
}
} else {
error(KIO::ERR_DOES_NOT_EXIST, ksrc.toDisplayString());
return;
}
if (!srcFile.open(QFile::ReadOnly)) {
qCDebug(KIO_SMB) << "could not read from" << ksrc;
switch (srcFile.error()) {
case QFile::PermissionsError:
error(KIO::ERR_WRITE_ACCESS_DENIED, ksrc.toDisplayString());
break;
case QFile::OpenError:
default:
error(KIO::ERR_CANNOT_OPEN_FOR_READING, ksrc.toDisplayString());
break;
}
return;
}
totalSize(static_cast<filesize_t>(srcInfo.size()));
bool bResume = false;
bool bPartExists = false;
const bool bMarkPartial = config()->readEntry("MarkPartial", true);
const SMBUrl dstOrigUrl (kdst);
if (bMarkPartial) {
const int errNum = cache_stat(dstOrigUrl.partUrl(), &st);
bPartExists = (errNum == 0);
if (bPartExists) {
if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {
bResume = canResume(st.st_size);
} else {
bResume = (flags & KIO::Resume);
}
}
}
int dstfd = -1;
int errNum = cache_stat(dstOrigUrl, &st);
if (errNum == 0 && !(flags & KIO::Overwrite) && !(flags & KIO::Resume)) {
if (S_ISDIR(st.st_mode)) {
error( KIO::ERR_IS_DIRECTORY, dstOrigUrl.toDisplayString());
} else {
error( KIO::ERR_FILE_ALREADY_EXIST, dstOrigUrl.toDisplayString());
}
return;
}
KIO::filesize_t processed_size = 0;
const SMBUrl dstUrl(bMarkPartial ? dstOrigUrl.partUrl() : dstOrigUrl);
if (bResume) {
// append if resuming
qCDebug(KIO_SMB) << "resume" << dstUrl;
dstfd = smbc_open(dstUrl.toSmbcUrl(), O_RDWR, 0 );
if (dstfd < 0) {
errNum = errno;
} else {
const off_t offset = smbc_lseek(dstfd, 0, SEEK_END);
if (offset == (off_t)-1) {
error(KIO::ERR_COULD_NOT_SEEK, dstUrl.toDisplayString());
smbc_close(dstfd);
return;
} else {
processed_size = offset;
}
}
} else {
mode_t mode;
if (permissions == -1) {
mode = 600;
} else {
mode = permissions | S_IRUSR | S_IWUSR;
}
qCDebug(KIO_SMB) << "NO resume" << dstUrl;
dstfd = smbc_open(dstUrl.toSmbcUrl(), O_CREAT | O_TRUNC | O_WRONLY, mode);
if (dstfd < 0) {
errNum = errno;
}
}
if (dstfd < 0) {
if (errNum == EACCES) {
qCDebug(KIO_SMB) << "access denied";
error( KIO::ERR_WRITE_ACCESS_DENIED, dstUrl.toDisplayString());
}
else {
qCDebug(KIO_SMB) << "can not open for writing";
error( KIO::ERR_CANNOT_OPEN_FOR_WRITING, dstUrl.toDisplayString());
}
return;
}
bool isErr = false;
if (processed_size == 0 || srcFile.seek(processed_size)) {
// Perform the copy
char buf[MAX_XFER_BUF_SIZE];
while (1) {
const ssize_t bytesRead = srcFile.read(buf, MAX_XFER_BUF_SIZE);
if (bytesRead <= 0) {
if (bytesRead < 0) {
error(KIO::ERR_COULD_NOT_READ, ksrc.toDisplayString());
isErr = true;
}
break;
}
const qint64 bytesWritten = smbc_write(dstfd, buf, bytesRead);
if (bytesWritten == -1) {
error(KIO::ERR_COULD_NOT_WRITE, kdst.toDisplayString());
isErr = true;
break;
}
processed_size += bytesWritten;
processedSize(processed_size);
}
} else {
isErr = true;
error(KIO::ERR_COULD_NOT_SEEK, ksrc.toDisplayString());
}
// FINISHED
if (smbc_close(dstfd) < 0) {
qCDebug(KIO_SMB) << dstUrl << "could not write";
error( KIO::ERR_COULD_NOT_WRITE, dstUrl.toDisplayString());
return;
}
// Handle error condition.
if (isErr) {
if (bMarkPartial) {
const int size = config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE);
const int errNum = cache_stat(dstUrl, &st);
if (errNum == 0 && st.st_size < size) {
smbc_unlink(dstUrl.toSmbcUrl());
}
}
return;
}
// Rename partial file to its original name.
if (bMarkPartial) {
smbc_unlink(dstOrigUrl.toSmbcUrl());
if (smbc_rename(dstUrl.toSmbcUrl(), dstOrigUrl.toSmbcUrl()) < 0) {
qCDebug(KIO_SMB) << "failed to rename" << dstUrl << "to" << dstOrigUrl << "->" << strerror(errno);
error(ERR_CANNOT_RENAME_PARTIAL, dstUrl.toDisplayString());
return;
}
}
#ifdef HAVE_UTIME_H
// set modification time
const QString mtimeStr = metaData( "modified" );
if (!mtimeStr.isEmpty() ) {
QDateTime dt = QDateTime::fromString( mtimeStr, Qt::ISODate );
if ( dt.isValid() ) {
struct utimbuf utbuf;
utbuf.actime = st.st_atime; // access time, unchanged
utbuf.modtime = dt.toTime_t(); // modification time
smbc_utime( dstUrl.toSmbcUrl(), &utbuf );
}
}
#endif
// We have done our job => finish
finished();
}
void SMBSlave::smbCopy(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags)
{
SMBUrl src;
SMBUrl dst;
mode_t initialmode;
ssize_t n;
int dstflags;
int srcfd = -1;
int dstfd = -1;
int errNum = 0;
KIO::filesize_t processed_size = 0;
unsigned char buf[MAX_XFER_BUF_SIZE];
qCDebug(KIO_SMB) << "SMBSlave::copy with src = " << ksrc << "and dest = " << kdst;
// setup urls
src = ksrc;
dst = kdst;
// Obtain information about source
errNum = cache_stat(src, &st );
if( errNum != 0 )
{
if ( errNum == EACCES )
{
error( KIO::ERR_ACCESS_DENIED, src.toDisplayString());
}
else
{
error( KIO::ERR_DOES_NOT_EXIST, src.toDisplayString());
}
return;
}
if ( S_ISDIR( st.st_mode ) )
{
error( KIO::ERR_IS_DIRECTORY, src.toDisplayString() );
return;
}
totalSize(st.st_size);
// Check to se if the destination exists
errNum = cache_stat(dst, &st);
if( errNum == 0 )
{
if(S_ISDIR(st.st_mode))
{
error( KIO::ERR_DIR_ALREADY_EXIST, dst.toDisplayString());
return;
}
if(!(flags & KIO::Overwrite))
{
error( KIO::ERR_FILE_ALREADY_EXIST, dst.toDisplayString());
return;
}
}
// Open the source file
srcfd = smbc_open(src.toSmbcUrl(), O_RDONLY, 0);
if (srcfd < 0){
errNum = errno;
} else {
errNum = 0;
}
if(srcfd < 0)
{
if(errNum == EACCES)
{
error( KIO::ERR_ACCESS_DENIED, src.toDisplayString() );
}
else
{
error( KIO::ERR_DOES_NOT_EXIST, src.toDisplayString() );
}
return;
}
// Determine initial creation mode
if(permissions != -1)
{
initialmode = permissions | S_IWUSR;
}
else
{
initialmode = 0 | S_IWUSR;//0666;
}
// Open the destination file
dstflags = O_CREAT | O_TRUNC | O_WRONLY;
if(!(flags & KIO::Overwrite))
{
dstflags |= O_EXCL;
}
dstfd = smbc_open(dst.toSmbcUrl(), dstflags, initialmode);
if (dstfd < 0){
errNum = errno;
} else {
errNum = 0;
}
if(dstfd < 0)
{
if(errNum == EACCES)
{
error(KIO::ERR_WRITE_ACCESS_DENIED, dst.toDisplayString());
}
else
{
error(KIO::ERR_CANNOT_OPEN_FOR_READING, dst.toDisplayString());
}
if(srcfd >= 0 )
{
smbc_close(srcfd);
}
return;
}
// Perform copy
while(1)
{
n = smbc_read(srcfd, buf, MAX_XFER_BUF_SIZE );
if(n > 0)
{
n = smbc_write(dstfd, buf, n);
if(n == -1)
{
qCDebug(KIO_SMB) << "SMBSlave::copy copy now KIO::ERR_COULD_NOT_WRITE";
error( KIO::ERR_COULD_NOT_WRITE, dst.toDisplayString());
break;
}
processed_size += n;
processedSize(processed_size);
}
else if(n == 0)
{
break; // finished
}
else
{
error( KIO::ERR_COULD_NOT_READ, src.toDisplayString());
break;
}
}
// FINISHED:
if(srcfd >= 0 )
{
smbc_close(srcfd);
}
if(dstfd >= 0)
{
if(smbc_close(dstfd) == 0)
{
// TODO: set final permissions
}
else
{
error( KIO::ERR_COULD_NOT_WRITE, dst.toDisplayString());
return;
}
}
finished();
}
void SMBSlave::smbCopyGet(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags)
{
qCDebug(KIO_SMB) << "src = " << ksrc << ", dest = " << kdst;
// check if destination is ok ...
const QString dstFile = kdst.toLocalFile();
const QFileInfo dstInfo (dstFile);
if(dstInfo.exists()) {
if(dstInfo.isDir()) {
error (ERR_IS_DIRECTORY, kdst.toDisplayString());
return;
}
if(!(flags & KIO::Overwrite)) {
error(ERR_FILE_ALREADY_EXIST, kdst.toDisplayString());
return;
}
}
bool bResume = false;
const QFileInfo partInfo (dstFile + QLatin1String(".part"));
const bool bPartExists = partInfo.exists();
const bool bMarkPartial = config()->readEntry("MarkPartial", true);
if (bMarkPartial && bPartExists && partInfo.size() > 0) {
if (partInfo.isDir()) {
error(ERR_IS_DIRECTORY, partInfo.absoluteFilePath());
return;
}
bResume = canResume(partInfo.size());
}
if (bPartExists && !bResume) // get rid of an unwanted ".part" file
QFile::remove(partInfo.absoluteFilePath());
// open the output file...
QFile::OpenMode mode;
QString filename;
if (bResume) {
filename = partInfo.absoluteFilePath();
mode = QFile::WriteOnly | QFile::Append;
}
else {
filename = (bMarkPartial ? partInfo.absoluteFilePath() : dstFile);
mode = QFile::WriteOnly | QFile::Truncate;
}
QFile file (filename);
if (!bResume) {
QFile::Permissions perms;
if (permissions == -1) {
perms = QFile::ReadOwner | QFile::WriteOwner;
} else {
perms = KIO::convertPermissions(permissions | QFile::WriteOwner);
}
file.setPermissions(perms);
}
if (!file.open(mode)) {
qCDebug(KIO_SMB) << "could not write to" << dstFile;
switch (file.error()) {
case QFile::OpenError:
if (bResume) {
error (ERR_CANNOT_RESUME, kdst.toDisplayString());
} else {
error(ERR_CANNOT_OPEN_FOR_WRITING, kdst.toDisplayString());
}
break;
case QFile::PermissionsError:
error(ERR_WRITE_ACCESS_DENIED, kdst.toDisplayString());
break;
default:
error(ERR_CANNOT_OPEN_FOR_WRITING, kdst.toDisplayString());
break;
}
return;
}
// setup the source urls
const SMBUrl src(ksrc);
// Obtain information about source
int errNum = cache_stat (src, &st);
if (errNum != 0) {
if (errNum == EACCES) {
error (KIO::ERR_ACCESS_DENIED, src.toDisplayString());
} else {
error (KIO::ERR_DOES_NOT_EXIST, src.toDisplayString());
}
return;
}
if (S_ISDIR( st.st_mode )) {
error (KIO::ERR_IS_DIRECTORY, src.toDisplayString());
return;
}
totalSize(st.st_size);
// Open the source file
KIO::filesize_t processed_size = 0;
int srcfd = smbc_open(src.toSmbcUrl(), O_RDONLY, 0);
if (srcfd < 0){
errNum = errno;
} else {
errNum = 0;
if (bResume) {
qCDebug(KIO_SMB) << "seeking to size" << partInfo.size();
off_t offset = smbc_lseek(srcfd, partInfo.size(), SEEK_SET);
if (offset == -1) {
error(KIO::ERR_COULD_NOT_SEEK, src.toDisplayString());
smbc_close(srcfd);
return;
} else {
processed_size += offset;
}
}
}
if (srcfd < 0) {
if(errNum == EACCES) {
error( KIO::ERR_ACCESS_DENIED, src.toDisplayString() );
} else {
error( KIO::ERR_DOES_NOT_EXIST, src.toDisplayString() );
}
return;
}
// Perform the copy
char buf[MAX_XFER_BUF_SIZE];
bool isErr = false;
while (1) {
const ssize_t bytesRead = smbc_read(srcfd, buf, MAX_XFER_BUF_SIZE);
if (bytesRead <= 0) {
if (bytesRead < 0) {
error( KIO::ERR_COULD_NOT_READ, src.toDisplayString());
isErr = true;
}
break;
}
const qint64 bytesWritten = file.write(buf, bytesRead);
if (bytesWritten == -1) {
qCDebug(KIO_SMB) << "copy now KIO::ERR_COULD_NOT_WRITE";
error( KIO::ERR_COULD_NOT_WRITE, kdst.toDisplayString());
isErr = true;
break;
}
processed_size += bytesWritten;
processedSize(processed_size);
}
// FINISHED
smbc_close(srcfd);
// Handle error condition.
if (isErr) {
const QString sPart = partInfo.absoluteFilePath();
if (bMarkPartial) {
const int size = config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE);
if (partInfo.size() < size) {
QFile::remove(sPart);
}
}
return;
}
// Rename partial file to its original name.
if (bMarkPartial) {
const QString sPart = partInfo.absoluteFilePath();
// Remove old dest file if it exists..
if (dstInfo.exists()) {
QFile::remove(dstFile);
}
if (!QFile::rename(sPart, dstFile)) {
qCDebug(KIO_SMB) << "failed to rename" << sPart << "to" << dstFile;
error(ERR_CANNOT_RENAME_PARTIAL, sPart);
return;
}
}
// Restore the mtime on the file.
const QString mtimeStr = metaData("modified");
qCDebug(KIO_SMB) << "modified:" << mtimeStr;
if (!mtimeStr.isEmpty()) {
QDateTime dt = QDateTime::fromString(mtimeStr, Qt::ISODate);
if (dt.isValid()) {
struct utimbuf utbuf;
utbuf.actime = QFileInfo(file).lastRead().toTime_t(); // access time, unchanged
utbuf.modtime = dt.toTime_t(); // modification time
utime(QFile::encodeName(dstFile).constData(), &utbuf);
}
}
finished();
}
