[sgt/putty] / mac / macstore.c

/* $Id: macstore.c,v 1.10 2003/01/18 16:10:21 ben Exp $ */

/*
 * macstore.c: Macintosh-specific impementation of the interface
 * defined in storage.h
 */

#include <MacTypes.h>
#include <Folders.h>
#include <Memory.h>
#include <Resources.h>
#include <TextUtils.h>

#include <string.h>

#include "putty.h"
#include "storage.h"
#include "mac.h"
#include "macresid.h"

#define PUTTY_CREATOR	FOUR_CHAR_CODE('pTTY')
#define INTERNAL_CREATOR FOUR_CHAR_CODE('pTTI')
#define SESS_TYPE	FOUR_CHAR_CODE('Sess')
#define SEED_TYPE	FOUR_CHAR_CODE('Seed')


OSErr FSpGetDirID(FSSpec *f, long *idp, Boolean makeit);

/*
 * We store each session as a file in the "PuTTY" sub-directory of the
 * preferences folder.  Each (key,value) pair is stored as a resource.
 */

OSErr get_putty_dir(Boolean makeit, short *pVRefNum, long *pDirID)
{
    OSErr error = noErr;
    short prefVRefNum;
    FSSpec puttydir;
    long prefDirID, puttyDirID;

    error = FindFolder(kOnSystemDisk, kPreferencesFolderType, makeit,
		       &prefVRefNum, &prefDirID);
    if (error != noErr) goto out;

    error = FSMakeFSSpec(prefVRefNum, prefDirID, "\pPuTTY", &puttydir);
    if (error != noErr && error != fnfErr) goto out;
    error = FSpGetDirID(&puttydir, &puttyDirID, makeit);
    if (error != noErr) goto out;

    *pVRefNum = prefVRefNum;
    *pDirID = puttyDirID;

  out:
    return error;
}

OSErr get_session_dir(Boolean makeit, short *pVRefNum, long *pDirID) {
    OSErr error = noErr;
    short puttyVRefNum;
    FSSpec sessdir;
    long puttyDirID, sessDirID;

    error = get_putty_dir(makeit, &puttyVRefNum, &puttyDirID);
    if (error != noErr) goto out;
    error = FSMakeFSSpec(puttyVRefNum, puttyDirID, "\pSaved Sessions",
			 &sessdir);
    if (error != noErr && error != fnfErr) goto out;
    error = FSpGetDirID(&sessdir, &sessDirID, makeit);
    if (error != noErr) goto out;

    *pVRefNum = puttyVRefNum;
    *pDirID = sessDirID;

  out:
    return error;
}

OSErr FSpGetDirID(FSSpec *f, long *idp, Boolean makeit) {
    CInfoPBRec pb;
    OSErr error = noErr;

    pb.dirInfo.ioNamePtr = f->name;
    pb.dirInfo.ioVRefNum = f->vRefNum;
    pb.dirInfo.ioDrDirID = f->parID;
    pb.dirInfo.ioFDirIndex = 0;
    error = PBGetCatInfoSync(&pb);
    if (error == fnfErr && makeit)
	return FSpDirCreate(f, smSystemScript, idp);
    if (error != noErr) goto out;
    if ((pb.dirInfo.ioFlAttrib & ioDirMask) == 0) {
	error = dirNFErr;
	goto out;
    }
    *idp = pb.dirInfo.ioDrDirID;

  out:
    return error;
}

/* Copy a resource into the current resource file */
static OSErr copy_resource(ResType restype, short resid)
{
    Handle h;
    Str255 resname;

    fprintf(stderr, "getting resource %x, id %d\n", restype, resid);
    h = GetResource(restype, resid);
    if (h != NULL) {
	GetResInfo(h, &resid, &restype, resname);
	DetachResource(h);
	AddResource(h, restype, resid, resname);
	if (ResError() == noErr)
	    WriteResource(h);
    }
    fprintf(stderr, "ResError() == %d\n", ResError());
    return ResError();
}

struct write_settings {
    int fd;
    FSSpec tmpfile;
    FSSpec dstfile;
};

