![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to posixemu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src / od-win32|
Return to posixemu.c CVS log | Up to [UNIX Amiga Emulator] / uae / src / od-win32 |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * Win32 interface
5: *
6: * Copyright 1997 Mathias Ortmann
7: */
8:
9: #ifdef __GNUC__
10: #define __int64 long long
11: #include "machdep/winstuff.h"
12: #else
13: #include <windows.h>
14: #include <ddraw.h>
15: #include <stdlib.h>
16: #include <stdarg.h>
17: #include <commctrl.h>
18: #include <commdlg.h>
19: #include <stdio.h>
20: #include <fcntl.h>
21: #include <sys/stat.h>
22: #include <io.h>
23: #endif
24:
25: #include "config.h"
26: #include "sysconfig.h"
27: #include "sysdeps.h"
28: #include "options.h"
29: #include "memory.h"
30: #include "osdep/win32.h"
31:
32: /* stdioemu, posixemu, mallocemu, and various file system helper routines */
33: static DWORD lasterror;
34:
35: static int isillegal (unsigned char *str)
36: {
37: unsigned char a = *str, b = str[1], c = str[2];
38:
39: if (a >= 'a' && a <= 'z')
40: a &= ~' ';
41: if (b >= 'a' && b <= 'z')
42: b &= ~' ';
43: if (c >= 'a' && c <= 'z')
44: c &= ~' ';
45:
46: return (a == 'A' && b == 'U' && c == 'X' ||
47: a == 'C' && b == 'O' && c == 'N' ||
48: a == 'P' && b == 'R' && c == 'N' ||
49: a == 'N' && b == 'U' && c == 'L');
50: }
51:
52: static int checkspace (char *str, char s, char d)
53: {
54: char *ptr = str;
55:
56: while (*ptr && *ptr == s)
57: ptr++;
58:
59: if (!*ptr || *ptr == '/' || *ptr == '\\') {
60: while (str < ptr)
61: *(str++) = d;
62: return 0;
63: }
64: return 1;
65: }
66:
67: /* This is sick and incomplete... in the meantime, I have discovered six new illegal file name formats
68: * M$ sucks! */
69: void fname_atow (char *src, char *dst, int size)
70: {
71: char *lastslash = dst, *strt = dst;
72: int i, j;
73:
74: while (size-- > 0) {
75: if (!(*dst = *src++))
76: break;
77:
78: if (*dst == '~' || *dst == '|' || *dst == '*' || *dst == '?') {
79: if (size > 2) {
80: sprintf (dst, "~%02x", *dst);
81: size -= 2;
82: dst += 2;
83: }
84: } else if (*dst == '/') {
85: if (checkspace (lastslash, ' ', 0xa0) && (dst - lastslash == 3 || (dst - lastslash > 3 && lastslash[3] == '.')) && isillegal (lastslash)) {
86: i = dst - lastslash - 3;
87: dst++;
88: for (j = i + 1; j--; dst--)
89: *dst = dst[-1];
90: *(dst++) = 0xa0;
91: dst += i;
92: size--;
93: } else if (*lastslash == '.' && (dst - lastslash == 1 || lastslash[1] == '.' && dst - lastslash == 2) && size) {
94: *(dst++) = 0xa0;
95: size--;
96: }
97: *dst = '\\';
98: lastslash = dst + 1;
99: }
100: dst++;
101: }
102:
103: if (checkspace (lastslash, ' ', 0xa0) && (dst - lastslash == 3 || (dst - lastslash > 3 && lastslash[3] == '.')) && isillegal (lastslash) && size > 1) {
104: i = dst - lastslash - 3;
105: dst++;
106: for (j = i + 1; j--; dst--)
107: *dst = dst[-1];
108: *(dst++) = 0xa0;
109: } else if (!strcmp (lastslash, ".") || !strcmp (lastslash, ".."))
110: strcat (lastslash, "\xa0");
111: }
112:
113: int getdiskfreespace (char *name, int *f_blocks, int *f_bavail, int *f_bsize)
114: {
115: char buf1[1024];
116: char buf2[1024];
117: DWORD SectorsPerCluster;
118: DWORD BytesPerSector;
119: DWORD NumberOfFreeClusters;
120: DWORD TotalNumberOfClusters;
121:
122: fname_atow (name, buf1, sizeof buf1);
123:
124: GetFullPathName (buf1, sizeof buf2, buf2, NULL);
125:
126: buf2[3] = 0;
127:
128: if (!GetDiskFreeSpace (buf2, &SectorsPerCluster, &BytesPerSector, &NumberOfFreeClusters, &TotalNumberOfClusters)) {
129: lasterror = GetLastError ();
130: return FALSE;
131: }
132: *f_blocks = TotalNumberOfClusters;
133: *f_bavail = NumberOfFreeClusters;
134: *f_bsize = SectorsPerCluster * BytesPerSector;
135:
136: return TRUE;
137: }
138:
139: /* Translate lasterror to valid AmigaDOS error code
140: * The mapping is probably not 100% correct yet */
141: long dos_errno (void)
142: {
143: int i;
144:
145: static DWORD errtbl[][2] =
146: {
147: {ERROR_FILE_NOT_FOUND, 205}, /* 2 */
148: {ERROR_PATH_NOT_FOUND, 205}, /* 3 */
149: {ERROR_SHARING_VIOLATION, 202},
150: {ERROR_ACCESS_DENIED, 223}, /* 5 */
151: {ERROR_ARENA_TRASHED, 103}, /* 7 */
152: {ERROR_NOT_ENOUGH_MEMORY, 103}, /* 8 */
153: {ERROR_INVALID_BLOCK, 219}, /* 9 */
154: {ERROR_INVALID_DRIVE, 204}, /* 15 */
155: {ERROR_CURRENT_DIRECTORY, 214}, /* 16 */
156: {ERROR_NO_MORE_FILES, 232}, /* 18 */
157: {ERROR_LOCK_VIOLATION, 214}, /* 33 */
158: {ERROR_BAD_NETPATH, 204}, /* 53 */
159: {ERROR_NETWORK_ACCESS_DENIED, 214}, /* 65 */
160: {ERROR_BAD_NET_NAME, 204}, /* 67 */
161: {ERROR_FILE_EXISTS, 203}, /* 80 */
162: {ERROR_CANNOT_MAKE, 214}, /* 82 */
163: {ERROR_FAIL_I24, 223}, /* 83 */
164: {ERROR_DRIVE_LOCKED, 202}, /* 108 */
165: {ERROR_DISK_FULL, 221}, /* 112 */
166: {ERROR_NEGATIVE_SEEK, 219}, /* 131 */
167: {ERROR_SEEK_ON_DEVICE, 219}, /* 132 */
168: {ERROR_DIR_NOT_EMPTY, 216}, /* 145 */
169: {ERROR_ALREADY_EXISTS, 203}, /* 183 */
170: {ERROR_FILENAME_EXCED_RANGE, 205}, /* 206 */
171: {ERROR_NOT_ENOUGH_QUOTA, 221}, /* 1816 */
172: {ERROR_DIRECTORY, 212}};
173:
174: for (i = sizeof (errtbl) / sizeof (errtbl[0]); i--;) {
175: if (errtbl[i][0] == lasterror)
176: return errtbl[i][1];
177: }
178: return 236;
179: }
180:
181: static DWORD getattr (char *name, LPFILETIME lpft, size_t * size)
182: {
183: HANDLE hFind;
184: WIN32_FIND_DATA fd;
185:
186: if ((hFind = FindFirstFile (name, &fd)) == INVALID_HANDLE_VALUE) {
187: lasterror = GetLastError ();
188:
189: fd.dwFileAttributes = GetFileAttributes (name);
190:
191: return fd.dwFileAttributes;
192: }
193: FindClose (hFind);
194:
195: if (lpft)
196: *lpft = fd.ftLastWriteTime;
197: if (size)
198: *size = fd.nFileSizeLow;
199:
200: return fd.dwFileAttributes;
201: }
202:
203: int posixemu_access (char *name, int mode)
204: {
205: DWORD attr;
206: char buf[1024];
207:
208: fname_atow (name, buf, sizeof buf - 4);
209:
210: if ((attr = getattr (buf, NULL, NULL)) == ~0)
211: return -1;
212:
213: if (attr & FILE_ATTRIBUTE_READONLY && (mode & 4)) {
214: lasterror = ERROR_ACCESS_DENIED;
215: return -1;
216: } else
217: return 0;
218: }
219:
220: int posixemu_open (char *name, int oflag, int dummy)
221: {
222: DWORD fileaccess;
223: DWORD filecreate;
224: char buf[1024];
225:
226: HANDLE hFile;
227:
228: switch (oflag & (O_RDONLY | O_WRONLY | O_RDWR)) {
229: case O_RDONLY:
230: fileaccess = GENERIC_READ;
231: break;
232: case O_WRONLY:
233: fileaccess = GENERIC_WRITE;
234: break;
235: case O_RDWR:
236: fileaccess = GENERIC_READ | GENERIC_WRITE;
237: break;
238: default:
239: return -1;
240: }
241:
242: switch (oflag & (O_CREAT | O_EXCL | O_TRUNC)) {
243: case 0:
244: case O_EXCL:
245: filecreate = OPEN_EXISTING;
246: break;
247: case O_CREAT:
248: filecreate = OPEN_ALWAYS;
249: break;
250: case O_CREAT | O_EXCL:
251: case O_CREAT | O_TRUNC | O_EXCL:
252: filecreate = CREATE_NEW;
253: break;
254: case O_TRUNC:
255: case O_TRUNC | O_EXCL:
256: filecreate = TRUNCATE_EXISTING;
257: break;
258: case O_CREAT | O_TRUNC:
259: filecreate = CREATE_ALWAYS;
260: break;
261: }
262:
263: fname_atow (name, buf, sizeof buf);
264:
265: if ((hFile = CreateFile (buf,
266: fileaccess,
267: FILE_SHARE_READ | FILE_SHARE_WRITE,
268: NULL,
269: filecreate,
270: FILE_ATTRIBUTE_NORMAL,
271: NULL)) == INVALID_HANDLE_VALUE)
272: lasterror = GetLastError ();
273:
274: return (int) hFile;
275: }
276:
277: void posixemu_close (int hFile)
278: {
279: CloseHandle ((HANDLE) hFile);
280: }
281:
282: int w32fopendel (char *name, char *mode, int delflag)
283: {
284: HANDLE hFile;
285: hFile = CreateFile (name,
286: mode[1] == '+' ? GENERIC_READ | GENERIC_WRITE : GENERIC_READ,
287: FILE_SHARE_READ | FILE_SHARE_WRITE,
288: NULL,
289: OPEN_EXISTING,
290: delflag ? FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE : FILE_ATTRIBUTE_NORMAL,
291: NULL);
292:
293: if (hFile == INVALID_HANDLE_VALUE) {
294: lasterror = GetLastError ();
295: hFile = 0;
296: }
297: return (int) hFile;
298: }
299:
300: int stdioemu_fclose (FILE * fd)
301: {
302: if (fd)
303: CloseHandle ((HANDLE) fd);
304: return 0;
305: }
306:
307: void *mallocemu_malloc (int size)
308: {
309: return GlobalAlloc (GPTR, size);
310: }
311:
312: void mallocemu_free (void *ptr)
313: {
314: GlobalFree (ptr);
315: }
316:
317: static int hextol (char a)
318: {
319: if (a >= '0' && a <= '9')
320: return a - '0';
321: if (a >= 'a' && a <= 'f')
322: return a - 'a' + 10;
323: if (a >= 'A' && a <= 'F')
324: return a - 'A' + 10;
325: return 2;
326: }
327:
328: /* Win32 file name restrictions suck... */
329: void fname_wtoa (unsigned char *ptr)
330: {
331: unsigned char *lastslash = ptr;
332:
333: while (*ptr) {
334: if (*ptr == '~') {
335: *ptr = hextol (ptr[1]) * 16 + hextol (ptr[2]);
336: strcpy (ptr + 1, ptr + 3);
337: } else if (*ptr == '\\') {
338: if (checkspace (lastslash, ' ', 0xa0) && ptr - lastslash > 3 && lastslash[3] == 0xa0 && isillegal (lastslash)) {
339: ptr--;
340: strcpy (lastslash + 3, lastslash + 4);
341: }
342: *ptr = '/';
343: lastslash = ptr + 1;
344: }
345: ptr++;
346: }
347:
348: if (checkspace (lastslash, ' ', 0xa0) && ptr - lastslash > 3 && lastslash[3] == 0xa0 && isillegal (lastslash))
349: strcpy (lastslash + 3, lastslash + 4);
350: }
351:
352: DIR {
353: WIN32_FIND_DATA finddata;
354: HANDLE hDir;
355: int getnext;
356: };
357:
358: DIR *opendir (char *path)
359: {
360: char buf[1024];
361: DIR *dir;
362:
363: if (!(dir = (DIR *) GlobalAlloc (GPTR, sizeof (DIR)))) {
364: lasterror = GetLastError ();
365: return 0;
366: }
367: fname_atow (path, buf, sizeof buf - 4);
368: strcat (buf, "\\*");
369:
370: if ((dir->hDir = FindFirstFile (buf, &dir->finddata)) == INVALID_HANDLE_VALUE) {
371: lasterror = GetLastError ();
372: GlobalFree (dir);
373: return 0;
374: }
375: return dir;
376: }
377:
378: struct dirent *readdir (DIR * dir)
379: {
380: if (dir->getnext) {
381: if (!FindNextFile (dir->hDir, &dir->finddata)) {
382: lasterror = GetLastError ();
383: return 0;
384: }
385: }
386: dir->getnext = TRUE;
387:
388: fname_wtoa (dir->finddata.cFileName);
389: return (struct dirent *) dir->finddata.cFileName;
390: }
391:
392: void closedir (DIR * dir)
393: {
394: FindClose (dir->hDir);
395: GlobalFree (dir);
396: }
397:
398: int setfiletime (char *name, unsigned int days, int minute, int tick)
399: {
400: FILETIME LocalFileTime, FileTime;
401: HANDLE hFile;
402: int success;
403: char buf[1024];
404:
405: fname_atow (name, buf, sizeof buf);
406:
407: if ((hFile = CreateFile (buf, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE) {
408: lasterror = GetLastError ();
409: return 0;
410: }
411: *(__int64 *) & LocalFileTime = (((__int64) (377 * 365 + 91 + days) * (__int64) 1440 + (__int64) minute) * (__int64) (60 * 50) + (__int64) tick) * (__int64) 200000;
412:
413: if (!LocalFileTimeToFileTime (&LocalFileTime, &FileTime))
414: FileTime = LocalFileTime;
415:
416: if (!(success = SetFileTime (hFile, &FileTime, &FileTime, &FileTime)))
417: lasterror = GetLastError ();
418: CloseHandle (hFile);
419:
420: return success;
421: }
422:
423: int posixemu_read (int hFile, char *ptr, int size)
424: {
425: DWORD actual;
426:
427: if (!ReadFile ((HANDLE) hFile, ptr, size, &actual, NULL))
428: lasterror = GetLastError ();
429:
430: return actual;
431: }
432:
433: int posixemu_write (int hFile, char *ptr, int size)
434: {
435: DWORD actual;
436:
437: if (!WriteFile ((HANDLE) hFile, ptr, size, &actual, NULL))
438: lasterror = GetLastError ();
439:
440: return actual;
441: }
442:
443: int posixemu_seek (int hFile, int pos, int type)
444: {
445: int result;
446:
447: switch (type) {
448: case SEEK_SET:
449: type = FILE_BEGIN;
450: break;
451: case SEEK_CUR:
452: type = FILE_CURRENT;
453: break;
454: case SEEK_END:
455: type = FILE_END;
456: }
457:
458: if ((result = SetFilePointer ((HANDLE) hFile, pos, NULL, type)) == ~0)
459: lasterror = GetLastError ();
460:
461: return result;
462: }
463:
464: int stdioemu_fread (char *buf, int l1, int l2, FILE * hFile)
465: {
466: return posixemu_read ((int) hFile, buf, l1 * l2);
467: }
468:
469: int stdioemu_fwrite (char *buf, int l1, int l2, FILE * hFile)
470: {
471: return posixemu_write ((int) hFile, buf, l1 * l2);
472: }
473:
474: int stdioemu_fseek (FILE * hFile, int pos, int type)
475: {
476: return posixemu_seek ((int) hFile, pos, type);
477: }
478:
479: int stdioemu_ftell (FILE * hFile)
480: {
481: return SetFilePointer ((HANDLE) hFile, 0, 0, FILE_CURRENT);
482: }
483:
484: int posixemu_stat (char *name, struct stat *statbuf)
485: {
486: char buf[1024];
487: DWORD attr;
488: HANDLE hFile;
489: FILETIME ft, lft;
490:
491: fname_atow (name, buf, sizeof buf);
492:
493: if ((attr = getattr (buf, &ft, &statbuf->st_size)) == ~0) {
494: lasterror = GetLastError ();
495: return -1;
496: } else {
497: statbuf->st_mode = (attr & FILE_ATTRIBUTE_READONLY) ? 5 : 0;
498: if (attr & FILE_ATTRIBUTE_ARCHIVE)
499: statbuf->st_mode |= 0x10;
500: if (attr & FILE_ATTRIBUTE_DIRECTORY)
501: statbuf->st_mode |= 0x100;
502:
503: FileTimeToLocalFileTime (&ft, &lft);
504: statbuf->st_mtime = (*(__int64 *) & lft - ((__int64) (369 * 365 + 89) * (__int64) (24 * 60 * 60) * (__int64) 10000000)) / (__int64) 10000000;
505: }
506:
507: return 0;
508: }
509:
510: int posixemu_mkdir (char *name, int mode)
511: {
512: char buf[1024];
513:
514: fname_atow (name, buf, sizeof buf);
515:
516: if (CreateDirectory (buf, NULL))
517: return 0;
518:
519: lasterror = GetLastError ();
520:
521: return -1;
522: }
523:
524: int posixemu_unlink (char *name)
525: {
526: char buf[1024];
527:
528: fname_atow (name, buf, sizeof buf);
529: if (DeleteFile (buf))
530: return 0;
531:
532: lasterror = GetLastError ();
533:
534: return -1;
535: }
536:
537: int posixemu_rmdir (char *name)
538: {
539: char buf[1024];
540:
541: fname_atow (name, buf, sizeof buf);
542: if (RemoveDirectory (buf))
543: return 0;
544:
545: lasterror = GetLastError ();
546:
547: return -1;
548: }
549:
550: int posixemu_rename (char *name1, char *name2)
551: {
552: char buf1[1024];
553: char buf2[1024];
554:
555: fname_atow (name1, buf1, sizeof buf1);
556: fname_atow (name2, buf2, sizeof buf2);
557: if (MoveFile (name1, name2))
558: return 0;
559:
560: lasterror = GetLastError ();
561:
562: return -1;
563: }
564:
565: int posixemu_chmod (char *name, int mode)
566: {
567: char buf[1024];
568: DWORD attr = FILE_ATTRIBUTE_NORMAL;
569:
570: fname_atow (name, buf, sizeof buf);
571:
572: if (mode & 1)
573: attr |= FILE_ATTRIBUTE_READONLY;
574: if (mode & 0x10)
575: attr |= FILE_ATTRIBUTE_ARCHIVE;
576:
577: if (SetFileAttributes (buf, attr))
578: return 1;
579:
580: lasterror = GetLastError ();
581:
582: return 0;
583: }
584:
585: void posixemu_tmpnam (char *name)
586: {
587: char buf[MAX_PATH];
588:
589: GetTempPath (MAX_PATH, buf);
590: GetTempFileName (buf, "uae", 0, name);
591: }
592:
593: /* pthread Win32 emulation */
594: void sem_init (HANDLE * event, int manual_reset, int initial_state)
595: {
596: *event = CreateEvent (NULL, manual_reset, initial_state, NULL);
597: }
598:
599: void sem_wait (HANDLE * event)
600: {
601: WaitForSingleObject (*event, INFINITE);
602: }
603:
604: void sem_post (HANDLE * event)
605: {
606: SetEvent (*event);
607: }
608:
609: int sem_trywait (HANDLE * event)
610: {
611: return WaitForSingleObject (*event, 0) == WAIT_OBJECT_0;
612: }
613:
614: /* Mega-klduge to prevent problems with Watcom's habit of passing
615: * arguments in registers... */
616: static HANDLE thread_sem;
617: static void *(*thread_startfunc) (void *);
618: #ifndef __GNUC__
619: static void * __stdcall thread_starter (void *arg)
620: #else
621: static void * thread_starter( void *arg )
622: #endif
623: {
624: void *(*func) (void *) = thread_startfunc;
625: SetEvent (thread_sem);
626: return (*func) (arg);
627: }
628:
629: /* this creates high priority threads by default to speed up the file system (kludge, will be
630: * replaced by a set_penguin_priority() routine soon) */
631: int start_penguin (void *(*f) (void *), void *arg, DWORD * foo)
632: {
633: static int have_event = 0;
634: HANDLE hThread;
635:
636: if (! have_event) {
637: thread_sem = CreateEvent (NULL, 0, 0, NULL);
638: have_event = 1;
639: }
640: thread_startfunc = f;
641: hThread = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) thread_starter, arg, 0, foo);
642: SetThreadPriority (hThread, THREAD_PRIORITY_HIGHEST);
643: WaitForSingleObject (thread_sem, INFINITE);
644: }
645:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.