Project

General

Profile

Download (5.92 KB) Statistics
| Revision:

repo2/firmware_legacy/sockit/linuxdir.c

#include "linuxdir.h"

#include "linuxfile.h"

#include <sys/types.h>
#include <dirent.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

enum SimpleFileStatus openfile(struct SimpleFile * file)
{
char buffer[256];
strncpy(&buffer[0],file->path,sizeof(buffer));
strncat(&buffer[0],"/",sizeof(buffer));
strncat(&buffer[0],file->name,sizeof(buffer));

if (0==access(buffer,R_OK|W_OK))
{
file->file = fopen(buffer,"r+");
}
else if (0==access(buffer,R_OK))
{
file->file = fopen(buffer,"r");
}

if (file->file)
{
return SimpleFile_OK;
}
else
{
return SimpleFile_FAIL;
}
}

enum SimpleFileStatus file_open_name(char const * path, struct SimpleFile * file)
{
strncpy(file->name,path,sizeof(file->name));
strncpy(file->path,path,sizeof(file->path));

return openfile(file);
}

enum SimpleFileStatus file_open_name_in_dir(struct SimpleDirEntry * entries, char const * filename, struct SimpleFile * file)
{
//entries->filename + "/" + filename;
strncpy(&file->name[0],filename,sizeof(file->name));
strncpy(&file->path[0],entries->path,sizeof(file->name));

return openfile(file);
}

enum SimpleFileStatus file_open_dir(struct SimpleDirEntry * entry, struct SimpleFile * file)
{
strncpy(&file->path[0],entry->path,sizeof(file->path));
strncpy(&file->name[0],entry->entry.d_name,sizeof(file->path));

return openfile(file);
}

// Reads entire dir into memory (i.e. give it a decent chunk of sdram)
char * dir_mem;
int dir_space;
enum SimpleFileStatus dir_init(void * mem, int space)
{
// Does own memory allow...
dir_mem = mem;
dir_space = space;
return SimpleFile_OK;
}

int dircmp(struct SimpleDirEntry * a, struct SimpleDirEntry * b)
{
if (dir_is_subdir(a)==dir_is_subdir(b))
return strcmp(a->entry.d_name,b->entry.d_name);
else
return (dir_is_subdir(a)<dir_is_subdir(b));
}

void sort_ll(struct SimpleDirEntry * h)
{
//struct SimpleDirEntry
//{
// char path[MAX_PATH_LENGTH];
// char * filename_ptr;
// int size;
// int is_subdir;
// struct SimpleDirEntry * next; // as linked list - want to allow sorting...
//};

struct SimpleDirEntry * p,*temp,*prev;
int i,j,n,sorted=0;
temp=h;
prev=0;
for(n=0;temp!=0;temp=temp->next) n++;

for(i=0;i<n-1 && !sorted;i++){
p=h;sorted=1;
prev=0;
for(j=0;j<n-(i+1);j++){
// printf("p->issubdir:%d(%s) p->next->issubdir:%d(%s)",p->is_subdir,p->path,p->next->is_subdir,p->next->path);

if(dircmp(p,p->next)>0) {
// printf("SWITCH!\n");
struct SimpleDirEntry * a = p;
struct SimpleDirEntry * b = p->next;
a->next=b->next;
b->next=a;
if (prev)
prev->next=b;
p=b;

sorted=0;
}
prev=p;
p=p->next;
}
}

//temp=h;
//for(n=0;temp!=0;temp=temp->next) printf("POST:%s\n",temp->path);
}

struct SimpleDirEntry * dir_entries_filtered(char const * dirPath, int (*filter)(struct SimpleDirEntry *))
{
struct SimpleDirEntry * entry = dir_entries(dirPath);
if (!entry) return 0;

struct SimpleDirEntry * temp1 = entry;
while (temp1)
{
printf("Entry_PRE filtered:%s\n",temp1->entry.d_name);
temp1 = temp1->next;
}

struct SimpleDirEntry * head = entry;
struct SimpleDirEntry * prev = 0;
while (entry)
{
if (!(*filter)(entry))
{
if (entry == head)
head = head->next;
else if (prev)
prev->next = entry->next;
}
else
{
prev = entry;
}

entry = entry->next;
}

struct SimpleDirEntry * temp = head;
while (temp)
{
printf("Entry_filtered:%s\n",temp->entry.d_name);
temp = temp->next;
}

printf("Sorting\n\n");

if (filter)
{
sort_ll((struct SimpleDirEntry *) head);
}

printf("sorted\n\n");
temp = head;
while (temp)
{
printf("Entry_sorted:%s\n",temp->entry.d_name);
temp = temp->next;
}

return head;
}

struct SimpleDirEntry * dir_entries(char const * dirPath)
{
DIR * dir = opendir(dirPath);
if (!dir) return 0;

char * mem = dir_mem;
int remaining_space = dir_space;

struct SimpleDirEntry * head = (struct SimpleDirEntry *)(mem);
mem += sizeof(struct SimpleDirEntry);
remaining_space -= sizeof(struct SimpleDirEntry);

struct SimpleDirEntry * prev = head;
while (1)
{
if (remaining_space < (int)sizeof(struct SimpleDirEntry))
{
prev->next = 0;
return head;
}

struct SimpleDirEntry * myentry = (struct SimpleDirEntry *)(mem);
myentry->next = 0;

struct dirent * result;
readdir_r(dir,&myentry->entry,&result);

if (!result)
{
break;
}

if (strcmp(".",myentry->entry.d_name) == 0) continue;
if (strcmp("..",myentry->entry.d_name) == 0)
{
strcpy(head->path,myentry->path);
head->entry = myentry->entry;
continue;
}

mem += sizeof(struct SimpleDirEntry);
remaining_space -= sizeof(struct SimpleDirEntry);

strncpy(myentry->path,dirPath,sizeof(myentry->path));

if (!head) head = myentry;
if (prev) prev->next = myentry;
prev = myentry;

printf("Entry:%s :%d\n",myentry->entry.d_name,dir_is_subdir(myentry));
}

closedir(dir);

printf("All done\n\n");

return head;
}

char const * dir_filename(struct SimpleDirEntry * entry)
{
return &entry->entry.d_name[0];
}

char dir_buffer[256];
char const * dir_path(struct SimpleDirEntry * entry)
{
strncpy(&dir_buffer[0],entry->path,sizeof(dir_buffer));
strncat(&dir_buffer[0],"/",sizeof(dir_buffer));
strncat(&dir_buffer[0],entry->entry.d_name,sizeof(dir_buffer));
return &dir_buffer[0];
}

int dir_filesize(struct SimpleDirEntry * entry)
{
char buffer[256];
strncpy(&buffer[0],entry->path,sizeof(buffer));
strncat(&buffer[0],"/",sizeof(buffer));
strncat(&buffer[0],entry->entry.d_name,sizeof(buffer));

struct stat buf;
stat(buffer, &buf);
return buf.st_size;
}

struct SimpleDirEntry * dir_next(struct SimpleDirEntry * entry)
{
return entry->next;
}

int dir_is_subdir(struct SimpleDirEntry * entry)
{
char buffer[256];
strncpy(&buffer[0],entry->path,sizeof(buffer));
strncat(&buffer[0],"/",sizeof(buffer));
strncat(&buffer[0],entry->entry.d_name,sizeof(buffer));

struct stat buf;
stat(buffer, &buf);
return S_ISDIR(buf.st_mode);
}

(2-2/7)