//-----------------------------------------------------------------------------
int KMFolder::rename(const QString aName)
{
QString oldLoc, oldIndexLoc, newLoc, newIndexLoc, oldName;
int rc=0, openCount=mOpenCount;
assert(!aName.isEmpty());
oldLoc = location().copy();
oldIndexLoc = indexLocation().copy();
close(TRUE);
oldName = name();
setName(aName);
newLoc = location();
newIndexLoc = indexLocation();
if (_rename(oldLoc, newLoc))
{
setName(oldName);
rc = errno;
}
else if (!oldIndexLoc.isEmpty()) _rename(oldIndexLoc, newIndexLoc);
if (openCount > 0)
{
open();
mOpenCount = openCount;
}
return rc;
}
extern int
close(int fd)
{
int r;
int oerrno;
struct stat st;
char buf[PATH_MAX];
if (fd >= 0 && fd < elementsof(exe) && exe[fd])
{
r = exe[fd]->test;
exe[fd]->test = 0;
if (r > 0 && !fstat(fd, &st) && st.st_ino == exe[fd]->ino)
{
if (r = _close(fd))
return r;
oerrno = errno;
if (!stat(exe[fd]->path, &st) && st.st_ino == exe[fd]->ino)
{
snprintf(buf, sizeof(buf), "%s.exe", exe[fd]->path);
_rename(exe[fd]->path, buf);
}
errno = oerrno;
return 0;
}
}
return _close(fd);
}
extern int
chmod(const char* path, mode_t mode)
{
int r;
int oerrno;
char buf[PATH_MAX];
if ((r = _chmod(path, mode)) && errno == ENOENT && execrate(path, buf, sizeof(buf), 0))
{
errno = oerrno;
return _chmod(buf, mode);
}
if (!(r = _chmod(path, mode)) &&
(mode & (S_IXUSR|S_IXGRP|S_IXOTH)) &&
!suffix(path) &&
(strlen(path) + 4) < sizeof(buf))
{
oerrno = errno;
if (!magic(path, NiL))
{
snprintf(buf, sizeof(buf), "%s.exe", path);
_rename(path, buf);
}
errno = oerrno;
}
return r;
}
IndexSpec& IndexSpec::addKey(const StringData& field, IndexType type) {
uassert(0, kDuplicateKey, !_keys.asTempObj().hasField(field));
if (type <= kIndexTypeDescending)
_keys.append(field, kIndexTypeNumbers[type]);
else
_keys.append(field, kIndexTypeStrings[type]);
_rename();
return *this;
}
extern int
rename(const char* fp, const char* tp)
{
int r;
int oerrno;
char fb[PATH_MAX];
char tb[PATH_MAX];
oerrno = errno;
if ((r = _rename(fp, tp)) && errno == ENOENT && execrate(fp, fb, sizeof(fb), 1))
{
if (execrate(tp, tb, sizeof(tb), 1))
tp = tb;
errno = oerrno;
r = _rename(fb, tp);
}
return r;
}
/*static*/ unsigned int CRhoFile::renameFile( const char* szOldFilePath, const char* szNewFilePath )
{
#if defined(OS_WINCE)
return _rename( szOldFilePath, szNewFilePath );
#else
return rename( szOldFilePath, szNewFilePath );
#endif
}
//-----------------------------------------------------------------------------
int KMFolder::compact(void)
{
KMFolder* tempFolder;
KMMessage* msg;
QString tempName, msgStr;
int openCount = mOpenCount;
int num, numStatus;
if (!needsCompact)
{
//debug ("Not compacting %s; it's clean", name().data());
return 0;
}
debug ("Compacting %s ", name().data());
tempName = "." + name();
tempName.detach();
tempName += ".compacted";
unlink(tempName);
//tempFolder = parent()->createFolder(tempName); //sven: shouldn't be in list
tempFolder = new KMFolder(parent(), tempName); //sven: we create it
if(tempFolder->create()) {
debug("KMFolder::compact() Creating tempFolder failed!\n");
delete tempFolder; //sven: and we delete it
return 0;
}
quiet(TRUE);
tempFolder->open();
open();
for(num=1,numStatus=9; count() > 0; num++, numStatus--)
{
if (numStatus <= 0)
{
msgStr.sprintf(i18n("Compacting folder: %d messages done"), num);
emit statusMsg(msgStr);
numStatus = 10;
}
msg = getMsg(0);
if(msg)
tempFolder->moveMsg(msg);
}
tempName = tempFolder->location();
tempFolder->close(TRUE);
close(TRUE);
mMsgList.clear(TRUE);
_rename(tempName, location());
_rename(tempFolder->indexLocation(), indexLocation());
// Now really free all memory
delete tempFolder; //sven: we delete it, not the manager
if (openCount > 0)
{
open();
mOpenCount = openCount;
}
quiet(FALSE);
if (!mQuiet) emit changed();
needsCompact = false; // We are clean now
return 0;
}
IndexSpec& IndexSpec::addKey(const BSONElement& fieldAndType) {
uassert(0, kDuplicateKey, !_keys.asTempObj().hasField(fieldAndType.fieldName()));
_keys.append(fieldAndType);
_rename();
return *this;
}
extern int
unlink(const char* path)
{
int r;
int drive;
int mask;
int suffix;
int stop;
int oerrno;
unsigned long base;
char buf[PATH_MAX];
char tmp[MAX_PATH];
#define DELETED_DIR_1 7
#define DELETED_DIR_2 16
static char deleted[] = "%c:\\temp\\.deleted\\%08x.%03x";
static int count = 0;
#if __CYGWIN__
DWORD fattr = FILE_ATTRIBUTE_NORMAL|FILE_FLAG_DELETE_ON_CLOSE;
DWORD share = FILE_SHARE_DELETE;
HANDLE hp;
struct stat st;
char nat[MAX_PATH];
oerrno = errno;
if (lstat(path, &st) || !S_ISREG(st.st_mode))
goto try_unlink;
cygwin_conv_to_full_win32_path(path, nat);
if (!strncasecmp(nat + 1, ":\\temp\\", 7))
goto try_unlink;
drive = nat[0];
path = (const char*)nat;
for (;;)
{
hp = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_DELETE_ON_CLOSE, NULL);
if (hp != INVALID_HANDLE_VALUE)
{
CloseHandle(hp);
errno = oerrno;
return 0;
}
if (GetLastError() != ERROR_FILE_NOT_FOUND)
break;
if (path == (const char*)buf || !execrate(path, buf, sizeof(buf), 1))
{
errno = ENOENT;
return -1;
}
path = (const char*)buf;
}
#else
if (_access(path, 0))
#if _win32_botch_access
{
if (errno != ENOENT || !execrate(path, buf, sizeof(buf), 1) || _access(buf, 0))
return -1;
path = (const char*)buf;
}
#else
return -1;
#endif
drive = 'C':
#endif
/*
* rename to a `deleted' path just in case the file is open
* otherwise directory readers may choke on phantom entries
*/
base = ((getuid() & 0xffff) << 16) | (time(NiL) & 0xffff);
suffix = (getpid() & 0xfff) + count++;
snprintf(tmp, sizeof(tmp), deleted, drive, base, suffix);
if (!_rename(path, tmp))
{
path = (const char*)tmp;
goto try_delete;
}
if (errno != ENOTDIR && errno != ENOENT)
goto try_unlink;
tmp[DELETED_DIR_2] = 0;
if (_access(tmp, 0))
{
mask = umask(0);
tmp[DELETED_DIR_1] = 0;
if (_access(tmp, 0) && _mkdir(tmp, S_IRWXU|S_IRWXG|S_IRWXO))
{
umask(mask);
goto try_unlink;
}
tmp[DELETED_DIR_1] = '\\';
r = _mkdir(tmp, S_IRWXU|S_IRWXG|S_IRWXO);
umask(mask);
if (r)
goto try_unlink;
errno = 0;
}
tmp[DELETED_DIR_2] = '\\';
if (!errno && !_rename(path, tmp))
{
path = (const char*)tmp;
goto try_delete;
}
#if !__CYGWIN__
if (errno == ENOENT)
{
#if !_win32_botch_access
if (execrate(path, buf, sizeof(buf), 1) && !_rename(buf, tmp))
path = (const char*)tmp;
#endif
goto try_unlink;
}
#endif
stop = suffix;
do
{
snprintf(tmp, sizeof(tmp), deleted, drive, base, suffix);
if (!_rename(path, tmp))
{
path = (const char*)tmp;
goto try_delete;
}
if (++suffix > 0xfff)
suffix = 0;
} while (suffix != stop);
try_delete:
#if __CYGWIN__
hp = CreateFile(path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_DELETE_ON_CLOSE, NULL);
if (hp != INVALID_HANDLE_VALUE)
{
CloseHandle(hp);
errno = oerrno;
return 0;
}
#endif
try_unlink:
errno = oerrno;
return _unlink(path);
}
int
rename(const char *oldpath, const char *newpath)
{
_gfs_hook_debug_v(fputs("Hooking rename\n", stderr));
return (_rename(oldpath, newpath));
}
int rename(const char *oldname, const char *newname){
// doesn't appear to work on a540
return _rename(oldname, newname);
}
/**
* Interrupt 80h. Handles the system calls.
*
* @param regs Pointer to struct containing micro's registers.
*/
void int80(registers* regs) {
switch (regs->eax) {
case _SYS_READ:
regs->eax = _read((unsigned int)regs->ebx, (char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_WRITE:
regs->eax = _write((unsigned int)regs->ebx, (const char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_TIME:
regs->eax = _time((time_t*)translate(regs->ebx));
break;
case _SYS_IOCTL:
regs->eax = _ioctl(regs->ebx, regs->ecx, (void*)translate(regs->edx));
break;
case _SYS_TICKS:
regs->eax = _getTicksSinceStart();
break;
case _SYS_YIELD:
// This just makes sure we call the scheduler again, for now
break;
case _SYS_EXIT:
_exit();
break;
case _SYS_GETPID:
regs->eax = _getpid();
break;
case _SYS_GETPPID:
regs->eax = _getppid();
break;
case _SYS_RUN:
regs->eax = _run((EntryPoint) translate(regs->ebx), (char*) translate(regs->ecx), regs->edx);
break;
case _SYS_WAIT:
regs->eax = _wait();
break;
case _SYS_KILL:
_kill((pid_t) regs->ebx);
break;
case _SYS_PINFO:
regs->eax = _pinfo((struct ProcessInfo*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_SLEEP:
_sleep(regs->ebx);
break;
case _SYS_NICE:
regs->eax = _nice(regs->ebx);
break;
case _SYS_RENICE:
regs->eax = _renice(regs->ebx, regs->ecx);
break;
case _SYS_CLOSE:
regs->eax = _close(regs->ebx);
break;
case _SYS_OPEN:
regs->eax = _open((char*)translate(regs->ebx), regs->ecx, regs->edx);
break;
case _SYS_CREAT:
regs->eax = _creat((char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_MKDIR:
regs->eax = _mkdir((const char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_RMDIR:
regs->eax = _rmdir((const char*)translate(regs->ebx));
break;
case _SYS_UNLINK:
regs->eax = _unlink((const char*)translate(regs->ebx));
break;
case _SYS_RENAME:
regs->eax = _rename((const char*)translate(regs->ebx), (const char*)translate(regs->ecx));
break;
case _SYS_CHDIR:
regs->eax = _chdir((const char*)translate(regs->ebx));
break;
case _SYS_GETCWD:
regs->eax = _getcwd((char*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_READDIR:
regs->eax = _readdir(regs->ebx, (struct fs_DirectoryEntry*)translate(regs->ecx), regs->edx);
break;
case _SYS_SETPPERSONA:
_setProcessPersona(regs->ebx, regs->ecx, regs->edx);
break;
case _SYS_GETPPERSONA:
_getProcessPersona(regs->ebx, (int*)translate(regs->ecx), (int*) translate(regs->edx));
break;
case _SYS_SYMLINK:
regs->eax = _symlink((const char *)translate(regs->ebx), (const char *)translate(regs->ecx));
break;
case _SYS_MKFIFO:
regs->eax = _mkfifo((const char*)translate(regs->ebx));
break;
case _SYS_CHMOD:
regs->eax = _chmod(regs->ebx, (const char*)translate(regs->ecx));
break;
case _SYS_STAT:
regs->eax = _stat((const char*)translate(regs->ebx), (struct stat*)translate(regs->ecx));
break;
case _SYS_CHOWN:
regs->eax = _chown((const char*)translate(regs->ebx));
break;
case _SYS_LOG:
_loglevel(regs->ebx);
break;
case _SYS_STACKSIZE:
regs->eax = _stacksize();
}
}