void *open_settings_w(char const *sessionname) {
    short sessVRefNum, tmpVRefNum;
    long sessDirID, tmpDirID;
    OSErr error;
    Str255 psessionname;
    struct write_settings *ws;
    
    ws = safemalloc(sizeof *ws);
    error = get_session_dir(kCreateFolder, &sessVRefNum, &sessDirID);
    if (error != noErr) goto out;

    c2pstrcpy(psessionname, sessionname);
    error = FSMakeFSSpec(sessVRefNum, sessDirID, psessionname, &ws->dstfile);
    if (error != noErr && error != fnfErr) goto out;
    if (error == fnfErr) {
	FSpCreateResFile(&ws->dstfile, PUTTY_CREATOR, SESS_TYPE,
			 smSystemScript);
	if ((error = ResError()) != noErr) goto out;
    }

    /* Create a temporary file to save to first. */
    error = FindFolder(sessVRefNum, kTemporaryFolderType, kCreateFolder,
		       &tmpVRefNum, &tmpDirID);
    if (error != noErr) goto out;
    error = FSMakeFSSpec(tmpVRefNum, tmpDirID, psessionname, &ws->tmpfile);
    if (error != noErr && error != fnfErr) goto out;
    if (error == noErr) {
	error = FSpDelete(&ws->tmpfile);
	if (error != noErr) goto out;
    }
    FSpCreateResFile(&ws->tmpfile, PUTTY_CREATOR, SESS_TYPE, smSystemScript);
    if ((error = ResError()) != noErr) goto out;

    ws->fd = FSpOpenResFile(&ws->tmpfile, fsWrPerm);
    if (ws->fd == -1) {error = ResError(); goto out;}

    /* Set up standard resources.  Doesn't matter if these fail. */
    copy_resource('STR ', -16396);
    copy_resource('TMPL', TMPL_Int);

    return ws;

  out:
    safefree(ws);
    fatalbox("Failed to open session for write (%d)", error);
}

void write_setting_s(void *handle, char const *key, char const *value) {
    int fd = *(int *)handle;
    Handle h;
    int id;
    OSErr error;

    UseResFile(fd);
    if (ResError() != noErr)
        fatalbox("Failed to open saved session (%d)", ResError());

    error = PtrToHand(value, &h, strlen(value));
    if (error != noErr)
	fatalbox("Failed to allocate memory");
    /* Put the data in a resource. */
    id = Unique1ID(FOUR_CHAR_CODE('TEXT'));
    if (ResError() != noErr)
	fatalbox("Failed to get ID for resource %s (%d)", key, ResError());
    addresource(h, FOUR_CHAR_CODE('TEXT'), id, key);
    if (ResError() != noErr)
	fatalbox("Failed to add resource %s (%d)", key, ResError());
}

void write_setting_i(void *handle, char const *key, int value) {
    int fd = *(int *)handle;
    Handle h;
    int id;
    OSErr error;

    UseResFile(fd);
    if (ResError() != noErr)
        fatalbox("Failed to open saved session (%d)", ResError());

    /* XXX assume all systems have the same "int" format */
    error = PtrToHand(&value, &h, sizeof(int));
    if (error != noErr)
	fatalbox("Failed to allocate memory (%d)", error);

    /* Put the data in a resource. */
    id = Unique1ID(FOUR_CHAR_CODE('Int '));
    if (ResError() != noErr)
	fatalbox("Failed to get ID for resource %s (%d)", key, ResError());
    addresource(h, FOUR_CHAR_CODE('Int '), id, key);
    if (ResError() != noErr)
	fatalbox("Failed to add resource %s (%d)", key, ResError());
}

void close_settings_w(void *handle) {
    struct write_settings *ws = handle;
    OSErr error;

    CloseResFile(ws->fd);
    if ((error = ResError()) != noErr)
	goto out;
    error = FSpExchangeFiles(&ws->tmpfile, &ws->dstfile);
    if (error != noErr) goto out;
    error = FSpDelete(&ws->tmpfile);
    if (error != noErr) goto out;
    return;

  out:
    fatalbox("Close of saved session failed (%d)", error);
    safefree(handle);
}

