diff options
| -rw-r--r-- | Mac/Modules/hfsplusmodule.c | 1547 |
1 files changed, 1547 insertions, 0 deletions
diff --git a/Mac/Modules/hfsplusmodule.c b/Mac/Modules/hfsplusmodule.c new file mode 100644 index 0000000..31510b3 --- /dev/null +++ b/Mac/Modules/hfsplusmodule.c @@ -0,0 +1,1547 @@ +/* + $Log$ + Revision 1.1 2001/11/06 11:10:13 jackjansen + HFS+ API contributed by Nitin Ganatra. This checkin is identical to what he sent me, except for the namechange (fmgr->hfsplus). + + Revision 1.8 2001/10/03 17:29:01 ganatra + add parent method to FSRef class + + Revision 1.7 2001/04/13 20:54:19 ganatra + More standard format for MacOSError exceptions + + Revision 1.6 2001/04/11 04:07:40 ganatra + Add permissions constants and log header.. + +*/ + + +#include <CoreServices/CoreServices.h> +#include "Python.h" + +static PyObject * +dict_from_cataloginfo(FSCatalogInfoBitmap bitmap, const FSCatalogInfo *info, HFSUniStr255 *uni); +static +PyObject *macos_error_for_call(OSErr err, const char *name, const char *item); +static +int insert_long(FSCatalogInfoBitmap bitmap, UInt32 bit, PyObject *dict, const char *symbol, UInt32 value); +static +int insert_slong(FSCatalogInfoBitmap bitmap, UInt32 bit, PyObject *dict, const char *symbol, long value); +static +int insert_int(PyObject *d, const char *symbol, int value); +static +Boolean fsref_isdirectory(const FSRef *ref); +static +PyObject *obj_to_hfsunistr(PyObject *in, HFSUniStr255 *uni); + +static +int cataloginfo_from_dict(FSCatalogInfoBitmap bitmap, FSCatalogInfo *info, const PyObject *dict); + + +static PyObject *ErrorObject; + +//__________________________________________________________________________________________________ +//_______________________________________ FORKREF OBJECT ___________________________________________ +//__________________________________________________________________________________________________ + +typedef struct { + PyObject_HEAD + PyObject *x_attr; + short forkref; +} forkRefObject; + +staticforward PyTypeObject forkRefObject_Type; + +#define forkRefObject_Check(v) ((v)->ob_type == &forkRefObject_Type) + +//__________________________________________________________________________________________________ + +static +forkRefObject *newForkRefObject(PyObject *arg, FSRef *ref, Boolean resourceFork, SInt8 permissions) +{ + OSErr err; + HFSUniStr255 forkName; + + forkRefObject *self = PyObject_New(forkRefObject, &forkRefObject_Type); + if (self == NULL) + return NULL; + + if (resourceFork) + (void) FSGetResourceForkName(&forkName); + else + (void) FSGetDataForkName(&forkName); + + Py_BEGIN_ALLOW_THREADS + err = FSOpenFork(ref, forkName.length, forkName.unicode, permissions, &self->forkref); + Py_END_ALLOW_THREADS + if (err != noErr) { + Py_DECREF(self); + return (forkRefObject *) macos_error_for_call(err, "FSOpenFork", NULL); + } + + return self; +} + +//__________________________________________________________________________________________________ +// forkRefObject methods +// +static +void forkRefObject_dealloc(forkRefObject *self) +{ + Py_BEGIN_ALLOW_THREADS + if (self->forkref != -1) + FSClose(self->forkref); + Py_END_ALLOW_THREADS + PyObject_Del(self); +} + +//__________________________________________________________________________________________________ +static char forkRefObject_read__doc__[] = +"read([bytecount[, posmode[, offset]]]) -> String\n\n\ +Read bytes from a fork, optionally passing number of\n\ +bytes (default: 128 bytes), posmode (below) and offset:\n\ + 0: ignore offset; write at current mark (default)\n\ + 1: offset relative to the start of fork\n\ + 2: offset relative to the end of fork\n\ + 3: offset relative to current fork position\n\ +\n\ +Returns a string containing the contents of the buffer"; + +static +PyObject *forkRefObject_read(forkRefObject *self, PyObject *args) +{ + OSErr err; + ByteCount request = 128, actual; + unsigned posmode = fsAtMark; + long tempoffset = 0; + SInt64 posoffset; + PyObject *buffer; + + if (!PyArg_ParseTuple(args, "|lil:read", &request, &posmode, &tempoffset)) + return NULL; + + posoffset = tempoffset; + buffer = PyString_FromStringAndSize((char *)NULL, request); + if (buffer == NULL) + return NULL; + + Py_BEGIN_ALLOW_THREADS + err = FSReadFork(self->forkref, posmode, posoffset, request, PyString_AsString(buffer), &actual); + Py_END_ALLOW_THREADS + if ((err != noErr) && (err != eofErr)) { + Py_DECREF(buffer); + return macos_error_for_call(err, "FSReadFork", NULL); + } + + if (actual != request) + _PyString_Resize(&buffer, actual); + + Py_INCREF(buffer); + return buffer; +} + +//__________________________________________________________________________________________________ +static char forkRefObject_write__doc__[] = +"write(buffer [bytecount[, posmode[, offset]]]) -> None\n\n\ +Write buffer to fork, optionally passing number of bytes, posmode (below) and offset:\n\ + 0: ignore offset; write at current mark (default)\n\ + 1: offset relative to the start of fork\n\ + 2: offset relative to the end of fork\n\ + 3: offset relative to current fork position"; + +static +PyObject *forkRefObject_write(forkRefObject *self, PyObject *args) +{ + OSErr err; + ByteCount request = -1, actual; + int size; + char *buffer; + unsigned posmode = fsAtMark; + long tempoffset = 0; + SInt64 posoffset; + + if (!PyArg_ParseTuple(args, "s#|lil:write", &buffer, &size, &request, &posmode, &tempoffset)) + return NULL; + + posoffset = tempoffset; + if (request == -1) + request = size; + + Py_BEGIN_ALLOW_THREADS + err = FSWriteFork(self->forkref, posmode, posoffset, request, buffer, &actual); + Py_END_ALLOW_THREADS + if (err) + return macos_error_for_call(err, "FSWriteFork", NULL); + + Py_INCREF(Py_None); + return Py_None; +} + +//__________________________________________________________________________________________________ +static char forkRefObject_close__doc__[] = +"close() -> None\n\n\ +Close a reference to an open fork."; + +static +PyObject *forkRefObject_close(forkRefObject *self, PyObject *args) +{ + OSErr err; + + Py_BEGIN_ALLOW_THREADS + err = FSClose(self->forkref); + Py_END_ALLOW_THREADS + if (err) + return macos_error_for_call(err, "FSClose", NULL); + + self->forkref = -1; + + Py_INCREF(Py_None); + return Py_None; +} + +//__________________________________________________________________________________________________ +static char forkRefObject_seek__doc__[] = +"seek(offset [,posmode]) -> None\n\n\ +Set the current position in the fork with an optional posmode:\n\ + 1: offset relative to the start of fork (default)\n\ + 2: offset relative to the end of fork\n\ + 3: offset relative to current fork position"; + +static +PyObject *forkRefObject_seek(forkRefObject *self, PyObject *args) +{ + OSErr err; + unsigned posmode = fsFromStart; + long tempoffset = 0; + SInt64 posoffset; + + if (!PyArg_ParseTuple(args, "l|l:seek", &tempoffset, &posmode)) + return NULL; + + posoffset = tempoffset; + Py_BEGIN_ALLOW_THREADS + err = FSSetForkPosition(self->forkref, posmode, posoffset); + Py_END_ALLOW_THREADS + + if (err) + return macos_error_for_call(err, "FSSetForkPosition", NULL); + + Py_INCREF(Py_None); + return Py_None; +} + +//__________________________________________________________________________________________________ +static char forkRefObject_resize__doc__[] = +"resize(offset [,posmode]) -> None\n\n\ +Set the fork size with an optional posmode:\n\ + 1: offset relative to the start of fork (default)\n\ + 2: offset relative to the end of fork\n\ + 3: offset relative to current fork position"; + +static +PyObject *forkRefObject_resize(forkRefObject *self, PyObject *args) +{ + OSErr err; + unsigned posmode = fsFromStart; + long tempoffset = 0; + SInt64 posoffset; + + if (!PyArg_ParseTuple(args, "l|l:resize", &tempoffset, &posmode)) + return NULL; + + posoffset = tempoffset; + Py_BEGIN_ALLOW_THREADS + err = FSSetForkSize(self->forkref, posmode, posoffset); + Py_END_ALLOW_THREADS + + if (err) + return macos_error_for_call(err, "FSSetForkSize", NULL); + + Py_INCREF(Py_None); + return Py_None; +} + +//__________________________________________________________________________________________________ +static char forkRefObject_tell__doc__[] = +"tell() -> current position (Long)\n\n\ +Return the current position in the fork."; + +static +PyObject *forkRefObject_tell(forkRefObject *self, PyObject *args) +{ + OSErr err; + SInt64 position; + + Py_BEGIN_ALLOW_THREADS + err = FSGetForkPosition(self->forkref, &position); + Py_END_ALLOW_THREADS + if (err) + return macos_error_for_call(err, "FSGetForkPosition", NULL); + + return PyLong_FromLongLong(position); +} + +//__________________________________________________________________________________________________ +static char forkRefObject_length__doc__[] = +"length() -> fork length (Long)\n\n\ +Return the logical length of the fork."; + +static +PyObject *forkRefObject_length(forkRefObject *self, PyObject *args) +{ + OSErr err; + SInt64 size; + + Py_BEGIN_ALLOW_THREADS + err = FSGetForkSize(self->forkref, &size); + Py_END_ALLOW_THREADS + if (err) + return macos_error_for_call(err, "FSGetForkSize", NULL); + + return PyLong_FromLongLong(size); +} + +//__________________________________________________________________________________________________ + +static PyMethodDef forkRefObject_methods[] = { + {"read", (PyCFunction)forkRefObject_read,METH_VARARGS, forkRefObject_read__doc__}, + {"write", (PyCFunction)forkRefObject_write,METH_VARARGS, forkRefObject_write__doc__}, + {"close", (PyCFunction)forkRefObject_close,METH_VARARGS, forkRefObject_close__doc__}, + {"seek", (PyCFunction)forkRefObject_seek,METH_VARARGS, forkRefObject_seek__doc__}, + {"tell", (PyCFunction)forkRefObject_tell,METH_VARARGS, forkRefObject_tell__doc__}, + {"length", (PyCFunction)forkRefObject_length,METH_VARARGS, forkRefObject_length__doc__}, + {"resize", (PyCFunction)forkRefObject_resize,METH_VARARGS, forkRefObject_resize__doc__}, + {NULL, NULL} +}; + +//__________________________________________________________________________________________________ + +static +PyObject *forkRefObject_getattr(forkRefObject *self, char *name) +{ + return Py_FindMethod(forkRefObject_methods, (PyObject *)self, name); +} + +//__________________________________________________________________________________________________ + +static int +forkRefObject_print(forkRefObject *self, FILE *fp, int flags) +{ + fprintf(fp, "%d", self->forkref); + return 0; +} + +//__________________________________________________________________________________________________ + +statichere PyTypeObject forkRefObject_Type = { + /* The ob_type field must be initialized in the module init function + * to be portable to Windows without using C++. */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "openfile", /*tp_name*/ + sizeof(forkRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)forkRefObject_dealloc, /*tp_dealloc*/ + (printfunc)forkRefObject_print, /*tp_print*/ + (getattrfunc)forkRefObject_getattr, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ +}; + + + +//__________________________________________________________________________________________________ +//_______________________________________ ITERATOR OBJECT __________________________________________ +//__________________________________________________________________________________________________ + +typedef struct { + PyObject_HEAD + PyObject *x_attr; + FSIterator iterator; +} iteratorObject; + +staticforward PyTypeObject iteratorObject_Type; + +#define iteratorObject_Check(v) ((v)->ob_type == &iteratorObject_Type) + +static +iteratorObject *newIteratorObject(PyObject *arg, FSRef *ref) +{ + OSErr err; + iteratorObject *self = PyObject_New(iteratorObject, &iteratorObject_Type); + if (self == NULL) + return NULL; + + self->x_attr = NULL; + Py_BEGIN_ALLOW_THREADS + err = FSOpenIterator(ref, kFSIterateFlat, &self->iterator); + Py_END_ALLOW_THREADS + if (err != noErr) { + Py_DECREF(self); + return NULL; + } + + return self; +} + +//__________________________________________________________________________________________________ +// iteratorObject methods +// +static +void iteratorObject_dealloc(iteratorObject *self) +{ + Py_XDECREF(self->x_attr); + FSCloseIterator(self->iterator); + PyObject_Del(self); +} + +//__________________________________________________________________________________________________ +static char iteratorObject_listdir__doc__[] = +"listdir([itemcount [, bitmap]]) -> Dict\n\n\ +Returns a dictionary of items and their attributes\n\ +for the given iterator and an optional bitmap describing\n\ +the attributes to be fetched (see CarbonCore/Files.h for\n\ +details of the bit definitions and key definitions)."; + +static +PyObject *iteratorObject_listdir(iteratorObject *self, PyObject *args) +{ + OSErr err; + int count = 500; + UInt32 actual; + FSCatalogInfoPtr infos; + HFSUniStr255 *unis; + PyObject *items; + unsigned i; + FSCatalogInfoBitmap bitmap = kFSCatInfoGettableInfo; + + if (!PyArg_ParseTuple(args, "|il:listdir", &count, &bitmap)) + return NULL; + + items = PyList_New(0); + if (items == NULL) + return NULL; + + infos = malloc(sizeof(FSCatalogInfo) * count); + if (infos == NULL) + return PyErr_NoMemory(); + + unis = malloc(sizeof(HFSUniStr255) * count); + if (unis == NULL) { + free(infos); + return PyErr_NoMemory(); + } + + err = FSGetCatalogInfoBulk(self->iterator, count, &actual, NULL, bitmap, infos, NULL, NULL, unis); + + if (err == noErr || err == errFSNoMoreItems) { + for (i = 0; i < actual; i ++) { + PyObject *item; + + item = dict_from_cataloginfo(bitmap, &infos[i], &unis[i]); + if (item == NULL) + continue; + + if (PyList_Append(items, item) != 0) { + printf("ack! (PyList_Append)\n"); + continue; + } + Py_DECREF(item); + } + } + + free(infos); + free(unis); + + Py_INCREF(items); + return items; +} + +//__________________________________________________________________________________________________ + +static PyMethodDef iteratorObject_methods[] = { + {"listdir", (PyCFunction)iteratorObject_listdir,METH_VARARGS, iteratorObject_listdir__doc__}, + {NULL, NULL} +}; + +//__________________________________________________________________________________________________ + +static +PyObject *iteratorObject_getattr(iteratorObject *self, char *name) +{ + if (self->x_attr != NULL) { + PyObject *v = PyDict_GetItemString(self->x_attr, name); + if (v != NULL) { + Py_INCREF(v); + return v; + } + } + return Py_FindMethod(iteratorObject_methods, (PyObject *)self, name); +} + +//__________________________________________________________________________________________________ + +static +int iteratorObject_setattr(iteratorObject *self, char *name, PyObject *v) +{ + if (self->x_attr == NULL) { + self->x_attr = PyDict_New(); + if (self->x_attr == NULL) + return -1; + } + if (v == NULL) { + int rv = PyDict_DelItemString(self->x_attr, name); + if (rv < 0) + PyErr_SetString(PyExc_AttributeError, "delete non-existing iteratorObject attribute"); + return rv; + } + else + return PyDict_SetItemString(self->x_attr, name, v); +} + +//__________________________________________________________________________________________________ + +statichere PyTypeObject iteratorObject_Type = { + /* The ob_type field must be initialized in the module init function + * to be portable to Windows without using C++. */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "iterator", /*tp_name*/ + sizeof(iteratorObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)iteratorObject_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)iteratorObject_getattr, /*tp_getattr*/ + (setattrfunc)iteratorObject_setattr, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ +}; + + +//__________________________________________________________________________________________________ +//_________________________________________ FSREF OBJECT ___________________________________________ +//__________________________________________________________________________________________________ + +typedef struct { + PyObject_HEAD + PyObject *x_attr; + FSRef ref; + int typeknown; + Boolean directory; +} fsRefObject; + +staticforward PyTypeObject fsRefObject_Type; + +#define fsRefObject_Check(v) ((v)->ob_type == &fsRefObject_Type) + +static +fsRefObject *newFSRefObject(PyObject *arg, FSRef *ref, Boolean typeknown, Boolean directory) +{ + fsRefObject *self = PyObject_New(fsRefObject, &fsRefObject_Type); + if (self == NULL) + return NULL; + + self->x_attr = PyDict_New(); + if (self->x_attr == NULL) { + Py_DECREF(self); + return NULL; + } + + if (PyDict_SetItemString(self->x_attr, "directory", directory ? Py_True : Py_False) < 0) { + Py_XDECREF(self->x_attr); + Py_DECREF(self); + return NULL; + } + + self->ref = *ref; + self->typeknown = typeknown; + self->directory = directory; + return self; +} + +//__________________________________________________________________________________________________ + +Boolean fsRefObject_isdir(fsRefObject *self) +{ + if (self->typeknown == false) { + self->directory = fsref_isdirectory(&self->ref); + self->typeknown = true; + } + return self->directory; +} + +//__________________________________________________________________________________________________ +// fsRefObject methods +// +static +void fsRefObject_dealloc(fsRefObject *self) +{ + Py_XDECREF(self->x_attr); + PyObject_Del(self); +} + +//__________________________________________________________________________________________________ +static char fsRefObject_opendir__doc__[] = +"opendir() -> iterator\n\n\ +Return an iterator"; + +static +PyObject *fsRefObject_opendir(fsRefObject *self, PyObject *args) +{ + iteratorObject *obj; + + obj = newIteratorObject(args, &self->ref); + if (obj == NULL) + return NULL; + return (PyObject *) obj; +} + +//__________________________________________________________________________________________________ +static char fsRefObject_namedfsref__doc__[] = +"namedfsref(String) -> FSref\n\n\ +Return an FSRef for the named item in the container FSRef"; + +static +PyObject *fsRefObject_namedfsref(fsRefObject *self, PyObject *args) +{ + OSErr err; + fsRefObject *newObject; + FSRef newref; + HFSUniStr255 uni; + PyObject *namearg, *nameobj; + + if (!PyArg_ParseTuple(args, "O|l:namedfsref", &namearg)) + return NULL; + + nameobj = obj_to_hfsunistr(namearg, &uni); + if (nameobj == NULL) + return NULL; + Py_DECREF(nameobj); + + Py_BEGIN_ALLOW_THREADS + err = FSMakeFSRefUnicode(&self->ref, uni.length, uni.unicode, kTextEncodingUnknown, &newref); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSMakeFSRefUnicode", NULL); + + newObject = newFSRefObject(args, &newref, false, false); + + Py_INCREF(newObject); + return (PyObject *) newObject; +} + +//__________________________________________________________________________________________________ +static char fsRefObject_parent__doc__[] = +"parent() -> FSref\n\n\ +Return an FSRef for the parent of this FSRef, or NULL (if this \n\ +is the root.)"; + +static +PyObject *fsRefObject_parent(fsRefObject *self, PyObject *args) +{ + OSErr err; + fsRefObject *newObject; + FSRef parentref; + FSCatalogInfo info; + + Py_BEGIN_ALLOW_THREADS + err = FSGetCatalogInfo(&self->ref, kFSCatInfoParentDirID, &info, NULL, NULL, &parentref); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSGetCatalogInfo", NULL); + + if (info.parentDirID == fsRtParID) + return NULL; + + newObject = newFSRefObject(args, &parentref, false, false); + Py_INCREF(newObject); + return (PyObject *) newObject; +} + +//__________________________________________________________________________________________________ +static char fsRefObject_openfork__doc__[] = +"openfork([resourcefork [,perms]]) -> forkRef\n\n\ +Return a forkRef object for reading/writing/etc. Optionally,\n\ +pass 1 for the resourcefork param to open the resource fork,\n\ +and permissions to open read-write or something else:\n\ +0: fsCurPerm\n\ +1: fsRdPerm (default)\n\ +2: fsWrPerm\n\ +3: fsRdWrPerm\n\ +4: fsRdWrShPerm"; + +static +PyObject *fsRefObject_openfork(fsRefObject *self, PyObject *args) +{ + forkRefObject *obj; + int resfork = 0, perms = fsRdPerm; + + if (!PyArg_ParseTuple(args, "|ii:openfork", &resfork, &perms)) + return NULL; + + obj = newForkRefObject(args, &self->ref, resfork, perms); + if (obj == NULL) + return NULL; + return (PyObject *) obj; +} + +//__________________________________________________________________________________________________ + +static +PyObject *fsRefObject_createcommon(Boolean createdir, fsRefObject *self, PyObject *args) +{ + OSErr err; + PyObject *nameobj, *namearg, *attrs = NULL; + FSRef newref; + fsRefObject *newObject; + HFSUniStr255 uni; + FSCatalogInfoBitmap bitmap = kFSCatInfoSettableInfo; + FSCatalogInfo info; + + if (!PyArg_ParseTuple(args, "O|Ol", &namearg, &attrs, &bitmap)) + return NULL; + + nameobj = obj_to_hfsunistr(namearg, &uni); + if (nameobj == NULL) + return NULL; + Py_DECREF(nameobj); + + if (attrs) { + if (!cataloginfo_from_dict(bitmap, &info, attrs)) + return NULL; + } else { + bitmap = 0L; + } + + if (createdir) { + Py_BEGIN_ALLOW_THREADS + err = FSCreateDirectoryUnicode(&self->ref, uni.length, uni.unicode, bitmap, &info, &newref, NULL, NULL); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSCreateDirectoryUnicode", NULL); + } else { + Py_BEGIN_ALLOW_THREADS + err = FSCreateFileUnicode(&self->ref, uni.length, uni.unicode, bitmap, &info, &newref, NULL); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSCreateFileUnicode", NULL); + } + + newObject = newFSRefObject(args, &newref, true, createdir); + if (newObject == NULL) + return NULL; + + Py_INCREF(newObject); + return (PyObject *) newObject; +} + +//__________________________________________________________________________________________________ +static char fsRefObject_create__doc__[] = +"create(name [,dict]) -> FSRef\n\n\ +Create a file in the specified directory with the given name\n\ +and return an FSRef object of the newly created item"; + +static +PyObject *fsRefObject_create(fsRefObject *self, PyObject *args) +{ + return fsRefObject_createcommon(false, self, args); +} + +//__________________________________________________________________________________________________ +static char fsRefObject_mkdir__doc__[] = +"mkdir(name [,dict]) -> FSRef\n\n\ +Create a directory in the specified directory with the given name\n\ +and return an FSRef object of the newly created item"; + +static +PyObject *fsRefObject_mkdir(fsRefObject *self, PyObject *args) +{ + return fsRefObject_createcommon(true, self, args); +} + +//__________________________________________________________________________________________________ +static char fsRefObject_getcatinfo__doc__[] = +"getcatinfo([bitmap]) -> Dict\n\n\ +Returns a dictionary of attributes for the given item\n\ +and an optional bitmap describing the attributes to be\n\ +fetched (see CarbonCore/Files.h for details of the bit\n\ +definitions and key definitions)."; + +static +PyObject *fsRefObject_getcatinfo(fsRefObject *self, PyObject *args) +{ + PyObject *dict; + OSErr err; + FSCatalogInfo info = {0}; + HFSUniStr255 uni; + FSCatalogInfoBitmap bitmap = kFSCatInfoGettableInfo; + + if (!PyArg_ParseTuple(args, "|l:getcatinfo", &bitmap)) + return NULL; + + Py_BEGIN_ALLOW_THREADS + err = FSGetCatalogInfo(&self->ref, bitmap, &info, &uni, NULL, NULL); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSGetCatalogInfo", NULL); + + dict = dict_from_cataloginfo(bitmap, &info, &uni); + if (dict == NULL) + return NULL; + + Py_INCREF(dict); + return dict; +} + +//__________________________________________________________________________________________________ +static char fsRefObject_setcatinfo__doc__[] = +"setcatinfo(Dict [,bitmap]) -> None\n\n\ +Sets attributes for the given item. An optional\n\ +bitmap describing the attributes to be set can be\n\ +given as well (see CarbonCore/Files.h for details\n\ +of the bit definitions and key definitions)."; + +static +PyObject *fsRefObject_setcatinfo(fsRefObject *self, PyObject *args) +{ + PyObject *dict; + OSErr err; + FSCatalogInfo info = {0}; + FSCatalogInfoBitmap bitmap = kFSCatInfoSettableInfo; + + if (!PyArg_ParseTuple(args, "O|l:setcatinfo", &dict, &bitmap)) + return NULL; + + if (!cataloginfo_from_dict(bitmap, &info, dict)) return NULL; + + Py_BEGIN_ALLOW_THREADS + err = FSSetCatalogInfo(&self->ref, bitmap, &info); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSSetCatalogInfo", NULL); + + Py_INCREF(Py_None); + return Py_None; +} + +//__________________________________________________________________________________________________ +static char fsRefObject_delete__doc__[] = +"delete() -> None\n\n\ +Delete the item"; + +static +PyObject *fsRefObject_delete(fsRefObject *self, PyObject *args) +{ + OSErr err; + + Py_BEGIN_ALLOW_THREADS + err = FSDeleteObject(&self->ref); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSDeleteObject", NULL); + + Py_INCREF(Py_None); + return Py_None; +} + +//__________________________________________________________________________________________________ +static char fsRefObject_exchange__doc__[] = +"exchange(FSRef) -> None\n\n\ +Exchange this file with another."; + +static +PyObject *fsRefObject_exchange(fsRefObject *self, PyObject *args) +{ + OSErr err; + fsRefObject *fsrefobj; + + if (!PyArg_ParseTuple(args, "O|:exchange", &fsrefobj)) + return NULL; + + if (fsRefObject_Check(fsrefobj) == false) + return NULL; + + Py_BEGIN_ALLOW_THREADS + err = FSExchangeObjects(&self->ref, &fsrefobj->ref); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSExchangeObjects", NULL); + + Py_INCREF(Py_None); + return Py_None; +} + +//__________________________________________________________________________________________________ +static char fsRefObject_move__doc__[] = +"move(FSRef) -> FSRef\n\n\ +Move the item to the container and return an FSRef to\n\ +the new item."; + +static +PyObject *fsRefObject_move(fsRefObject *self, PyObject *args) +{ + OSErr err; + fsRefObject *newObject; + FSRef newref; + fsRefObject *fsrefobj; + + if (!PyArg_ParseTuple(args, "O|:move", &fsrefobj)) + return NULL; + + if (fsRefObject_Check(fsrefobj) == false) + return NULL; + + Py_BEGIN_ALLOW_THREADS + err = FSMoveObject(&self->ref, &fsrefobj->ref, &newref); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSMoveObject", NULL); + + newObject = newFSRefObject(args, &newref, false, false); + if (newObject == NULL) + return NULL; + + Py_INCREF(newObject); + return (PyObject *) newObject; +} + +//__________________________________________________________________________________________________ +static char fsRefObject_rename__doc__[] = +"rename(String [,encoding]) -> FSRef\n\n\ +Rename the item to the new name and return an FSRef to\n\ +the new item."; + +static +PyObject *fsRefObject_rename(fsRefObject *self, PyObject *args) +{ + OSErr err; + fsRefObject *newObject; + FSRef newref; + TextEncoding hint = kTextEncodingUnknown; + HFSUniStr255 uni; + PyObject *namearg, *nameobj; + + if (!PyArg_ParseTuple(args, "O|l:rename", &namearg, &hint)) + return NULL; + + nameobj = obj_to_hfsunistr(namearg, &uni); + if (nameobj == NULL) + return NULL; + Py_DECREF(nameobj); + + Py_BEGIN_ALLOW_THREADS + err = FSRenameUnicode(&self->ref, uni.length, uni.unicode, hint, &newref); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSRenameUnicode", NULL); + + newObject = newFSRefObject(args, &newref, false, false); + if (newObject == NULL) + return NULL; + + Py_INCREF(newObject); + return (PyObject *) newObject; +} + + +//__________________________________________________________________________________________________ + +static PyMethodDef fsRefObject_methods[] = { + {"getcatinfo", (PyCFunction)fsRefObject_getcatinfo,METH_VARARGS, fsRefObject_getcatinfo__doc__}, + {"setcatinfo", (PyCFunction)fsRefObject_setcatinfo,METH_VARARGS, fsRefObject_setcatinfo__doc__}, + {"create", (PyCFunction)fsRefObject_create, METH_VARARGS, fsRefObject_create__doc__}, + {"mkdir", (PyCFunction)fsRefObject_mkdir, METH_VARARGS, fsRefObject_mkdir__doc__}, + {"namedfsref", (PyCFunction)fsRefObject_namedfsref,METH_VARARGS, fsRefObject_namedfsref__doc__}, + {"parent", (PyCFunction)fsRefObject_parent, METH_VARARGS, fsRefObject_parent__doc__}, + {"delete", (PyCFunction)fsRefObject_delete, METH_VARARGS, fsRefObject_delete__doc__}, + {"rename", (PyCFunction)fsRefObject_rename, METH_VARARGS, fsRefObject_rename__doc__}, + {"move", (PyCFunction)fsRefObject_move, METH_VARARGS, fsRefObject_move__doc__}, + {"exchange", (PyCFunction)fsRefObject_exchange, METH_VARARGS, fsRefObject_exchange__doc__}, + + {"opendir", (PyCFunction)fsRefObject_opendir, METH_VARARGS, fsRefObject_opendir__doc__}, + {"openfork", (PyCFunction)fsRefObject_openfork, METH_VARARGS, fsRefObject_openfork__doc__}, + + {NULL, NULL} +}; + +//__________________________________________________________________________________________________ + +static +PyObject *fsRefObject_getattr(fsRefObject *self, char *name) +{ + if (self->x_attr != NULL) { + PyObject *v = PyDict_GetItemString(self->x_attr, name); + if (v != NULL) { + Py_INCREF(v); + return v; + } + } + return Py_FindMethod(fsRefObject_methods, (PyObject *)self, name); +} + +//__________________________________________________________________________________________________ + +static +int fsRefObject_setattr(fsRefObject *self, char *name, PyObject *v) +{ + if (self->x_attr == NULL) { + self->x_attr = PyDict_New(); + if (self->x_attr == NULL) + return -1; + } + if (v == NULL) { + int rv = PyDict_DelItemString(self->x_attr, name); + if (rv < 0) + PyErr_SetString(PyExc_AttributeError, "delete non-existing fsRefObject attribute"); + return rv; + } + else + return PyDict_SetItemString(self->x_attr, name, v); +} + +//__________________________________________________________________________________________________ + +statichere PyTypeObject fsRefObject_Type = { + /* The ob_type field must be initialized in the module init function + * to be portable to Windows without using C++. */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "fsref", /*tp_name*/ + sizeof(fsRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)fsRefObject_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)fsRefObject_getattr, /*tp_getattr*/ + (setattrfunc)fsRefObject_setattr, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ +}; + + + +//__________________________________________________________________________________________________ +//____________________________________ MODULE FUNCTIONS ____________________________________________ +//__________________________________________________________________________________________________ +static char fmgrmodule_getcatinfo__doc__[] = +"getcatinfo(path[,bitmap]) -> Dict\n\n\ +Returns a dictionary of attributes for the given item\n\ +and an optional bitmap describing the attributes to be\n\ +fetched (see CarbonCore/Files.h for details of the bit\n\ +definitions and key definitions)."; + +static +PyObject *fmgrmodule_getcatinfo(PyObject *self, PyObject *args) +{ + char *path; + PyObject *dict; + FSRef ref; + OSErr err; + FSCatalogInfo info = {0}; + HFSUniStr255 uni; + FSCatalogInfoBitmap bitmap = kFSCatInfoGettableInfo; + + if (!PyArg_ParseTuple(args, "s|l", &path, &bitmap)) + return NULL; + + Py_BEGIN_ALLOW_THREADS + err = FSPathMakeRef(path, &ref, NULL); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSPathMakeRef", path); + + Py_BEGIN_ALLOW_THREADS + err = FSGetCatalogInfo(&ref, bitmap, &info, &uni, NULL, NULL); + Py_END_ALLOW_THREADS + if (err != noErr) + return macos_error_for_call(err, "FSGetCatalogInfo", path); + + dict = dict_from_cataloginfo(bitmap, &info, &uni); + if (dict == NULL) + return NULL; + + Py_INCREF(dict); + return dict; +} + +//__________________________________________________________________________________________________ +static char fmgrmodule_opendir__doc__[] = +"opendir(path) -> iterator\n\n\ +Return an iterator for listdir."; + +static +PyObject *fmgrmodule_opendir(PyObject *self, PyObject *args) +{ + char *path; + iteratorObject *rv; + FSRef ref; + OSErr err; + Boolean isdir; + + if (!PyArg_ParseTuple(args, "s", &path)) + return NULL; + + Py_BEGIN_ALLOW_THREADS + err = FSPathMakeRef(path, &ref, &isdir); + Py_END_ALLOW_THREADS + + if (err != noErr) + return macos_error_for_call(err, "FSPathMakeRef", path); + else if (isdir == false) + return PyErr_Format(PyExc_SyntaxError, "requires a directory"); + + rv = newIteratorObject(args, &ref); + if (rv == NULL) + return NULL; + return (PyObject *) rv; +} + +//__________________________________________________________________________________________________ +static char fmgrmodule_fsref__doc__[] = +"fsref(path) -> FSRef\n\n\ +Return an FSRef object."; + +static +PyObject *fmgrmodule_fsref(PyObject *self, PyObject *args) +{ + char *path; + fsRefObject *obj; + FSRef ref; + OSErr err; + Boolean isdir; + + if (!PyArg_ParseTuple(args, "s", &path)) + return NULL; + + Py_BEGIN_ALLOW_THREADS + err = FSPathMakeRef(path, &ref, &isdir); + Py_END_ALLOW_THREADS + + if (err != noErr) + return macos_error_for_call(err, "FSPathMakeRef", path); + + obj = newFSRefObject(args, &ref, true, isdir); + if (obj == NULL) + return NULL; + return (PyObject *) obj; +} + +//__________________________________________________________________________________________________ +static char fmgrmodule_openfork__doc__[] = +"openfork(path[,resourcefork[,perms]]) -> forkRef\n\n\ +Return a forkRef object for reading/writing/etc. Optionally,\n\ +pass 1 for the resourcefork param to open the resource fork,\n\ +and permissions to open read-write or something else:\n\ +0: fsCurPerm\n\ +1: fsRdPerm\n\ +2: fsWrPerm\n\ +3: fsRdWrPerm\n\ +4: fsRdWrShPerm"; + +static +PyObject *fmgrmodule_openfork(PyObject *self, PyObject *args) +{ + char *path; + forkRefObject *rv; + FSRef ref; + OSErr err; + Boolean isdir; + int resfork = 0, perms = fsRdPerm; + + if (!PyArg_ParseTuple(args, "s|ii", &path, &resfork, &perms)) + return NULL; + + Py_BEGIN_ALLOW_THREADS + err = FSPathMakeRef(path, &ref, &isdir); + Py_END_ALLOW_THREADS + + if (err != noErr) { + return macos_error_for_call(err, "FSPathMakeRef", path); + } else if (isdir == true) { + return PyErr_Format(PyExc_SyntaxError, "requires a file"); + } + + rv = newForkRefObject(args, &ref, resfork, perms); + if (rv == NULL) + return NULL; + return (PyObject *) rv; +} + +//__________________________________________________________________________________________________ +// List of functions defined in the module +// +static PyMethodDef fmgrmodule_methods[] = { + {"getcatinfo", fmgrmodule_getcatinfo, METH_VARARGS, fmgrmodule_getcatinfo__doc__}, + {"opendir", fmgrmodule_opendir, METH_VARARGS, fmgrmodule_opendir__doc__}, + {"openfork", fmgrmodule_openfork, METH_VARARGS, fmgrmodule_openfork__doc__}, + {"fsref", fmgrmodule_fsref, METH_VARARGS, fmgrmodule_fsref__doc__}, + {NULL, NULL} +}; + +//__________________________________________________________________________________________________ +// Initialization function for the module (*must* be called initfmgr) +// +DL_EXPORT(void) +initfmgr(void) +{ + PyObject *m, *d; + + /* Initialize the type of the new type object here; doing it here + * is required for portability to Windows without requiring C++. */ + iteratorObject_Type.ob_type = &PyType_Type; + forkRefObject_Type.ob_type = &PyType_Type; + fsRefObject_Type.ob_type = &PyType_Type; + + /* Create the module and add the functions */ + m = Py_InitModule("fmgr", fmgrmodule_methods); + + /* Add some symbolic constants to the module */ + d = PyModule_GetDict(m); + insert_int(d, "fsCurPerm", fsCurPerm); + insert_int(d, "fsRdPerm", fsRdPerm); + insert_int(d, "fsWrPerm", fsWrPerm); + insert_int(d, "fsRdWrPerm", fsRdWrPerm); + insert_int(d, "fsRdWrShPerm", fsRdWrShPerm); + insert_int(d, "fsAtMark", fsAtMark); + insert_int(d, "fsFromStart", fsFromStart); + insert_int(d, "fsFromLEOF", fsFromLEOF); + insert_int(d, "fsFromMark", fsFromMark); + insert_int(d, "noCacheMask", noCacheMask); + ErrorObject = PyErr_NewException("fmgr.error", NULL, NULL); + PyDict_SetItemString(d, "error", ErrorObject); +} + +//__________________________________________________________________________________________________ +//_________________________________________ UTILITIES ______________________________________________ +//__________________________________________________________________________________________________ + +static const char *_kFSCatInfoPrintableName = "pname"; +static const char *_kFSCatInfoUnicodeName = "uname"; + +static const char *_kFSCatInfoVolume = "volume"; +static const char *_kFSCatInfoNodeID = "nodeid"; +static const char *_kFSCatInfoParentDirID = "parid"; +static const char *_kFSCatInfoTextEncoding = "encoding"; +static const char *_kFSCatInfoNodeFlags = "flags"; + +static const char *_kFSCatInfoDataLogical = "datalogicalsize"; +static const char *_kFSCatInfoRsrcLogical = "rsrclogicalsize"; +static const char *_kFSCatInfoDataPhysical = "dataphysicalsize"; +static const char *_kFSCatInfoRsrcPhysical = "rsrcphysicalsize"; + +static const char *_kFSCatInfoUserID = "uid"; +static const char *_kFSCatInfoGroupID = "gid"; +static const char *_kFSCatInfoUserAccess = "useraccess"; +static const char *_kFSCatInfoMode = "mode"; + +static const char *_kFSCatInfoFinderInfo = "finfo"; +static const char *_kFSCatInfoFinderXInfo = "fxinfo"; + +static const char *_kFSCatInfoCreateDate = "crdate"; +static const char *_kFSCatInfoContentMod = "mddate"; +static const char *_kFSCatInfoAttrMod = "amdate"; +static const char *_kFSCatInfoAccessDate = "acdate"; +static const char *_kFSCatInfoBackupDate = "bkdate"; + +//__________________________________________________________________________________________________ + +static +PyObject *macos_error_for_call(OSErr err, const char *name, const char *item) +{ + PyObject *v; + char buffer[1024]; + + if (item) + sprintf(buffer, "mac error calling %s on %s", name, item); + else + sprintf(buffer, "mac error calling %s", name); + + v = Py_BuildValue("(is)", err, buffer); + if (v != NULL) { + PyErr_SetObject(PyExc_OSError, v); + Py_DECREF(v); + } + return NULL; +} +//__________________________________________________________________________________________________ + +static +int insert_slong(FSCatalogInfoBitmap bitmap, UInt32 bit, PyObject *d, const char *symbol, long value) +{ + if (bitmap & bit) { + PyObject* v = PyLong_FromLong(value); + if (!v || PyDict_SetItemString(d, (char *) symbol, v) < 0) + return -1; + Py_DECREF(v); + } + return 0; +} + +//__________________________________________________________________________________________________ + +static +int insert_long(FSCatalogInfoBitmap bitmap, UInt32 bit, PyObject *d, const char *symbol, UInt32 value) +{ + if (bitmap & bit) { + PyObject* v = PyLong_FromUnsignedLong(value); + if (!v || PyDict_SetItemString(d, (char *) symbol, v) < 0) + return -1; + Py_DECREF(v); + } + return 0; +} + +//__________________________________________________________________________________________________ + +static +int insert_int(PyObject *d, const char *symbol, int value) +{ + PyObject* v = PyInt_FromLong(value); + if (!v || PyDict_SetItemString(d, (char *) symbol, v) < 0) + return -1; + + Py_DECREF(v); + return 0; +} + +//__________________________________________________________________________________________________ + +static +int insert_longlong(FSCatalogInfoBitmap bitmap, UInt32 bit, PyObject *d, const char *symbol, UInt64 value) +{ + if (bitmap & bit) { + PyObject* v = PyLong_FromLongLong(value); + if (!v || PyDict_SetItemString(d, (char *) symbol, v) < 0) + return -1; + Py_DECREF(v); + } + return 0; +} + +//__________________________________________________________________________________________________ + +static +int insert_utcdatetime(FSCatalogInfoBitmap bitmap, UInt32 bit, PyObject *d, const char *symbol, const UTCDateTime *utc) +{ + if (bitmap & bit) { + PyObject* tuple = Py_BuildValue("ili", utc->highSeconds, utc->lowSeconds, utc->fraction); + if (!tuple || PyDict_SetItemString(d, (char *) symbol, tuple) < 0) + return -1; + Py_DECREF(tuple); + } + return 0; +} + +//__________________________________________________________________________________________________ + +static +int fetch_long(FSCatalogInfoBitmap bitmap, UInt32 bit, const PyObject *d, const char *symbol, UInt32 *value) +{ + if (bitmap & bit) { + PyObject* v = PyDict_GetItemString((PyObject *) d, (char *) symbol); + if (v == NULL) + return -1; + + *value = PyLong_AsUnsignedLong(v); + } + return 0; +} + +//__________________________________________________________________________________________________ + +static +int fetch_utcdatetime(FSCatalogInfoBitmap bitmap, UInt32 bit, const PyObject *d, const char *symbol, UTCDateTime *utc) +{ + if (bitmap & bit) { + PyObject* tuple = PyDict_GetItemString((PyObject *) d, (char *) symbol); + if (tuple == NULL) + return -1; + + if (!PyArg_ParseTuple(tuple, "ili", &utc->highSeconds, &utc->lowSeconds, &utc->fraction)) + return -1; + } + + return 0; +} + +//__________________________________________________________________________________________________ + +static +void printableUniStr(const HFSUniStr255 *uni, char *buffer) +{ + int i; + char localbuf[32]; + + buffer[0] = 0; + for (i = 0; i < uni->length; i ++) { + UniChar uch = uni->unicode[i]; + + if ((uch & 0x7f) == uch) { + sprintf(localbuf, "%c", uch); + } else { + sprintf(localbuf, "\\u%04x", uch); + } + strcat(buffer, localbuf); + } +} + +//__________________________________________________________________________________________________ + +static +int cataloginfo_from_dict(FSCatalogInfoBitmap bitmap, FSCatalogInfo *info, const PyObject *dict) +{ + UInt32 storage; + FSPermissionInfo *permissions; + + // Dates + if (fetch_utcdatetime(bitmap, kFSCatInfoCreateDate, dict, _kFSCatInfoCreateDate, &info->createDate)) return NULL; + if (fetch_utcdatetime(bitmap, kFSCatInfoContentMod, dict, _kFSCatInfoContentMod, &info->contentModDate)) return NULL; + if (fetch_utcdatetime(bitmap, kFSCatInfoAttrMod, dict, _kFSCatInfoAttrMod, &info->attributeModDate)) return NULL; + if (fetch_utcdatetime(bitmap, kFSCatInfoAccessDate, dict, _kFSCatInfoAccessDate, &info->accessDate)) return NULL; + if (fetch_utcdatetime(bitmap, kFSCatInfoBackupDate, dict, _kFSCatInfoBackupDate, &info->backupDate)) return NULL; + + // Permissions + permissions = (FSPermissionInfo *) info->permissions; + if (fetch_long(bitmap, kFSCatInfoPermissions, dict, _kFSCatInfoUserID, &permissions->userID)) return NULL; + if (fetch_long(bitmap, kFSCatInfoPermissions, dict, _kFSCatInfoGroupID, &permissions->groupID)) return NULL; + if (fetch_long(bitmap, kFSCatInfoPermissions, dict, _kFSCatInfoMode, &storage)) return NULL; + permissions->mode = (UInt16) storage; + if (fetch_long(bitmap, kFSCatInfoPermissions, dict, _kFSCatInfoUserAccess, &storage)) return NULL; + permissions->userAccess = (UInt8) storage; + + // IDs + if (fetch_long(bitmap, kFSCatInfoTextEncoding, dict, _kFSCatInfoTextEncoding, &info->textEncodingHint)) return NULL; + if (fetch_long(bitmap, kFSCatInfoNodeFlags, dict, _kFSCatInfoNodeFlags, &storage)) return NULL; + info->nodeFlags = (UInt16) storage; + + // FinderInfo + if (bitmap & kFSCatInfoFinderInfo) { + PyObject *obj = PyDict_GetItemString((PyObject *) dict, (char *) _kFSCatInfoFinderInfo); + if (obj == NULL) + return NULL; + BlockMoveData(PyString_AsString(obj), info->finderInfo, sizeof(FInfo)); + } + + if (bitmap & kFSCatInfoFinderXInfo) { + PyObject *obj = PyDict_GetItemString((PyObject *) dict, (char *) _kFSCatInfoFinderXInfo); + if (obj == NULL) + return NULL; + BlockMoveData(PyString_AsString(obj), info->extFinderInfo, sizeof(FXInfo)); + } + + return 1; +} + +//__________________________________________________________________________________________________ + +static +PyObject *dict_from_cataloginfo(FSCatalogInfoBitmap bitmap, const FSCatalogInfo *info, HFSUniStr255 *uni) +{ + PyObject *dict; + PyObject *id; + FSPermissionInfo *permissions; + char buffer[1024]; + + dict = PyDict_New(); + if (dict == NULL) + return NULL; + + // Name + if (uni) { + id = PyUnicode_FromUnicode(uni->unicode, uni->length); + PyDict_SetItemString(dict, (char*) _kFSCatInfoUnicodeName, id); Py_XDECREF(id); + + printableUniStr(uni, buffer); + id = PyString_FromString(buffer); + PyDict_SetItemString(dict, (char*) _kFSCatInfoPrintableName, id); Py_XDECREF(id); + } + + // IDs + if (insert_slong(bitmap, kFSCatInfoVolume, dict, _kFSCatInfoVolume, info->volume)) return NULL; + if (insert_long(bitmap, kFSCatInfoNodeID, dict, _kFSCatInfoNodeID, info->nodeID)) return NULL; + if (insert_long(bitmap, kFSCatInfoParentDirID, dict, _kFSCatInfoParentDirID, info->parentDirID)) return NULL; + if (insert_long(bitmap, kFSCatInfoTextEncoding, dict, _kFSCatInfoTextEncoding, info->textEncodingHint)) return NULL; + if (insert_long(bitmap, kFSCatInfoNodeFlags, dict, _kFSCatInfoNodeFlags, info->nodeFlags)) return NULL; + + // Sizes + if (insert_longlong(bitmap, kFSCatInfoDataSizes, dict, _kFSCatInfoDataLogical, info->dataLogicalSize)) return NULL; + if (insert_longlong(bitmap, kFSCatInfoDataSizes, dict, _kFSCatInfoDataPhysical, info->dataPhysicalSize)) return NULL; + if (insert_longlong(bitmap, kFSCatInfoRsrcSizes, dict, _kFSCatInfoRsrcLogical, info->rsrcLogicalSize)) return NULL; + if (insert_longlong(bitmap, kFSCatInfoRsrcSizes, dict, _kFSCatInfoRsrcPhysical, info->rsrcPhysicalSize)) return NULL; + + // Permissions + permissions = (FSPermissionInfo *) info->permissions; + if (insert_long(bitmap, kFSCatInfoPermissions, dict, _kFSCatInfoUserID, permissions->userID)) return NULL; + if (insert_long(bitmap, kFSCatInfoPermissions, dict, _kFSCatInfoGroupID, permissions->groupID)) return NULL; + if (insert_long(bitmap, kFSCatInfoPermissions, dict, _kFSCatInfoUserAccess, permissions->userAccess)) return NULL; + if (insert_long(bitmap, kFSCatInfoPermissions, dict, _kFSCatInfoMode, permissions->mode)) return NULL; + + // Dates + if (insert_utcdatetime(bitmap, kFSCatInfoCreateDate, dict, _kFSCatInfoCreateDate, &info->createDate)) return NULL; + if (insert_utcdatetime(bitmap, kFSCatInfoContentMod, dict, _kFSCatInfoContentMod, &info->contentModDate)) return NULL; + if (insert_utcdatetime(bitmap, kFSCatInfoAttrMod, dict, _kFSCatInfoAttrMod, &info->attributeModDate)) return NULL; + if (insert_utcdatetime(bitmap, kFSCatInfoAccessDate, dict, _kFSCatInfoAccessDate, &info->accessDate)) return NULL; + if (insert_utcdatetime(bitmap, kFSCatInfoBackupDate, dict, _kFSCatInfoBackupDate, &info->backupDate)) return NULL; + + // FinderInfo + if (bitmap & kFSCatInfoFinderInfo) { + id = Py_BuildValue("s#", (char *) info->finderInfo, sizeof(FInfo)); + PyDict_SetItemString(dict, (char*) _kFSCatInfoFinderInfo, id); Py_XDECREF(id); + } + if (bitmap & kFSCatInfoFinderXInfo) { + id = Py_BuildValue("s#", (char *) info->extFinderInfo, sizeof(FXInfo)); + PyDict_SetItemString(dict, (char*) _kFSCatInfoFinderXInfo, id); Py_XDECREF(id); + } + + return dict; +} + +//__________________________________________________________________________________________________ + +static +Boolean fsref_isdirectory(const FSRef *ref) +{ + Boolean isdir = false; + OSErr err; + FSCatalogInfo info; + + err = FSGetCatalogInfo(ref, kFSCatInfoNodeFlags, &info, NULL, NULL, NULL); + + if (err == noErr) + isdir = (info.nodeFlags & kioFlAttribDirMask); + + return isdir; +} + +//__________________________________________________________________________________________________ + +static +PyObject *obj_to_hfsunistr(PyObject *in, HFSUniStr255 *uni) +{ + PyObject *out; + + out = PyUnicode_FromObject(in); + if (out == NULL) + return NULL; + + BlockMoveData(PyUnicode_AS_UNICODE(out), uni->unicode, PyUnicode_GET_DATA_SIZE(out)); + uni->length = PyUnicode_GET_SIZE(out); + + return out; +} + + |