osapi/beos/sysfile.cc

/* 
 *      HT Editor
 *      sysfile.cc - file system functions for BeOS
 *
 *      Copyright (C) 1999-2002 Stefan Weyergraf
 *      Copyright (C) 2004 Francois Revol (revol@free.fr)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <cerrno>
#include <fcntl.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

#include <OS.h>
#include <Entry.h>
#include <Path.h>

#include <limits.h>    /* for PAGESIZE */
#ifndef PAGESIZE
#ifdef B_PAGE_SIZE
#define PAGESIZE B_PAGE_SIZE
#else
#define PAGESIZE 4096
#endif
#endif


#define USE_AREAS

#ifndef HAVE_REALPATH
char *realpath(const char *filename, char *result)
{
        BPath p;
        BEntry ent(filename, true); /* traverse symlinks */
        if (ent.InitCheck())
                return NULL;
        if (ent.GetPath(&p))
                return NULL;
        strcpy(result, p.Path());
        return result;
}
#endif

#include "system/file.h"

#include <dirent.h>

struct posixfindstate {
        DIR *fhandle;
};

inline bool sys_filename_is_absolute(const char *filename)
{
        return sys_is_path_delim(filename[0]);
}

int sys_file_mode(int mode)
{
        int m = 0;
        if (S_ISREG(mode)) {
                m |= HT_S_IFREG;
        } else if (S_ISBLK(mode)) {
                m |= HT_S_IFBLK;
        } else if (S_ISCHR(mode)) {
                m |= HT_S_IFCHR;
        } else if (S_ISDIR(mode)) {
                m |= HT_S_IFDIR;
        } else if (S_ISFIFO(mode)) {
                m |= HT_S_IFFIFO;
        } else if (S_ISLNK(mode)) {
                m |= HT_S_IFLNK;
#ifdef S_ISSOCK
        } else if (S_ISSOCK(mode)) {
                m |= HT_S_IFSOCK;
#endif
        }
        if (mode & S_IRUSR) m |= HT_S_IRUSR;
        if (mode & S_IRGRP) m |= HT_S_IRGRP;
        if (mode & S_IROTH) m |= HT_S_IROTH;
        
        if (mode & S_IWUSR) m |= HT_S_IWUSR;
        if (mode & S_IWGRP) m |= HT_S_IWGRP;
        if (mode & S_IWOTH) m |= HT_S_IWOTH;
        
        if (mode & S_IXUSR) m |= HT_S_IXUSR;
        if (mode & S_IXGRP) m |= HT_S_IXGRP;
        if (mode & S_IXOTH) m |= HT_S_IXOTH;
        return m;
}

bool sys_is_path_delim(char c)
{
        return c == '/';
}

int sys_filename_cmp(const char *a, const char *b)
{
        while (*a && *b) {
                if (sys_is_path_delim(*a) && sys_is_path_delim(*b)) {
                } else if (*a != *b) {
                        break;
                }
                a++;
                b++;
        }
        return *a - *b;
}

int sys_canonicalize(char *result, const char *filename)
{
        if (!sys_filename_is_absolute(filename)) return ENOENT;
        return (realpath(filename, result)==result) ? 0 : ENOENT;
}

static char sys_find_dirname[HT_NAME_MAX];

int sys_findclose(pfind_t &pfind)
{
        int r = closedir(((posixfindstate*)pfind.findstate)->fhandle);
        free(pfind.findstate);
        return r;
}

int sys_findfirst(pfind_t &pfind, const char *dirname)
{
        if (!sys_filename_is_absolute(dirname)) return ENOENT;
        int r;
        pfind.findstate = malloc(sizeof (posixfindstate));
        posixfindstate *pfs = (posixfindstate*)pfind.findstate;
        if ((pfs->fhandle = opendir(dirname))) {
                strcpy(sys_find_dirname, dirname);
                char *s = sys_find_dirname+strlen(sys_find_dirname);
                if ((s > sys_find_dirname) && (*(s-1) != '/')) {
                    *(s++) = '/';
                    *s = 0;
                }
                r = sys_findnext(pfind);
        } else r = errno ? errno : ENOENT;
        if (r) free(pfind.findstate);
        return r;
}