void *open_settings_r(char const *sessionname)
{
    short sessVRefNum;
    long sessDirID;
    FSSpec sessfile;
    OSErr error;
    Str255 psessionname;

    error = get_session_dir(kDontCreateFolder, &sessVRefNum, &sessDirID);

    c2pstrcpy(psessionname, sessionname);
    error = FSMakeFSSpec(sessVRefNum, sessDirID, psessionname, &sessfile);
    if (error != noErr) goto out;
    return open_settings_r_fsp(&sessfile);

  out:
    return NULL;
}

void *open_settings_r_fsp(FSSpec *sessfile)
{
    OSErr error;
    int fd;
    int *handle;

    fd = FSpOpenResFile(sessfile, fsRdPerm);
    if (fd == 0) {error = ResError(); goto out;}

    handle = safemalloc(sizeof *handle);
    *handle = fd;
    return handle;

  out:
    return NULL;
}

char *read_setting_s(void *handle, char const *key, char *buffer, int buflen) {
    int fd;
    Handle h;
    size_t len;

    if (handle == NULL) goto out;
    fd = *(int *)handle;
    UseResFile(fd);
    if (ResError() != noErr) goto out;
    h = get1namedresource(FOUR_CHAR_CODE('TEXT'), key);
    if (h == NULL) goto out;

    len = GetHandleSize(h);
    if (len + 1 > buflen) goto out;
    memcpy(buffer, *h, len);
    buffer[len] = '\0';

    ReleaseResource(h);
    if (ResError() != noErr) goto out;
    return buffer;

  out:
    return NULL;
}

int read_setting_i(void *handle, char const *key, int defvalue) {
    int fd;
    Handle h;
    int value;

    if (handle == NULL) goto out;
    fd = *(int *)handle;
    UseResFile(fd);
    if (ResError() != noErr) goto out;
    h = get1namedresource(FOUR_CHAR_CODE('Int '), key);
    if (h == NULL) goto out;
    value = *(int *)*h;
    ReleaseResource(h);
    if (ResError() != noErr) goto out;
    return value;

  out:
    return defvalue;
}

void close_settings_r(void *handle) {
    int fd;

    if (handle == NULL) return;
    fd = *(int *)handle;
    CloseResFile(fd);
    if (ResError() != noErr)
	fatalbox("Close of saved session failed (%d)", ResError());
    safefree(handle);
}

void del_settings(char const *sessionname) {
    OSErr error;
    FSSpec sessfile;
    short sessVRefNum;
    long sessDirID;
    Str255 psessionname;

    error = get_session_dir(kDontCreateFolder, &sessVRefNum, &sessDirID);

    c2pstrcpy(psessionname, sessionname);
    error = FSMakeFSSpec(sessVRefNum, sessDirID, psessionname, &sessfile);
    if (error != noErr) goto out;

    error = FSpDelete(&sessfile);
    return;
  out:
    fatalbox("Delete session failed (%d)", error);
}

struct enum_settings_state {
    short vRefNum;
    long dirID;
    int index;
};

void *enum_settings_start(void) {
    OSErr error;
    struct enum_settings_state *state;

    state = safemalloc(sizeof(*state));
    error = get_session_dir(kDontCreateFolder, &state->vRefNum, &state->dirID);
    if (error != noErr) {
	safefree(state);
	return NULL;
    }
    state->index = 1;
    return state;
}

char *enum_settings_next(void *handle, char *buffer, int buflen) {
    struct enum_settings_state *e = handle;
    CInfoPBRec pb;
    OSErr error = noErr;
    Str255 name;

    if (e == NULL) return NULL;
    do {
	pb.hFileInfo.ioNamePtr = name;
	pb.hFileInfo.ioVRefNum = e->vRefNum;
	pb.hFileInfo.ioDirID = e->dirID;
	pb.hFileInfo.ioFDirIndex = e->index++;
	error = PBGetCatInfoSync(&pb);
	if (error != noErr) return NULL;
    } while (!((pb.hFileInfo.ioFlAttrib & ioDirMask) == 0 &&
	       pb.hFileInfo.ioFlFndrInfo.fdCreator == PUTTY_CREATOR &&
	       pb.hFileInfo.ioFlFndrInfo.fdType == SESS_TYPE &&
	       name[0] < buflen));

    p2cstrcpy(buffer, name);
    return buffer;
}

