X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;ds=sidebyside;f=Kernel%2Fvfs%2Fopen.c;h=1845b7a43cc55ca97935b4e636f37921fefe756e;hb=f0ffa8c904a7a99e115e926b4bf59d9749e86334;hp=03d8b2b1d3e0fa54068fb4edc4f1f7ee2c3ed58f;hpb=17637d37f347ede8f7dcd0c5ce92f0579d32a6ff;p=tpg%2Facess2.git diff --git a/Kernel/vfs/open.c b/Kernel/vfs/open.c index 03d8b2b1..1845b7a4 100644 --- a/Kernel/vfs/open.c +++ b/Kernel/vfs/open.c @@ -19,6 +19,9 @@ extern tVFS_Node gVFS_MemRoot; extern tVFS_Mount *gVFS_RootMount; extern int VFS_AllocHandle(int bIsUser, tVFS_Node *Node, int Mode); +// === PROTOTYPES === + int VFS_int_CreateHandle( tVFS_Node *Node, tVFS_Mount *Mount, int Mode ); + // === CODE === /** * \fn char *VFS_GetAbsPath(const char *Path) @@ -61,13 +64,14 @@ char *VFS_GetAbsPath(const char *Path) // Check if the path is already absolute if(Path[0] == '/') { - ret = malloc(pathLen + 1); + ret = malloc(chrootLen + pathLen + 1); if(!ret) { Log_Warning("VFS", "VFS_GetAbsPath: malloc() returned NULL"); return NULL; } - strcpy(ret, Path); - } else { + strcpy(ret + chrootLen, Path); + } + else { if(cwd == NULL) { cwd = "/"; cwdLen = 1; @@ -76,15 +80,15 @@ char *VFS_GetAbsPath(const char *Path) cwdLen = strlen(cwd); } // Prepend the current directory - ret = malloc( cwdLen + 1 + pathLen + 1 ); - strcpy(ret, cwd); + ret = malloc(chrootLen + cwdLen + 1 + pathLen + 1 ); + strcpy(ret+chrootLen, cwd); ret[cwdLen] = '/'; - strcpy(&ret[cwdLen+1], Path); + strcpy(ret+chrootLen+cwdLen+1, Path); //Log("ret = '%s'", ret); } // Parse Path - pathComps[iPos++] = tmpStr = ret+1; + pathComps[iPos++] = tmpStr = ret+chrootLen+1; while(*tmpStr) { if(*tmpStr++ == '/') @@ -132,7 +136,7 @@ char *VFS_GetAbsPath(const char *Path) pathComps[iPos2] = NULL; // Build New Path - iPos2 = 1; iPos = 0; + iPos2 = chrootLen + 1; iPos = 0; ret[0] = '/'; while(pathComps[iPos]) { @@ -149,17 +153,12 @@ char *VFS_GetAbsPath(const char *Path) ret[iPos2-1] = 0; else ret[iPos2] = 0; - - + // Prepend the chroot - tmpStr = malloc(chrootLen + strlen(ret) + 1); - strcpy( tmpStr, chroot ); - strcpy( tmpStr+chrootLen, ret ); - free(ret); - ret = tmpStr; + memcpy( ret, chroot, chrootLen ); LEAVE('s', ret); - //Log("VFS_GetAbsPath: RETURN '%s'", ret); +// Log_Debug("VFS", "VFS_GetAbsPath: RETURN '%s'", ret); return ret; } @@ -167,7 +166,7 @@ char *VFS_GetAbsPath(const char *Path) * \fn char *VFS_ParsePath(const char *Path, char **TruePath) * \brief Parses a path, resolving sysmlinks and applying permissions */ -tVFS_Node *VFS_ParsePath(const char *Path, char **TruePath) +tVFS_Node *VFS_ParsePath(const char *Path, char **TruePath, tVFS_Mount **MountPoint) { tVFS_Mount *mnt, *longestMount; int cmp, retLength = 0; @@ -186,6 +185,9 @@ tVFS_Node *VFS_ParsePath(const char *Path, char **TruePath) strcpy(*TruePath, Path); } curNode = gVFS_MemRoot.FindDir(&gVFS_MemRoot, Path); + if(MountPoint) { + *MountPoint = NULL; + } LEAVE('p', curNode); return curNode; } @@ -197,6 +199,7 @@ restart_parse: *TruePath = malloc( gVFS_RootMount->MountPointLen+1 ); strcpy(*TruePath, gVFS_RootMount->MountPoint); } + if(MountPoint) *MountPoint = gVFS_RootMount; LEAVE('p', gVFS_RootMount->RootNode); return gVFS_RootMount->RootNode; } @@ -226,6 +229,8 @@ restart_parse: *TruePath = malloc( mnt->MountPointLen+1 ); strcpy(*TruePath, mnt->MountPoint); } + if(MountPoint) + *MountPoint = mnt; LEAVE('p', mnt->RootNode); return mnt->RootNode; } @@ -400,7 +405,7 @@ restart_parse: } // Get last node - LOG("VFS_ParsePath: FindDir(%p, '%s')", curNode, &Path[ofs]); + LOG("FindDir(%p, '%s')", curNode, &Path[ofs]); tmpNode = curNode->FindDir(curNode, &Path[ofs]); LOG("tmpNode = %p", tmpNode); if(curNode->Close) curNode->Close(curNode); @@ -433,11 +438,51 @@ restart_parse: // - Extend Path //retLength += strlen(tmpNode->Name) + 1; } + + if( MountPoint ) { + *MountPoint = mnt; + } LEAVE('p', tmpNode); return tmpNode; } +/** + * \brief Create and return a handle number for the given node and mode + */ +int VFS_int_CreateHandle( tVFS_Node *Node, tVFS_Mount *Mount, int Mode ) +{ + int i; + + ENTER("pNode pMount iMode", Node, Mount, Mode); + + i = 0; + i |= (Mode & VFS_OPENFLAG_EXEC) ? VFS_PERM_EXECUTE : 0; + i |= (Mode & VFS_OPENFLAG_READ) ? VFS_PERM_READ : 0; + i |= (Mode & VFS_OPENFLAG_WRITE) ? VFS_PERM_WRITE : 0; + + LOG("i = 0b%b", i); + + // Permissions Check + if( !VFS_CheckACL(Node, i) ) { + if(Node->Close) Node->Close( Node ); + Log_Log("VFS", "VFS_int_CreateHandle: Permissions Failed"); + errno = EACCES; + LEAVE_RET('i', -1); + } + + i = VFS_AllocHandle( !!(Mode & VFS_OPENFLAG_USER), Node, Mode ); + if( i < 0 ) { + Log_Notice("VFS", "VFS_int_CreateHandle: Out of handles"); + errno = ENFILE; + LEAVE_RET('i', -1); + } + + VFS_GetHandle(i)->Mount = Mount; + + LEAVE_RET('x', i); +} + /** * \fn int VFS_Open(const char *Path, Uint Mode) * \brief Open a file @@ -445,8 +490,8 @@ restart_parse: int VFS_Open(const char *Path, Uint Mode) { tVFS_Node *node; + tVFS_Mount *mnt; char *absPath; - int i; ENTER("sPath xMode", Path, Mode); @@ -458,12 +503,13 @@ int VFS_Open(const char *Path, Uint Mode) } LOG("absPath = \"%s\"", absPath); // Parse path and get mount point - node = VFS_ParsePath(absPath, NULL); + node = VFS_ParsePath(absPath, NULL, &mnt); // Free generated path free(absPath); if(!node) { LOG("Cannot find node"); + errno = ENOENT; LEAVE_RET('i', -1); } @@ -484,89 +530,84 @@ int VFS_Open(const char *Path, Uint Mode) tmppath[ node->Size ] = '\0'; if(node->Close) node->Close( node ); // Open the target - node = VFS_ParsePath(tmppath, NULL); + node = VFS_ParsePath(tmppath, NULL, &mnt); if(!node) { LOG("Cannot find symlink target node (%s)", tmppath); + errno = ENOENT; LEAVE_RET('i', -1); } } - - i = 0; - i |= (Mode & VFS_OPENFLAG_EXEC) ? VFS_PERM_EXECUTE : 0; - i |= (Mode & VFS_OPENFLAG_READ) ? VFS_PERM_READ : 0; - i |= (Mode & VFS_OPENFLAG_WRITE) ? VFS_PERM_WRITE : 0; - - LOG("i = 0b%b", i); - - // Permissions Check - if( !VFS_CheckACL(node, i) ) { - if(node->Close) node->Close( node ); - Log_Log("VFS", "VFS_Open: Permissions Failed"); - LEAVE_RET('i', -1); - } - - i = VFS_AllocHandle( !!(Mode & VFS_OPENFLAG_USER), node, Mode ); - if( i < 0 ) { - Log_Notice("VFS", "VFS_Open: Out of handles"); - LEAVE_RET('i', -1); - } - - LEAVE_RET('x', i); + + LEAVE_RET('x', VFS_int_CreateHandle(node, mnt, Mode)); } /** * \brief Open a file from an open directory */ -int VFS_OpenChild(Uint *Errno, int FD, const char *Name, Uint Mode) +int VFS_OpenChild(int FD, const char *Name, Uint Mode) { tVFS_Handle *h; tVFS_Node *node; - int i; + ENTER("xFD sName xMode", FD, Name, Mode); + // Get handle h = VFS_GetHandle(FD); if(h == NULL) { Log_Warning("VFS", "VFS_OpenChild - Invalid file handle 0x%x", FD); - if(Errno) *Errno = EINVAL; + errno = EINVAL; LEAVE_RET('i', -1); } // Check for directory if( !(h->Node->Flags & VFS_FFLAG_DIRECTORY) ) { Log_Warning("VFS", "VFS_OpenChild - Passed handle is not a directory", FD); - if(Errno) *Errno = ENOTDIR; + errno = ENOTDIR; LEAVE_RET('i', -1); } // Find Child node = h->Node->FindDir(h->Node, Name); if(!node) { - if(Errno) *Errno = ENOENT; + errno = ENOENT; LEAVE_RET('i', -1); } + + LEAVE_RET('x', VFS_int_CreateHandle(node, h->Mount, Mode)); +} + +int VFS_OpenInode(Uint32 Mount, Uint64 Inode, int Mode) +{ + tVFS_Mount *mnt; + tVFS_Node *node; + + ENTER("iMount XInode xMode", Mount, Inode, Mode); - i = 0; - i |= (Mode & VFS_OPENFLAG_EXEC) ? VFS_PERM_EXECUTE : 0; - i |= (Mode & VFS_OPENFLAG_READ) ? VFS_PERM_READ : 0; - i |= (Mode & VFS_OPENFLAG_WRITE) ? VFS_PERM_WRITE : 0; - - // Permissions Check - if( !VFS_CheckACL(node, i) ) { - if(node->Close) node->Close( node ); - Log_Notice("VFS", "VFS_OpenChild - Permissions Failed"); - if(Errno) *Errno = EACCES; + // Get mount point + mnt = VFS_GetMountByIdent(Mount); + if( !mnt ) { + LOG("Mount point ident invalid"); + errno = ENOENT; LEAVE_RET('i', -1); } - i = VFS_AllocHandle( !!(Mode & VFS_OPENFLAG_USER), node, Mode ); - if( i >= 0 ) { - LEAVE_RET('x', i); + // Does the filesystem support this? + if( !mnt->Filesystem->GetNodeFromINode ) { + LOG("Filesystem does not support inode accesses"); + errno = ENOENT; + LEAVE_RET('i', -1); + } + + // Get node + node = mnt->Filesystem->GetNodeFromINode(mnt->RootNode, Inode); + if( !node ) { + LOG("Unable to find inode"); + errno = ENOENT; + LEAVE_RET('i', -1); } - Log_Error("VFS", "VFS_OpenChild - Out of handles"); - if(Errno) *Errno = ENFILE; - LEAVE_RET('i', -1); + LEAVE_RET('x', VFS_int_CreateHandle(node, mnt, Mode)); } /** @@ -610,14 +651,14 @@ int VFS_ChDir(const char *Dest) // Create Absolute buf = VFS_GetAbsPath(Dest); if(buf == NULL) { - Log("VFS_ChDir: Path expansion failed"); + Log_Notice("VFS", "VFS_ChDir: Path expansion failed"); return -1; } // Check if path exists fd = VFS_Open(buf, VFS_OPENFLAG_EXEC); if(fd == -1) { - Log("VFS_ChDir: Path is invalid"); + Log_Notice("VFS", "VFS_ChDir: Path is invalid"); return -1; }