int sys_findnext(pfind_t &pfind)
{
        posixfindstate *pfs = (posixfindstate*)pfind.findstate;
        struct dirent *d;
        if ((d = readdir(pfs->fhandle))) {
                pfind.name = d->d_name;
                char *s = sys_find_dirname+strlen(sys_find_dirname);
                strcpy(s, d->d_name);
                sys_pstat(pfind.stat, sys_find_dirname);
                *s = 0;
                return 0;
        }
        return ENOENT;
}

static void stat_to_pstat_t(const struct stat &st, pstat_t &s)
{
        s.caps = pstat_ctime|pstat_mtime|pstat_atime|pstat_uid|pstat_gid|pstat_mode_all|pstat_size|pstat_inode;
        s.ctime = st.st_ctime;
        s.mtime = st.st_mtime;
        s.atime = st.st_atime;
        s.gid = st.st_uid;
        s.uid = st.st_gid;
        s.mode = sys_file_mode(st.st_mode);
        s.size = st.st_size;
        s.fsid = st.st_ino;
}

int sys_pstat(pstat_t &s, const char *filename)
{
        if (!sys_filename_is_absolute(filename)) return ENOENT;
        struct stat st;
        errno = 0;
        int e = lstat(filename, &st);
        if (e) return errno ? errno : ENOENT;
        stat_to_pstat_t(st, s);
        return 0;
}

int sys_pstat_fd(pstat_t &s, int fd)
{
        struct stat st;
        errno = 0;
        int e = fstat(fd, &st);
        if (e) return errno ? errno : ENOENT;
        stat_to_pstat_t(st, s);
        return 0;
}

int sys_truncate(const char *filename, FileOfs ofs)
{
        if (!sys_filename_is_absolute(filename)) return ENOENT;
        int fd = open(filename, O_RDWR, 0);
        if (fd < 0) return errno;
        if (ftruncate(fd, ofs) != 0) return errno;
        return close(fd);
}

int sys_deletefile(const char *filename)
{
        if (!sys_filename_is_absolute(filename)) return ENOENT;
        return remove(filename);
}

int sys_truncate_fd(int fd, FileOfs ofs)
{
        if (ftruncate(fd, ofs) != 0) return errno;
        return 0;
}

void sys_suspend()
{
        snooze(100LL);
}

int sys_get_free_mem()
{
        return 0;
}

SYS_FILE *sys_fopen(const char *filename, int openmode)
{
        if (openmode & SYS_OPEN_CREATE) {
                return (SYS_FILE *)fopen(filename, "w+");
        } else {
                if (openmode & SYS_OPEN_WRITE) {
                        return (SYS_FILE *)fopen(filename, "r+");
                } else {
                        return (SYS_FILE *)fopen(filename, "r");
                }
        }
}

void sys_fclose(SYS_FILE *file)
{
        fclose((FILE *)file);
}

int sys_fread(SYS_FILE *file, byte *buf, int size)
{
        return fread(buf, 1, size, (FILE *)file);
}

int sys_fwrite(SYS_FILE *file, byte *buf, int size)
{
        return fwrite(buf, 1, size, (FILE *)file);
}

int sys_fseek(SYS_FILE *file, FileOfs newofs, int seekmode)
{
        int r;
        switch (seekmode) {
        case SYS_SEEK_SET: r = _fseek((FILE *)file, newofs, SEEK_SET); break;
        case SYS_SEEK_REL: r = _fseek((FILE *)file, newofs, SEEK_CUR); break;
        case SYS_SEEK_END: r = _fseek((FILE *)file, newofs, SEEK_END); break;
        default: return EINVAL;
        }
        return r ? errno : 0;
}

void sys_flush(SYS_FILE *file)
{
        fflush((FILE *)file);
}

FileOfs sys_ftell(SYS_FILE *file)
{
        fpos_t pos;
        int err;

// BeOS *is* 64 bits :p
// ftell and fseek use long !! whoever invented the buffered io stuff should be slapped :^)
// _fseek does work, but not _ftell... use _fgetpos

        err = fgetpos((FILE *)file, &pos);
        if (err < 0)
                return err;
        return pos;
}