void enum_settings_finish(void *handle) {

    safefree(handle);
}

#define SEED_SIZE 512

void read_random_seed(noise_consumer_t consumer)
{
    short puttyVRefNum;
    long puttyDirID;
    OSErr error;
    char buf[SEED_SIZE];
    short refnum;
    long count = SEED_SIZE;

    if (get_putty_dir(kDontCreateFolder, &puttyVRefNum, &puttyDirID) != noErr)
	return;
    if (HOpenDF(puttyVRefNum, puttyDirID, "\pPuTTY Random Seed", fsRdPerm,
		&refnum) != noErr)
	return;
    error = FSRead(refnum, &count, buf);
    if (error != noErr && error != eofErr)
	return;
    (*consumer)(buf, count);
    FSClose(refnum);
}

/*
 * We don't bother with the usual FSpExchangeFiles dance here because
 * it doesn't really matter if the old random seed gets lost.
 */
void write_random_seed(void *data, int len)
{
    short puttyVRefNum;
    long puttyDirID;
    OSErr error;
    FSSpec dstfile;
    short refnum;
    long count = len;

    if (get_putty_dir(kCreateFolder, &puttyVRefNum, &puttyDirID) != noErr)
	return;

    error = FSMakeFSSpec(puttyVRefNum, puttyDirID, "\pPuTTY Random Seed",
			 &dstfile);
    if (error == fnfErr) {
	/* Set up standard resources */
	FSpCreateResFile(&dstfile, INTERNAL_CREATOR, SEED_TYPE, smRoman);
	refnum = FSpOpenResFile(&dstfile, fsWrPerm);
	if (ResError() == noErr) {
	    copy_resource('STR ', -16397);
	    CloseResFile(refnum);
	}
    } else if (error != noErr) return;

    if (FSpOpenDF(&dstfile, fsWrPerm, &refnum) != noErr) return;
    FSWrite(refnum, &count, data);
    FSClose(refnum);

    return;
}

/*
 * Emacs magic:
 * Local Variables:
 * c-file-style: "simon"
 * End:
 */
Commit	Line	Data
1d4cb74b	1	/* $Id: macstore.c,v 1.10 2003/01/18 16:10:21 ben Exp $ */
d082ac49	2
	3	/*
	4	* macstore.c: Macintosh-specific impementation of the interface
	5	* defined in storage.h
	6	*/
	7
	8	#include <MacTypes.h>
	9	#include <Folders.h>
	10	#include <Memory.h>
	11	#include <Resources.h>
	12	#include <TextUtils.h>
	13
	14	#include <string.h>
	15
	16	#include "putty.h"
	17	#include "storage.h"
ce283213	18	#include "mac.h"
1d4cb74b	19	#include "macresid.h"
d082ac49	20
d082ac49	21	#define PUTTY_CREATOR FOUR_CHAR_CODE('pTTY')
1d4cb74b	22	#define INTERNAL_CREATOR FOUR_CHAR_CODE('pTTI')
d082ac49	23	#define SESS_TYPE FOUR_CHAR_CODE('Sess')
0c4b7799	24	#define SEED_TYPE FOUR_CHAR_CODE('Seed')
d082ac49	25
d082ac49	26
d082ac49	27	OSErr FSpGetDirID(FSSpec f, long idp, Boolean makeit);
	28
	29	/*
	30	* We store each session as a file in the "PuTTY" sub-directory of the
	31	* preferences folder. Each (key,value) pair is stored as a resource.
	32	*/
	33
