/** * Get attributes from an open file * * This method is called instead of the getattr() method if the * file information is available. * * Currently this is only called after the create() method if that * is implemented (see above). Later it may be called for * invocations of fstat() too. * */ int nphfuse_fgetattr(const char *path, struct stat *statbuf, struct fuse_file_info *fi) { log_msg("Into fgetattr.\n"); npheap_store *inode = NULL; char dir[236]; char filename[128]; if(strcmp(path,"/")==0){ inode = getRootDirectory(); if(inode==NULL) { log_msg("Root directory not found in getattr.\n"); return -ENOENT; }else{ log_msg("Everything worked fine\n"); memcpy(statbuf, &inode->mystat, sizeof(struct stat)); return 0; } } inode = retrieve_inode(path); if(inode==NULL){ return -ENOENT; } log_msg("Worked fine\n"); memcpy(statbuf, &inode->mystat, sizeof(struct stat)); return 0; }
/** Get file attributes. * * Similar to stat(). The 'st_dev' and 'st_blksize' fields are * ignored. The 'st_ino' field is ignored except if the 'use_ino' * mount option is given. */ int nphfuse_getattr(const char *path, struct stat *stbuf){ // extract_directory_file(dir,filename,path); npheap_store *inode = NULL; if(strcmp(path,"/")==0){ inode = getRootDirectory(); if(inode==NULL) { log_msg("Root directory not found in getattr.\n"); return -ENOENT; } else { log_msg("Assigning root stbuf in getattr\n"); memcpy(stbuf, &inode->mystat, sizeof(struct stat)); return 0; } } inode = retrieve_inode(path); if(inode == NULL){ return -ENOENT; } // else return the proper value log_msg("Assigning normal stbuf in getattr\n"); memcpy(stbuf, &inode->mystat, sizeof(struct stat)); return 0; }
/** Change the owner and group of a file */ int nphfuse_chown(const char *path, uid_t uid, gid_t gid){ log_msg("Entry into CHOWN.\n"); npheap_store *inode = NULL; struct timeval currTime; if(strcmp (path,"/")==0){ log_msg("Calling getRootDirectory() in CHOWN.\n"); inode = getRootDirectory(); if(inode==NULL) { log_msg("Root directory not found. in CHOWN.\n"); return -ENOENT; } else { log_msg("Root directory found. in CHOWN.\n"); //Check if accessibilty can be given int flag = checkAccess(inode); //Deny the access if(flag == 0){ return -EACCES; } //else set correct value log_msg("Owner of root changed in CHOWN.\n", path); gettimeofday(&currTime, NULL); inode->mystat.st_uid = uid; inode->mystat.st_gid = gid; inode->mystat.st_ctime = currTime.tv_sec; log_msg("Exit from CHOWN.\n"); return 0; } } inode = retrieve_inode(path); if(inode == NULL){ log_msg("Couldn't find path - %s - in CHOWN.\n", path); return -ENOENT; } //Check Accessibility int flag1 = checkAccess(inode); //Deny the access if(flag1 == 0){ return -EACCES; } //else set correct value log_msg("Owner of path - %s - changed in CHOWN.\n", path); gettimeofday(&currTime, NULL); inode->mystat.st_uid = uid; inode->mystat.st_gid = gid; inode->mystat.st_ctime = currTime.tv_sec; log_msg("Exit from CHOWN.\n"); return 0; }
ConfigImpl::ConfigImpl(MemoryPool& p) : ConfigRoot(p), confMessage(p) { // Prepare some stuff ConfigFile file(p); root_dir = getRootDirectory(); const int size = FB_NELEM(entries); values = FB_NEW(p) ConfigValue[size]; //string val_sep = ","; file.setConfigFilePath(getConfigFilePath()); // Iterate through the known configuration entries for (int i = 0; i < size; i++) { const ConfigEntry entry = entries[i]; const string value = getValue(file, entries[i].key); if (!value.length()) { // Assign the default value values[i] = entries[i].default_value; continue; } // Assign the actual value switch (entry.data_type) { case TYPE_BOOLEAN: values[i] = (ConfigValue) asBoolean(value); break; case TYPE_INTEGER: values[i] = (ConfigValue) asInteger(value); break; case TYPE_STRING: { const char* src = asString(value); char* dst = FB_NEW(p) char[strlen(src) + 1]; strcpy(dst, src); values[i] = (ConfigValue) dst; } break; //case TYPE_STRING_VECTOR: // break; } } if (file.getMessage()) { confMessage = file.getMessage(); } }
/** Change the access and/or modification times of a file */ int nphfuse_utime(const char *path, struct utimbuf *ubuf){ log_msg("Into utime.\n"); npheap_store *temp = NULL; if(strcmp(path,"/")==0){ temp = getRootDirectory(); if(temp==NULL) { log_msg("Root directory not found in utime.\n"); return -ENOENT; } else { int flag = checkAccess(temp); if(flag==0){ log_msg("Cannot access in root.\n"); return - EACCES; } // Set from ubuf if(ubuf->actime){ temp->mystat.st_atime = ubuf->actime; } if(ubuf->modtime){ temp->mystat.st_mtime = ubuf->modtime; } log_msg("Ubuf ran successfully.! \n"); return 0; } } temp = retrieve_inode(path); if(temp==0){ log_msg("Cannot find the inode in ubuf.\n"); return -ENOENT; } int flag1 = checkAccess(temp); if(flag1==0){ log_msg("Cannot access the asked inode.\n"); return - EACCES; } if(ubuf->actime){ temp->mystat.st_atime = ubuf->actime; } if(ubuf->modtime){ temp->mystat.st_mtime = ubuf->modtime; } log_msg("Ubuf ran successfully.! \n"); return 0; }
WidgetErrorType WidgetDigSignValidation::updateInstallationPaths( const QString& processUid ) { if( processUid.isEmpty() ) return EErrorDigSigValidationGeneral; QString rootDirectory = m_WidgetInfo[ EPropertyInstallDirectory ].toString(); QString rootDir = getRootDirectory( rootDirectory, processUid ); if(rootDir.isEmpty() || rootDir.isNull() ) return EErrorFileSystemPermissionDenied; m_WidgetInfo[ EPropertyInstallDirectory ] = rootDir; m_WidgetInfo[ EPropertySettingsDirectory ] = DefaultDrive + QDir::separator() + PrivateDirectory + QDir::separator() + processUid + QDir::separator() + DataFolderName; //DataPath; return EErrorNone; }
//Allocate the superblock and the inode static void initialAllocationNPheap(void){ uint64_t offset = 1; npheap_store *npheap_dt = NULL; char *block_dt = NULL; npheap_store *head_dir = NULL; npheap_fd = open(nphfuse_data->device_name, O_RDWR); log_msg("Allocation started for %d.\n", offset); if(npheap_getsize(npheap_fd, offset) == 0){ log_msg("Allocating root block into NPHeap!\n"); block_dt = (char *)npheap_alloc(npheap_fd,offset, 8192); if(block_dt == NULL){ log_msg("Allocation of root block failed.\n"); return; } memset(block_dt,0, npheap_getsize(npheap_fd, offset)); memset(blk_array,0, sizeof(char *) * 9999); memset(&dt_link,0,sizeof(dt_link)); } log_msg("Allocation done for npheap %d.\n", npheap_getsize(npheap_fd, offset)); for(offset = 2; offset < 502; offset++){ //log_msg("Inode allocation for %d offset\n", offset); if(npheap_getsize(npheap_fd, offset)==0){ block_dt = npheap_alloc(npheap_fd, offset, BLOCK_SIZE); memset(block_dt, 0, npheap_getsize(npheap_fd, offset)); } log_msg("Inode allocation for %d offset and %d size\n", offset,(npheap_getsize(npheap_fd, offset))); } head_dir = getRootDirectory(); log_msg("Assigning stat values\n"); strcpy(head_dir->dirname, "/"); strcpy(head_dir->filename, "/"); head_dir->mystat.st_ino = inode_off; inode_off++; head_dir->mystat.st_mode = S_IFDIR | 0755; head_dir->mystat.st_nlink = 2; head_dir->mystat.st_size = npheap_getsize(npheap_fd,1); head_dir->mystat.st_uid = getuid(); head_dir->mystat.st_gid = getgid(); return; }
/** File open operation * * No creation, or truncation flags (O_CREAT, O_EXCL, O_TRUNC) * will be passed to open(). Open should check if the operation * is permitted for the given flags. Optionally open may also * return an arbitrary filehandle in the fuse_file_info structure, * which will be passed to all file operations. * * Changed in version 2.2 */ int nphfuse_open(const char *path, struct fuse_file_info *fi){ struct timeval currTime; npheap_store *temp = NULL; //Check for root directory if(strcmp(path,"/")==0){ temp = getRootDirectory(); if(temp==NULL) { log_msg("Root directory not found in open.\n"); return -ENOENT; } else { int flag = checkAccess(temp); //If cannot access if(flag == 0){ log_msg("Root access denied.\n"); return -EACCES; } // Worked fine log_msg("Access granted to root.\n"); return 0; } } temp = retrieve_inode(path); if(temp == NULL){ return -ENOENT; } int flag1 = checkAccess(temp); //if cannot access if(flag1 == 0){ log_msg("Access denied.\n"); return -EACCES; } //Everything worked fine fi->fh = temp->mystat.st_ino; gettimeofday(&currTime, NULL); temp->mystat.st_atime = currTime.tv_sec; return 0; }
/** Open directory * * This method should check if the open operation is permitted for * this directory * * Introduced in version 2.3 */ int nphfuse_opendir(const char *path, struct fuse_file_info *fi){ // char *filename, *dir; // extract_directory_file(&dir,&filename,path); npheap_store *inode = NULL; log_msg("Entry into OPENDIR.\n"); if(strcmp (path,"/")==0){ inode = getRootDirectory(); if(inode==NULL) { log_msg("Root directory not found in opendir.\n"); return -ENOENT; } else { //Check if accessibilty can be given int flag = checkAccess(inode); //Deny the access log_msg("Root access %d (if 1 then yes)",flag); if(flag == 0){ return -EACCES; } return 0; } } inode = retrieve_inode(path); if(inode == NULL){ log_msg("Couldn't find path - %s - in OPENDIR.\n", path); return -ENOENT; } //Check Accessibility int flag1 = checkAccess(inode); //Deny the access log_msg("Normal access %d (if 1 then yes)",flag1); if(flag1 == 0){ return -EACCES; } //else return correct value log_msg("Exit into OPENDIR.\n"); return 0; }
int nphfuse_access(const char *path, int mask){ npheap_store *inode = NULL; if(strcmp(path,"/")==0){ inode = getRootDirectory(); if(inode==NULL) { log_msg("Root directory not found in access.\n"); return -ENOENT; } else { log_msg("Checking Access of root\n"); int flag = checkAccess(inode); if(flag==0){ log_msg("Cannot access the directory\n"); return -EACCES; } return 0; } } inode = retrieve_inode(path); if(inode == NULL){ return -ENOENT; } int flag = checkAccess(inode); if(flag==0){ log_msg("Cannot access the directory\n"); return -EACCES; } return 0; }
void ossimRpfToc::buildTocEntryList(ossimRpfHeader* rpfHeader) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimRpfToc::buildTocEntryList: entered.....\n"; } std::ifstream in(m_filename.c_str(), std::ios::in | std::ios::binary); if(!in) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimRpfToc::buildTocEntryList: invalid input leaving..... " << std::endl; } return; } if(rpfHeader) { if(traceDebug()) { rpfHeader->print(ossimNotify(ossimNotifyLevel_DEBUG)); } deleteTocEntryList(); ossimRpfBoundaryRectSectionSubheader *boundaryRect = rpfHeader->getNewBoundaryRectSectSubheader(in); if(boundaryRect) { if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG: Got boundary rect\n"; } std::streamoff current = in.tellg(); // they give the offset from the // end of the boundary subheader to the start of the // entry table. We have to create an absolute // offset. current += boundaryRect->getTableOffset(); // take to the start of the table entries in.seekg(current, ios::beg); allocateTocEntryList(boundaryRect->getNumberOfEntries()); // now we can read the entries if(m_tocEntryList.size() > 0) { for(ossim_uint32 index = 0; index < m_tocEntryList.size(); index++) { m_tocEntryList[index]->parseStream(in, rpfHeader->getByteOrder()); } } ossimRpfFrameFileIndexSectionSubheader* frameFileIndexHead = rpfHeader->getNewFrameFileIndexSectionSubheader(in); // get the offset to the table long offsetToIndexSubsection = in.tellg(); if(frameFileIndexHead) { ossimRpfFrameFileIndexRecord tempIndexRec; ossimRpfPathnameRecord tempPathNameRec; ossim_int32 count = frameFileIndexHead->getNumberOfIndexRecords(); while(count > 0) { tempIndexRec.parseStream(in, rpfHeader->getByteOrder() ); // get the path information. we must seek to a different location // within the file. So we must remember where we currently are at std::streamoff currentPosition = in.tellg(); in.seekg(offsetToIndexSubsection + tempIndexRec.getPathnameRecordOffset(), ios::beg); tempPathNameRec.parseStream(in, rpfHeader->getByteOrder()); // We have the root directory where all frame files are subfiles of // ossimString rootDirectory(ossimFilename(m_filename.path())+ // ossimFilename(ossimFilename::thePathSeparator)); ossimFilename rootDirectory; getRootDirectory(rootDirectory); // we have the actual path from the root directory to the // frame file. We must separate the two. There have been // occurrences where the path in the A.TOC file // is upper case but the path in the directory on the file // system is lower case. This // will fool the system in thinking the file does not exist // when it actually does. ossimString pathToFrameFile( ossimFilename(tempPathNameRec.getPathname()) + tempIndexRec.getFilename()); ossimRpfFrameEntry entry(rootDirectory, pathToFrameFile); m_tocEntryList[tempIndexRec.getBoundaryRecNumber()]->setEntry(entry, tempIndexRec.getLocationRowNumber(), tempIndexRec.getLocationColNumber()); // now go back to where we were in.seekg(currentPosition, ios::beg); --count; } delete frameFileIndexHead; frameFileIndexHead = 0; } } delete boundaryRect; boundaryRect = NULL; } if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "ossimRpfToc::buildTocEntryList: leaving....." << std::endl; } }
uHTTP::HTTP::StatusCode FileServer::httpRequestRecieved(uHTTP::HTTPRequest *httpReq) { if (isVerbose()) { std::string firstHeader; std::cout << "> " << httpReq->getRequestLine(firstHeader) << std::endl; for (uHTTP::HTTPHeaderList::iterator header = httpReq->getHeaders().begin(); header != httpReq->getHeaders().end(); header++) { std::cout << "> " << (*header)->getName() << " : " << (*header)->getValue() << std::endl; } } if (!httpReq->isGetRequest()) { return httpReq->returnBadRequest(); } uHTTP::URI reqUri; httpReq->getURI(reqUri); std::string systemPath; systemPath.append(getRootDirectory()); systemPath.append(reqUri.getPath()); std::ifstream contentFs; contentFs.open(systemPath.c_str(), std::ifstream::in | std::ifstream::binary); if (!contentFs.is_open()) { return httpReq->returnNotFound(); } size_t fileSize = (size_t)contentFs.seekg(0, std::ios::end).tellg(); contentFs.seekg(0, std::ios::beg); bool isBinary = false; while (contentFs.good()) { unsigned char c = contentFs.get(); if (contentFs.good()) { if (c == 0) { isBinary = true; break; } } } contentFs.close(); uHTTP::HTTPResponse httpRes; httpRes.setStatusCode(uHTTP::HTTP::OK_REQUEST); httpRes.setContentType(isBinary ? "application/octet-stream" : "text/plain"); httpRes.setContentLength(fileSize); if (verboseMode) { std::cout << "< " << httpRes.getFirstLine() << std::endl; for (uHTTP::HTTPHeaderList::iterator header = httpRes.getHeaders().begin(); header != httpRes.getHeaders().end(); header++) { std::cout << "< " << (*header)->getName() << " : " << (*header)->getValue() << std::endl; } } httpReq->post(&httpRes, true); if (httpReq->isHeadRequest()) { return uHTTP::HTTP::OK_REQUEST; } uHTTP::HTTPSocket *httpSocket = httpReq->getSocket(); contentFs.open(systemPath.c_str(), std::ifstream::in | std::ifstream::binary); if (contentFs.is_open()) { while (contentFs.good()) { unsigned char c = contentFs.get(); if (contentFs.good()) { httpSocket->post(c); if (isVerbose()) std::cout << c; } } } contentFs.close(); return uHTTP::HTTP::OK_REQUEST; }