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; }