0c4b7799	34	OSErr get_putty_dir(Boolean makeit, short pVRefNum, long pDirID)
0c4b7799	35	{
d082ac49	36	OSErr error = noErr;
d082ac49	37	short prefVRefNum;
0c4b7799	38	FSSpec puttydir;
0c4b7799	39	long prefDirID, puttyDirID;
d082ac49	40
	41	error = FindFolder(kOnSystemDisk, kPreferencesFolderType, makeit,
	42	&prefVRefNum, &prefDirID);
	43	if (error != noErr) goto out;
	44
	45	error = FSMakeFSSpec(prefVRefNum, prefDirID, "\pPuTTY", &puttydir);
	46	if (error != noErr && error != fnfErr) goto out;
	47	error = FSpGetDirID(&puttydir, &puttyDirID, makeit);
	48	if (error != noErr) goto out;
	49
0c4b7799	50	*pVRefNum = prefVRefNum;
	51	*pDirID = puttyDirID;
	52
	53	out:
	54	return error;
	55	}
	56
	57	OSErr get_session_dir(Boolean makeit, short pVRefNum, long pDirID) {
	58	OSErr error = noErr;
	59	short puttyVRefNum;
	60	FSSpec sessdir;
	61	long puttyDirID, sessDirID;
	62
	63	error = get_putty_dir(makeit, &puttyVRefNum, &puttyDirID);
	64	if (error != noErr) goto out;
	65	error = FSMakeFSSpec(puttyVRefNum, puttyDirID, "\pSaved Sessions",
d082ac49	66	&sessdir);
	67	if (error != noErr && error != fnfErr) goto out;
	68	error = FSpGetDirID(&sessdir, &sessDirID, makeit);
	69	if (error != noErr) goto out;
	70
0c4b7799	71	*pVRefNum = puttyVRefNum;
d082ac49	72	*pDirID = sessDirID;
	73
	74	out:
	75	return error;
	76	}
	77
	78	OSErr FSpGetDirID(FSSpec f, long idp, Boolean makeit) {
	79	CInfoPBRec pb;
	80	OSErr error = noErr;
	81
	82	pb.dirInfo.ioNamePtr = f->name;
	83	pb.dirInfo.ioVRefNum = f->vRefNum;
	84	pb.dirInfo.ioDrDirID = f->parID;
	85	pb.dirInfo.ioFDirIndex = 0;
	86	error = PBGetCatInfoSync(&pb);
	87	if (error == fnfErr && makeit)
	88	return FSpDirCreate(f, smSystemScript, idp);
	89	if (error != noErr) goto out;
	90	if ((pb.dirInfo.ioFlAttrib & ioDirMask) == 0) {
	91	error = dirNFErr;
	92	goto out;
	93	}
	94	*idp = pb.dirInfo.ioDrDirID;
	95
	96	out:
	97	return error;
	98	}
	99
1d4cb74b	100	/* Copy a resource into the current resource file */
	101	static OSErr copy_resource(ResType restype, short resid)
	102	{
	103	Handle h;
	104	Str255 resname;
	105
	106	fprintf(stderr, "getting resource %x, id %d\n", restype, resid);
	107	h = GetResource(restype, resid);
	108	if (h != NULL) {
	109	GetResInfo(h, &resid, &restype, resname);
	110	DetachResource(h);
	111	AddResource(h, restype, resid, resname);
	112	if (ResError() == noErr)
	113	WriteResource(h);
	114	}
	115	fprintf(stderr, "ResError() == %d\n", ResError());
	116	return ResError();
	117	}
	118
d082ac49	119	struct write_settings {
	120	int fd;
	121	FSSpec tmpfile;
	122	FSSpec dstfile;
	123	};
	124
