Modules/Ext2 - Fixed zero-length filenames and memory leaks
[tpg/acess2.git] / KernelLand / Kernel / drv / proc.c
1 /*
2  * Acess2
3  * - Kernel Status Driver
4  */
5 #define DEBUG   1
6 #include <acess.h>
7 #include <modules.h>
8 #include <fs_devfs.h>
9 #include <fs_sysfs.h>
10
11 // === CONSTANTS ===
12 #define VERSION ((0 << 8) | (1))        // 0.01
13
14 // === TYPES ===
15 typedef struct sSysFS_Ent
16 {
17         struct sSysFS_Ent       *Next;
18         struct sSysFS_Ent       *ListNext;
19         struct sSysFS_Ent       *Parent;
20         tVFS_Node       Node;
21         char    Name[];
22 } tSysFS_Ent;
23
24 // === PROTOTYPES ===
25  int    SysFS_Install(char **Arguments);
26  int    SysFS_IOCtl(tVFS_Node *Node, int Id, void *Data);
27
28 #if 0
29  int    SysFS_RegisterFile(const char *Path, const char *Data, int Length);
30  int    SysFS_UpdateFile(int ID, const char *Data, int Length);
31  int    SysFS_RemoveFile(int ID);
32 #endif
33
34 char    *SysFS_Comm_ReadDir(tVFS_Node *Node, int Id);
35 tVFS_Node       *SysFS_Comm_FindDir(tVFS_Node *Node, const char *Filename);
36 size_t  SysFS_Comm_ReadFile(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer);
37 void    SysFS_Comm_CloseFile(tVFS_Node *Node);
38
39 // === GLOBALS ===
40 extern tSysFS_Ent       gSysFS_Version; // Defined Later
41 extern tSysFS_Ent       gSysFS_Root;    // Defined Later
42 MODULE_DEFINE(0, VERSION, SysFS, SysFS_Install, NULL, NULL);
43 tVFS_NodeType   gSysFS_FileNodeType = {
44         .TypeName = "SysFS File",
45         .Read = SysFS_Comm_ReadFile
46         };
47 tVFS_NodeType   gSysFS_DirNodeType = {
48         .TypeName = "SysFS Dir",
49         .ReadDir = SysFS_Comm_ReadDir,
50         .FindDir = SysFS_Comm_FindDir
51         };
52 tSysFS_Ent      gSysFS_Version_Kernel = {
53         NULL, NULL,     // Nexts
54         &gSysFS_Version,        // Parent
55         {
56                 .Inode = 1,     // File #1
57                 .ImplPtr = NULL,
58                 .ImplInt = (Uint)&gSysFS_Version_Kernel,        // Self-Link
59                 .Size = 0,
60                 .NumACLs = 1,
61                 .ACLs = &gVFS_ACL_EveryoneRO,
62                 .Type = &gSysFS_FileNodeType
63         },
64         "Kernel"
65 };
66 tSysFS_Ent      gSysFS_Version = {
67         NULL, NULL,
68         &gSysFS_Root,
69         {
70                 .Size = 1,
71                 .ImplPtr = &gSysFS_Version_Kernel,
72                 .ImplInt = (Uint)&gSysFS_Version,       // Self-Link
73                 .NumACLs = 1,
74                 .ACLs = &gVFS_ACL_EveryoneRX,
75                 .Flags = VFS_FFLAG_DIRECTORY,
76                 .Type = &gSysFS_DirNodeType
77         },
78         "Version"
79 };
80 // Root of the SysFS tree (just used to keep the code clean)
81 tSysFS_Ent      gSysFS_Root = {
82         NULL, NULL,
83         NULL,
84         {
85                 .Size = 1,
86                 .ImplPtr = &gSysFS_Version,
87                 .ImplInt = (Uint)&gSysFS_Root   // Self-Link
88         },
89         "/"
90 };
91 tDevFS_Driver   gSysFS_DriverInfo = {
92         NULL, "system",
93         {
94         .NumACLs = 1,
95         .ACLs = &gVFS_ACL_EveryoneRX,
96         .Flags = VFS_FFLAG_DIRECTORY,
97         .ImplPtr = &gSysFS_Version,
98         .Size = sizeof(gSysFS_Root)/sizeof(tSysFS_Ent),
99         .Type = &gSysFS_DirNodeType
100         }
101 };
102  int    giSysFS_NextFileID = 2;
103 tSysFS_Ent      *gSysFS_FileList;
104
105 // === CODE ===
106 /**
107  * \fn int SysFS_Install(char **Options)
108  * \brief Installs the SysFS Driver
109  */
110 int SysFS_Install(char **Options)
111 {
112         gSysFS_Version_Kernel.Node.Size = strlen(gsBuildInfo);
113         gSysFS_Version_Kernel.Node.ImplPtr = (void*)gsBuildInfo;
114
115         DevFS_AddDevice( &gSysFS_DriverInfo );
116         return MODULE_ERR_OK;
117 }
118
119 /**
120  * \fn int SysFS_RegisterFile(char *Path, char *Data, int Length)
121  * \brief Registers a file (buffer) for the user to be able to read from
122  * \param Path  Path for the file to be accessable from (relative to SysFS root)
123  * \param Data  Pointer to the data buffer (must be non-volatile)
124  * \param Length        Length of the data buffer
125  * \return The file's identifier
126  */
127 int SysFS_RegisterFile(const char *Path, const char *Data, int Length)
128 {
129          int    start = 0;
130          int    tmp;
131         tSysFS_Ent      *ent = NULL;
132         tSysFS_Ent      *child, *prev;
133         
134         // Find parent directory
135         while( (tmp = strpos(&Path[start], '/')) != -1 )
136         {
137                 prev = NULL;
138                 
139                 if(ent)
140                         child = ent->Node.ImplPtr;
141                 else
142                         child = gSysFS_DriverInfo.RootNode.ImplPtr;
143                 for( ; child; prev = child, child = child->Next )
144                 {
145                         if( strncmp( &Path[start], child->Name, tmp+1 ) == '/' )
146                                 break;
147                 }
148                 
149                 // Need a new directory?
150                 if( !child )
151                 {
152                         child = calloc( 1, sizeof(tSysFS_Ent)+tmp+1 );
153                         child->Next = NULL;
154                         memcpy(child->Name, &Path[start], tmp);
155                         child->Name[tmp] = '\0';
156                         child->Parent = ent;
157                         child->Node.Inode = 0;
158                         child->Node.ImplPtr = NULL;
159                         child->Node.ImplInt = (Uint)child;      // Uplink
160                         child->Node.NumACLs = 1;
161                         child->Node.ACLs = &gVFS_ACL_EveryoneRX;
162                         child->Node.Flags = VFS_FFLAG_DIRECTORY;
163                         child->Node.Type = &gSysFS_DirNodeType;
164                         if( !prev ) {
165                                 if(ent)
166                                         ent->Node.ImplPtr = child;
167                                 else
168                                         gSysFS_DriverInfo.RootNode.ImplPtr = child;
169                                 // ^^^ Impossible (There is already /Version)
170                         }
171                         else
172                                 prev->Next = child;
173                         if(ent)
174                                 ent->Node.Size ++;
175                         else
176                                 gSysFS_DriverInfo.RootNode.Size ++;
177                         Log_Log("SysFS", "Added directory '%s'", child->Name);
178                 }
179                 
180                 ent = child;
181                 
182                 start = tmp+1;
183         }
184         
185         // ent: Parent tSysFS_Ent or NULL
186         // start: beginning of last path element
187         
188         // Check if the name is taken
189         prev = NULL;
190         if(ent)
191                 child = ent->Node.ImplPtr;
192         else
193                 child = gSysFS_DriverInfo.RootNode.ImplPtr;
194         for( ; child; child = child->Next )
195         {
196                 if( strcmp( &Path[start], child->Name ) == 0 )
197                         break;
198         }
199         if( child ) {
200                 Log_Warning("SysFS", "'%s' is taken (in '%s')\n", &Path[start], Path);
201                 return 0;
202         }
203         
204         // Create new node
205         child = calloc( 1, sizeof(tSysFS_Ent)+strlen(&Path[start])+1 );
206         child->Next = NULL;
207         strcpy(child->Name, &Path[start]);
208         child->Parent = ent;
209         
210         child->Node.Inode = giSysFS_NextFileID++;
211         child->Node.ImplPtr = (void*)Data;
212         child->Node.ImplInt = (Uint)child;      // Uplink
213         child->Node.Size = Length;
214         child->Node.NumACLs = 1;
215         child->Node.ACLs = &gVFS_ACL_EveryoneRO;
216         child->Node.Type = &gSysFS_FileNodeType;
217         
218         // Add to parent's child list
219         if(ent) {
220                 ent->Node.Size ++;
221                 child->Next = ent->Node.ImplPtr;
222                 ent->Node.ImplPtr = child;
223         }
224         else {
225                 gSysFS_DriverInfo.RootNode.Size ++;
226                 child->Next = gSysFS_DriverInfo.RootNode.ImplPtr;
227                 gSysFS_DriverInfo.RootNode.ImplPtr = child;
228         }
229         // Add to global file list
230         child->ListNext = gSysFS_FileList;
231         gSysFS_FileList = child;
232         
233         Log_Log("SysFS", "Added '%s' (%p)", Path, Data);
234         
235         return child->Node.Inode;
236 }
237
238 /**
239  * \fn int SysFS_UpdateFile(int ID, char *Data, int Length)
240  * \brief Updates a file
241  * \param ID    Identifier returned by ::SysFS_RegisterFile
242  * \param Data  Pointer to the data buffer
243  * \param Length        Length of the data buffer
244  * \return Boolean Success
245  */
246 int SysFS_UpdateFile(int ID, const char *Data, int Length)
247 {
248         tSysFS_Ent      *ent;
249         
250         for( ent = gSysFS_FileList; ent; ent = ent->Next )
251         {
252                 // It's a reverse sorted list
253                 if(ent->Node.Inode < ID)        return 0;
254                 if(ent->Node.Inode == ID)
255                 {
256                         ent->Node.ImplPtr = (void*)Data;
257                         ent->Node.Size = Length;
258                         return 1;
259                 }
260         }
261         
262         return 0;
263 }
264
265 /**
266  * \fn int SysFS_RemoveFile(int ID)
267  * \brief Removes a file from user access
268  * \param ID    Identifier returned by ::SysFS_RegisterFile
269  * \return Boolean Success
270  * \note If a handle is still open to the file, it will be invalidated
271  */
272 int SysFS_RemoveFile(int ID)
273 {
274         tSysFS_Ent      *file;
275         tSysFS_Ent      *ent, *parent, *prev;
276         
277         prev = NULL;
278         for( ent = gSysFS_FileList; ent; prev = ent, ent = ent->Next )
279         {
280                 // It's a reverse sorted list
281                 if(ent->Node.Inode < ID)        return 0;
282                 if(ent->Node.Inode == ID)       break;
283         }
284         
285         if(!ent)        return 0;
286         
287         // Set up for next part
288         file = ent;
289         parent = file->Parent;
290         
291         // Remove from file list
292         if(prev)
293                 prev->ListNext = file->ListNext;
294         else
295                 gSysFS_FileList = file->ListNext;
296         file->Node.Size = 0;
297         file->Node.ImplPtr = NULL;
298         
299         // Search parent directory
300         for( ent = parent->Node.ImplPtr; ent; prev = ent, ent = ent->Next )
301         {
302                 if( ent == file )       break;
303         }
304         if(!ent) {
305                 Log_Warning("SysFS", "Bookkeeping Error: File in list, but not in directory");
306                 return 0;
307         }
308         
309         // Remove from parent directory
310         if(prev)
311                 prev->Next = ent->Next;
312         else
313                 parent->Node.ImplPtr = ent->Next;
314         
315         // Free if not in use
316         if(file->Node.ReferenceCount == 0)
317                 free(file);
318         
319         return 1;
320 }
321
322 /**
323  * \fn char *SysFS_Comm_ReadDir(tVFS_Node *Node, int Pos)
324  * \brief Reads from a SysFS directory
325  */
326 char *SysFS_Comm_ReadDir(tVFS_Node *Node, int Pos)
327 {
328         tSysFS_Ent      *child = (tSysFS_Ent*)Node->ImplPtr;
329         if(Pos < 0 || Pos >= Node->Size)        return NULL;
330         
331         for( ; child; child = child->Next, Pos-- )
332         {
333                 if( Pos == 0 )  return strdup(child->Name);
334         }
335         return NULL;
336 }
337
338 /**
339  * \fn tVFS_Node *SysFS_Comm_FindDir(tVFS_Node *Node, const char *Filename)
340  * \brief Find a file in a SysFS directory
341  */
342 tVFS_Node *SysFS_Comm_FindDir(tVFS_Node *Node, const char *Filename)
343 {
344         tSysFS_Ent      *child = (tSysFS_Ent*)Node->ImplPtr;
345         
346         for( ; child; child = child->Next )
347         {
348                 if( strcmp(child->Name, Filename) == 0 )
349                         return &child->Node;
350         }
351         
352         return NULL;
353 }
354
355 /**
356  * \brief Read from an exposed buffer
357  */
358 size_t SysFS_Comm_ReadFile(tVFS_Node *Node, off_t Offset, size_t Length, void *Buffer)
359 {
360         if( Offset > Node->Size )       return -1;
361         if( Length > Node->Size )       Length = Node->Size;
362         if( Offset + Length > Node->Size)       Length = Node->Size - Offset;
363         
364         if( Node->ImplPtr )
365                 memcpy(Buffer, (void*)((Uint)Node->ImplPtr+(Uint)Offset), Length);
366         else
367                 return -1;
368         
369         return Length;
370 }
371
372 /**
373  * \fn void SysFS_Comm_CloseFile(tVFS_Node *Node)
374  * \brief Closes an open file
375  * \param Node  Node to close
376  */
377 void SysFS_Comm_CloseFile(tVFS_Node *Node)
378 {
379         // Dereference
380         Node->ReferenceCount --;
381         if( Node->ReferenceCount > 0 )  return;
382         
383         // Check if it is still valid
384         if( Node->ImplPtr )     return;
385         
386         // Delete
387         free( (void*)Node->ImplInt );
388 }

UCC git Repository :: git.ucc.asn.au