/* See if a file can be decompressed */
static dsk_err_t comp_iopen(COMPRESS_DATA **cd, const char *filename, int nc)
{
COMPRESS_CLASS *cc = classes[nc];
dsk_err_t err;
if (!cc) return DSK_ERR_BADPTR;
(*cd) = dsk_malloc(cc->cc_selfsize);
if (!*cd) return DSK_ERR_NOMEM;
memset((*cd), 0, cc->cc_selfsize);
err = comp_construct(*cd, filename);
(*cd)->cd_class = cc;
if (err == DSK_ERR_OK)
{
char *s = dsk_malloc(strlen(cc->cc_description) + 50);
if (s)
{
sprintf(s, "Checking compression: %s...", cc->cc_description);
dsk_report(s);
dsk_free(s);
}
else dsk_report("Checking compression...");
err = (cc->cc_open)(*cd);
dsk_report_end();
}
if (err == DSK_ERR_OK) return err;
comp_free (*cd);
*cd = NULL;
return err;
}
void random_slice(DskBuffer* buf)
{
DskBuffer tmpbuf;
char *copy, *copy_at;
unsigned orig_size = buf->size;
dsk_buffer_init (&tmpbuf);
copy = dsk_malloc (buf->size);
copy_at = copy;
while (1)
{
int r;
r = (rand () % 16384) + 1;
r = dsk_buffer_read (buf, r, copy_at);
dsk_buffer_append (&tmpbuf, r, copy_at);
if (r == 0)
break;
}
dsk_assert (copy_at == copy + orig_size);
dsk_assert (buf->size == 0);
dsk_assert (tmpbuf.size == orig_size);
copy_at = dsk_malloc (orig_size);
dsk_assert (dsk_buffer_read (&tmpbuf, orig_size, copy_at) == orig_size);
dsk_assert (dsk_buffer_read (&tmpbuf, orig_size, copy_at) == 0);
dsk_assert (memcmp (copy, copy_at, orig_size) == 0);
dsk_free (copy);
dsk_free (copy_at);
}
dsk_err_t dsk_r_properties(DSK_PDRIVER self, RPCFUNC func,
unsigned int nDriver)
{
unsigned char ibuf[SMALLBUF], *iptr = ibuf;
unsigned char obuf[400], *optr = obuf;
dsk_err_t err;
int ilen = sizeof ibuf;
int olen = sizeof obuf;
dsk_err_t err2;
int16 fncount, fnid;
int n;
char *desc;
if (!self || !self->dr_remote) return DSK_ERR_BADPTR;
err = dsk_pack_i16 (&iptr, &ilen, RPC_DSK_PROPERTIES);
if (err) return err;
err = dsk_pack_i32 (&iptr, &ilen, nDriver); if (err) return err;
err = (*func)(self, ibuf, iptr - ibuf, obuf, &olen);
if (err) return err;
err = dsk_unpack_err (&optr, &olen, &err2); if (err) return err;
if (err2 == DSK_ERR_UNKRPC) return err2;
err = dsk_unpack_i16 (&optr, &olen, &fncount); if (err) return err;
if (self->dr_remote->rd_functions != NULL)
{
dsk_free(self->dr_remote->rd_functions);
self->dr_remote->rd_functions = NULL;
}
if (fncount)
{
self->dr_remote->rd_functions
= dsk_malloc((fncount+1) * sizeof(unsigned));
if (!self->dr_remote->rd_functions)
{
err2 = DSK_ERR_NOMEM;
}
else
{
for (n = 0; n < fncount; n++)
{
err = dsk_unpack_i16 (&optr, &olen, &fnid);
if (err) return err;
self->dr_remote->rd_functions[n] = fnid;
}
self->dr_remote->rd_functions[n] = 0;
}
}
err = dsk_unpack_string(&optr, &olen, &desc);
if (err) return err;
if (self->dr_remote->rd_name) dsk_free(self->dr_remote->rd_name);
self->dr_remote->rd_name = NULL;
if (desc)
{
self->dr_remote->rd_name = dsk_malloc(1 + strlen(desc));
if (!self->dr_remote->rd_name) err2 = DSK_ERR_NOMEM;
else strcpy(self->dr_remote->rd_name, desc);
}
return err2;
}
static void
handle_update_game (DskHttpServerRequest *request)
{
DskCgiVariable *user_var = dsk_http_server_request_lookup_cgi (request, "user");
DskCgiVariable *dx_var = dsk_http_server_request_lookup_cgi (request, "dx");
DskCgiVariable *dy_var = dsk_http_server_request_lookup_cgi (request, "dy");
DskCgiVariable *bx_var = dsk_http_server_request_lookup_cgi (request, "bx");
DskCgiVariable *by_var = dsk_http_server_request_lookup_cgi (request, "by");
User *user = find_user (user_var->value);
char buf[512];
if (user == NULL)
{
snprintf (buf, sizeof (buf), "user %s not found", user_var->value);
dsk_http_server_request_respond_error (request, DSK_HTTP_STATUS_BAD_REQUEST, buf);
return;
}
parse_int_clamp (dx_var, &user->move_x);
parse_int_clamp (dy_var, &user->move_y);
parse_int_clamp (bx_var, &user->bullet_x);
parse_int_clamp (by_var, &user->bullet_y);
if (user->last_update == user->base.game->latest_update)
{
/* wait for next frame */
PendingUpdate *pu = dsk_malloc (sizeof (PendingUpdate));
pu->user = user;
pu->request = request;
pu->next = user->base.game->pending_updates;
user->base.game->pending_updates = pu;
}
else
{
DskJsonValue *state_json = create_user_update (user);
respond_take_json (request, state_json);
}
}
/* --- Creating a user in a game --- */
static User *
create_user (Game *game, const char *name, unsigned width, unsigned height)
{
User *user = dsk_malloc (sizeof (User));
Cell *cell;
user->name = dsk_strdup (name);
user->base.type = OBJECT_TYPE_USER;
user->base.game = game;
/* pick random unoccupied position */
teleport_object (&user->base);
cell = game->cells
+ (user->base.x / CELL_SIZE)
+ (user->base.y / CELL_SIZE) * game->universe_width;
add_object_to_game_list (&user->base);
add_object_to_cell_list (&user->base);
user->bullet_block = 0;
user->bullet_x = user->bullet_y = 0;
user->width = width;
user->height = height;
user->dead_count = 0;
user->last_seen_time = dsk_dispatch_default ()->last_dispatch_secs;
user->move_x = user->move_y = 0;
user->last_update = (unsigned)(-1);
return user;
}
LDPUBLIC32 dsk_err_t LDPUBLIC16 dsk_xcheck(DSK_DRIVER *self, const DSK_GEOMETRY *geom,
const void *buf,
dsk_pcyl_t cylinder, dsk_phead_t head,
dsk_pcyl_t cyl_expect, dsk_phead_t head_expect,
dsk_psect_t sector, size_t sector_len)
{
DRV_CLASS *dc;
void *buf2;
dsk_err_t e = DSK_ERR_UNKNOWN;
unsigned n;
if (!self || !geom || !buf || !self->dr_class) return DSK_ERR_BADPTR;
dc = self->dr_class;
WALK_VTABLE(dc, dc_xread)
if (!dc->dc_xread) return DSK_ERR_NOTIMPL;
buf2 = dsk_malloc(geom->dg_secsize);
if (!buf2) return DSK_ERR_NOMEM;
for (n = 0; n < self->dr_retry_count; n++)
{
e = (dc->dc_xread)(self,geom,buf2,cylinder,head,
cyl_expect, head_expect, sector, sector_len, 0);
if (!DSK_TRANSIENT_ERROR(e)) break;
}
if (e == DSK_ERR_OK && memcmp(buf, buf2, geom->dg_secsize))
{
e = DSK_ERR_MISMATCH;
}
dsk_free(buf2);
return e;
}
dsk_err_t win16_secid(DSK_DRIVER *self, const DSK_GEOMETRY *geom,
dsk_pcyl_t cylinder, dsk_phead_t head,
DSK_FORMAT *result)
{
/* We don't implement a proper READ_SECTOR_ID, because Windows
* doesn't expose this functionality. Instead, emulate just enough
* to autodetect CPC-format discs (slowly) */
dsk_err_t err;
unsigned char *buf = dsk_malloc(geom->dg_secsize);
unsigned char psect;
if (geom->dg_fm) return DSK_ERR_NOADDR;
if (!buf) return DSK_ERR_NOMEM;
err = win16_read(self, geom, buf, cylinder, head, psect=0x01);
if (err) err = win16_read(self, geom, buf, cylinder, head, psect=0x41);
if (err) err = win16_read(self, geom, buf, cylinder, head, psect=0xC1);
if (result)
{
result->fmt_cylinder = cylinder;
result->fmt_head = head;
result->fmt_sector = psect;
result->fmt_secsize = geom->dg_secsize;
}
dsk_free(buf);
return err;
}
/* Attempt to open a DSK file with driver <ndrv> */
static dsk_err_t dsk_iopen(DSK_DRIVER **self, const char *filename, int ndrv, COMPRESS_DATA *cd)
{
DRV_CLASS *dc = classes[ndrv];
dsk_err_t err;
/* If we're handling compressed data, use the temporary uncompressed file */
if (cd) filename = cd->cd_ufilename;
if (!dc) return DSK_ERR_BADPTR;
(*self) = dsk_malloc(dc->dc_selfsize);
if (!*self) return DSK_ERR_NOMEM;
dr_construct(*self, dc);
err = (dc->dc_open)(*self, filename);
/* printf("%s: open %s = %d\n", dc->dc_drvname, filename, err); */
if (err == DSK_ERR_OK)
{
(*self)->dr_compress = cd;
return err;
}
dsk_free (*self);
*self = NULL;
return err;
}
static State *
state_table_force (StateTable *table, const unsigned *positions)
{
unsigned hash = state_hash (table->n_entries, positions);
unsigned idx = hash % table->n_entries;
State *at = table->hash_table[idx];
while (at != NULL)
{
if (memcmp (at->positions, positions, sizeof (unsigned) * table->n_entries) == 0)
return at;
at = at->hash_next;
}
/* Allocate a state */
if (table->n_states_free_in_slab == 0)
{
StateSlab *slab = dsk_malloc (table->sizeof_slab);
table->next_free_in_cur_slab = (State *)(slab + 1);
table->n_states_free_in_slab = table->n_states_in_slab;
slab->next_slab = table->cur_slab;
table->cur_slab = slab;
}
at = table->next_free_in_cur_slab;
table->next_free_in_cur_slab = (State *) ((char*)table->next_free_in_cur_slab + table->sizeof_state);
table->n_states_free_in_slab -= 1;
table->occupancy++;
if (table->occupancy * 2 > table->table_size)
{
unsigned new_table_size = ...;
...
idx = hash % table->table_size;
}
static dsk_err_t comp_construct(COMPRESS_DATA *cd, const char *filename)
{
cd->cd_cfilename = dsk_malloc(1 + strlen(filename));
if (!cd->cd_cfilename) return DSK_ERR_NOMEM;
strcpy(cd->cd_cfilename, filename);
cd->cd_ufilename = NULL;
cd->cd_readonly = 0;
return DSK_ERR_OK;
}
static char *generate_str (unsigned min_length, unsigned max_length)
{
unsigned len = dsk_random_int_range (min_length, max_length);
char *rv = dsk_malloc (len + 1);
unsigned i;
for (i = 0; i < len; i++)
rv[i] = dsk_random_int_range (0, 26)["abcdefghijklmnopqrstuvwxyz"];
rv[i] = 0;
return rv;
}
HRESULT CDisk::GetFormat(VARIANT *buf, DSK_FORMAT **bufout, unsigned length)
{
long lBound, uBound;
unsigned char HUGEP* FAR pData;
SAFEARRAY *psa;
HRESULT hr;
unsigned n;
DSK_FORMAT *fmt;
if (V_VT(buf) != (VT_ARRAY | VT_UI1))
{
return Error("Passed parameter must be an array of unsigned characters", IID_IDisk, E_INVALIDARG);
}
psa = V_ARRAY(buf);
// Check dimensions of the array.
if (SafeArrayGetDim(psa) != 1)
{
return Error("Passed parameter must be a 1-dimensional array", IID_IDisk, E_INVALIDARG);
}
// Get array bounds.
hr = SafeArrayGetLBound(psa, 1, &lBound);
if (FAILED(hr))
{
return Error("Could not get array bounds", IID_IDisk, hr);
}
hr = SafeArrayGetUBound(psa, 1, &uBound);
if (FAILED(hr))
{
return Error("Could not get array bounds", IID_IDisk, hr);
}
if (uBound + 1 - lBound < (long)length*4)
{
return Error("Passed array is too short", IID_IDisk, E_INVALIDARG);
}
// Get a pointer to the elements of the array.
hr = SafeArrayAccessData(psa, (void HUGEP * FAR *)&pData);
if (FAILED(hr))
{
return Error("Could not access array data", IID_IDisk, E_INVALIDARG);
}
*bufout = (DSK_FORMAT *)dsk_malloc(length * sizeof(DSK_FORMAT));
if (!bufout) return MapError(DSK_ERR_NOMEM);
fmt = bufout[0];
for (n = 0; n < length; n++)
{
fmt->fmt_cylinder = *pData++;
fmt->fmt_head = *pData++;
fmt->fmt_sector = *pData++;
fmt->fmt_secsize = 128 << (*pData++);
++fmt;
}
SafeArrayUnaccessData(psa);
return S_OK;
}
dsk_err_t linux_format(DSK_DRIVER *self, DSK_GEOMETRY *geom,
dsk_pcyl_t cylinder, dsk_phead_t head,
const DSK_FORMAT *format, unsigned char filler)
{
struct floppy_raw_cmd raw_cmd;
LINUX_DSK_DRIVER *lxself;
int n;
dsk_err_t err;
unsigned char *buf;
unsigned char mask = 0xFF;
if (!self || !geom || !format) return DSK_ERR_BADPTR;
if (self->dr_class != &dc_linux) return DSK_ERR_BADPTR;
lxself = (LINUX_DSK_DRIVER *)self;
if (lxself->lx_fd < 0) return DSK_ERR_NOTRDY;
err = check_geom(lxself, geom);
if (err) return err;
if (geom->dg_fm) mask &= ~0x40;
if (geom->dg_nomulti) mask &= ~0x80;
buf = dsk_malloc(geom->dg_sectors * 4);
if (!buf) return DSK_ERR_NOMEM;
for (n = 0; n < geom->dg_sectors; n++)
{
buf[n*4] = format[n].fmt_cylinder;
buf[n*4+1] = format[n].fmt_head;
buf[n*4+2] = format[n].fmt_sector;
buf[n*4+3] = dsk_get_psh(format[n].fmt_secsize);
}
init_raw_cmd(&raw_cmd);
raw_cmd.flags = FD_RAW_WRITE | FD_RAW_INTR;
if (cylinder != lxself->lx_cylinder) raw_cmd.flags |= FD_RAW_NEED_SEEK;
raw_cmd.track = cylinder;
if (lxself->lx_doublestep) raw_cmd.track *= 2;
raw_cmd.rate = get_rate(geom);
raw_cmd.length= 4 * geom->dg_sectors;
raw_cmd.data = buf;
raw_cmd.cmd[raw_cmd.cmd_count++] = FD_FORMAT & mask;
raw_cmd.cmd[raw_cmd.cmd_count++] = encode_head(self, head);
raw_cmd.cmd[raw_cmd.cmd_count++] = dsk_get_psh(geom->dg_secsize);
raw_cmd.cmd[raw_cmd.cmd_count++] = geom->dg_sectors;
raw_cmd.cmd[raw_cmd.cmd_count++] = geom->dg_fmtgap;
raw_cmd.cmd[raw_cmd.cmd_count++] = filler;
if (ioctl(lxself->lx_fd, FDRAWCMD, &raw_cmd) < 0) return DSK_ERR_SYSERR;
memcpy(lxself->lx_status, raw_cmd.reply, 4);
if (raw_cmd.reply[0] & 0x40) return xlt_error(raw_cmd.reply);
lxself->lx_cylinder = cylinder;
return DSK_ERR_OK;
}
LDPUBLIC32 dsk_err_t LDPUBLIC16 dsk_set_comment(DSK_PDRIVER self, const char *comment)
{
if (!self || !comment) return DSK_ERR_BADPTR;
if (self->dr_comment) dsk_free(self->dr_comment);
self->dr_comment = dsk_malloc(1 + strlen(comment));
if (!self->dr_comment) return DSK_ERR_NOMEM;
strcpy(self->dr_comment, comment);
return DSK_ERR_OK;
}
char *get_string(BSTR bs)
{
char *buf;
int len;
len = WideCharToMultiByte(CP_UTF8, 0, bs, -1, NULL, 0, NULL, NULL);
buf = (char *)dsk_malloc(len + 1);
if (!buf) return NULL;
WideCharToMultiByte(CP_UTF8, 0, bs, -1, buf, len, NULL, NULL);
buf[len] = 0;
return buf;
}
/* Return whether 'buffer' begins with 'str'; remove it if so. */
static dsk_boolean
try_initial_remove (DskBuffer *buffer, const char *str)
{
unsigned len = strlen (str);
if (buffer->size < len)
return DSK_FALSE;
char *tmp = dsk_malloc (len);
dsk_buffer_read (buffer, len, tmp);
dsk_boolean rv = memcmp (str, tmp, len) == 0;
dsk_free (tmp);
return rv;
}
dsk_err_t comp_mktemp(COMPRESS_DATA *self, FILE **fp)
{
char *tdir;
int fd;
char tmpdir[PATH_MAX];
self->cd_ufilename = dsk_malloc(PATH_MAX);
/* Win32: Create temp file using GetTempFileName() */
#ifdef HAVE_GETTEMPFILENAME
GetTempPath(PATH_MAX, tmpdir);
if (!GetTempFileName(tmpdir, "dsk", 0, self->cd_ufilename))
{
dsk_free(self->cd_ufilename);
self->cd_ufilename = NULL;
return DSK_ERR_SYSERR;
}
*fp = fopen(self->cd_ufilename, "wb");
(void)fd;
(void)tdir;
#else /* def HAVE_GETTEMPFILENAME */
/* Modern Unixes: Use mkstemp() */
#ifdef HAVE_MKSTEMP
tdir = getenv("TMPDIR");
if (tdir) sprintf(tmpdir, "%s/libdskdXXXXXXXX", tdir);
else sprintf(tmpdir, TMPDIR "/libdskXXXXXXXX");
fd = mkstemp(tmpdir);
*fp = NULL;
if (fd != -1) fp[0] = fdopen(fd, "wb");
strcpy(self->cd_ufilename, tmpdir);
#else /* def HAVE_MKSTEMP */
/* Old Unixes, old xenix clones such as DOS */
tdir = getenv("TMP");
if (!tdir) tdir = getenv("TEMP");
if (tdir) sprintf(tmpdir, "%s/LDXXXXXX", tdir);
else sprintf(tmpdir, "./LDXXXXXX");
strcpy(self->cd_ufilename, mktemp(tmpdir));
fp[0] = fopen(self->cd_ufilename, "wb");
(void)fd;
#endif /* HAVE_MKSTEMP */
#endif /* HAVE_GETTEMPFILENAME */
if (!*fp)
{
dsk_free(self->cd_ufilename);
self->cd_ufilename = NULL;
return DSK_ERR_SYSERR;
}
return DSK_ERR_OK;
}
static void
handle_get_games_list (DskHttpServerRequest *request)
{
unsigned n_games = 0;
Game *game;
DskJsonValue **game_info, **at;
for (game = all_games; game; game = game->next_game)
n_games++;
game_info = dsk_malloc (sizeof (DskJsonValue *) * n_games);
at = game_info;
for (game = all_games; game; game = game->next_game, at++)
{
Object *object;
unsigned n_players = 0;
DskJsonValue **pat;
DskJsonMember members[2] = {
{ "name", dsk_json_value_new_string (strlen (game->name), game->name) },
{ "players", NULL },
};
DskJsonValue **players;
for (object = game->objects[OBJECT_TYPE_USER]; object != NULL; object = object->next_in_game)
n_players++;
players = dsk_malloc (sizeof (DskJsonValue *) * n_players);
pat = players;
for (object = game->objects[OBJECT_TYPE_USER]; object != NULL; object = object->next_in_game)
{
User *player = (User *)object;
*pat++ = dsk_json_value_new_string (strlen (player->name), player->name);
}
members[1].value = dsk_json_value_new_array (n_players, players);
dsk_free (players);
*at++ = dsk_json_value_new_object (DSK_N_ELEMENTS (members), members);
}
respond_take_json (request, dsk_json_value_new_array (n_games, game_info));
dsk_free (game_info);
}
dsk_err_t ntwdm_format(DSK_DRIVER *self, DSK_GEOMETRY *geom,
dsk_pcyl_t cylinder, dsk_phead_t head,
const DSK_FORMAT *format, unsigned char filler)
{
NTWDM_DSK_DRIVER *ntself;
unsigned u, fsize;
dsk_err_t err;
FD_FORMAT_PARAMS *pfp;
FD_ID_HEADER *ph;
if (!self || !geom || !format) return DSK_ERR_BADPTR;
if (self->dr_class != &dc_ntwdm) return DSK_ERR_BADPTR;
ntself = (NTWDM_DSK_DRIVER *)self;
if (ntself->nt_hdisk == INVALID_HANDLE_VALUE) return DSK_ERR_NOTRDY;
err = check_geom(ntself, geom);
if (err) return err;
fsize = sizeof(FD_FORMAT_PARAMS) + geom->dg_sectors * sizeof(FD_ID_HEADER);
pfp = (FD_FORMAT_PARAMS *)dsk_malloc(fsize);
if (!pfp) return DSK_ERR_NOMEM;
pfp->flags = geom->dg_fm ? 0 : FD_OPTION_MFM;
pfp->phead = encode_head(self, head);
pfp->size = dsk_get_psh(geom->dg_secsize);
pfp->sectors = geom->dg_sectors;
pfp->gap = geom->dg_fmtgap;
pfp->fill = filler;
ph = (FD_ID_HEADER *)(pfp+1);
for (u = 0; u < geom->dg_sectors; u++)
{
ph[u].cyl = format[u].fmt_cylinder;
ph[u].head = format[u].fmt_head;
ph[u].sector = format[u].fmt_sector;
ph[u].size = dsk_get_psh(format[u].fmt_secsize);
}
if (cylinder != ntself->nt_cylinder)
{
UCHAR cyl = ntself->nt_doublestep ? cylinder*2 : cylinder;
if (!DeviceIoControl(ntself->nt_hdisk, IOCTL_FDCMD_SEEK, &cyl, sizeof(cyl),
NULL, 0, &dwRet, NULL)) return xlt_error(GetLastError());
ntself->nt_cylinder = cylinder;
}
if (!DeviceIoControl(ntself->nt_hdisk, IOCTL_FDCMD_FORMAT_TRACK, pfp, fsize,
NULL, 0, &dwRet, NULL)) return xlt_error(GetLastError());
return DSK_ERR_OK;
}
STDMETHODIMP CDisk::ltread(IGeometry *g, long track, VARIANT *var)
{
DSK_GEOMETRY geom;
dsk_err_t err;
HRESULT hr;
g_to_dg(g, &geom);
unsigned char *tmpbuf = (unsigned char *)dsk_malloc(geom.dg_secsize * geom.dg_sectors);
if (!tmpbuf) return MapError(DSK_ERR_NOMEM);
err = dsk_ltread(m_driver, &geom, tmpbuf, track);
hr = PutBuffer(tmpbuf, var, geom.dg_secsize * geom.dg_sectors, err);
dsk_free(tmpbuf);
return hr;
}
STDMETHODIMP CDisk::pread(IGeometry *g, long cylinder, short head, short sector, VARIANT *var)
{
DSK_GEOMETRY geom;
HRESULT hr;
dsk_err_t err;
g_to_dg(g, &geom);
unsigned char *tmpbuf = (unsigned char *)dsk_malloc(geom.dg_secsize);
if (!tmpbuf) return MapError(DSK_ERR_NOMEM);
err = dsk_pread(m_driver, &geom, tmpbuf, cylinder, head, sector);
hr = PutBuffer(tmpbuf, var, geom.dg_secsize, err);
dsk_free(tmpbuf);
return hr;
}
dsk_err_t win16_format(DSK_DRIVER *self, DSK_GEOMETRY *geom,
dsk_pcyl_t cylinder, dsk_phead_t head,
const DSK_FORMAT *format, unsigned char filler)
{
WIN16_DSK_DRIVER *w16self;
union REGS reg;
struct SREGS sreg;
dsk_err_t err;
unsigned char *trkbuf;
unsigned int n, tries;
unsigned char old_dpt[11];
if (!format || !self || !geom || self->dr_class != &dc_win16) return DSK_ERR_BADPTR;
w16self = (WIN16_DSK_DRIVER *)self;
if (w16self->w16_readonly) return DSK_ERR_RDONLY;
trkbuf = dsk_malloc(4 * geom->dg_sectors);
if (!trkbuf) return DSK_ERR_NOMEM;
err = win16_checkgeom(w16self, geom, old_dpt, filler);
if (err) { dsk_free(trkbuf); return err; }
for (n = 0; n < geom->dg_sectors; n++)
{
trkbuf[4*n ] = (unsigned char)format[n].fmt_cylinder;
trkbuf[4*n+1] = (unsigned char)format[n].fmt_head;
trkbuf[4*n+2] = (unsigned char)format[n].fmt_sector;
trkbuf[4*n+3] = dsk_get_psh(format[n].fmt_secsize);
}
for (tries = 0; tries < 3; tries++)
{
reg.h.ah = 0x05;
reg.h.al = geom->dg_sectors;
reg.x.bx = FP_OFF(trkbuf);
reg.h.ch = cylinder;
reg.h.cl = 0;
reg.h.dh = head;
reg.h.dl = w16self->w16_unit - 1;
reg.x.cflag = 1;
int86x(0x13, ®, ®, &sreg);
if (!reg.x.cflag) break;
}
dsk_free(trkbuf);
set_dpt(old_dpt);
if ( reg.x.cflag ) return translate_int13_error(reg.h.ah);
return DSK_ERR_OK;
}
LDPUBLIC32 dsk_err_t LDPUBLIC16 dsk_lcheck(DSK_DRIVER *self, const DSK_GEOMETRY *geom,
const void *buf, dsk_lsect_t sector)
{
void *buf2;
dsk_err_t e;
if (!self || !geom || !buf || !self->dr_class) return DSK_ERR_BADPTR;
buf2 = dsk_malloc(geom->dg_secsize);
if (!buf2) return DSK_ERR_NOMEM;
e = dsk_lread(self,geom,buf2,sector);
if (e == 0 && memcmp(buf, buf2, geom->dg_secsize)) e = DSK_ERR_MISMATCH;
dsk_free(buf2);
return e;
}
HRESULT CDisk::GetBuffer(VARIANT *buf, unsigned char **bufout, unsigned length)
{
long lBound, uBound;
void HUGEP* FAR pData;
SAFEARRAY *psa;
HRESULT hr;
if (V_VT(buf) != (VT_ARRAY | VT_UI1))
{
return Error("Passed parameter must be an array of unsigned characters", IID_IDisk, E_INVALIDARG);
}
psa = V_ARRAY(buf);
// Check dimensions of the array.
if (SafeArrayGetDim(psa) != 1)
{
return Error("Passed parameter must be a 1-dimensional array", IID_IDisk, E_INVALIDARG);
}
// Get array bounds.
hr = SafeArrayGetLBound(psa, 1, &lBound);
if (FAILED(hr))
{
return Error("Could not get array bounds", IID_IDisk, hr);
}
hr = SafeArrayGetUBound(psa, 1, &uBound);
if (FAILED(hr))
{
return Error("Could not get array bounds", IID_IDisk, hr);
}
if (uBound + 1 - lBound < (long)length)
{
return Error("Passed array is too short", IID_IDisk, E_INVALIDARG);
}
// Get a pointer to the elements of the array.
hr = SafeArrayAccessData(psa, &pData);
if (FAILED(hr))
{
return Error("Could not access array data", IID_IDisk, E_INVALIDARG);
}
*bufout = (unsigned char *)dsk_malloc(length);
if (!*bufout) return MapError(DSK_ERR_NOMEM);
memcpy(*bufout, pData, length);
SafeArrayUnaccessData(psa);
return S_OK;
}
BSTR ret_string(const char *s)
{
int len;
OLECHAR *buf;
BSTR bs;
len = MultiByteToWideChar(CP_UTF8, 0, s, strlen(s), NULL, 0);
buf = (OLECHAR *)dsk_malloc((len + 1) * sizeof(OLECHAR));
if (!buf)
{
return CComBSTR(s).Detach();
}
buf[len] = 0;
MultiByteToWideChar(CP_UTF8, 0, s, strlen(s), buf, len);
bs = SysAllocString(buf);
dsk_free(buf);
return bs;
}
STDMETHODIMP CDisk::xread(IGeometry *g, long cylinder, short head,
long cyl_expected, short head_expected, short sector, long sector_len, short *deleted, VARIANT *var)
{
DSK_GEOMETRY geom;
dsk_err_t err;
HRESULT hr;
int del = deleted[0];
g_to_dg(g, &geom);
unsigned char *tmpbuf = (unsigned char *)dsk_malloc(sector_len);
if (!tmpbuf) return MapError(DSK_ERR_NOMEM);
err = dsk_xread(m_driver, &geom, tmpbuf, cylinder, head, cyl_expected, head_expected, sector, sector_len, &del);
hr = PutBuffer(tmpbuf, var, sector_len, err);
dsk_free(tmpbuf);
deleted[0] = del;
return hr;
}
static dsk_err_t dg_parse_file(FILE *fp)
{
DSK_NAMEDGEOM ng, *pg;
char linebuf[160];
char formname[160];
char formdesc[160];
char *s;
long pos;
dsk_err_t err;
while (fgets(linebuf, sizeof(linebuf), fp))
{
formdesc[0] = 0;
/* Drop comments and newlines */
s = strchr(linebuf, ';'); if (s) *s = 0;
s = strchr(linebuf, '#'); if (s) *s = 0;
s = strchr(linebuf, '\n'); if (s) *s = 0;
if (linebuf[0] != '[') continue;
/* Format names cannot start with "-", so any section beginning "[-" is
* going to be something other than a format. */
if (linebuf[1] == '-') continue;
strcpy(formname, linebuf+1);
s = strchr(formname, ']');
if (s) *s = 0;
pos = ftell(fp);
err = dg_parse(fp, &ng.dg, formdesc);
if (err) return err;
fseek(fp, pos, SEEK_SET);
pg = dsk_malloc(sizeof(ng) + 2 +
strlen(formdesc) + strlen(formname));
if (!pg) return DSK_ERR_NOMEM;
memcpy(pg, &ng, sizeof(ng));
pg->name = ((char *)pg) + sizeof(ng);
pg->desc = ((char *)pg) + sizeof(ng) + 1 + strlen(formname);
strcpy((char *)pg->name, formname);
strcpy((char *)pg->desc, formdesc);
pg->next = customgeom;
customgeom = pg;
}
return DSK_ERR_OK;
}
/* Attempt to create a DSK file with driver number <ndrv> */
static dsk_err_t dsk_icreat(DSK_DRIVER **self, const char *filename, int ndrv, COMPRESS_DATA *cd)
{
DRV_CLASS *dc = classes[ndrv];
dsk_err_t err;
if (!dc) return DSK_ERR_BADPTR;
(*self) = dsk_malloc(dc->dc_selfsize);
if (!*self) return DSK_ERR_NOMEM;
dr_construct(*self, dc);
err = (dc->dc_creat)(*self, filename);
if (err == DSK_ERR_OK)
{
(*self)->dr_compress = cd;
return err;
}
dsk_free (*self);
*self = NULL;
return err;
}
/* See if a file can be decompressed */
static dsk_err_t comp_icreat(COMPRESS_DATA **cd, const char *filename, int nc)
{
COMPRESS_CLASS *cc = classes[nc];
dsk_err_t err;
FILE *fp;
if (!cc) return DSK_ERR_BADPTR;
(*cd) = dsk_malloc(cc->cc_selfsize);
if (!*cd) return DSK_ERR_NOMEM;
memset((*cd), 0, cc->cc_selfsize);
err = comp_construct(*cd, filename);
(*cd)->cd_class = cc;
if (err == DSK_ERR_OK) err = (cc->cc_creat)(*cd);
/* Stake out our claim to the temporary file. */
if (err == DSK_ERR_OK) err = comp_mktemp(*cd, &fp);
if (fp) fclose(fp);
if (err == DSK_ERR_OK) return err;
comp_free (*cd);
*cd = NULL;
return err;
}
dsk_err_t dsk_r_trackids(DSK_DRIVER *self, RPCFUNC func, unsigned nDriver,
const DSK_GEOMETRY *geom, dsk_pcyl_t cylinder,
dsk_phead_t head, dsk_psect_t *count, DSK_FORMAT **result)
{
unsigned char ibuf[SMALLBUF], *iptr = ibuf;
unsigned char obuf[LARGEBUF], *optr = obuf;
dsk_err_t err;
int ilen = sizeof ibuf;
int olen = sizeof obuf;
dsk_err_t err2;
int32 rcount, n;
DSK_FORMAT *buf;
err = dsk_pack_i16 (&iptr, &ilen, RPC_DSK_TRACKIDS);if (err) return err;
err = dsk_pack_i32 (&iptr, &ilen, nDriver); if (err) return err;
err = dsk_pack_geom (&iptr, &ilen, geom); if (err) return err;
err = dsk_pack_i32 (&iptr, &ilen, cylinder); if (err) return err;
err = dsk_pack_i32 (&iptr, &ilen, head); if (err) return err;
err = (*func)(self, ibuf, iptr - ibuf, obuf, &olen); if (err) return err;
err = dsk_unpack_err (&optr, &olen, &err2); if (err) return err;
if (err2 == DSK_ERR_UNKRPC) return err2;
err = dsk_unpack_i32 (&optr, &olen, &rcount); if (err) return err;
*count = rcount;
*result = NULL;
if (rcount)
{
buf = dsk_malloc(rcount * sizeof(DSK_FORMAT));
for (n = 0; n < rcount; n++)
{
err = dsk_unpack_format(&optr, &olen, &buf[n]);
if (err) return err;
}
*result = buf;
}
return err2;
}