f5d2d791	125	void open_settings_w(char const sessionname) {
d082ac49	126	short sessVRefNum, tmpVRefNum;
d082ac49	127	long sessDirID, tmpDirID;
d082ac49	128	OSErr error;
	129	Str255 psessionname;
	130	struct write_settings *ws;
	131
	132	ws = safemalloc(sizeof *ws);
	133	error = get_session_dir(kCreateFolder, &sessVRefNum, &sessDirID);
	134	if (error != noErr) goto out;
	135
	136	c2pstrcpy(psessionname, sessionname);
	137	error = FSMakeFSSpec(sessVRefNum, sessDirID, psessionname, &ws->dstfile);
	138	if (error != noErr && error != fnfErr) goto out;
	139	if (error == fnfErr) {
	140	FSpCreateResFile(&ws->dstfile, PUTTY_CREATOR, SESS_TYPE,
	141	smSystemScript);
	142	if ((error = ResError()) != noErr) goto out;
	143	}
	144
	145	/* Create a temporary file to save to first. */
	146	error = FindFolder(sessVRefNum, kTemporaryFolderType, kCreateFolder,
	147	&tmpVRefNum, &tmpDirID);
	148	if (error != noErr) goto out;
	149	error = FSMakeFSSpec(tmpVRefNum, tmpDirID, psessionname, &ws->tmpfile);
	150	if (error != noErr && error != fnfErr) goto out;
	151	if (error == noErr) {
	152	error = FSpDelete(&ws->tmpfile);
	153	if (error != noErr) goto out;
	154	}
	155	FSpCreateResFile(&ws->tmpfile, PUTTY_CREATOR, SESS_TYPE, smSystemScript);
	156	if ((error = ResError()) != noErr) goto out;
	157
	158	ws->fd = FSpOpenResFile(&ws->tmpfile, fsWrPerm);
	159	if (ws->fd == -1) {error = ResError(); goto out;}
	160
1d4cb74b	161	/* Set up standard resources. Doesn't matter if these fail. */
	162	copy_resource('STR ', -16396);
	163	copy_resource('TMPL', TMPL_Int);
	164
d082ac49	165	return ws;
	166
	167	out:
	168	safefree(ws);
	169	fatalbox("Failed to open session for write (%d)", error);
	170	}
	171
f5d2d791	172	void write_setting_s(void handle, char const key, char const *value) {
d082ac49	173	int fd = (int )handle;
	174	Handle h;
	175	int id;
803efcdf	176	OSErr error;
d082ac49	177
	178	UseResFile(fd);
	179	if (ResError() != noErr)
	180	fatalbox("Failed to open saved session (%d)", ResError());
	181
	182	error = PtrToHand(value, &h, strlen(value));
	183	if (error != noErr)
	184	fatalbox("Failed to allocate memory");
	185	/* Put the data in a resource. */
	186	id = Unique1ID(FOUR_CHAR_CODE('TEXT'));
	187	if (ResError() != noErr)
	188	fatalbox("Failed to get ID for resource %s (%d)", key, ResError());
	189	addresource(h, FOUR_CHAR_CODE('TEXT'), id, key);
	190	if (ResError() != noErr)
	191	fatalbox("Failed to add resource %s (%d)", key, ResError());
	192	}
	193
f5d2d791	194	void write_setting_i(void handle, char const key, int value) {
d082ac49	195	int fd = (int )handle;
	196	Handle h;
	197	int id;
	198	OSErr error;
	199
	200	UseResFile(fd);
	201	if (ResError() != noErr)
	202	fatalbox("Failed to open saved session (%d)", ResError());
	203
	204	/* XXX assume all systems have the same "int" format */
	205	error = PtrToHand(&value, &h, sizeof(int));
	206	if (error != noErr)
	207	fatalbox("Failed to allocate memory (%d)", error);
	208
	209	/* Put the data in a resource. */
	210	id = Unique1ID(FOUR_CHAR_CODE('Int '));
	211	if (ResError() != noErr)
	212	fatalbox("Failed to get ID for resource %s (%d)", key, ResError());
	213	addresource(h, FOUR_CHAR_CODE('Int '), id, key);
	214	if (ResError() != noErr)
	215	fatalbox("Failed to add resource %s (%d)", key, ResError());
	216	}
	217
	218	void close_settings_w(void *handle) {
	219	struct write_settings *ws = handle;
	220	OSErr error;
	221
	222	CloseResFile(ws->fd);
	223	if ((error = ResError()) != noErr)
	224	goto out;
	225	error = FSpExchangeFiles(&ws->tmpfile, &ws->dstfile);
	226	if (error != noErr) goto out;
	227	error = FSpDelete(&ws->tmpfile);
	228	if (error != noErr) goto out;
	229	return;
	230
	231	out:
	232	fatalbox("Close of saved session failed (%d)", error);
	233	safefree(handle);
	234	}
	235
