void keep(unsigned char status, unsigned size)
{
__dpmi_regs regs;
_farsetsel(_dos_ds);
/* Keep size default is current PSP block size */
if(_farnspeekw(_go32_info_block.linear_address_of_original_psp - 15) !=
_go32_info_block.linear_address_of_original_psp / 16)
/* Not a real PSP? attempt to continue */
regs.x.dx = (_go32_info_block.size_of_transfer_buffer + 256) / 16;
else
regs.x.dx = _farnspeekw(_go32_info_block.linear_address_of_original_psp - 13);
/* Default is to keep PSP and transfer buffer, but the user may want to
not use and release transfer buffer to decrease DOS footprint. */
if(size >= 16 && size < regs.x.dx)
regs.x.dx = size;
regs.x.ax = 0x3100 + status;
__dpmi_int(0x21, ®s);
}
/* Get inode number by searching DOS Swappable Data Area.
The entire directory entry for a file found by FindFirst/FindNext
appears at a certain (version-dependent) offset in the SDA after
one of those function is called.
Should be called immediately after calling DOS FindFirst function,
before the info is overwritten by somebody who calls it again. */
static unsigned int
get_inode_from_sda(const char *basename)
{
int count = dirent_count;
unsigned int * dirent_p = dirent_table;
unsigned short dos_mem_base = _dos_ds;
unsigned short our_mem_base = _my_ds();
char * dot = strchr(basename, '.');
size_t total_len = strlen(basename);
int name_len = dot ? dot - basename : total_len;
int ext_len = dot ? total_len - name_len - 1 : 0;
int cluster_offset = offsetof(struct full_dirent, fcluster);
/* Restore failure bits set by last call to init_dirent_table(), so
they will be reported as if it were called now. */
_djstat_fail_bits |= init_dirent_table_bits;
/* Force reinitialization in restarted programs (emacs). */
if (stat_count != __bss_count)
{
stat_count = __bss_count;
dirent_count = 0;
}
/* Initialize the table of SDA entries where we are to look for
our file. */
if (!dirent_count && !init_dirent_table())
{
/* Don't save the truename failure bit. */
init_dirent_table_bits = (_djstat_fail_bits & ~_STFAIL_TRUENAME);
return 0;
}
init_dirent_table_bits = (_djstat_fail_bits & ~_STFAIL_TRUENAME);
if (dirent_count == -1)
return 0;
count = dirent_count;
dirent_p = dirent_table;
_farsetsel(dos_mem_base);
/* This is DOS 4.x lossage: this loop might execute many times.
For other DOS versions it is executed exactly once. */
while (count--)
{
unsigned int src_address = *dirent_p & 0x000fffff;
char cmp_buf[sizeof(struct full_dirent)];
/* Copy the directory entry from the SDA to local storage.
The filename is stored there in infamous DOS format: name and
extension blank-padded to 8/3 characters, no dot between them. */
movedata(dos_mem_base, src_address, our_mem_base, (unsigned int)cmp_buf,
sizeof(struct full_dirent));
/* If this is the filename we are looking for, return
its starting cluster. */
if (!strncmp(cmp_buf, basename, name_len) &&
(ext_len == 0 || !strncmp(cmp_buf + 8, dot + 1, ext_len)))
return (unsigned int)_farnspeekw(*dirent_p + cluster_offset);
/* This is not our file. Search more, if more addresses left. */
dirent_p++;
}
/* If not found, give up. */
_djstat_fail_bits |= _STFAIL_BADSDA;
return 0;
}
/* Compute table of pointers to look for directory entry of a file. */
static int
init_dirent_table (void)
{
short get_sda_func;
unsigned short dirent_offset;
unsigned short true_dos_version;
unsigned short dos_major, dos_minor;
__dpmi_regs regs;
if (dirent_count == -1) /* we already tried and found we can't */
return 0;
/* Compute INT 21h function number and offset of directory entry
from start of SDA. These depend on the DOS version.
We need exact knowledge about DOS internals, so we need the
TRUE DOS version (not the simulated one by SETVER), if that's
available. */
true_dos_version = _get_dos_version(1);
dos_major = true_dos_version >> 8;
dos_minor = true_dos_version & 0xff;
if ((dos_major == 3) && (dos_minor >= 10))
{
get_sda_func = 0x5d06;
dirent_offset = 0x1a7;
}
else if (dos_major == 4)
{
/* According to ``Undocumented DOS, 2nd edition'', I could have
used 5d06 here, as for DOS 5 and above, but I like to be
defensive. In fact, the above book itself uses 5d0b, contrary
to its own recommendation. */
get_sda_func = 0x5d0b;
dirent_offset = 0x1b3;
}
else if (dos_major >= 5)
{
get_sda_func = 0x5d06;
dirent_offset = 0x1b3;
}
else
{
_djstat_fail_bits |= _STFAIL_OSVER;
dirent_count = -1;
return 0;
}
_djstat_fail_bits &= ~_STFAIL_OSVER; /* version is OK */
/* Get the pointer to SDA by calling undocumented function 5dh of INT 21. */
regs.x.ax = get_sda_func;
__dpmi_int(0x21, ®s);
if (regs.x.flags & 1)
{
_djstat_fail_bits |= _STFAIL_SDA;
dirent_count = -1; /* if the call failed, never try this later */
return 0;
}
_djstat_fail_bits &= ~_STFAIL_SDA; /* Get SDA succeeded */
/* DOS 4.x might have several SDA's, which means we might have more
than one place to look into. (It is typical of DOS 4 to complicate
things.)
Compute all the possible addresses where we will have to look. */
if (dos_major == 4)
{
/* The pointer returned by INT 21h, AX=5D0b points to a header
which holds a number of SDA's and then an array of that number
of records each one of which includes address of an SDA (DWORD)
and its length and type (encoded in a WORD).
While walking this list of SDA's, we add to each pointer the
offset of directory entry and stash the resulting address in
our table for later use. */
int sda_list_walker = MK_FOFF(regs.x.ds, regs.x.si);
int i;
int *tbl;
dirent_count = _farpeekw(_dos_ds, sda_list_walker); /* number of SDA's */
/* Allocate storage for table. */
tbl = dirent_table = (int *)malloc(dirent_count*sizeof(int));
if (!dirent_table)
{
/* If malloc() failed, maybe later it will succeed, so don't
store -1 in dirent_count. */
dirent_count = 0;
_djstat_fail_bits |= _STFAIL_DCOUNT;
return 0;
}
memset(dirent_table, 0, dirent_count*sizeof(int));
_djstat_fail_bits &= ~_STFAIL_DCOUNT; /* dirent_count seems OK */
/* Walk the array of pointers, computing addresses of directory
entries and stashing them in our table. */
_farsetsel(_dos_ds);
for (i = dirent_count, sda_list_walker += 2; i--; sda_list_walker += 6)
{
int sda_start = _farnspeekl(sda_list_walker);
unsigned short sda_len = _farnspeekw(sda_list_walker + 4) & 0x7fff;
/* Let's be defensive here: if this SDA is too short to have
place for directory entry, we won't use it. */
if (sda_len > dirent_offset)
*tbl++ = sda_start + dirent_offset;
else
dirent_count--;
}
}
/* DOS 3.1 and 5.0 or later. We have only one SDA pointed to by
whatever INT 21h, AH=5d returns. */
else
{
dirent_count = 1;
dirent_place = MK_FOFF(regs.x.ds, regs.x.si) + dirent_offset;
dirent_table = &dirent_place;
}
return 1;
}
