/* 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; }