f5d2d791	236	void open_settings_r(char const sessionname)
ce283213	237	{
d082ac49	238	short sessVRefNum;
	239	long sessDirID;
	240	FSSpec sessfile;
	241	OSErr error;
	242	Str255 psessionname;
d082ac49	243
	244	error = get_session_dir(kDontCreateFolder, &sessVRefNum, &sessDirID);
	245
	246	c2pstrcpy(psessionname, sessionname);
	247	error = FSMakeFSSpec(sessVRefNum, sessDirID, psessionname, &sessfile);
	248	if (error != noErr) goto out;
ce283213	249	return open_settings_r_fsp(&sessfile);
	250
	251	out:
	252	return NULL;
	253	}
	254
	255	void open_settings_r_fsp(FSSpec sessfile)
	256	{
	257	OSErr error;
	258	int fd;
	259	int *handle;
	260
	261	fd = FSpOpenResFile(sessfile, fsRdPerm);
d082ac49	262	if (fd == 0) {error = ResError(); goto out;}
	263
	264	handle = safemalloc(sizeof *handle);
	265	*handle = fd;
	266	return handle;
	267
	268	out:
	269	return NULL;
	270	}
	271
f5d2d791	272	char read_setting_s(void handle, char const key, char buffer, int buflen) {
d082ac49	273	int fd;
d082ac49	274	Handle h;
086efcde	275	size_t len;
d082ac49	276
	277	if (handle == NULL) goto out;
	278	fd = (int )handle;
	279	UseResFile(fd);
	280	if (ResError() != noErr) goto out;
	281	h = get1namedresource(FOUR_CHAR_CODE('TEXT'), key);
	282	if (h == NULL) goto out;
	283
086efcde	284	len = GetHandleSize(h);
	285	if (len + 1 > buflen) goto out;
	286	memcpy(buffer, *h, len);
	287	buffer[len] = '\0';
	288
d082ac49	289	ReleaseResource(h);
	290	if (ResError() != noErr) goto out;
	291	return buffer;
	292
	293	out:
	294	return NULL;
	295	}
	296
f5d2d791	297	int read_setting_i(void handle, char const key, int defvalue) {
d082ac49	298	int fd;
d082ac49	299	Handle h;
d082ac49	300	int value;
	301
	302	if (handle == NULL) goto out;
	303	fd = (int )handle;
	304	UseResFile(fd);
	305	if (ResError() != noErr) goto out;
	306	h = get1namedresource(FOUR_CHAR_CODE('Int '), key);
	307	if (h == NULL) goto out;
	308	value = (int )*h;
	309	ReleaseResource(h);
	310	if (ResError() != noErr) goto out;
	311	return value;
	312
	313	out:
	314	return defvalue;
	315	}
	316
	317	void close_settings_r(void *handle) {
	318	int fd;
	319
	320	if (handle == NULL) return;
	321	fd = (int )handle;
	322	CloseResFile(fd);
	323	if (ResError() != noErr)
	324	fatalbox("Close of saved session failed (%d)", ResError());
	325	safefree(handle);
	326	}
	327
