LDPUBLIC32 dsk_err_t LDPUBLIC16 dsk_close(DSK_DRIVER **self)
{
dsk_err_t e, e2;
COMPRESS_DATA *dc;
DSK_OPTION *opt, *opt2;
if (!self || (!(*self)) || (!(*self)->dr_class)) return DSK_ERR_BADPTR;
e = ((*self)->dr_class->dc_close)(*self);
dc = (*self)->dr_compress;
if (dc)
{
if ((*self)->dr_dirty) e2 = comp_commit(&dc);
else e2 = comp_abort (&dc);
if (!e) e = e2;
}
/* Free any option blocks the driver has accumulated */
opt = (*self)->dr_options;
while (opt)
{
opt2 = opt->do_next;
dsk_free(opt);
opt = opt2;
}
/* And any comments */
dsk_set_comment(*self, NULL);
dsk_free (*self);
*self = NULL;
return e;
}
dsk_err_t ldbsdisk_attach(DSK_DRIVER *pdriver)
{
LDBSDISK_DSK_DRIVER *self;
char *comment;
dsk_err_t err;
DC_CHECK(pdriver)
self = (LDBSDISK_DSK_DRIVER *)pdriver;
err = ldbs_get_dpb(self->ld_store, &self->ld_dpb);
if (err) return err;
err = ldbs_get_comment(self->ld_store, &comment);
if (err) return err;
if (comment)
{
/* dsk_set_comment() sets the dirty flag, so preserve it */
int dirty = pdriver->dr_dirty;
;
dsk_set_comment(pdriver, comment);
ldbs_free(comment);
pdriver->dr_dirty = dirty;
}
self->ld_cur_cyl = -1;
self->ld_cur_head = -1;
self->ld_cur_track = NULL;
return DSK_ERR_OK;
}
STDMETHODIMP CDisk::put_comment(BSTR newVal)
{
char *buf;
dsk_err_t err;
buf = get_string(newVal);
if (!buf) return MapError(DSK_ERR_NOMEM);
err = dsk_set_comment(m_driver, buf);
dsk_free(buf);
return MapError(err);
}
dsk_err_t remote_creat(DSK_DRIVER *self, const char *filename)
{
RPCFUNC function;
char *outname, *outtype, *outcomp, *comment;
dsk_err_t err = remote_lookup(self, filename, &outname, &outtype, &outcomp);
if (err) return err;
function = self->dr_remote->rd_class->rc_call;
err = dsk_r_creat(self, function, &self->dr_remote->rd_handle,
outname, outtype, outcomp);
dsk_free(outname);
if (err) return err;
err = dsk_r_properties(self, function, self->dr_remote->rd_handle);
if (err) return err;
/* if (implements(self, RPC_DSK_GETCOMMENT))
{ */
err = dsk_r_get_comment(self, function,
self->dr_remote->rd_handle, &comment);
if (err) return err;
if (comment != NULL) err = dsk_set_comment(self, comment);
/* } */
return err;
}
/* Decode an RPC packet and execute it.
* If nRefCount is nonzero, it is increased each time a dsk_open or dsk_creat
* succeeds, and decreased when a dsk_close succeeds. This allows a server
* program to terminate automatically when the reference count reaches 0.
*
* The only RPC codes that are currently obeyed are those sent by drvwin32.c
* through rpccli.c
*/
LDPUBLIC32 dsk_err_t LDPUBLIC16 dsk_rpc_server(unsigned char *input, int inp_len,
unsigned char *output, int *out_len, int *nRefCount)
{
dsk_err_t err, err2;
int16 function;
DSK_DRIVER *pDriver;
DSK_GEOMETRY geom;
DSK_FORMAT fmt, *pfmt;
int32 nd, int1, int2, int3, int4, int5, int6, int7;
int16 filler;
char *str1, *str2, *str3;
dsk_psect_t rcount;
DSK_FORMAT *trkids;
unsigned int nDriver, n;
unsigned char secbuf[8192], *pbuf;
unsigned char status;
int deleted, value;
int16 props[sizeof(DRV_CLASS)];
err = dsk_unpack_i16(&input, &inp_len, &function); if (err) return err;
switch(function)
{
case RPC_DSK_OPEN:
err = dsk_unpack_string(&input, &inp_len, &str1); if (err) return err;
err = dsk_unpack_string(&input, &inp_len, &str2); if (err) return err;
err = dsk_unpack_string(&input, &inp_len, &str3); if (err) return err;
err2= dsk_open(&pDriver, str1, str2, str3);
err = dsk_map_dtoi(pDriver, &nDriver); if (err) return err;
err = dsk_pack_err (&output, out_len, err2); if (err) return err;
err = dsk_pack_i32 (&output, out_len, nDriver); if (err) return err;
if (nRefCount && err2 == DSK_ERR_OK) ++(*nRefCount);
return DSK_ERR_OK;
case RPC_DSK_CREAT:
err = dsk_unpack_string(&input, &inp_len, &str1); if (err) return err;
err = dsk_unpack_string(&input, &inp_len, &str2); if (err) return err;
err = dsk_unpack_string(&input, &inp_len, &str3); if (err) return err;
err2= dsk_creat(&pDriver, str1, str2, str3);
err = dsk_map_dtoi(pDriver, &nDriver); if (err) return err;
err = dsk_pack_err (&output, out_len, err2); if (err) return err;
err = dsk_pack_i32 (&output, out_len, nDriver); if (err) return err;
if (nRefCount && err2 == DSK_ERR_OK) ++(*nRefCount);
return DSK_ERR_OK;
case RPC_DSK_CLOSE:
err = dsk_unpack_i32(&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_close(&pDriver);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
if (nRefCount) --(*nRefCount);
return DSK_ERR_OK;
case RPC_DSK_PREAD:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int3); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_pread(pDriver, &geom, secbuf, (dsk_pcyl_t)int1, (dsk_phead_t)int2, (dsk_psect_t)int3);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_bytes(&output, out_len, secbuf, geom.dg_secsize); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_PWRITE:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_bytes(&input, &inp_len, &pbuf); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int3); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_pwrite(pDriver, &geom, pbuf, (dsk_pcyl_t)int1, (dsk_phead_t)int2, (dsk_psect_t)int3);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_PFORMAT:
pfmt = (DSK_FORMAT *)secbuf;
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
for (n = 0; n < geom.dg_sectors; n++)
{
err = dsk_unpack_format(&input, &inp_len, &pfmt[n]); if (err) return err;
}
err = dsk_unpack_i16 (&input, &inp_len, &filler); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_pformat(pDriver, &geom, (dsk_pcyl_t)int1, (dsk_phead_t)int2, pfmt, (unsigned char)filler);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_geom(&output, out_len, &geom); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_PSECID:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_psecid(pDriver, &geom, (dsk_pcyl_t)int1, (dsk_phead_t)int2, &fmt);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_format(&output, out_len, &fmt); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_DRIVE_STATUS:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_drive_status(pDriver, &geom, (dsk_phead_t)int1, &status);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_i16(&output, out_len, status); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_GETGEOM:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_getgeom(pDriver, &geom);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_geom(&output, out_len, &geom); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_PSEEK:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_pseek(pDriver, &geom, (dsk_pcyl_t)int1, (dsk_phead_t)int2);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_XREAD:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int3); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int4); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int5); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int6); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int7); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
deleted = int7;
err2= dsk_xread(pDriver, &geom, secbuf,
(dsk_pcyl_t)int1,
(dsk_phead_t)int2,
(dsk_pcyl_t)int3,
(dsk_phead_t)int4,
(dsk_psect_t)int5,
(size_t)int6,
&deleted);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_bytes(&output, out_len, secbuf, int6); if (err) return err;
err = dsk_pack_i32(&output, out_len, deleted);
return DSK_ERR_OK;
case RPC_DSK_XWRITE:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_bytes(&input, &inp_len, &pbuf); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int3); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int4); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int5); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int6); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int7); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_xwrite(pDriver, &geom, pbuf,
(dsk_pcyl_t)int1,
(dsk_phead_t)int2,
(dsk_pcyl_t)int3,
(dsk_phead_t)int4,
(dsk_psect_t)int5,
(size_t)int6,
(int)int7);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_TRACKIDS:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2 = dsk_ptrackids(pDriver, &geom, int1,
int2, &rcount, &trkids);
if (err2 || !trkids) rcount = 0;
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_i32(&output, out_len, rcount); if (err) return err;
for (n = 0; n < rcount; n++)
{
err = dsk_pack_format(&output, out_len, &trkids[n]);
if (err) return err;
}
if (trkids) dsk_free(trkids);
return DSK_ERR_OK;
case RPC_DSK_PTREAD:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_ptread(pDriver, &geom, secbuf, (dsk_pcyl_t)int1, (dsk_phead_t)int2);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_bytes(&output, out_len, secbuf, geom.dg_secsize * geom.dg_sectors); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_XTREAD:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int3); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int4); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_xtread(pDriver, &geom, secbuf, (dsk_pcyl_t)int1, (dsk_phead_t)int2, (dsk_pcyl_t)int3, (dsk_phead_t)int4);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_bytes(&output, out_len, secbuf, geom.dg_secsize * geom.dg_sectors); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_OPTION_ENUM:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_option_enum(pDriver, int1, &str1);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_string(&output, out_len, str1); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_OPTION_SET:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_string(&input, &inp_len, &str1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_set_option(pDriver, str1, int1);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_OPTION_GET:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_string(&input, &inp_len, &str1); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_get_option(pDriver, str1, &value);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_i32 (&output, out_len, value); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_GETCOMMENT:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_get_comment(pDriver, &str1);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
err = dsk_pack_string(&output, out_len, str1); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_SETCOMMENT:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err = dsk_unpack_string(&input, &inp_len, &str1); if (err) return err;
err2= dsk_set_comment(pDriver, str1);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
return DSK_ERR_OK;
case RPC_DSK_RTREAD:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_unpack_geom(&input, &inp_len, &geom); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int1); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int2); if (err) return err;
err = dsk_unpack_i32 (&input, &inp_len, &int3); if (err) return err;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
err2= dsk_rtread(pDriver, &geom, secbuf, (dsk_pcyl_t)int1, (dsk_phead_t)int2, int3);
err = dsk_pack_err(&output, out_len, err2); if (err) return err;
/* XXX This is a completely arbitrary buffer size */
err = dsk_pack_i32(&output, out_len, geom.dg_secsize * geom.dg_sectors); if (err) return err;
err = dsk_pack_bytes(&output, out_len, secbuf, geom.dg_secsize * geom.dg_sectors); if (err) return err;
return DSK_ERR_OK;
/* Return a list of implemented functions */
case RPC_DSK_PROPERTIES:
err = dsk_unpack_i32 (&input, &inp_len, &nd); if (err) return err; nDriver = (unsigned int)nd;
err = dsk_map_itod(nDriver, &pDriver); if (err) return err;
int1 = 0; /* Count of implemented functions */
#define PROPCHECK(func, rid) if (pDriver->dr_class->func) props[int1++] = rid;
PROPCHECK(dc_open, RPC_DSK_OPEN)
PROPCHECK(dc_creat, RPC_DSK_CREAT)
PROPCHECK(dc_close, RPC_DSK_CLOSE)
PROPCHECK(dc_read, RPC_DSK_PREAD)
PROPCHECK(dc_write, RPC_DSK_PWRITE)
PROPCHECK(dc_format, RPC_DSK_PFORMAT)
PROPCHECK(dc_secid, RPC_DSK_PSECID)
PROPCHECK(dc_getgeom, RPC_DSK_GETGEOM)
PROPCHECK(dc_xseek, RPC_DSK_PSEEK)
PROPCHECK(dc_status, RPC_DSK_DRIVE_STATUS)
PROPCHECK(dc_xread, RPC_DSK_XREAD)
PROPCHECK(dc_xwrite, RPC_DSK_XWRITE)
PROPCHECK(dc_tread, RPC_DSK_PTREAD)
PROPCHECK(dc_xtread, RPC_DSK_XTREAD)
PROPCHECK(dc_option_enum, RPC_DSK_OPTION_ENUM)
PROPCHECK(dc_option_get, RPC_DSK_OPTION_GET)
PROPCHECK(dc_option_set, RPC_DSK_OPTION_SET)
PROPCHECK(dc_trackids, RPC_DSK_TRACKIDS)
PROPCHECK(dc_rtread, RPC_DSK_RTREAD)
#undef PROPCHECK
props[int1++] = RPC_DSK_PROPERTIES;
err = dsk_pack_err(&output, out_len, DSK_ERR_OK); if (err) return err;
err = dsk_pack_i16(&output, out_len, (unsigned short)int1); if (err) return err;
for (int2 = 0; int2 < int1; int2++)
{
err = dsk_pack_i16(&output, out_len, props[int2]); if (err) return err;
}
err = dsk_pack_string(&output, out_len, pDriver->dr_class->dc_description); if (err) return err;
return DSK_ERR_OK;
/* Unsupported function. Return DSK_ERR_UNKRPC */
default:
err2 = dsk_pack_err(&output, out_len,
DSK_ERR_UNKRPC);
return DSK_ERR_OK;
}
}
dsk_err_t tele_open(DSK_DRIVER *s, const char *filename)
{
unsigned char header[12];
DC_CHECK(s);
self->tele_fp = fopen(filename, "rb");
if (!self->tele_fp) return DSK_ERR_NOTME;
/* This does use fread not tele_fread, because it's not compressed
* by the Advanced compression */
if (fread(header, 1, sizeof(header), self->tele_fp) < (int)sizeof(header) ||
(memcmp(header, "TD", 2) && memcmp(header, "td", 2)))
{
fclose(self->tele_fp);
return DSK_ERR_NOTME;
}
memcpy(self->tele_head.magic, header, 2);
self->tele_head.magic[2] = 0;
self->tele_head.volume_seq = header[2];
self->tele_head.volume_id = header[3];
self->tele_head.ver = header[4];
self->tele_head.datarate = header[5];
self->tele_head.drivetype = header[6];
self->tele_head.doubletrack = header[7];
self->tele_head.dosmode = header[8];
self->tele_head.sides = header[9];
self->tele_head.crc = ((tele_word)header[11]) << 8 | header[10];
/* XXX Advanced compression not supported */
if (!strcmp((char *)header, "td"))
{
#ifndef WIN16
fprintf(stderr, "LibDsk TD0 driver: Advanced compression not supported\n");
#endif
fclose(self->tele_fp);
return DSK_ERR_NOTIMPL;
}
/* Read a comment if there is one */
if (self->tele_head.doubletrack & 0x80)
{
int comment_len, n;
if (tele_fread(self, header, 10))
{
fclose(self->tele_fp);
return DSK_ERR_SYSERR;
}
comment_len = ((int)(header[3])) << 8 | header[2];
self->tele_comment = dsk_malloc(comment_len + sizeof(TELE_COMMENT));
if (!self->tele_comment)
{
fclose(self->tele_fp);
return DSK_ERR_NOMEM;
}
self->tele_comment->year = header[4] + 1900;
self->tele_comment->mon = header[5];
self->tele_comment->day = header[6];
self->tele_comment->hour = header[7];
self->tele_comment->min = header[8];
self->tele_comment->sec = header[9];
if (tele_fread(self, self->tele_comment->text, comment_len))
{
fclose(self->tele_fp);
return DSK_ERR_SYSERR;
}
self->tele_comment->text[comment_len] = 0;
for (n = 0; n < comment_len; n++)
{
if (self->tele_comment->text[n] == 0 &&
self->tele_comment->text[n+1] == 0)
{
self->tele_comment->text[n] = '\r';
self->tele_comment->text[n+1] = '\n';
}
}
dsk_set_comment(s, self->tele_comment->text);
}
self->tele_track_addr[0][0] = ftell(self->tele_fp);
return DSK_ERR_OK;
}
int do_test(char *outfile, char *outtyp, char *outcomp, int forcehead)
{
DSK_PDRIVER outdr = NULL;
dsk_err_t e;
DSK_GEOMETRY dg, dg2;
static DSK_FORMAT fmt[9] =
{
{ 0, 0, 1, 512 },
{ 0, 0, 3, 512 },
{ 3, 1, 5, 512 },
{ 0, 0, 7, 512 },
{ 0, 0, 9, 512 },
{ 0, 1, 2, 512 },
{ 0, 0, 4, 512 },
{ 2, 0, 6, 512 },
{ 0, 0, 8, 512 },
};
static DSK_FORMAT fmt2[9] =
{
{ 4, 0, 1, 512 },
{ 4, 0, 3, 512 },
{ 4, 0, 5, 512 },
{ 4, 0, 7, 512 },
{ 4, 0, 9, 512 },
{ 4, 0, 2, 512 },
{ 4, 0, 4, 512 },
{ 4, 0, 6, 512 },
{ 4, 0, 8, 512 },
};
DSK_FORMAT secid, *pfmt;
char *comment;
unsigned char status;
dsk_psect_t count, n;
char *optname;
int value;
dsk_reportfunc_set(report, report_end);
dg_stdformat(&dg, FMT_180K, NULL, NULL);
if (t80) dg.dg_cylinders = 80;
printf("Checking dsk_creat\n");
e = dsk_creat(&outdr, outfile, outtyp, outcomp);
CHECKERR("dsk_creat")
else
{
dsk_set_option(outdr, "REMOTE:TESTING", 1);
printf("Checking set_comment\n");
e = dsk_set_comment(outdr, "Example comment");
CHECKERR3("dsk_set_comment");
printf("Checking pformat\n");
e = dsk_pformat(outdr, &dg, 0, 0, fmt, 0xE5);
CHECKERR("dsk_pformat")
printf("Checking apform\n");
e = dsk_apform(outdr, &dg, 1, 0, 0xF6);
CHECKERR("dsk_apform")
printf("Checking lformat\n");
e = dsk_lformat(outdr, &dg, 2, fmt2, 0xD4);
CHECKERR("dsk_pformat")
printf("Checking ptrackids\n");
e = dsk_ptrackids(outdr, &dg, 0, 0, &count, &pfmt);
CHECKERR("dsk_ptrackids")
else
{
dsk_psect_t n;
printf("Cyl Head Sec Size\n");
printf("-----------------\n");
for (n = 0; n < count; n++)
{
printf("%3d %3d %3d %4d\n",
pfmt[n].fmt_cylinder,
pfmt[n].fmt_head,
pfmt[n].fmt_sector,
(int)pfmt[n].fmt_secsize);
}
printf("-----------------\n");
dsk_free(pfmt);
}
memset(secbuf, 0, sizeof(secbuf));
memcpy(secbuf, spec180, sizeof(spec180));
printf("Checking dsk_lwrite\n");
e = dsk_lwrite(outdr, &dg, secbuf, 0);
CHECKERR("dsk_lwrite")
strcpy((char *)secbuf, "Cyl=3 Head=1 Sec=5");
printf("Checking dsk_xwrite\n");
e = dsk_xwrite(outdr, &dg, secbuf, 0, 0, 3, 1, 5, 512, 0);
CHECKERR("dsk_xwrite")
printf("Checking dsk_psecid\n");
e = dsk_psecid(outdr, &dg, 1, 0, &secid);
CHECKERR("dsk_psecid")
else
{
printf("%3d %3d %3d %4d\n",
secid.fmt_cylinder,
secid.fmt_head,
secid.fmt_sector,
(int)secid.fmt_secsize);
if (secid.fmt_cylinder != 1 || secid.fmt_head != 0 ||
secid.fmt_secsize != 512)
{
++failures;
printf("-- mismatch!\n");
}
}
}
if (outdr)
{
dsk_close(&outdr);
CHECKERR("dsk_close")
}
printf("Checking dsk_open\n");
e = dsk_open(&outdr, outfile, outtyp, outcomp);
CHECKERR("dsk_open")
else
{
dsk_set_option(outdr, "REMOTE:TESTING", 1);
printf("Checking dsk_getgeom\n");
e = dsk_getgeom(outdr, &dg2);
if (t80 && dg2.dg_cylinders == 40) dg2.dg_cylinders = 80;
CHECKERR("dsk_getgeom")
else if (memcmp(&dg, &dg2, sizeof(dg)))
{
++failures;
printf("-- mismatch!\n");
printf("Cyls: %3d %3d\n", dg.dg_cylinders, dg2.dg_cylinders);
printf("Heads: %3d %3d\n", dg.dg_heads, dg2.dg_heads);
printf("Secs: %3d %3d\n", dg.dg_sectors, dg2.dg_sectors);
}
printf("Checking dsk_lread\n");
e = dsk_lread(outdr, &dg, secbuf, 0);
CHECKERR("dsk_lread")
else if (memcmp(secbuf, spec180, sizeof(spec180)))
{
++failures;
printf("-- mismatch!\n");
}
printf("Checking dsk_xread\n");
e = dsk_xread(outdr, &dg, secbuf, 0, 0, 3, 1, 5, 512, NULL);
CHECKERR("dsk_xread")
else if (strcmp((char *)secbuf, "Cyl=3 Head=1 Sec=5"))
{
++failures;
printf("-- mismatch!\n");
}
printf("Checking dsk_lseek\n");
e = dsk_lseek(outdr, &dg, 1);
CHECKERR("dsk_lseek")
printf("Checking dsk_drive_status\n");
e = dsk_drive_status(outdr, &dg, 0, &status);
CHECKERR("dsk_drive_status")
else printf("-- status=0x%02x\n", status);
printf("Checking dsk_tread\n");
e = dsk_ptread(outdr, &dg, trkbuf, 1, 0);
CHECKERR("dsk_ptread")
else
{
for (n = 0; n < 4608; n++) if (trkbuf[n] != 0xF6)
{
printf("-- mismatch!\n");
++failures;
break;
}
}
printf("Checking dsk_xtread\n");
e = dsk_xtread(outdr, &dg, trkbuf, 2, 0, 4, 0);
CHECKERR("dsk_xtread")
else
{
for (n = 0; n < 4608; n++) if (trkbuf[n] != 0xD4)
{
printf("-- mismatch!\n");
++failures;
break;
}
}
printf("Checking dsk_option_enum\n");
e = dsk_option_enum(outdr, 0, &optname);
CHECKERR("dsk_option_enum")
else
{
printf("-- first option is %s\n", optname);
}
if (!optname) optname = "dummy";
printf("Checking dsk_get_option(%s)\n", optname);
e = dsk_get_option(outdr, optname, &value);
CHECKERR2("dsk_get_option")
else
{
printf("-- value=%d\n", value);
}
printf("Checking dsk_set_option(example, 2)\n");
e = dsk_set_option(outdr, "example", 2);
CHECKERR2("dsk_set_option")
printf("Checking dsk_rtread\n");
e = dsk_rtread(outdr, &dg, trkbuf, 0, 0, 0);
CHECKERR3("dsk_rtread")
printf("Checking dsk_get_comment\n");
e = dsk_get_comment(outdr, &comment);
CHECKERR3("dsk_get_comment")
else if (comment) printf("-- comment=%s\n", comment);
}
if (outdr)
{
dsk_close(&outdr);
CHECKERR("dsk_close")
}
printf("\n");
printf("Failed calls (failure important): %2d\n", failures);
printf("Failed calls (failure unimportant): %2d\n", warnings);
printf("Unimplemented functions: %2d\n", unimpl);
printf("Unimplemented functions over RPC: %2d\n", rpcunimp);
return failures;
}