X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fvfs%2Fopen.c;h=1845b7a43cc55ca97935b4e636f37921fefe756e;hb=7b8c541cd83b70296325dbbf047d682fd7b03c22;hp=02c9266f6f28e702667f39b05df31f2da201eba0;hpb=1c0241059f70e035cc1189d2bbc55ebf16dcc1d6;p=tpg%2Facess2.git diff --git a/Kernel/vfs/open.c b/Kernel/vfs/open.c index 02c9266f..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,21 +199,20 @@ 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; } // Check if there is anything mounted if(!gVFS_Mounts) { - Warning("WTF! There's nothing mounted?"); + Log_Error("VFS", "VFS_ParsePath - No filesystems mounted"); return NULL; } // Find Mountpoint longestMount = gVFS_RootMount; - for(mnt = gVFS_Mounts; - mnt; - mnt = mnt->Next) + for(mnt = gVFS_Mounts; mnt; mnt = mnt->Next) { // Quick Check if( Path[mnt->MountPointLen] != '/' && Path[mnt->MountPointLen] != '\0') @@ -228,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; } @@ -318,7 +321,7 @@ restart_parse: *TruePath = NULL; } if(!curNode->Read) { - Warning("VFS_ParsePath - Read of node %p is NULL (%s)", + Log_Warning("VFS", "VFS_ParsePath - Read of symlink node %p'%s' is NULL", curNode, Path); if(curNode->Close) curNode->Close(curNode); // No need to free *TruePath, it should already be NULL @@ -345,12 +348,12 @@ restart_parse: } curNode->Read( curNode, 0, curNode->Size, path_buffer ); path_buffer[ curNode->Size ] = '\0'; - strcat(path_buffer, &Path[ofs+nextSlash]); + strcat(path_buffer, Path + ofs+nextSlash); Path = path_buffer; +// Log_Debug("VFS", "VFS_ParsePath: Symlink translated to '%s'", Path); iNestedLinks ++; } - // EVIL: Goto :) goto restart_parse; @@ -359,7 +362,7 @@ restart_parse: // Handle Non-Directories if( !(curNode->Flags & VFS_FFLAG_DIRECTORY) ) { - Warning("VFS_ParsePath - File in directory context"); + Log_Warning("VFS", "VFS_ParsePath - Path segment is not a directory"); if(TruePath) free(*TruePath); LEAVE('n'); return NULL; @@ -372,7 +375,7 @@ restart_parse: tmp = realloc( *TruePath, retLength + strlen(pathEle) + 1 + 1 ); // Check if allocation succeeded if(!tmp) { - Warning("VFS_ParsePath - Unable to reallocate true path buffer"); + Log_Warning("VFS", "VFS_ParsePath - Unable to reallocate true path buffer"); free(*TruePath); *TruePath = NULL; if(curNode->Close) curNode->Close(curNode); @@ -396,13 +399,13 @@ restart_parse: free(*TruePath); *TruePath = NULL; } - Log("FindDir fail on '%s'", Path); + Log_Warning("VFS", "VFS_ParsePath - FindDir doesn't exist for element of '%s'", Path); LEAVE('n'); return NULL; } // 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); @@ -435,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 @@ -447,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); @@ -456,128 +499,115 @@ int VFS_Open(const char *Path, Uint Mode) absPath = VFS_GetAbsPath(Path); if(absPath == NULL) { Log_Warning("VFS", "VFS_Open: Path expansion failed '%s'", Path); - return -1; + LEAVE_RET('i', -1); } 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"); - LEAVE('i', -1); - return -1; + errno = ENOENT; + LEAVE_RET('i', -1); } // Check for symlinks if( !(Mode & VFS_OPENFLAG_NOLINK) && (node->Flags & VFS_FFLAG_SYMLINK) ) { + char tmppath[node->Size+1]; + if( node->Size > MAX_PATH_LEN ) { + Log_Warning("VFS", "VFS_Open - Symlink is too long (%i)", node->Size); + LEAVE_RET('i', -1); + } if( !node->Read ) { - Warning("No read method on symlink"); - LEAVE('i', -1); - return -1; + Log_Warning("VFS", "VFS_Open - No read method on symlink"); + LEAVE_RET('i', -1); } - absPath = malloc(node->Size+1); // Allocate Buffer - node->Read( node, 0, node->Size, absPath ); // Read Path - - absPath[ node->Size ] = '\0'; // End String - if(node->Close) node->Close( node ); // Close old node - node = VFS_ParsePath(absPath, NULL); // Get new node - free( absPath ); // Free allocated path - } - - if(!node) { - LOG("Cannot find node"); - LEAVE('i', -1); - return -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) ) { + // Read symlink's path + node->Read( node, 0, node->Size, tmppath ); + tmppath[ node->Size ] = '\0'; if(node->Close) node->Close( node ); - Log("VFS_Open: Permissions Failed"); - LEAVE('i', -1); - return -1; - } - - i = VFS_AllocHandle( !!(Mode & VFS_OPENFLAG_USER), node, Mode ); - if( i >= 0 ) { - LEAVE('x', i); - return i; + // Open the target + node = VFS_ParsePath(tmppath, NULL, &mnt); + if(!node) { + LOG("Cannot find symlink target node (%s)", tmppath); + errno = ENOENT; + LEAVE_RET('i', -1); + } } - - Log("VFS_Open: Out of handles"); - LEAVE('i', -1); - return -1; + + 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; - LEAVE('i', -1); - return -1; + 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; - LEAVE('i', -1); - return -1; + errno = ENOTDIR; + LEAVE_RET('i', -1); } // Find Child node = h->Node->FindDir(h->Node, Name); if(!node) { - if(Errno) *Errno = ENOENT; - LEAVE('i', -1); - return -1; + 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; - LEAVE('i', -1); - return -1; + // 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('x', i); - return 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('i', -1); - return -1; + LEAVE_RET('x', VFS_int_CreateHandle(node, mnt, Mode)); } /** @@ -621,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; }