f5d2d791	328	void del_settings(char const *sessionname) {
d082ac49	329	OSErr error;
	330	FSSpec sessfile;
	331	short sessVRefNum;
	332	long sessDirID;
	333	Str255 psessionname;
	334
	335	error = get_session_dir(kDontCreateFolder, &sessVRefNum, &sessDirID);
	336
	337	c2pstrcpy(psessionname, sessionname);
	338	error = FSMakeFSSpec(sessVRefNum, sessDirID, psessionname, &sessfile);
	339	if (error != noErr) goto out;
	340
	341	error = FSpDelete(&sessfile);
	342	return;
	343	out:
	344	fatalbox("Delete session failed (%d)", error);
	345	}
	346
	347	struct enum_settings_state {
	348	short vRefNum;
	349	long dirID;
	350	int index;
	351	};
	352
	353	void *enum_settings_start(void) {
	354	OSErr error;
	355	struct enum_settings_state *state;
	356
	357	state = safemalloc(sizeof(*state));
	358	error = get_session_dir(kDontCreateFolder, &state->vRefNum, &state->dirID);
	359	if (error != noErr) {
	360	safefree(state);
	361	return NULL;
	362	}
	363	state->index = 1;
	364	return state;
	365	}
	366
	367	char enum_settings_next(void handle, char *buffer, int buflen) {
	368	struct enum_settings_state *e = handle;
	369	CInfoPBRec pb;
	370	OSErr error = noErr;
	371	Str255 name;
	372
	373	if (e == NULL) return NULL;
	374	do {
	375	pb.hFileInfo.ioNamePtr = name;
	376	pb.hFileInfo.ioVRefNum = e->vRefNum;
	377	pb.hFileInfo.ioDirID = e->dirID;
	378	pb.hFileInfo.ioFDirIndex = e->index++;
	379	error = PBGetCatInfoSync(&pb);
	380	if (error != noErr) return NULL;
	381	} while (!((pb.hFileInfo.ioFlAttrib & ioDirMask) == 0 &&
	382	pb.hFileInfo.ioFlFndrInfo.fdCreator == PUTTY_CREATOR &&
	383	pb.hFileInfo.ioFlFndrInfo.fdType == SESS_TYPE &&
	384	name[0] < buflen));
	385
	386	p2cstrcpy(buffer, name);
	387	return buffer;
	388	}
	389
	390	void enum_settings_finish(void *handle) {
	391
	392	safefree(handle);
393	}
394
0c4b7799	395	#define SEED_SIZE 512
	396
	397	void read_random_seed(noise_consumer_t consumer)
	398	{
	399	short puttyVRefNum;
	400	long puttyDirID;
	401	OSErr error;
	402	char buf[SEED_SIZE];
	403	short refnum;
	404	long count = SEED_SIZE;
	405
	406	if (get_putty_dir(kDontCreateFolder, &puttyVRefNum, &puttyDirID) != noErr)
	407	return;
	408	if (HOpenDF(puttyVRefNum, puttyDirID, "\pPuTTY Random Seed", fsRdPerm,
	409	&refnum) != noErr)
	410	return;
	411	error = FSRead(refnum, &count, buf);
	412	if (error != noErr && error != eofErr)
	413	return;
	414	(*consumer)(buf, count);
	415	FSClose(refnum);
	416	}
	417
604379f1	418	/*
	419	* We don't bother with the usual FSpExchangeFiles dance here because
	420	* it doesn't really matter if the old random seed gets lost.
	421	*/
0c4b7799	422	void write_random_seed(void *data, int len)
0c4b7799	423	{
604379f1	424	short puttyVRefNum;
604379f1	425	long puttyDirID;
0c4b7799	426	OSErr error;
604379f1	427	FSSpec dstfile;
0c4b7799	428	short refnum;
	429	long count = len;
	430
	431	if (get_putty_dir(kCreateFolder, &puttyVRefNum, &puttyDirID) != noErr)
	432	return;
	433
	434	error = FSMakeFSSpec(puttyVRefNum, puttyDirID, "\pPuTTY Random Seed",
	435	&dstfile);
1d4cb74b	436	if (error == fnfErr) {
	437	/* Set up standard resources */
	438	FSpCreateResFile(&dstfile, INTERNAL_CREATOR, SEED_TYPE, smRoman);
	439	refnum = FSpOpenResFile(&dstfile, fsWrPerm);
	440	if (ResError() == noErr) {
	441	copy_resource('STR ', -16397);
	442	CloseResFile(refnum);
	443	}
	444	} else if (error != noErr) return;
0c4b7799	445
604379f1	446	if (FSpOpenDF(&dstfile, fsWrPerm, &refnum) != noErr) return;
604379f1	447	FSWrite(refnum, &count, data);
0c4b7799	448	FSClose(refnum);
1d4cb74b	449
604379f1	450	return;
0c4b7799	451	}
d082ac49	452
	453	/*
	454	* Emacs magic:
	455	* Local Variables:
	456	* c-file-style: "simon"
	457	* End:
	458	*/