int32_t File::readData(uint64_t offset, void* data, int32_t len)
{
trace("File::readData(fd=%d, offset=%"PRIu64", len=%d)\n", impl->fh, offset, len);
if (!isValid())
return VFS_ERR_BADHANDLE;
impl->overlapped.Offset = (uint32_t)offset;
impl->overlapped.OffsetHigh = (uint32_t)(offset>>32);
impl->overlapped.hEvent = 0;
if (!ReadFile(impl->fh, data, len, NULL, &impl->overlapped))
{
DWORD err = GetLastError();
if (err == ERROR_HANDLE_EOF)
return 0;
if (err != ERROR_IO_PENDING)
return translateError();
}
DWORD rlen;
if (!GetOverlappedResult(impl->fh, &impl->overlapped, &rlen, TRUE))
{
DWORD err = GetLastError();
if (err == ERROR_HANDLE_EOF)
return 0;
return translateError();
}
return rlen;
}
int32_t File::writeData(uint64_t offset, const void* data, int32_t len)
{
trace("File::writeData(fd=%d, offset=%"PRIu64", len=%d)\n", impl->fd,
offset, len);
if (impl->fd < 0)
return VFS_ERR_BADHANDLE;
if (impl->offset != offset)
{
int64_t result = lseek64(impl->fd, (int64_t)offset, SEEK_SET);
if (result == -1)
return translateError(result);
impl->offset = result;
}
ssize_t ret = write(impl->fd, data, len);
if (ret == -1)
return translateError(ret);
impl->offset += ret;
return ret;
}
SPIFI::SpifiError SPIFI::program(uint32_t dest, unsigned len, char* src, Options options, bool verify, char* scratch)
{
unsigned written = 0;
SPIFIopers opers;
opers.dest = (char *)dest;
opers.length = SPIFI_MIN(len, PROG_SIZE);
opers.scratch = scratch;
opers.protect = 0;
opers.options = options;
if (verify) {
opers.options |= S_VERIFY_PROG;
}
if (IS_ADDR_IN_SPIFI(src))
{
// The SPIFI ROM driver cannot write data from SPIFI into
// SPIFI (i.e. cannot read and write at the same time).
// The workaround is to copy the source data into a buffer
// in local memory and use that as source for the write
// instead.
while (written < len) {
memcpy(_addrConflictBuff, src + written, opers.length);
int rc = _spifi->spifi_program(_romData, _addrConflictBuff, &opers);
if (rc)
{
// got an error
return translateError(rc, verify);
}
written += opers.length;
opers.dest += opers.length;
opers.length = SPIFI_MIN(len - written, PROG_SIZE);
}
}
else
{
while (written < len) {
int rc = _spifi->spifi_program(_romData, src + written, &opers);
if (rc)
{
// got an error
return translateError(rc, verify);
}
written += opers.length;
opers.dest += opers.length;
opers.length = SPIFI_MIN(len - written, PROG_SIZE);
}
}
return Ok;
}
/*!
\fn qint64 Posix_QextSerialPort::bytesAvailable()
Returns the number of bytes waiting in the port's receive queue. This function will return 0 if
the port is not currently open, or -1 on error. Error information can be retrieved by calling
Posix_QextSerialPort::getLastError().
*/
qint64 Posix_QextSerialPort::bytesAvailable()
{
LOCK_MUTEX();
if (isOpen()) {
int bytesQueued;
fd_set fileSet;
FD_ZERO(&fileSet);
FD_SET(Posix_File->handle(), &fileSet);
/*on Linux systems the Posix_Timeout structure will be altered by the select() call.
Make sure we use the right timeout values*/
//memcpy(&Posix_Timeout, &Posix_Copy_Timeout, sizeof(struct timeval));
Posix_Timeout = Posix_Copy_Timeout;
int n=select(Posix_File->handle()+1, &fileSet, NULL, &fileSet, &Posix_Timeout);
if (!n) {
lastErr=E_PORT_TIMEOUT;
UNLOCK_MUTEX();
return -1;
}
if (n==-1 || ioctl(Posix_File->handle(), FIONREAD, &bytesQueued)==-1) {
translateError(errno);
UNLOCK_MUTEX();
return -1;
}
lastErr=E_NO_ERROR;
UNLOCK_MUTEX();
return bytesQueued + QIODevice::bytesAvailable();
}
UNLOCK_MUTEX();
return 0;
}
int32_t Mount::createFile(const char* filename)
{
trace("Mount::createFile(%s)\n", filename);
char cname[PATH_MAX];
int ret = canonicalise(cname, PATH_MAX, filename);
if (ret < 0)
return ret;
ret = open(cname, O_RDWR|O_CREAT|O_TRUNC, 0666);
if (ret < 0)
return translateError(ret);
return translateError(close(ret));
}
int32_t File::setSize(uint64_t size)
{
trace("File::setSize(fd=%d)\n", impl->fh);
if (!isValid())
return VFS_ERR_BADHANDLE;
LARGE_INTEGER pos;
pos.QuadPart = size;
if (!SetFilePointerEx(impl->fh, pos, NULL, FILE_BEGIN))
return translateError();
return translateError(SetEndOfFile(impl->fh));
}
GLContext* Win32Context::clone() const
{
// Create new context based on own HDC
HGLRC newCtx = wglCreateContext(mHDC);
if (!newCtx)
{
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
"Error calling wglCreateContext", "Win32Context::clone");
}
HGLRC oldrc = wglGetCurrentContext();
HDC oldhdc = wglGetCurrentDC();
wglMakeCurrent(NULL, NULL);
// Share lists with old context
if (!wglShareLists(mGlrc, newCtx))
{
String errorMsg = translateError();
wglDeleteContext(newCtx);
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, String("wglShareLists() failed: ") + errorMsg, "Win32Context::clone");
}
// restore old context
wglMakeCurrent(oldhdc, oldrc);
return new Win32Context(mHDC, newCtx);
}
int32_t MetaData::setFatAttributes(uint32_t attr)
{
DWORD dwAttr = 0;
if (attr & VFS_FAT_ATTR_READONLY)
dwAttr |= FILE_ATTRIBUTE_READONLY;
if (attr & VFS_FAT_ATTR_HIDDEN)
dwAttr |= FILE_ATTRIBUTE_HIDDEN;
if (attr & VFS_FAT_ATTR_SYSTEM)
dwAttr |= FILE_ATTRIBUTE_SYSTEM;
if (attr & VFS_FAT_ATTR_ARCHIVE)
dwAttr |= FILE_ATTRIBUTE_ARCHIVE;
// not essential
if (attr & VFS_FAT_ATTR_DIRECTORY)
{
if (type != VFS_TYPE_DIR)
return VFS_ERR_NOTDIR;
dwAttr |= FILE_ATTRIBUTE_DIRECTORY;
}
if (!(attr & VFS_FAT_ATTR_DIRECTORY))
{
if (type == VFS_TYPE_DIR)
return VFS_ERR_ISDIR;
}
if (dwAttr == 0)
dwAttr = FILE_ATTRIBUTE_NORMAL;
return translateError(SetFileAttributes(hostpath, dwAttr));
}
void TCPNetwork::tryConnect(unsigned short port, const std::string &ipAddress)
{
_sock.connectToHost(QString(ipAddress.c_str()), port);
if (_sock.waitForConnected(1000))
_onConnectHandler();
else
translateError();
}
int32_t File::syncData()
{
trace("File::syncData(fd=%d)\n", impl->fd);
if (impl->fd < 0)
return VFS_ERR_BADHANDLE;
return translateError(fsync(impl->fd));
}
int32_t File::syncData()
{
trace("File::syncData(fd=%d)\n", impl->fh);
if (!isValid())
return VFS_ERR_BADHANDLE;
return translateError(FlushFileBuffers(impl->fh));
}
int32_t DirIter::open()
{
trace("DirIter::open(name=%s)\n", impl->name);
impl->dir = opendir(impl->name);
if (impl->dir == NULL)
return translateError(-1);
return VFS_ERR_OK;
}
int MetaData::populate(const char* cname)
{
trace("MetaData::populate(name=%s)\n", cname);
if (hostpath)
free(hostpath);
if (filename)
free(filename);
hostpath = strdup(cname);
WIN32_FILE_ATTRIBUTE_DATA file_data;
if ( !GetFileAttributesEx(hostpath,
GetFileExInfoStandard,
&file_data) )
{
type = VFS_TYPE_NONE;
filename = strdup("");
return translateError();
}
mtime = vfs_time_from_filetime(file_data.ftLastWriteTime);
atime = vfs_time_from_filetime(file_data.ftLastAccessTime);
ctime = vfs_time_from_filetime(file_data.ftCreationTime);
// cache the attributes so we can generate fat attributes if required
mode = file_data.dwFileAttributes;
access = 0777;
filesize = ((uint64_t)(file_data.nFileSizeHigh)<<32) + file_data.nFileSizeLow;
char *slash;
slash = strrchr(hostpath, '\\');
if ( slash )
{
filename = strdup(slash + 1);
}
else
{
filename = strdup("");
}
if (file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
type = VFS_TYPE_DIR;
else
type = VFS_TYPE_FILE;
// TODO - links
trace(" mtime=%"PRIu64", access=%d, filesize=%"PRIu64", type=%d, name=%s\n", mtime, access, filesize, type, filename);
return VFS_ERR_OK;
}
int32_t File::setSize(uint64_t size)
{
trace("File::setSize(fd=%d)\n", impl->fd);
if (impl->fd < 0)
return VFS_ERR_BADHANDLE;
impl->offset = size;
return translateError(ftruncate(impl->fd, size));
}
int32_t Mount::createDir(const char* dirname)
{
trace("Mount::createDir(%s)\n", dirname);
char cname[PATH_MAX];
int ret = canonicalise(cname, PATH_MAX, dirname);
if (ret < 0)
return ret;
return translateError(mkdir(cname, 0777));
}
STATUS ossMutexTake
(
MUTEX_HANDLE mutexHandle, /* Mutex to take */
UINT32 blockFlag /* specifies blocking action */
)
{
if (semTake ((SEM_ID) mutexHandle, TIMEOUT (blockFlag)) != OK)
return ossStatus (translateError ());
return OK;
}
int32_t Mount::removeFile(const char* filename)
{
trace("Mount::removeFile(%s)\n", filename);
char cname[PATH_MAX];
int ret = canonicalise(cname, PATH_MAX, filename);
if (ret < 0)
return ret;
return translateError(remove(cname));
}
int32_t Mount::removeDir(const char* dirname)
{
trace("Mount::removeDir(%s)\n", dirname);
char cname[PATH_MAX];
int ret = canonicalise(cname, PATH_MAX, dirname);
if (ret < 0)
return ret;
return translateError(RemoveDirectory(cname));
}
STATUS ossSemTake
(
SEM_HANDLE semHandle, /* semaphore to take */
UINT32 blockFlag /* specifies blocking action */
)
{
if (semTake ((SEM_ID) semHandle, TIMEOUT (blockFlag)) != OK)
return ossStatus (translateError ());
return OK;
}
int MetaData::populate(const char* cname)
{
trace("MetaData::populate(name=%s)\n", cname);
if (hostpath)
free(hostpath);
hostpath = strdup(cname);
// this should be done by using Mount to call getInfo, or by deriving from
// MetaData
struct stat s;
int ret = lstat(cname, &s);
if (ret < 0)
return translateError(ret);
// todo mtime, access, etc
mtime = vfs_time_from_filetime(s.st_mtime);
atime = vfs_time_from_filetime(s.st_atime);
ctime = vfs_time_from_filetime(s.st_ctime);
access = 0777;
filesize = s.st_size;
// todo - not pretty
filename = strrchr(hostpath, '/') + 1;
if (ret == 0)
{
if (S_ISREG(s.st_mode))
type = VFS_TYPE_FILE;
else if (S_ISDIR(s.st_mode))
type = VFS_TYPE_DIR;
else if (S_ISLNK(s.st_mode))
type = VFS_TYPE_LINK;
else
type = VFS_TYPE_UNKNOWN;
}
else
{
type = VFS_TYPE_UNKNOWN;
}
// needed to synthesize fat attributes
mode = s.st_mode;
trace(" mtime=%"PRIu64", access=%d, filesize=%"PRIu64", type=%d, name=%s\n",
mtime, access, filesize, type, filename);
return 0;
}
int32_t File::close()
{
trace("File::close(fd=%d)\n", impl->fh);
if (!isValid())
return VFS_ERR_BADHANDLE;
if (!CloseHandle(impl->fh))
return translateError();
impl->fh = INVALID_HANDLE_VALUE;
return VFS_ERR_OK;
}
int32_t DirIter::close()
{
trace("DirIter::close(name=%s)\n", impl->name);
if (impl->dir == NULL)
return VFS_ERR_BADHANDLE;
int ret = translateError(closedir(impl->dir));
impl->dir = NULL;
impl->name[impl->namelen] = 0;
return ret;
}
int32_t Mount::createFile(const char* filename)
{
trace("Mount::createFile(%s)\n", filename);
char cname[PATH_MAX];
int ret = canonicalise(cname, PATH_MAX, filename);
if (ret < 0)
return ret;
HANDLE fh = CreateFile(cname,
GENERIC_READ|GENERIC_WRITE, // access
FILE_SHARE_READ|FILE_SHARE_WRITE, // share mode
0, // securty
CREATE_ALWAYS, // creation
FILE_ATTRIBUTE_NORMAL, // flags
NULL); // template
if (fh == INVALID_HANDLE_VALUE)
return translateError();
return translateError(CloseHandle(fh));
}
int main(int argc, char **argv)
{
int retval = 0;
struct parameters params;
/* initialize the server-level settings */
initServerSettings(startWorker);
/* initialize the parameters structure and parse the cmd line args */
params.runAsDaemon = true;
params.pidFile = NULL;
argp_parse(&parser, argc, argv, 0, NULL, ¶ms);
/* run as a daemon if requested and possible */
if (params.runAsDaemon)
{
message(LOG_DEBUG, "Forking into the background.\n");
if (daemon(0, 0) == 0)
umask(0);
else
{
message(LOG_ERROR, "daemon() failed: %s\n", translateError(errno));
retval = 1;
}
}
/* write the pid out if requested */
if (retval == 0 && params.pidFile != NULL)
{
FILE *pf;
pf = fopen(params.pidFile, "w");
if (pf == NULL)
{
message(LOG_ERROR, "Failed to open pid file.\n");
retval = 2;
}
else
{
fprintf(pf, "%d\n", getpid());
fclose(pf);
}
}
/* if startup succeeded wait for user signals */
if (retval == 0)
workLoop();
return retval;
}
int32_t Mount::removeFile(const char* filename)
{
trace("Mount::removeFile(%s)\n", filename);
char cname[PATH_MAX];
int ret = canonicalise(cname, PATH_MAX, filename);
if (ret < 0)
return ret;
// we also let this remove directories - might need a generic 'get attr' function
WIN32_FIND_DATA finddata;
HANDLE fh = FindFirstFile(cname, &finddata);
if (fh == INVALID_HANDLE_VALUE)
return translateError(FALSE);
FindClose(fh);
if (finddata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
return translateError(RemoveDirectory(cname));
else
return translateError(DeleteFile(cname));
}
QString StaticHelpers::translateBEncodeError(error_code const& ec)
{
static char const* msgs[] =
{
QT_TRANSLATE_NOOP("ErrorMsg", "no error"),
QT_TRANSLATE_NOOP("ErrorMsg", "expected string in bencoded string"),
QT_TRANSLATE_NOOP("ErrorMsg", "expected colon in bencoded string"),
QT_TRANSLATE_NOOP("ErrorMsg", "unexpected end of file in bencoded string"),
QT_TRANSLATE_NOOP("ErrorMsg", "expected value (list, dict, int or string) in bencoded string"),
QT_TRANSLATE_NOOP("ErrorMsg", "bencoded nesting depth exceeded"),
QT_TRANSLATE_NOOP("ErrorMsg", "bencoded item count limit exceeded"),
QT_TRANSLATE_NOOP("ErrorMsg", "integer overflow")
};
return translateError(ec, const_cast<char**>(msgs), sizeof(msgs) / sizeof(msgs[0]));
}
SPIFI::SpifiError SPIFI::erase(uint32_t dest, unsigned len, bool verify, char* scratch)
{
SPIFIopers opers;
opers.dest = (char *)dest;
opers.length = len;
opers.scratch = scratch;
opers.protect = 0;
if (verify) {
opers.options = S_VERIFY_ERASE;
} else {
opers.options = S_NO_VERIFY;
}
int rc = _spifi->spifi_erase(_romData, &opers);
return translateError(rc);
}
int32_t File::open(uint32_t flags)
{
trace("File::open(0x%d:%s%s%s%s%s)\n", flags,
flags & VFS_OPEN_RDONLY ? "read " : "",
flags & VFS_OPEN_WRONLY ? "write " : "",
flags & VFS_OPEN_CREATE ? "create " : "",
flags & VFS_OPEN_NEW ? "new " : "",
flags & VFS_OPEN_TRUNCATE ? "truncate " : "");
int oflags = 0;
if ((flags & VFS_OPEN_RDWR) == VFS_OPEN_RDWR)
oflags |= GENERIC_READ|GENERIC_WRITE;
else if (flags & VFS_OPEN_RDONLY)
oflags |= GENERIC_READ;
else if (flags & VFS_OPEN_WRONLY)
oflags |= GENERIC_WRITE;
DWORD create = OPEN_EXISTING;
if (flags & VFS_OPEN_CREATE)
{
if (flags & VFS_OPEN_TRUNCATE)
create = CREATE_ALWAYS;
else if (flags & VFS_OPEN_NEW)
create = CREATE_NEW;
else
create = OPEN_ALWAYS;
}
else if (flags & VFS_OPEN_TRUNCATE)
create = TRUNCATE_EXISTING;
// files are currently alwasys open shared to match the linux host implementation
HANDLE fh = CreateFile(impl->name,
oflags,
FILE_SHARE_READ|FILE_SHARE_WRITE,
0,
create,
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
NULL);
if (fh == INVALID_HANDLE_VALUE)
return translateError();
impl->fh = fh;
trace(" <- fd=%d\n", impl->fh);
return VFS_ERR_OK;
}
QString StaticHelpers::translateI2PError(error_code const& ec)
{
static char const* msgs[] =
{
QT_TRANSLATE_NOOP("ErrorMsg", "no error"),
QT_TRANSLATE_NOOP("ErrorMsg", "parse failed"),
QT_TRANSLATE_NOOP("ErrorMsg", "cannot reach peer"),
QT_TRANSLATE_NOOP("ErrorMsg", "i2p error"),
QT_TRANSLATE_NOOP("ErrorMsg", "invalid key"),
QT_TRANSLATE_NOOP("ErrorMsg", "invalid id"),
QT_TRANSLATE_NOOP("ErrorMsg", "timeout"),
QT_TRANSLATE_NOOP("ErrorMsg", "key not found"),
QT_TRANSLATE_NOOP("ErrorMsg", "duplicated id")
};
return translateError(ec, const_cast<char**>(msgs), sizeof(msgs) / sizeof(msgs[0]));
}
int32_t File::getSize(uint64_t* size)
{
trace("File::getSize(fd=%d)", impl->fh);
if (!isValid())
return VFS_ERR_BADHANDLE;
LARGE_INTEGER ret;
if (!GetFileSizeEx(impl->fh, &ret))
return translateError();
*size = ret.QuadPart;
trace(" <- size=%"PRId64"\n", *size);
return VFS_ERR_OK;
}