void *sys_alloc_read_write_execute(int size)
{
#ifdef USE_AREAS
        area_id id = -1;
        void *addr;
        size = ((size + PAGESIZE-1) & ~(PAGESIZE-1));
        /* first try full lock, if it doesn't work, then no lock */
        
        id = create_area("PearPC rwx area", &addr, B_ANY_ADDRESS, size, B_NO_LOCK, B_READ_AREA|B_WRITE_AREA);
        /*
        if (id < B_OK) {
                fprintf(stderr, "warning: create_area failed with FULL_LOCK\n");
                id = create_area("PearPC rwx area", &addr, B_ANY_ADDRESS, size, B_NO_LOCK, B_READ_AREA|B_WRITE_AREA);
        }
        */      
        fprintf(stderr, "create_area(, , , %d, , ) = 0x%08lx\n", size, id);
        if (id < B_OK)
                return NULL;
        return addr;
#else
        void *p = malloc(size+PAGESIZE-1);
        if (!p) return NULL;
        
        void *ret = (void *)(((int)p + PAGESIZE-1) & ~(PAGESIZE-1));

#ifdef HAVE_MPROTECT    
        if (mprotect(ret, size, PROT_READ | PROT_WRITE | PROT_EXEC)) {
                free(p);
                return NULL;
        }
#endif
        return ret;
#endif
}

