ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/BeOS/extfs_beos.cpp
(Generate patch)

Comparing BasiliskII/src/BeOS/extfs_beos.cpp (file contents):
Revision 1.6 by cebix, 1999-11-01T16:24:14Z vs.
Revision 1.11 by cebix, 2000-08-14T14:38:16Z

# Line 1 | Line 1
1   /*
2   *  extfs_beos.cpp - MacOS file system for access native file system access, BeOS specific stuff
3   *
4 < *  Basilisk II (C) 1997-1999 Christian Bauer
4 > *  Basilisk II (C) 1997-2000 Christian Bauer
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 87 | Line 87 | void add_path_component(char *path, cons
87  
88  
89   /*
90 < *  Get/set finder type/creator for file specified by full path
90 > *  Get/set finder info for file/directory specified by full path
91   */
92  
93   struct mime2type {
# Line 137 | Line 137 | static const mime2type m2t_translation[]
137          {NULL, 0, 0, false}     // End marker
138   };
139  
140 < void get_finder_type(const char *path, uint32 &type, uint32 &creator)
140 > void get_finfo(const char *path, uint32 finfo, uint32 fxinfo)
141   {
142 <        type = 0;
143 <        creator = 0;
142 >        // Set default finder info
143 >        Mac_memset(finfo, 0, SIZEOF_FInfo);
144 >        if (fxinfo)
145 >                Mac_memset(fxinfo, 0, SIZEOF_FXInfo);
146 >        WriteMacInt16(finfo + fdFlags, DEFAULT_FINDER_FLAGS);
147 >        WriteMacInt32(finfo + fdLocation, (uint32)-1);
148  
149          // Open file
150          int fd = open(path, O_RDONLY);
151          if (fd < 0)
152                  return;
153  
154 <        // Read BeOS MIME type and close file
154 >        // Read BeOS MIME type
155          char mime[256];
156          ssize_t actual = fs_read_attr(fd, "BEOS:TYPE", B_MIME_STRING_TYPE, 0, mime, 256);
157          mime[255] = 0;
# Line 159 | Line 163 | void get_finder_type(const char *path, u
163                  if (sscanf(mime, "application/x-MacOS-%c%c%c%c", mactype, mactype+1, mactype+2, mactype+3) == 4) {
164  
165                          // MacOS style type
166 <                        memcpy(&type, mactype, 4);
166 >                        WriteMacInt32(finfo + fdType, mactype);
167  
168                  } else {
169  
170                          // MIME string, look in table
171                          for (int i=0; m2t_translation[i].mime; i++) {
172                                  if (!strcmp(mime, m2t_translation[i].mime)) {
173 <                                        type = m2t_translation[i].type;
174 <                                        creator = m2t_translation[i].creator;
173 >                                        WriteMacInt32(finfo + fdType, m2t_translation[i].type);
174 >                                        WriteMacInt32(finfo + fdCreator, m2t_translation[i].creator);
175                                          break;
176                                  }
177                          }
# Line 175 | Line 179 | void get_finder_type(const char *path, u
179          }
180  
181          // Override file type with MACOS:CREATOR attribute
182 <        fs_read_attr(fd, "MACOS:CREATOR", B_UINT32_TYPE, 0, &creator, 4);
182 >        if (fs_read_attr(fd, "MACOS:CREATOR", B_UINT32_TYPE, 0, &mime, 4) == 4)
183 >                WriteMacInt32(finfo + fdCreator, (mime[0] << 24) | (mime[1] << 16) | (mime[2] << 8) | mime[3]);
184 >
185 >        // Read MACOS:HFS_FLAGS attribute
186 >        if (fs_read_attr(fd, "MACOS:HFS_FLAGS", B_UINT16_TYPE, 0, &mime, 2) == 2)
187 >                WriteMacInt16(finfo + fdFlags, (mime[0] << 8) | mime[1]);
188  
189          // Close file
190          close(fd);
191   }
192  
193 < void set_finder_type(const char *path, uint32 type, uint32 creator)
193 > void set_finfo(const char *path, uint32 finfo, uint32 fxinfo)
194   {
195 +        char mime[256];
196 +
197          // Open file
198          int fd = open(path, O_WRONLY);
199          if (fd < 0)
200                  return;
201  
202          // Set BEOS:TYPE attribute
203 +        uint32 type = ReadMacInt32(finfo + fdType);
204          if (type) {
205                  bool written = false;
206                  for (int i=0; m2t_translation[i].mime; i++) {
# Line 199 | Line 211 | void set_finder_type(const char *path, u
211                          }
212                  }
213                  if (!written) {
202                        char mime[256];
214                          sprintf(mime, "application/x-MacOS-%c%c%c%c", type >> 24, type >> 16, type >> 8, type);
215                          fs_write_attr(fd, "BEOS:TYPE", B_MIME_STRING_TYPE, 0, mime, strlen(mime) + 1);
216                  }
217          }
218  
219          // Set MACOS:CREATOR attribute
220 <        if (creator)
221 <                fs_write_attr(fd, "MACOS:CREATOR", B_UINT32_TYPE, 0, &creator, 4);
222 <
223 <        // Close file
224 <        close(fd);
225 < }
226 <
227 <
217 < /*
218 < *  Get/set finder flags for file/dir specified by full path (MACOS:HFS_FLAGS attribute)
219 < */
220 <
221 < void get_finder_flags(const char *path, uint16 &flags)
222 < {
223 <        flags = DEFAULT_FINDER_FLAGS;   // Default
224 <
225 <        // Open file
226 <        int fd = open(path, O_RDONLY);
227 <        if (fd < 0)
228 <                return;
229 <
230 <        // Read MACOS:HFS_FLAGS attribute
231 <        fs_read_attr(fd, "MACOS:HFS_FLAGS", B_UINT16_TYPE, 0, &flags, 2);
232 <
233 <        // Close file
234 <        close(fd);
235 < }
236 <
237 < void set_finder_flags(const char *path, uint16 flags)
238 < {
239 <        // Open file
240 <        int fd = open(path, O_WRONLY);
241 <        if (fd < 0)
242 <                return;
220 >        uint32 creator = ReadMacInt32(finfo + fdType);
221 >        if (creator) {
222 >                mime[0] = creator >> 24;
223 >                mime[1] = creator >> 16;
224 >                mime[2] = creator >> 8;
225 >                mime[3] = creator;
226 >                fs_write_attr(fd, "MACOS:CREATOR", B_UINT32_TYPE, 0, &mime, 4);
227 >        }
228  
229          // Write MACOS:HFS_FLAGS attribute
230 <        if (flags != DEFAULT_FINDER_FLAGS)
231 <                fs_write_attr(fd, "MACOS:HFS_FLAGS", B_UINT16_TYPE, 0, &flags, 2);
232 <        else
230 >        uint16 flags = ReadMacInt16(finfo + fdFlags);
231 >        if (flags != DEFAULT_FINDER_FLAGS) {
232 >                mime[0] = flags >> 8;
233 >                mime[1] = flags;
234 >                fs_write_attr(fd, "MACOS:HFS_FLAGS", B_UINT16_TYPE, 0, &mime, 2);
235 >        } else
236                  fs_remove_attr(fd, "MACOS:HFS_FLAGS");
237  
238          // Close file
# Line 369 | Line 357 | void close_rfork(const char *path, int f
357  
358   /*
359   *  Read "length" bytes from file to "buffer",
360 < *  returns number of bytes read (or 0)
360 > *  returns number of bytes read (or -1 on error)
361   */
362  
363   static inline ssize_t sread(int fd, void *buf, size_t count)
# Line 379 | Line 367 | static inline ssize_t sread(int fd, void
367          return res;
368   }
369  
370 < size_t extfs_read(int fd, void *buffer, size_t length)
370 > ssize_t extfs_read(int fd, void *buffer, size_t length)
371   {
384        errno = 0;
385
372          // Buffer in kernel space?
387        size_t actual = 0;
373          if ((uint32)buffer < 0x80000000) {
374  
375                  // Yes, transfer via buffer
376 +                ssize_t actual = 0;
377                  while (length) {
378                          size_t transfer_size = (length > TMP_BUF_SIZE) ? TMP_BUF_SIZE : length;
379                          ssize_t res = sread(fd, tmp_buf, transfer_size);
380 <                        if (res >= 0) {
381 <                                memcpy(buffer, tmp_buf, res);
382 <                                buffer = (void *)((uint8 *)buffer + res);
383 <                                length -= res;
384 <                                actual += res;
385 <                        }
380 >                        if (res < 0)
381 >                                return res;
382 >                        memcpy(buffer, tmp_buf, res);
383 >                        buffer = (void *)((uint8 *)buffer + res);
384 >                        length -= res;
385 >                        actual += res;
386                          if (res != transfer_size)
387                                  return actual;
388                  }
389 +                return actual;
390  
391          } else {
392  
393                  // No, transfer directly
394 <                actual = sread(fd, buffer, length);
408 <                if (actual < 0)
409 <                        actual = 0;
394 >                return sread(fd, buffer, length);
395          }
411        return actual;
396   }
397  
398  
399   /*
400   *  Write "length" bytes from "buffer" to file,
401 < *  returns number of bytes written (or 0)
401 > *  returns number of bytes written (or -1 on error)
402   */
403  
404   static inline ssize_t swrite(int fd, void *buf, size_t count)
# Line 424 | Line 408 | static inline ssize_t swrite(int fd, voi
408          return res;
409   }
410  
411 < size_t extfs_write(int fd, void *buffer, size_t length)
411 > ssize_t extfs_write(int fd, void *buffer, size_t length)
412   {
429        errno = 0;
430
413          // Buffer in kernel space?
432        size_t actual = 0;
414          if ((uint32)buffer < 0x80000000) {
415  
416                  // Yes, transfer via buffer
417 +                ssize_t actual = 0;
418                  while (length) {
419                          size_t transfer_size = (length > TMP_BUF_SIZE) ? TMP_BUF_SIZE : length;
420                          memcpy(tmp_buf, buffer, transfer_size);
421                          ssize_t res = swrite(fd, tmp_buf, transfer_size);
422 <                        if (res >= 0) {
423 <                                buffer = (void *)((uint8 *)buffer + res);
424 <                                length -= res;
425 <                                actual += res;
426 <                        }
422 >                        if (res < 0)
423 >                                return res;
424 >                        buffer = (void *)((uint8 *)buffer + res);
425 >                        length -= res;
426 >                        actual += res;
427                          if (res != transfer_size)
428                                  return actual;
429                  }
430 +                return actual;
431  
432          } else {
433  
434                  // No, transfer directly
435 <                actual = swrite(fd, buffer, length);
453 <                if (actual < 0)
454 <                        actual = 0;
435 >                return swrite(fd, buffer, length);
436          }
437 <        return actual;
437 > }
438 >
439 >
440 > /*
441 > *  Remove file/directory, returns false on error (and sets errno)
442 > */
443 >
444 > bool extfs_remove(const char *path)
445 > {
446 >        if (remove(path) < 0) {
447 >                if (errno == EISDIR)
448 >                        return rmdir(path) == 0;
449 >                else
450 >                        return false;
451 >        }
452 >        return true;
453 > }
454 >
455 >
456 > /*
457 > *  Rename/move file/directory, returns false on error (and sets errno)
458 > */
459 >
460 > bool extfs_rename(const char *old_path, const char *new_path)
461 > {
462 >        return rename(old_path, new_path) == 0;
463   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines