Macintosh-Tools
/
hfsutils
mirror of https://github.com/JotaRandom/hfsutils.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
hfsutils/tclhfs.c

1485 lines
31 KiB
C
Raw Permalink Blame History

/*
* hfsutils - tools for reading and writing Macintosh HFS volumes
* Copyright (C) 1996-1998 Robert Leslie
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*
* $Id: tclhfs.c,v 1.12 1998/11/02 22:08:32 rob Exp $
*/
# ifdef HAVE_CONFIG_H
# include "config.h"
# endif
# ifdef HAVE_UNISTD_H
# include <unistd.h>
# endif
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <ctype.h>
# include <limits.h>
# include <tcl.h>
# include "tclhfs.h"
# include "hfs.h"
# include "glob.h"
# include "copyin.h"
# include "copyout.h"
# include "charset.h"
# include "suid.h"
# include "version.h"
# include <errno.h>
# define ERROR(code, str) (hfs_error = (str), errno = (code))
# define SIZE(type, n) ((size_t) (sizeof(type) * (n)))
# define ALLOC(type, n) ((type *) malloc(SIZE(type, n)))
# define ALLOCX(type, n) ((n) ? ALLOC(type, n) : (type *) 0)
# define FREE(ptr) ((ptr) ? (void) free((void *) ptr) : (void) 0)
# define REALLOC(ptr, type, n) \
((type *) ((ptr) ? realloc(ptr, SIZE(type, n)) : malloc(SIZE(type, n))))
# define REALLOCX(ptr, type, n) \
((n) ? REALLOC(ptr, type, n) : (FREE(ptr), (type *) 0))
# define CHARLEN(type) ((sizeof(type) * CHAR_BIT + 2) / 3 + 1)
static
int err_umount, err_close;
typedef struct {
hfsvol *vol;
unsigned long cwd;
} volref;
typedef struct {
hfsfile *file;
Tcl_Interp *interp;
Tcl_Command cmd;
} fileref;
Tcl_HashTable volumes; /* set containing mounted volumes (no values) */
Tcl_HashTable files; /* mapping of frefs -> vrefs */
/*
* NAME: error()
* DESCRIPTION: return a Tcl error for an HFS error
*/
static
int error(Tcl_Interp *interp, const char *msg)
{
const char *str;
char c[2];
str = strerror(errno);
c[0] = tolower(*str);
c[1] = 0;
Tcl_ResetResult(interp);
if (msg)
Tcl_AppendResult(interp, msg, ": ", (char *) 0);
if (hfs_error == 0)
Tcl_AppendResult(interp, c, str + 1, (char *) 0);
else
Tcl_AppendResult(interp, hfs_error, " (", str, ")", (char *) 0);
return TCL_ERROR;
}
/*
* NAME: direntstr()
* DESCRIPTION: return a Tcl stat list for a single HFS entity
*/
static
char *direntstr(hfsdirent *ent)
{
char
cnid[CHARLEN(unsigned long) + 1],
parid[CHARLEN(unsigned long) + 1],
rsize[CHARLEN(unsigned long) + 1],
dsize[CHARLEN(unsigned long) + 1],
crdate[CHARLEN(long) + 1],
mddate[CHARLEN(long) + 1],
bkdate[CHARLEN(long) + 1];
register int argc;
char *argv[24];
int locked, invis;
argc = 0;
argv[argc++] = "name";
argv[argc++] = ent->name;
sprintf(cnid, "%lu", ent->cnid);
sprintf(parid, "%lu", ent->parid);
argv[argc++] = "cnid";
argv[argc++] = cnid;
argv[argc++] = "parid";
argv[argc++] = parid;
argv[argc++] = "kind";
if (ent->flags & HFS_ISDIR)
{
argv[argc++] = "directory";
sprintf(dsize, "%u", ent->u.dir.valence);
argv[argc++] = "size";
argv[argc++] = dsize;
argv[argc++] = "flags";
argv[argc++] = (ent->fdflags & HFS_FNDR_ISINVISIBLE) ? "invis" : "";
}
else
{
argv[argc++] = "file";
argv[argc++] = "type";
argv[argc++] = ent->u.file.type;
argv[argc++] = "creator";
argv[argc++] = ent->u.file.creator;
locked = ent->flags & HFS_ISLOCKED;
invis = ent->fdflags & HFS_FNDR_ISINVISIBLE;
argv[argc++] = "flags";
argv[argc++] = (locked && invis) ? "locked invis" :
(locked ? "locked" : (invis ? "invis" : ""));
sprintf(rsize, "%lu", ent->u.file.rsize);
sprintf(dsize, "%lu", ent->u.file.dsize);
argv[argc++] = "rsize";
argv[argc++] = rsize;
argv[argc++] = "dsize";
argv[argc++] = dsize;
}
sprintf(crdate, "%ld", (long) ent->crdate);
sprintf(mddate, "%ld", (long) ent->mddate);
sprintf(bkdate, "%ld", (long) ent->bkdate);
argv[argc++] = "crdate";
argv[argc++] = crdate;
argv[argc++] = "mddate";
argv[argc++] = mddate;
argv[argc++] = "bkdate";
argv[argc++] = bkdate;
return Tcl_Merge(argc, argv);
}
/*
* NAME: getdir()
* DESCRIPTION: collect and return the contents of an HFS directory
*/
static
int getdir(Tcl_Interp *interp, volref *vref, const char *path)
{
hfsvol *vol = vref->vol;
hfsdir *dir;
hfsdirent ent;
char *str;
if (hfs_setcwd(vol, vref->cwd) == -1 ||
hfs_stat(vol, path, &ent) == -1)
return error(interp, 0);
if (ent.flags & HFS_ISDIR)
{
dir = hfs_opendir(vol, path);
if (dir == 0)
return error(interp, 0);
while (hfs_readdir(dir, &ent) != -1)
{
str = direntstr(&ent);
if (str == 0)
{
hfs_closedir(dir);
Tcl_SetResult(interp, "out of memory", TCL_STATIC);
return TCL_ERROR;
}
Tcl_AppendElement(interp, str);
Tcl_Free(str);
}
if (hfs_closedir(dir) == -1)
return error(interp, 0);
}
else /* ! HFS_ISDIR */
{
str = direntstr(&ent);
if (str == 0)
{
interp->result = "out of memory";
return TCL_ERROR;
}
Tcl_AppendElement(interp, str);
Tcl_Free(str);
}
return TCL_OK;
}
/*
* NAME: file->del()
* DESCRIPTION: called by Tcl when a file reference is deleted
*/
static
void file_del(ClientData clientData)
{
fileref *fref = clientData;
Tcl_HashEntry *entry;
entry = Tcl_FindHashEntry(&files, (char *) fref);
if (entry)
Tcl_DeleteHashEntry(entry);
err_close = hfs_close(fref->file);
FREE(fref);
}
/*
* NAME: file->cmd()
* DESCRIPTION: operate on an HFS file
*/
static
int file_cmd(ClientData clientData, Tcl_Interp *interp,
int argc, char *argv[])
{
fileref *fref = clientData;
hfsfile *file = fref->file;
switch (argc)
{
case 1:
interp->result = "missing command";
return TCL_ERROR;
case 2:
if (strcmp(argv[1], "close") == 0)
{
Tcl_DeleteCommand(interp, argv[0]);
if (err_close == -1)
return error(interp, 0);
}
else if (strcmp(argv[1], "tell") == 0)
{
long offset;
offset = hfs_seek(file, 0, HFS_SEEK_CUR);
if (offset == -1)
return error(interp, 0);
sprintf(interp->result, "%lu", offset);
}
else if (strcmp(argv[1], "stat") == 0)
{
hfsdirent ent;
char *str;
if (hfs_fstat(file, &ent) == -1)
return error(interp, 0);
str = direntstr(&ent);
if (str == 0)
{
interp->result = "out of memory";
return TCL_ERROR;
}
Tcl_SetResult(interp, str, TCL_DYNAMIC);
}
else if (strcmp(argv[1], "getfork") == 0)
{
interp->result = (hfs_getfork(file) == 0) ? "data" : "rsrc";
}
else
{
Tcl_AppendResult(interp, "bad command \"", argv[1],
"\" or wrong # args", (char *) 0);
return TCL_ERROR;
}
break;
case 3:
if (strcmp(argv[1], "setfork") == 0 ||
strcmp(argv[1], "fork") == 0)
{
int fork;
if (strcmp(argv[2], "data") == 0)
fork = 0;
else if (strcmp(argv[2], "rsrc") == 0 ||
strcmp(argv[2], "resource") == 0)
fork = 1;
else
{
interp->result = "bad arg to setfork: must be data or rsrc";
return TCL_ERROR;
}
hfs_setfork(file, fork);
}
else if (strcmp(argv[1], "seek") == 0)
{
long offset;
if (Tcl_ExprLong(interp, argv[2], &offset) != TCL_OK)
return TCL_ERROR;
offset = hfs_seek(file, offset, HFS_SEEK_SET);
if (offset == -1)
return error(interp, 0);
sprintf(interp->result, "%lu", offset);
}
else if (strcmp(argv[1], "read") == 0)
{
long bytes;
char *mem;
if (Tcl_ExprLong(interp, argv[2], &bytes) != TCL_OK)
return TCL_ERROR;
if (bytes < 0)
{
interp->result = "size must be >= 0";
return TCL_ERROR;
}
mem = Tcl_Alloc(bytes + 1);
bytes = hfs_read(file, mem, bytes);
if (bytes == -1)
{
Tcl_Free(mem);
return error(interp, 0);
}
mem[bytes] = 0;
Tcl_SetResult(interp, mem, TCL_DYNAMIC);
}
else if (strcmp(argv[1], "write") == 0)
{
long bytes;
bytes = hfs_write(file, argv[2], strlen(argv[2]));
if (bytes == -1)
return error(interp, 0);
sprintf(interp->result, "%lu", bytes);
}
else
{
Tcl_AppendResult(interp, "bad command \"", argv[1],
"\" or wrong # args", (char *) 0);
return TCL_ERROR;
}
break;
case 4:
if (strcmp(argv[1], "seek") == 0)
{
long offset;
int whence;
if (Tcl_ExprLong(interp, argv[2], &offset) != TCL_OK)
return TCL_ERROR;
if (strcmp(argv[3], "start") == 0 ||
strcmp(argv[3], "set") == 0)
whence = HFS_SEEK_SET;
else if (strcmp(argv[3], "current") == 0 ||
strcmp(argv[3], "cur") == 0)
whence = HFS_SEEK_CUR;
else if (strcmp(argv[3], "end") == 0)
whence = HFS_SEEK_END;
else
{
interp->result = "bad arg 3: must be start, current, or end";
return TCL_ERROR;
}
offset = hfs_seek(file, offset, whence);
if (offset == -1)
return error(interp, 0);
sprintf(interp->result, "%lu", offset);
}
else
{
Tcl_AppendResult(interp, "bad command \"", argv[1],
"\" or wrong # args", (char *) 0);
return TCL_ERROR;
}
break;
default:
Tcl_AppendResult(interp, "bad command \"", argv[1],
"\" or wrong # args", (char *) 0);
return TCL_ERROR;
}
return TCL_OK;
}
/*
* NAME: fork->native()
* DESCRIPTION: copy a single fork in native mode
*/
static
int fork_native(Tcl_Interp *interp, hfsfile *ifile, hfsfile *ofile)
{
char buf[HFS_BLOCKSZ * 8];
long chunk, bytes;
while (1)
{
chunk = hfs_read(ifile, buf, sizeof(buf));
if (chunk == -1)
return error(interp, "error reading source file");
else if (chunk == 0)
break;
bytes = hfs_write(ofile, buf, chunk);
if (bytes == -1)
return error(interp, "error writing destination file");
else if (bytes != chunk)
return error(interp, "wrote incomplete chunk");
}
return TCL_OK;
}
/*
* NAME: file->ref()
* DESCRIPTION: called to initialize a new file reference
*/
static
void file_ref(Tcl_Interp *interp, volref *vref, fileref *fref, hfsfile *file)
{
static int id = 0;
Tcl_CmdInfo info;
Tcl_HashEntry *entry;
int new;
do
sprintf(interp->result, "hfsfile%d", id++);
while (Tcl_GetCommandInfo(interp, interp->result, &info));
fref->file = file;
fref->interp = interp;
fref->cmd = Tcl_CreateCommand(interp, interp->result,
file_cmd, fref, file_del);
entry = Tcl_CreateHashEntry(&files, (char *) fref, &new);
Tcl_SetHashValue(entry, vref);
}
/*
* NAME: do_copynative()
* DESCRIPTION: perform native HFS file copy
*/
static
int do_copynative(Tcl_Interp *interp, hfsfile *ifile, hfsfile *ofile)
{
int result;
if (hfs_setfork(ifile, 0) == -1 ||
hfs_setfork(ofile, 0) == -1)
return error(interp, "error opening data fork");
result = fork_native(interp, ifile, ofile);
if (result != TCL_OK)
return result;
if (hfs_setfork(ifile, 1) == -1 ||
hfs_setfork(ofile, 1) == -1)
return error(interp, "error opening resource fork");
result = fork_native(interp, ifile, ofile);
if (result != TCL_OK)
return result;
return TCL_OK;
}
/*
* NAME: copynative()
* DESCRIPTION: copy an HFS file to another HFS volume
*/
static
int copynative(Tcl_Interp *interp, volref *srcvref, char *argv[])
{
volref *dstvref;
Tcl_CmdInfo info;
Tcl_HashEntry *entry = 0;
hfsdirent ent;
const char *srcname, *dstname;
hfsfile *ifile, *ofile;
int result;
unsigned long cnid;
if (Tcl_GetCommandInfo(interp, argv[3], &info))
entry = Tcl_FindHashEntry(&volumes, (char *) info.clientData);
if (entry == 0)
{
Tcl_AppendResult(interp, "unknown volume \"", argv[3], "\"", (char *) 0);
return TCL_ERROR;
}
dstvref = info.clientData;
srcname = argv[2];
dstname = argv[4];
if (hfs_setcwd(srcvref->vol, srcvref->cwd) == -1)
return error(interp, 0);
ifile = hfs_open(srcvref->vol, srcname);
if (ifile == 0)
return error(interp, "can't open source file");
if (hfs_setcwd(dstvref->vol, dstvref->cwd) == -1)
{
error(interp, 0);
hfs_close(ifile);
return TCL_ERROR;
}
cnid = 0;
if (hfs_stat(dstvref->vol, dstname, &ent) != -1)
{
if (ent.flags & HFS_ISDIR)
{
if (hfs_setcwd(dstvref->vol, ent.cnid) == -1)
{
error(interp, 0);
hfs_close(ifile);
return TCL_ERROR;
}
dstname = srcname;
if (hfs_stat(dstvref->vol, dstname, &ent) != -1)
cnid = ent.cnid;
}
else
cnid = ent.cnid;
}
if (hfs_fstat(ifile, &ent) == -1)
{
error(interp, "can't stat source file");
hfs_close(ifile);
return TCL_ERROR;
}
if (srcvref->vol == dstvref->vol &&
ent.cnid == cnid)
{
interp->result = "source and destination files are the same";
hfs_close(ifile);
return TCL_ERROR;
}
hfs_delete(dstvref->vol, dstname);
ofile = hfs_create(dstvref->vol, dstname,
ent.u.file.type, ent.u.file.creator);
if (ofile == 0)
{
error(interp, "can't create destination file");
hfs_close(ifile);
return TCL_ERROR;
}
result = do_copynative(interp, ifile, ofile);
ent.fdflags &= ~(HFS_FNDR_ISONDESK | HFS_FNDR_HASBEENINITED);
if (result == TCL_OK && hfs_fsetattr(ofile, &ent) == -1)
result = error(interp, "can't set destination file attributes");
if (hfs_close(ofile) == -1 && result == TCL_OK)
result = error(interp, "error closing destination file");
if (hfs_close(ifile) == -1 && result == TCL_OK)
result = error(interp, "error closing source file");
return result;
}
/*
* NAME: copyin()
* DESCRIPTION: copy a UNIX file into an HFS volume
*/
static
int copyin(Tcl_Interp *interp, hfsvol *vol, char *argv[])
{
cpifunc copyfile;
if (strcmp(argv[2], "macbinary") == 0 ||
strcmp(argv[2], "macb") == 0)
copyfile = cpi_macb;
else if (strcmp(argv[2], "binhex") == 0 ||
strcmp(argv[2], "binh") == 0)
copyfile = cpi_binh;
else if (strcmp(argv[2], "text") == 0)
copyfile = cpi_text;
else if (strcmp(argv[2], "raw") == 0 ||
strcmp(argv[2], "data") == 0)
copyfile = cpi_raw;
else
{
interp->result = "bad mode: must be macb, binh, text, or raw";
return TCL_ERROR;
}
if (copyfile(argv[3], vol, argv[4]) == -1)
{
ERROR(errno, cpi_error);
return error(interp, 0);
}
return TCL_OK;
}
/*
* NAME: copyout()
* DESCRIPTION: copy an HFS file out to a UNIX file
*/
static
int copyout(Tcl_Interp *interp, hfsvol *vol, char *argv[])
{
cpofunc copyfile;
if (strcmp(argv[2], "macbinary") == 0 ||
strcmp(argv[2], "macb") == 0)
copyfile = cpo_macb;
else if (strcmp(argv[2], "binhex") == 0 ||
strcmp(argv[2], "binh") == 0)
copyfile = cpo_binh;
else if (strcmp(argv[2], "text") == 0)
copyfile = cpo_text;
else if (strcmp(argv[2], "raw") == 0 ||
strcmp(argv[2], "data") == 0)
copyfile = cpo_raw;
else
{
interp->result = "bad mode: must be macb, binh, text, or raw";
return TCL_ERROR;
}
if (copyfile(vol, argv[3], argv[4]) == -1)
{
ERROR(errno, cpo_error);
return error(interp, 0);
}
return TCL_OK;
}
/*
* NAME: do_zero()
* DESCRIPTION: call hfs_zero() with necessary privileges
*/
static
int do_zero(const char *path, unsigned int nparts, unsigned long *len)
{
int result;
suid_enable();
result = hfs_zero(path, nparts, len);
suid_disable();
return result;
}
/*
* NAME: do_mkpart()
* DESCRIPTION: call hfs_mkpart() with necessary privileges
*/
static
int do_mkpart(const char *path, unsigned long len)
{
int result;
suid_enable();
result = hfs_mkpart(path, len);
suid_disable();
return result;
}
/*
* NAME: do_format()
* DESCRIPTION: call hfs_format() with necessary privileges
*/
static
int do_format(const char *path, int partno, int mode, const char *vname,
unsigned int nbadblocks, unsigned long badblocks[])
{
int result;
suid_enable();
result = hfs_format(path, partno, mode, vname, nbadblocks, badblocks);
suid_disable();
return result;
}
/*
* NAME: vol->del()
* DESCRIPTION: called by Tcl when a volume reference is deleted
*/
static
void vol_del(ClientData clientData)
{
volref *vref = clientData;
Tcl_HashEntry *entry;
entry = Tcl_FindHashEntry(&volumes, (char *) vref);
if (entry)
Tcl_DeleteHashEntry(entry);
do
{
Tcl_HashSearch search;
for (entry = Tcl_FirstHashEntry(&files, &search); entry;
entry = Tcl_NextHashEntry(&search))
{
if (Tcl_GetHashValue(entry) == vref)
{
fileref *fref = (fileref *) Tcl_GetHashKey(&files, entry);
Tcl_DeleteCommand(fref->interp,
Tcl_GetCommandName(fref->interp, fref->cmd));
break;
}
}
}
while (entry);
err_umount = hfs_umount(vref->vol);
FREE(vref);
}
/*
* NAME: vol->cmd()
* DESCRIPTION: operate on an HFS volume
*/
static
int vol_cmd(ClientData clientData, Tcl_Interp *interp,
int argc, char *argv[])
{
volref *vref = clientData;
hfsvol *vol = vref->vol;
switch (argc)
{
case 1:
interp->result = "missing command";
return TCL_ERROR;
case 2:
if (strcmp(argv[1], "vname") == 0)
{
hfsvolent ent;
hfs_vstat(vol, &ent);
Tcl_SetResult(interp, ent.name, TCL_VOLATILE);
}
else if (strcmp(argv[1], "size") == 0)
{
hfsvolent ent;
hfs_vstat(vol, &ent);
sprintf(interp->result, "%lu %lu", ent.totbytes, ent.freebytes);
}
else if (strcmp(argv[1], "crdate") == 0)
{
hfsvolent ent;
hfs_vstat(vol, &ent);
sprintf(interp->result, "%ld", (long) ent.crdate);
}
else if (strcmp(argv[1], "mddate") == 0)
{
hfsvolent ent;
hfs_vstat(vol, &ent);
sprintf(interp->result, "%ld", (long) ent.mddate);
}
else if (strcmp(argv[1], "islocked") == 0)
{
hfsvolent ent;
hfs_vstat(vol, &ent);
if (ent.flags & HFS_ISLOCKED)
interp->result = "1";
else
interp->result = "0";
}
else if (strcmp(argv[1], "umount") == 0)
{
Tcl_DeleteCommand(interp, argv[0]);
if (err_umount == -1)
return error(interp, 0);
}
else if (strcmp(argv[1], "cwd") == 0)
sprintf(interp->result, "%lu", vref->cwd);
else if (strcmp(argv[1], "path") == 0)
{
char name[HFS_MAX_FLEN + 1];
long id;
int listc, i;
char **listv;
char *result;
id = vref->cwd;
while (id != HFS_CNID_ROOTPAR)
{
if (hfs_dirinfo(vol, &id, name) == -1)
return error(interp, 0);
Tcl_AppendElement(interp, name);
}
/* reverse the resulting list */
if (Tcl_SplitList(interp, interp->result, &listc, &listv) != TCL_OK)
return TCL_ERROR;
for (i = 0; i < listc / 2; ++i)
{
char *tmp;
tmp = listv[i];
listv[i] = listv[listc - 1 - i];
listv[listc - 1 - i] = tmp;
}
result = Tcl_Merge(listc, listv);
Tcl_Free(listv);
Tcl_SetResult(interp, result, TCL_DYNAMIC);
}
else if (strcmp(argv[1], "dir") == 0)
{
if (getdir(interp, vref, ":") != TCL_OK)
return TCL_ERROR;
}
else if (strcmp(argv[1], "flush") == 0)
{
if (hfs_flush(vol) == -1)
return error(interp, 0);
}
else if (strcmp(argv[1], "sepchar") == 0)
interp->result = ":";
else
{
Tcl_AppendResult(interp, "bad command \"", argv[1],
"\" or wrong # args", (char *) 0);
return TCL_ERROR;
}
break;
case 3:
if (strcmp(argv[1], "cd") == 0 ||
strcmp(argv[1], "chdir") == 0)
{
if (hfs_setcwd(vol, vref->cwd) == -1 ||
hfs_chdir(vol, argv[2]) == -1)
return error(interp, 0);
vref->cwd = hfs_getcwd(vol);
}
else if (strcmp(argv[1], "dirinfo") == 0)
{
long id;
char name[HFS_MAX_FLEN + 1], idstr[CHARLEN(unsigned long) + 1];
if (Tcl_ExprLong(interp, argv[2], &id) != TCL_OK)
return TCL_ERROR;
if (hfs_dirinfo(vol, &id, name) == -1)
return error(interp, 0);
sprintf(idstr, "%lu", id);
Tcl_AppendElement(interp, name);
Tcl_AppendElement(interp, idstr);
}
else if (strcmp(argv[1], "dir") == 0)
{
if (getdir(interp, vref, argv[2]) != TCL_OK)
return TCL_ERROR;
}
else if (strcmp(argv[1], "open") == 0)
{
fileref *fref;
hfsfile *file;
fref = ALLOC(fileref, 1);
if (fref == 0)
{
interp->result = "out of memory";
return TCL_ERROR;
}
if (hfs_setcwd(vol, vref->cwd) == -1 ||
(file = hfs_open(vol, argv[2])) == 0)
{
FREE(fref);
return error(interp, 0);
}
file_ref(interp, vref, fref, file);
}
else if (strcmp(argv[1], "stat") == 0)
{
hfsdirent ent;
char *str;
if (hfs_setcwd(vol, vref->cwd) == -1 ||
hfs_stat(vol, argv[2], &ent) == -1)
return error(interp, 0);
str = direntstr(&ent);
if (str == 0)
{
interp->result = "out of memory";
return TCL_ERROR;
}
Tcl_SetResult(interp, str, TCL_DYNAMIC);
}
else if (strcmp(argv[1], "mkdir") == 0)
{
if (hfs_setcwd(vol, vref->cwd) == -1 ||
hfs_mkdir(vol, argv[2]) == -1)
return error(interp, 0);
}
else if (strcmp(argv[1], "rmdir") == 0)
{
if (hfs_setcwd(vol, vref->cwd) == -1 ||
hfs_rmdir(vol, argv[2]) == -1)
return error(interp, 0);
}
else if (strcmp(argv[1], "delete") == 0)
{
if (hfs_setcwd(vol, vref->cwd) == -1 ||
hfs_delete(vol, argv[2]) == -1)
return error(interp, 0);
}
else if (strcmp(argv[1], "touch") == 0)
{
hfsdirent ent;
if (hfs_setcwd(vol, vref->cwd) == -1 ||
hfs_stat(vol, argv[2], &ent) == -1)
return error(interp, 0);
ent.mddate = time(0);
if (hfs_setattr(vol, argv[2], &ent) == -1)
return error(interp, 0);
}
else if (strcmp(argv[1], "glob") == 0)
{
int listc, fargc;
char **listv, **fargv, *result;
if (hfs_setcwd(vol, vref->cwd) == -1)
return error(interp, 0);
if (Tcl_SplitList(interp, argv[2], &listc, &listv) != TCL_OK)
return TCL_ERROR;
fargv = hfs_glob(vol, listc, listv, &fargc);
free(listv);
if (fargv == 0)
{
interp->result = "globbing error";
return TCL_ERROR;
}
result = Tcl_Merge(fargc, fargv);
Tcl_Free(fargv);
Tcl_SetResult(interp, result, TCL_DYNAMIC);
}
else if (strcmp(argv[1], "bless") == 0)
{
hfsvolent volent;
hfsdirent dirent;
if (hfs_setcwd(vol, vref->cwd) == -1 ||
hfs_vstat(vol, &volent) == -1 ||
hfs_stat(vol, argv[2], &dirent) == -1)
return error(interp, 0);
volent.blessed = dirent.cnid;
if (hfs_vsetattr(vol, &volent) == -1)
return error(interp, 0);
}
else
{
Tcl_AppendResult(interp, "bad command \"", argv[1],
"\" or wrong # args", (char *) 0);
return TCL_ERROR;
}
break;
case 4:
if (strcmp(argv[1], "rename") == 0)
{
if (hfs_setcwd(vol, vref->cwd) == -1 ||
hfs_rename(vol, argv[2], argv[3]) == -1)
return error(interp, 0);
}
else
{
Tcl_AppendResult(interp, "bad command \"", argv[1],
"\" or wrong # args", (char *) 0);
return TCL_ERROR;
}
break;
case 5:
if (strcmp(argv[1], "create") == 0)
{
fileref *fref;
hfsfile *file;
if (strlen(argv[3]) != 4 ||
strlen(argv[4]) != 4)
{
interp->result = "type and creator must be 4 character strings";
return TCL_ERROR;
}
fref = ALLOC(fileref, 1);
if (fref == 0)
{
interp->result = "out of memory";
return TCL_ERROR;
}
if (hfs_setcwd(vol, vref->cwd) == -1 ||
(file = hfs_create(vol, argv[2], argv[3], argv[4])) == 0)
{
FREE(fref);
return error(interp, 0);
}
file_ref(interp, vref, fref, file);
}
else if (strcmp(argv[1], "copy") == 0)
return copynative(interp, vref, argv);
else if (strcmp(argv[1], "copyin") == 0)
{
if (hfs_setcwd(vol, vref->cwd) == -1)
return error(interp, 0);
return copyin(interp, vol, argv);
}
else if (strcmp(argv[1], "copyout") == 0)
{
if (hfs_setcwd(vol, vref->cwd) == -1)
return error(interp, 0);
return copyout(interp, vol, argv);
}
else
{
Tcl_AppendResult(interp, "bad command \"", argv[1],
"\" or wrong # args", (char *) 0);
return TCL_ERROR;
}
break;
default:
Tcl_AppendResult(interp, "bad command \"", argv[1],
"\" or wrong # args", (char *) 0);
return TCL_ERROR;
}
return TCL_OK;
}
/*
* NAME: cmd->hfs()
* DESCRIPTION: Tcl HFS command callback
*/
static
int cmd_hfs(ClientData clientData, Tcl_Interp *interp,
int argc, char *argv[])
{
static int id = 0;
if (argc < 2)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
if (strcmp(argv[1], "mount") == 0)
{
int partno;
hfsvol *vol;
volref *vref;
Tcl_CmdInfo info;
Tcl_HashEntry *entry;
int new;
if (argc < 3 || argc > 4)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
if (argc == 4)
{
if (Tcl_GetInt(interp, argv[3], &partno) != TCL_OK)
return TCL_ERROR;
}
else
{
int nparts;
suid_enable();
nparts = hfs_nparts(argv[2]);
suid_disable();
if (nparts > 1)
{
sprintf(interp->result, "must specify partition number "
"(%d available)", nparts);
return TCL_ERROR;
}
else if (nparts == -1)
partno = 0;
else
partno = 1;
}
vref = ALLOC(volref, 1);
if (vref == 0)
{
interp->result = "out of memory";
return TCL_ERROR;
}
suid_enable();
vol = hfs_mount(argv[2], partno, HFS_MODE_ANY);
suid_disable();
if (vol == 0)
{
error(interp, "can't mount volume");
FREE(vref);
return TCL_ERROR;
}
vref->vol = vol;
vref->cwd = HFS_CNID_ROOTDIR;
entry = Tcl_CreateHashEntry(&volumes, (char *) vref, &new);
do
sprintf(interp->result, "hfsvol%d", id++);
while (Tcl_GetCommandInfo(interp, interp->result, &info));
Tcl_CreateCommand(interp, interp->result,
vol_cmd, vref, vol_del);
}
else if (strcmp(argv[1], "zero") == 0)
{
int nparts;
unsigned long len;
if (argc != 4)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
if (Tcl_GetInt(interp, argv[3], &nparts) != TCL_OK)
return TCL_ERROR;
if (do_zero(argv[2], nparts, &len) == -1)
return error(interp, 0);
sprintf(interp->result, "%lu", len);
}
else if (strcmp(argv[1], "mkpart") == 0)
{
unsigned int len;
if (argc != 4)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
if (Tcl_GetInt(interp, argv[3], &len) != TCL_OK)
return TCL_ERROR;
if (do_mkpart(argv[2], len) == -1)
return error(interp, 0);
}
else if (strcmp(argv[1], "nparts") == 0)
{
int nparts;
if (argc != 3)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
suid_enable();
nparts = hfs_nparts(argv[2]);
suid_disable();
sprintf(interp->result, "%d", nparts);
}
else if (strcmp(argv[1], "format") == 0)
{
int partno;
if (argc < 5 || argc > 6)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
if (Tcl_GetInt(interp, argv[3], &partno) != TCL_OK)
return TCL_ERROR;
if (argc == 6)
{
int listc, i;
char **listv;
unsigned long *badblocks;
if (Tcl_SplitList(interp, argv[5], &listc, &listv) != TCL_OK)
return TCL_ERROR;
badblocks = ALLOCX(unsigned long, listc);
if (listc && badblocks == 0)
{
Tcl_Free(listv);
interp->result = "out of memory";
return TCL_ERROR;
}
for (i = 0; i < listc; ++i)
{
if (Tcl_ExprLong(interp, listv[i],
(long *) &badblocks[i]) != TCL_OK)
{
Tcl_Free(listv);
FREE(badblocks);
return TCL_ERROR;
}
}
Tcl_Free(listv);
if (do_format(argv[2], partno, 0, argv[4], listc, badblocks) == -1)
{
FREE(badblocks);
return error(interp, 0);
}
FREE(badblocks);
}
else
{
if (do_format(argv[2], partno, 0, argv[4], 0, 0) == -1)
return error(interp, 0);
}
}
else if (strcmp(argv[1], "flushall") == 0)
hfs_flushall();
else if (strcmp(argv[1], "chartrans") == 0)
{
char *result;
char *tclresult;
if (argc != 5)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
if ((strcmp(argv[2], "latin1") != 0 &&
strcmp(argv[2], "macroman") != 0) ||
(strcmp(argv[3], "latin1") != 0 &&
strcmp(argv[3], "macroman") != 0))
{
interp->result = "bad arg to chartrans: "
"charsets must be one of latin1, macroman";
return TCL_ERROR;
}
if (strcmp(argv[2], "latin1") == 0 &&
strcmp(argv[3], "macroman") == 0)
result = cs_macroman(argv[4], 0);
else if (strcmp(argv[2], "macroman") == 0 &&
strcmp(argv[3], "latin1") == 0)
result = cs_latin1(argv[4], 0);
else
{
Tcl_SetResult(interp, argv[4], TCL_VOLATILE);
return TCL_OK;
}
if (result == 0)
{
interp->result = "out of memory";
return TCL_ERROR;
}
tclresult = Tcl_Alloc(strlen(result) + 1);
memcpy(tclresult, result, strlen(result) + 1);
free(result);
Tcl_SetResult(interp, tclresult, TCL_DYNAMIC);
}
else if (strcmp(argv[1], "version") == 0)
{
if (argc != 2)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
interp->result = (char *) hfsutils_version;
}
else if (strcmp(argv[1], "copyright") == 0)
{
if (argc != 2)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
interp->result = (char *) hfsutils_copyright;
}
else if (strcmp(argv[1], "author") == 0)
{
if (argc != 2)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
interp->result = (char *) hfsutils_author;
}
else if (strcmp(argv[1], "license") == 0)
{
if (argc != 2)
{
interp->result = "wrong # args";
return TCL_ERROR;
}
interp->result = (char *) hfsutils_license;
}
else
{
Tcl_AppendResult(interp, "bad hfs command \"", argv[1],
"\": should be one of "
"mount, zero, mkpart, format, flushall, "
"version, copyright, author, license",
(char *) 0);
return TCL_ERROR;
}
return TCL_OK;
}
/*
* NAME: cmd->exit()
* DESCRIPTION: called to terminate; clean up volume state
*/
static
int cmd_exit(ClientData clientData, Tcl_Interp *interp,
int argc, char *argv[])
{
int status = 0;
if (argc > 2)
{
interp->result = "wrong # args: should be \"exit ?returnCode?\"";
return TCL_ERROR;
}
if (argc == 2 && Tcl_GetInt(interp, argv[1], &status) != TCL_OK)
return TCL_ERROR;
hfs_umountall();
exit(status);
return TCL_OK;
}
/*
* NAME: Hfs->Init()
* DESCRIPTION: initialize Tcl components for HFS handling
*/
int Hfs_Init(Tcl_Interp *interp)
{
Tcl_InitHashTable(&volumes, TCL_ONE_WORD_KEYS);
Tcl_InitHashTable(&files, TCL_ONE_WORD_KEYS);
Tcl_CreateCommand(interp, "hfs", cmd_hfs, 0, 0);
Tcl_CreateCommand(interp, "exit", cmd_exit, 0, 0);
return TCL_OK;
}
Reference in New Issue View Git Blame Copy Permalink