void sys_free_read_write_execute(void *p)
{
#ifdef USE_AREAS
        fprintf(stderr, "sys_free_read_write_execute(%p)\n", p);
        area_id id;
        id = area_for(p);
        if (id < B_OK)
                return;
        fprintf(stderr, "delete_area(%08lx)\n", id);
        //delete_area(id);
#endif
}
1	dpavlin	1	/*
2			* HT Editor
3			* sysfile.cc - file system functions for BeOS
4			*
5			* Copyright (C) 1999-2002 Stefan Weyergraf
6			* Copyright (C) 2004 Francois Revol (revol@free.fr)
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License version 2 as
10			* published by the Free Software Foundation.
11			*
12			* This program is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with this program; if not, write to the Free Software
19			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20			*/
21
22			#include <cerrno>
23			#include <fcntl.h>
24			#include <cstdio>
25			#include <cstdlib>
26			#include <cstring>
27			#include <sys/stat.h>
28			#include <sys/time.h>
29			#include <sys/types.h>
30			#include <unistd.h>
31
32			#include <OS.h>
33			#include <Entry.h>
34			#include <Path.h>
35
36			#include <limits.h> /* for PAGESIZE */
37			#ifndef PAGESIZE
38			#ifdef B_PAGE_SIZE
39			#define PAGESIZE B_PAGE_SIZE
40			#else
41			#define PAGESIZE 4096
42			#endif
43			#endif
44
45
46			#define USE_AREAS
47
48			#ifndef HAVE_REALPATH
49			char realpath(const char filename, char *result)
50			{
51			BPath p;
52			BEntry ent(filename, true); /* traverse symlinks */
53			if (ent.InitCheck())
54			return NULL;
55			if (ent.GetPath(&p))
56			return NULL;
57			strcpy(result, p.Path());
58			return result;
59			}
60			#endif
61
62			#include "system/file.h"
63
64			#include <dirent.h>
65
66			struct posixfindstate {
67			DIR *fhandle;
68			};
69
70			inline bool sys_filename_is_absolute(const char *filename)
71			{
72			return sys_is_path_delim(filename[0]);
73			}
74
75			int sys_file_mode(int mode)
76			{
77			int m = 0;
78			if (S_ISREG(mode)) {
79			m \|= HT_S_IFREG;
80			} else if (S_ISBLK(mode)) {
81			m \|= HT_S_IFBLK;
82			} else if (S_ISCHR(mode)) {
83			m \|= HT_S_IFCHR;
84			} else if (S_ISDIR(mode)) {
85			m \|= HT_S_IFDIR;
86			} else if (S_ISFIFO(mode)) {
87			m \|= HT_S_IFFIFO;
88			} else if (S_ISLNK(mode)) {
89			m \|= HT_S_IFLNK;
90			#ifdef S_ISSOCK
91			} else if (S_ISSOCK(mode)) {
92			m \|= HT_S_IFSOCK;
93			#endif
94			}
95			if (mode & S_IRUSR) m \|= HT_S_IRUSR;
96			if (mode & S_IRGRP) m \|= HT_S_IRGRP;
97			if (mode & S_IROTH) m \|= HT_S_IROTH;
98
99			if (mode & S_IWUSR) m \|= HT_S_IWUSR;
100			if (mode & S_IWGRP) m \|= HT_S_IWGRP;
101			if (mode & S_IWOTH) m \|= HT_S_IWOTH;
102
103			if (mode & S_IXUSR) m \|= HT_S_IXUSR;
104			if (mode & S_IXGRP) m \|= HT_S_IXGRP;
105			if (mode & S_IXOTH) m \|= HT_S_IXOTH;
106			return m;
107			}
108
109			bool sys_is_path_delim(char c)
110			{
111			return c == '/';
112			}
113
114			int sys_filename_cmp(const char a, const char b)
115			{
116			while (a && b) {
117			if (sys_is_path_delim(a) && sys_is_path_delim(b)) {
118			} else if (a != b) {
119			break;
120			}
121			a++;
122			b++;
123			}
124			return a - b;
125			}
126
127			int sys_canonicalize(char result, const char filename)
128			{
129			if (!sys_filename_is_absolute(filename)) return ENOENT;
130			return (realpath(filename, result)==result) ? 0 : ENOENT;
131			}
132
133			static char sys_find_dirname[HT_NAME_MAX];
134
135			int sys_findclose(pfind_t &pfind)
136			{
137			int r = closedir(((posixfindstate*)pfind.findstate)->fhandle);
138			free(pfind.findstate);
139			return r;
140			}
141
142			int sys_findfirst(pfind_t &pfind, const char *dirname)
143			{
144			if (!sys_filename_is_absolute(dirname)) return ENOENT;
145			int r;
146			pfind.findstate = malloc(sizeof (posixfindstate));
147			posixfindstate pfs = (posixfindstate)pfind.findstate;
148			if ((pfs->fhandle = opendir(dirname))) {
149			strcpy(sys_find_dirname, dirname);
150			char *s = sys_find_dirname+strlen(sys_find_dirname);
151			if ((s > sys_find_dirname) && (*(s-1) != '/')) {
152			*(s++) = '/';
153			*s = 0;
154			}
155			r = sys_findnext(pfind);
156			} else r = errno ? errno : ENOENT;
157			if (r) free(pfind.findstate);
158			return r;
159			}
160
161			int sys_findnext(pfind_t &pfind)
162			{
163			posixfindstate pfs = (posixfindstate)pfind.findstate;
164			struct dirent *d;
165			if ((d = readdir(pfs->fhandle))) {
166			pfind.name = d->d_name;
167			char *s = sys_find_dirname+strlen(sys_find_dirname);
168			strcpy(s, d->d_name);
169			sys_pstat(pfind.stat, sys_find_dirname);
170			*s = 0;
171			return 0;
172			}
173			return ENOENT;
174			}
175
176			static void stat_to_pstat_t(const struct stat &st, pstat_t &s)
177			{
178			s.caps = pstat_ctime\|pstat_mtime\|pstat_atime\|pstat_uid\|pstat_gid\|pstat_mode_all\|pstat_size\|pstat_inode;
179			s.ctime = st.st_ctime;
180			s.mtime = st.st_mtime;
181			s.atime = st.st_atime;
182			s.gid = st.st_uid;
183			s.uid = st.st_gid;
184			s.mode = sys_file_mode(st.st_mode);
185			s.size = st.st_size;
186			s.fsid = st.st_ino;
187			}
188
189			int sys_pstat(pstat_t &s, const char *filename)
190			{
191			if (!sys_filename_is_absolute(filename)) return ENOENT;
192			struct stat st;
193			errno = 0;
194			int e = lstat(filename, &st);
195			if (e) return errno ? errno : ENOENT;
196			stat_to_pstat_t(st, s);
197			return 0;
198			}
199
200			int sys_pstat_fd(pstat_t &s, int fd)
201			{
202			struct stat st;
203			errno = 0;
204			int e = fstat(fd, &st);
205			if (e) return errno ? errno : ENOENT;
206			stat_to_pstat_t(st, s);
207			return 0;
208			}
209
210			int sys_truncate(const char *filename, FileOfs ofs)
211			{
212			if (!sys_filename_is_absolute(filename)) return ENOENT;
213			int fd = open(filename, O_RDWR, 0);
214			if (fd < 0) return errno;
215			if (ftruncate(fd, ofs) != 0) return errno;
216			return close(fd);
217			}
218
219			int sys_deletefile(const char *filename)
220			{
221			if (!sys_filename_is_absolute(filename)) return ENOENT;
222			return remove(filename);
223			}
224
225			int sys_truncate_fd(int fd, FileOfs ofs)
226			{
227			if (ftruncate(fd, ofs) != 0) return errno;
228			return 0;
229			}
230
231			void sys_suspend()
232			{
233			snooze(100LL);
234			}
235
236			int sys_get_free_mem()
237			{
238			return 0;
239			}
240
241			SYS_FILE sys_fopen(const char filename, int openmode)
242			{
243			if (openmode & SYS_OPEN_CREATE) {
244			return (SYS_FILE *)fopen(filename, "w+");
245			} else {
246			if (openmode & SYS_OPEN_WRITE) {
247			return (SYS_FILE *)fopen(filename, "r+");
248			} else {
249			return (SYS_FILE *)fopen(filename, "r");
250			}
251			}
252			}
253
254			void sys_fclose(SYS_FILE *file)
255			{
256			fclose((FILE *)file);
257			}
258
259			int sys_fread(SYS_FILE file, byte buf, int size)
260			{
261			return fread(buf, 1, size, (FILE *)file);
262			}
263
264			int sys_fwrite(SYS_FILE file, byte buf, int size)
265			{
266			return fwrite(buf, 1, size, (FILE *)file);
267			}
268
269			int sys_fseek(SYS_FILE *file, FileOfs newofs, int seekmode)
270			{
271			int r;
272			switch (seekmode) {
273			case SYS_SEEK_SET: r = _fseek((FILE *)file, newofs, SEEK_SET); break;
274			case SYS_SEEK_REL: r = _fseek((FILE *)file, newofs, SEEK_CUR); break;
275			case SYS_SEEK_END: r = _fseek((FILE *)file, newofs, SEEK_END); break;
276			default: return EINVAL;
277			}
278			return r ? errno : 0;
279			}
280
281			void sys_flush(SYS_FILE *file)
282			{
283			fflush((FILE *)file);
284			}
285
286			FileOfs sys_ftell(SYS_FILE *file)
287			{
288			fpos_t pos;
289			int err;
290
291			// BeOS is 64 bits :p
292			// ftell and fseek use long !! whoever invented the buffered io stuff should be slapped :^)
293			// _fseek does work, but not _ftell... use _fgetpos
294
295			err = fgetpos((FILE *)file, &pos);
296			if (err < 0)
297			return err;
298			return pos;
299			}
300
301			void *sys_alloc_read_write_execute(int size)
302			{
303			#ifdef USE_AREAS
304			area_id id = -1;
305			void *addr;
306			size = ((size + PAGESIZE-1) & ~(PAGESIZE-1));
307			/* first try full lock, if it doesn't work, then no lock */
308
309			id = create_area("PearPC rwx area", &addr, B_ANY_ADDRESS, size, B_NO_LOCK, B_READ_AREA\|B_WRITE_AREA);
310			/*
311			if (id < B_OK) {
312			fprintf(stderr, "warning: create_area failed with FULL_LOCK\n");
313			id = create_area("PearPC rwx area", &addr, B_ANY_ADDRESS, size, B_NO_LOCK, B_READ_AREA\|B_WRITE_AREA);
314			}
315			*/
316			fprintf(stderr, "create_area(, , , %d, , ) = 0x%08lx\n", size, id);
317			if (id < B_OK)
318			return NULL;
319			return addr;
320			#else
321			void *p = malloc(size+PAGESIZE-1);
322			if (!p) return NULL;
323
324			void ret = (void )(((int)p + PAGESIZE-1) & ~(PAGESIZE-1));
325
326			#ifdef HAVE_MPROTECT
327			if (mprotect(ret, size, PROT_READ \| PROT_WRITE \| PROT_EXEC)) {
328			free(p);
329			return NULL;
330			}
331			#endif
332			return ret;
333			#endif
334			}
335
336			void sys_free_read_write_execute(void *p)
337			{
338			#ifdef USE_AREAS
339			fprintf(stderr, "sys_free_read_write_execute(%p)\n", p);
340			area_id id;
341			id = area_for(p);
342			if (id < B_OK)
343			return;
344			fprintf(stderr, "delete_area(%08lx)\n", id);
345			//delete_area(id);
346			#endif
347			}