bool SetMemory(int value, U16 size, long count, long offset, U16 handle)
{ // value is the value to set memory to
// offset is the number of units from the start of allocated memory
// size is the size of the unit, count is the number of units to set
// Returns true if successful, false if failure
BYTE diskbuf[DISKWRITELEN];
long start; // first location to set
long tomove; // number of bytes to set
U16 numwritten;
start = (long)offset * size;
tomove = (long)count * size;
if (debugflag == debug_flags::display_memory_statistics)
if (CheckBounds(start, tomove, handle))
return false; // out of bounds, don't do it
bool success = false;
switch (handletable[handle].Nowhere.stored_at)
{
case NOWHERE: // SetMemory
DisplayHandle(handle);
break;
case MEMORY: // SetMemory
for (int i = 0; i < size; i++)
{
memset(handletable[handle].Linearmem.memory+start, value, (U16)count);
start += count;
}
success = true; // No way to gauge success or failure
break;
case DISK: // SetMemory
memset(diskbuf, value, (U16)DISKWRITELEN);
rewind(handletable[handle].Disk.file);
fseek(handletable[handle].Disk.file, start, SEEK_SET);
while (tomove > DISKWRITELEN)
{
numwritten = (U16)write1(diskbuf, (U16)DISKWRITELEN, 1, handletable[handle].Disk.file);
if (numwritten != 1)
{
WhichDiskError(2);
goto diskerror;
}
tomove -= DISKWRITELEN;
}
numwritten = (U16)write1(diskbuf, (U16)tomove, 1, handletable[handle].Disk.file);
if (numwritten != 1)
{
WhichDiskError(2);
break;
}
success = true;
diskerror:
break;
} // end of switch
if (!success && debugflag == debug_flags::display_memory_statistics)
DisplayHandle(handle);
return success;
}
/* Reply has been mostly initialised by do_command */
void send_reply()
{
int i;
if ((vtcmd.cmd)==VTC_QUICK) { /* Only send buffer on a quick read */
writeP(portfd, &vtreply.cmd, 1);
if (vtreply.cmd!=VTC_QUICK) return; /* Must have been an error */
for (i=0; i< BLKSIZE; i++) writeP(portfd, &inbuf[i], 1);
return;
}
sum0 = 0;
sum1 = 0;
/* Transmit the reply */
write0(portfd, &vtreply.hdr1, 1);
write1(portfd, &vtreply.hdr2, 1);
write0(portfd, &vtreply.cmd, 1);
write1(portfd, &vtreply.record, 1);
if(block<0xff00)
{
unsigned char tmp;
tmp = block;
write0(portfd, &tmp, 1);
tmp = block>>8;
write1(portfd, &tmp, 1);
}
void inti()
{
dula=0;
wela=0;
wr=0;
e=0;
write1(0x38);
write1(0x0c);
write1(0x06);
write1(0x01);
}
int write_file(void)
{
static unsigned pos,size;
ozcls();
ozputs0(0,"Writing...");
if(open1(filename,O_WRONLY)<0)
{
ozcls();
ozputs0(0,"Error opening file!");
ozgetch();
return -1;
}
pos=0;
clear_wrap_to_end(0);
while(pos<file_length)
{
if(pos+LINE_BUF_LEN<=file_length) size=LINE_BUF_LEN;
else size=file_length-pos;
ozreadauxmem(pos,line_buf,size);
if(write1(line_buf,size)<size)
{
ozcls();
ozputs0(0,"Error writing!");
close1();
return -1;
}
pos+=size;
}
close1();
}
void ViCustomMaskCreator::create()
{
qint64 totalSamples = qMin(mRead1.bufferSamples(), mRead2.bufferSamples());
qint64 currentSamples = 0;
int i, end;
qreal difference;
while(mRead1.hasData() && mRead2.hasData())
{
mRead1.read();
mRead2.read();
const ViSampleChunk &samples1 = mRead1.samples();
const ViSampleChunk &samples2 = mRead2.samples();
end = qMin(samples1.size(), samples2.size());
currentSamples += end;
ViSampleChunk write1(end), write2(end);
for(i = 0; i < end; ++i)
{
difference = qAbs(samples1[i] - samples2[i]);
write1[i] = difference / 2;
if(difference >= THRESHOLD) write2[i] = 1;
else write2[i] = 0;
}
mWrite1.write(write1);
mWrite2.write(write2);
setProgress((currentSamples * 99.0) / totalSamples);
}
clear();
setProgress(100);
emit finished();
}
void main()
{
inti();
write1(0x80);
for(num=0;num<11;num++)
{
write2(table[num]);
delay(5);
}
write1(0x80+0x40);
for(num=0;num<13;num++)
{
write2(table1[num]);
delay(5);
}
while(1);
}
/********************************************************************
函数名称：write1byte
功 能：向I2C总线发送一个字节的数据
参 数：WriteData--发送的数据
返回值 ：无
********************************************************************/
void write1byte(uchar WriteData)
{
uchar i;
for(i = 8;i > 0;i--)
{
if(WriteData & 0x80) write1();
else write0();
WriteData <<= 1;
}
SDA_H;
_NOP();
}
static int test_full (int opts)
{
enum { SZ = 2 };
u_rb_t *rb = NULL;
con_err_if (u_rb_create(SZ, opts, &rb));
con_err_if (write1(rb));
con_err_if (write2(rb));
con_err_if (write3(rb) == 0); /* overflow, write3 must fail */
return 0;
err:
return 1;
}
/*-------------------------------------------------------------------------*/
void
reply1 (int32 handle, const void *data, int32 len)
/* Compose a reply message from <handle> and the <len> bytes of <data>
* and send it back to the driver.
*/
{
char reply[ERQ_MAX_REPLY];
write_32(reply, len+8);
write_32(reply+4, handle);
memcpy(reply+8, data, len);
write1(reply, len+8);
} /* reply1() */
void savebookmarks(void)
{
if(!bookmarksmod || strncmp(directory,filename,3)) return;
close1(); /* just in case */
_ozfilledbox(0,0,WIDTH,line_height,0);
ozputs(0,0,"Saving bookmarks...");
filename[0]='b';
filename[1]='m';
if(open1(filename,O_WRONLY)<0) return;
write1("BookMrkA",8);
last=screen_offset+buffer_offset;
write1(&last,4);
write1(&numbookmarks,1);
write1(bookmarks,sizeof bookmarks);
write1(&line_height,1);
write1(&show_bar,1);
write1(&positionptr,1);
write1(&numpositions,1);
write1(positions,sizeof positions);
close1();
}
void write(const VALUE& value, uint8_t bits) const
{
static_assert(std::is_scalar<VALUE>::value, "need scalar type");
static_assert(bits > sizeof(value)*8, "bits exceed value type's size");
latch(false);
VALUE mask;
if (m_direction == DIRECTION::LSBFIRST) mask = 1;
else mask = 1 << (bits - 1);
for (uint8_t b = 0; b < bits; ++b){
write1(value & mask);
if (m_direction == DIRECTION::LSBFIRST) mask <<= 1;
else mask >>= 1;
}
latch(true);
}
/*-------------------------------------------------------------------------*/
void
reply1keep (int32 handle, const void *data, int32 len)
/* Compose a reply message from <handle> and the <len> bytes of <data>
* and send it back to the driver. The message will be an _KEEP_HANDLE
* message.
*/
{
char reply[ERQ_MAX_REPLY];
write_32(reply, len+12);
write_32(reply+4, ERQ_HANDLE_KEEP_HANDLE);
write_32(reply+8, handle);
memcpy(reply+12, data, len);
write1(reply, len+12);
} /* reply1keep() */
void com_gw(int in)
{
fd_set fds;
int n, fdsbits;
static struct timeval tout = { TIMEOUT, 0 };
unsigned char buf[MBUFSIZ];
alarm(0);
fdsbits = in + 1;
while (1)
{
FD_ZERO(& fds);
FD_SET (in, &fds);
FD_SET (0 , &fds);
FD_SET (1 , &fds);
tout.tv_sec = TIMEOUT;
tout.tv_usec = 0;
if ((n = select(fdsbits, &fds, NULL, NULL, &tout)) > 0)
{
if (FD_ISSET(in, &fds))
{
if ((n = read(in, buf, sizeof buf)) > 0)
{
if (write1(buf, n) < 0) goto bad;
}
else
goto bad;
}
if (FD_ISSET(0, &fds))
{
if ((n = read0(buf, sizeof buf)) > 0)
{
if (write(in, buf, n) < 0) goto bad;
}
else goto bad;
}
}
else goto bad;
}
bad: ;
}
int savehighscores(char *name)
{
if(open1(name,O_WRONLY)==-1)
{
ozputs(0,0,"Error opening file. Press any key.");
ozngetch();
close1();
return -1;
}
sprintf(savechar,"%s %ld",initials,score);
if(write1(savechar,14)==-1)
{
ozputs(0,0,"Error writing file. Press any key.");
ozngetch();
close1();
return -1;
}
close1();
return 0;
}
int makenewconfigfile()
{
if(open1("ozcp20/config",O_WRONLY)==-1)
{
ozcls();
ozputs(0,70,"Error opening file. Press any key.");
ozngetch();
return -1;
}
configswitch();
sprintf(config,"%d %d %d",mov,spd,sound);
if(write1(config,6)==-1)
{
ozcls();
ozputs(0,70,"Error writing file. Press any key.");
ozngetch();
return -1;
}
close1();
return 0;
}
void frommemo(void)
#endif
{
static unsigned loc,page,offset,recnum;
register char *p;
static char filename[32];
static char parthead[21];
static char continued;
static unsigned int sum;
static byte val;
static byte version2;
static int i;
static unsigned j;
static int c;
static int partnumber;
static char checksum[6];
page=0;
offset=0;
while(loc=ozfindnext(TYPE_MEMO,&page,&offset,&recnum))
{
partnumber=0;
p=ozloadcluster(loc);
if(p[24]!='~' || p[25]!='~'
|| p[26]!='z'
|| strncmp(p+2+13+9+15,"00000",5)
|| strncmp(p+2+13+9+21,"**LIBOZ_UPLOAD*",15)) continue;
do
{
strcpy(parthead,p+24);
if(ozopenfile(loc)==-1)
{
ozwarn("Error opening memo!",anykey);
return;
}
for(i=0;i<13+9+21+15;i++) ozreadfilebyte();
continued=ozreadfilebyte();
p=filename;
while('\r'!=(c=ozreadfilebyte()) && '\n'!=c && p-filename<MAX_FILENAMELEN)
{
if(partnumber)
{
if(c!=*p)
{
ozputs(0,70,"You may have the remains of "
"another download.");
ozclosefile();
close1();
unlink(filename);
ozgetch();
return;
}
}
else *p=c;
p++;
}
if(p-filename>MAX_FILENAMELEN)
{
ozwarn("Filename too long!",anykey);
return;
}
*p=0;
ozputs(0,10,filename);
ozputs(0,20,parthead);
if(!partnumber)
{
ozsetowner(atoi(parthead+3));
if(open1(filename,O_WRONLY)==-1)
{
ozwarn("Error opening file!",anykey);
return;
}
}
sum=0;
p=filebuf;
if(!partnumber)
{
c=ozreadfilebyte();
if(c==TOMEMO2_MARKER)
{
version2=1;
for(j=0;j<NUMSPECIALS;j++)
{
c=ozreadfilebyte();
table[j]=(c-HEX)|((ozreadfilebyte()-HEX)<<4);
}
}
else
{
version2=0;
goto PROCESS_VERSION1;
}
}
if(version2)
{
while(-1!=(c=ozreadfilebyte()) && (byte)c!=EOF_MARKER)
{
if((byte)c>=SPECIAL)
val=table[c-SPECIAL];
else
val=(c-HEX)|((ozreadfilebyte()-HEX)<<4);
sum+=val;
*p++=val;
}
if(c==EOF_MARKER)
c='*';
}
else
{
while(-1!=(c=ozreadfilebyte()))
{
PROCESS_VERSION1:
if((byte)c=='*') break;
if((byte)c=='~')
{
while(-1!=(c=ozreadfilebyte()) && '~'!=(byte)c)
{
sum+=(byte)c;
*p++=c;
}
}
else
{
if('0'<=(byte)c && (byte)c<='9') val=(c-'0')<<4;
else val=(c+(10-'a'))<<4;
c=ozreadfilebyte();
if('0'<=(byte)c && (byte)c<='9') val+=(c-'0');
else val+=(c+(10-'a'));
*p++=val;
sum+=(byte)val;
}
}
c=ozreadfilebyte();
}
if('*'==c)
{
for(i=0;i<5;i++) checksum[i]=ozreadfilebyte();
checksum[5]=0;
}
if('*'!=c || (unsigned)(atoi(checksum))!=sum)
{
ozclosefile();
close1();
unlink(filename);
ozwarn("Error in memo!",anykey);
return;
}
ozclosefile();
if(write1(filebuf,p-filebuf) < (p-filebuf) )
{
close1();
unlink(filename);
ozwarn("Error in writing!",anykey);
return;
}
if(ozunlink(TYPENUM_MEMO,recnum))
{
if(ozwarn("Error unlinking! Continue?",yn)!=KEY_LOWER_ENTER) return;
}
/* ozputch(0,0,continued); */
if(continued=='L')
break;
partnumber++;
strcpy(parthead+15,utoa_0n(partnumber,5));
page=offset=0;
while(loc=ozfindmemo(parthead,&page,&offset,&recnum))
{
p=ozloadcluster(loc);
if(strncmp(p+2+13+9+21,"**LIBOZ_UPLOAD*",15)) continue;
break;
}
if(loc==0)
{
close1();
unlink(filename);
ozwarn("Error: Cannot find next part!",anykey);
return;
}
} while(loc);
close1();
page=offset=0;
}
}
// pat added: write an Optional Field controlled by an initial 0/1 field.
void MsgCommonWrite::writeOptField01(uint64_t value, unsigned len, int present, const char*)
{
if (present) { write1(); writeField(value,len); } else { write0(); }
}
int
urj_flash_cfi_detect (urj_bus_t *bus, uint32_t adr,
urj_flash_cfi_array_t **cfi_array)
{
unsigned int bw; /* bus width */
unsigned int d; /* data offset */
size_t ba; /* bus width address multiplier */
int ma; /* flash mode address multiplier */
urj_bus_area_t area;
if (!cfi_array || !bus)
{
urj_error_set (URJ_ERROR_INVALID, "cfi_array or bus");
return URJ_STATUS_FAIL;
}
*cfi_array = calloc (1, sizeof (urj_flash_cfi_array_t));
if (!*cfi_array)
{
urj_error_set (URJ_ERROR_OUT_OF_MEMORY, "calloc(%zd,%zd) fails",
(size_t) 1, sizeof (urj_flash_cfi_array_t));
return URJ_STATUS_FAIL;
}
(*cfi_array)->bus = bus;
(*cfi_array)->address = adr;
if (URJ_BUS_AREA (bus, adr, &area) != URJ_STATUS_OK)
// retain error state
return URJ_STATUS_FAIL;
if (URJ_BUS_TYPE (bus) != URJ_BUS_TYPE_PARALLEL)
return URJ_STATUS_FAIL;
bw = area.width;
if (bw != 8 && bw != 16 && bw != 32)
{
urj_error_set (URJ_ERROR_INVALID, "bus width = %d", bw);
return URJ_STATUS_FAIL;
}
(*cfi_array)->bus_width = ba = bw / 8;
(*cfi_array)->cfi_chips = calloc (ba, sizeof (urj_flash_cfi_chip_t *));
if (!(*cfi_array)->cfi_chips)
{
urj_error_set (URJ_ERROR_OUT_OF_MEMORY, "calloc(%zd,%zd) fails",
ba, sizeof (urj_flash_cfi_chip_t *));
return URJ_STATUS_FAIL;
}
for (d = 0; d < bw; d += 8)
{
#define A(off) (adr + (off) * ba * ma)
#define D(data) ((data) << d)
#define gD(data) (((data) >> d) & 0xFF)
#define read1(off) gD(URJ_BUS_READ( bus, A(off) ))
// @@@@ RFHH check status of URJ_BUS_READ_START
#define read2(off) (URJ_BUS_READ_START (bus, A(off)), gD (URJ_BUS_READ_NEXT (bus, A((off) + 1))) | gD (URJ_BUS_READ_END (bus)) << 8)
#define write1(off,data) URJ_BUS_WRITE( bus, A(off), D(data) )
urj_flash_cfi_query_structure_t *cfi;
uint32_t tmp;
int ret = -4; /* CFI not detected (Q) */
uint16_t pri_vendor_tbl_adr;
/* detect CFI capable devices - see Table 1 in [1] */
for (ma = 1; ma <= 4; ma *= 2)
{
write1 (CFI_CMD_QUERY_OFFSET, CFI_CMD_QUERY);
if (read1 (CFI_QUERY_ID_OFFSET) == 'Q')
{
ret = -5; /* CFI not detected (R) */
if (read1 (CFI_QUERY_ID_OFFSET + 1) == 'R')
break;
}
write1 (0, CFI_CMD_READ_ARRAY1);
write1 (0, CFI_CMD_READ_ARRAY2);
}
if (ma > 4)
{
if (ret == -4)
urj_error_set (URJ_ERROR_FLASH, "CFI not detected (Q)");
else
urj_error_set (URJ_ERROR_FLASH, "CFI not detected (R)");
return URJ_STATUS_FAIL;
}
if (read1 (CFI_QUERY_ID_OFFSET + 2) != 'Y')
{
write1 (0, CFI_CMD_READ_ARRAY1);
write1 (0, CFI_CMD_READ_ARRAY2);
urj_error_set (URJ_ERROR_FLASH, "CFI not detected (Y)");
return URJ_STATUS_FAIL;
}
(*cfi_array)->cfi_chips[d / 8] = calloc (1,
sizeof (urj_flash_cfi_chip_t));
if (!(*cfi_array)->cfi_chips[d / 8])
{
write1 (0, CFI_CMD_READ_ARRAY1);
write1 (0, CFI_CMD_READ_ARRAY2);
urj_error_set (URJ_ERROR_OUT_OF_MEMORY, "calloc(%zd,%zd) fails",
(size_t) 1, sizeof (urj_flash_cfi_chip_t));
return URJ_STATUS_FAIL;
}
cfi = &(*cfi_array)->cfi_chips[d / 8]->cfi;
/* Identification string - see Table 6 in [1] */
cfi->identification_string.pri_id_code = read2 (PRI_VENDOR_ID_OFFSET);
cfi->identification_string.pri_vendor_tbl = NULL;
cfi->identification_string.alt_id_code = read2 (ALT_VENDOR_ID_OFFSET);
cfi->identification_string.alt_vendor_tbl = NULL;
/* System interface information - see Table 7 in [1] */
tmp = read1 (VCC_MIN_WEV_OFFSET);
cfi->system_interface_info.vcc_min_wev =
((tmp >> 4) & 0xF) * 1000 + (tmp & 0xF) * 100;
tmp = read1 (VCC_MAX_WEV_OFFSET);
cfi->system_interface_info.vcc_max_wev =
((tmp >> 4) & 0xF) * 1000 + (tmp & 0xF) * 100;
tmp = read1 (VPP_MIN_WEV_OFFSET);
cfi->system_interface_info.vpp_min_wev =
((tmp >> 4) & 0xF) * 1000 + (tmp & 0xF) * 100;
tmp = read1 (VPP_MAX_WEV_OFFSET);
cfi->system_interface_info.vpp_max_wev =
((tmp >> 4) & 0xF) * 1000 + (tmp & 0xF) * 100;
/* TODO: Add out of range checks for timeouts */
tmp = read1 (TYP_SINGLE_WRITE_TIMEOUT_OFFSET);
cfi->system_interface_info.typ_single_write_timeout =
tmp ? (1 << tmp) : 0;
tmp = read1 (TYP_BUFFER_WRITE_TIMEOUT_OFFSET);
cfi->system_interface_info.typ_buffer_write_timeout =
tmp ? (1 << tmp) : 0;
tmp = read1 (TYP_BLOCK_ERASE_TIMEOUT_OFFSET);
cfi->system_interface_info.typ_block_erase_timeout =
tmp ? (1 << tmp) : 0;
tmp = read1 (TYP_CHIP_ERASE_TIMEOUT_OFFSET);
cfi->system_interface_info.typ_chip_erase_timeout =
tmp ? (1 << tmp) : 0;
tmp = read1 (MAX_SINGLE_WRITE_TIMEOUT_OFFSET);
cfi->system_interface_info.max_single_write_timeout =
(tmp ? (1 << tmp) : 0) *
cfi->system_interface_info.typ_single_write_timeout;
tmp = read1 (MAX_BUFFER_WRITE_TIMEOUT_OFFSET);
cfi->system_interface_info.max_buffer_write_timeout =
(tmp ? (1 << tmp) : 0) *
cfi->system_interface_info.typ_buffer_write_timeout;
tmp = read1 (MAX_BLOCK_ERASE_TIMEOUT_OFFSET);
cfi->system_interface_info.max_block_erase_timeout =
(tmp ? (1 << tmp) : 0) *
cfi->system_interface_info.typ_block_erase_timeout;
tmp = read1 (MAX_CHIP_ERASE_TIMEOUT_OFFSET);
cfi->system_interface_info.max_chip_erase_timeout =
(tmp ? (1 << tmp) : 0) *
cfi->system_interface_info.typ_chip_erase_timeout;
/* Device geometry - see Table 8 in [1] */
/* TODO: Add out of range check */
cfi->device_geometry.device_size = 1 << read1 (DEVICE_SIZE_OFFSET);
cfi->device_geometry.device_interface =
read2 (FLASH_DEVICE_INTERFACE_OFFSET);
/* TODO: Add out of range check */
cfi->device_geometry.max_bytes_write =
1 << read2 (MAX_BYTES_WRITE_OFFSET);
tmp = cfi->device_geometry.number_of_erase_regions =
read1 (NUMBER_OF_ERASE_REGIONS_OFFSET);
cfi->device_geometry.erase_block_regions =
malloc (tmp * sizeof (urj_flash_cfi_erase_block_region_t));
if (!cfi->device_geometry.erase_block_regions)
{
write1 (0, CFI_CMD_READ_ARRAY1);
write1 (0, CFI_CMD_READ_ARRAY2);
urj_error_set (URJ_ERROR_OUT_OF_MEMORY, "malloc(%zd) fails",
(size_t) tmp
* sizeof (urj_flash_cfi_erase_block_region_t));
return URJ_STATUS_FAIL;
}
{
int a;
int i;
for (i = 0, a = ERASE_BLOCK_REGION_OFFSET; i < tmp; i++, a += 4)
{
uint32_t y = read2 (a);
uint32_t z = read2 (a + 2) << 8;
if (z == 0)
z = 128;
cfi->device_geometry.erase_block_regions[i].erase_block_size =
z;
cfi->device_geometry.erase_block_regions[i].
number_of_erase_blocks = y + 1;
}
}
pri_vendor_tbl_adr = read2 (PRI_VENDOR_TABLE_ADR_OFFSET);
/* AMD CFI Primary Vendor-Specific Extended Query Table - see [3] and [4] */
if (cfi->identification_string.pri_id_code == CFI_VENDOR_AMD_SCS
&& pri_vendor_tbl_adr != 0)
{
urj_flash_cfi_amd_pri_extened_query_structure_t *pri_vendor_tbl;
uint8_t major_version;
uint8_t minor_version;
uint8_t num_of_banks;
int i;
#undef A
#define A(off) (adr + (pri_vendor_tbl_adr + (off)) * ba * ma)
if (read1 (0) != 'P' || read1 (1) != 'R' || read1 (2) != 'I')
{
write1 (0, CFI_CMD_READ_ARRAY1);
write1 (0, CFI_CMD_READ_ARRAY2);
urj_error_set (URJ_ERROR_FLASH,
"CFI primary vendor table not detected");
return URJ_STATUS_FAIL;
}
major_version = read1 (MAJOR_VERSION_OFFSET);
minor_version = read1 (MINOR_VERSION_OFFSET);
if (major_version > '1'
|| (major_version == '1' && minor_version >= '3'))
num_of_banks = read1 (BANK_ORGANIZATION_OFFSET);
else
num_of_banks = 0;
pri_vendor_tbl = calloc (1,
sizeof (urj_flash_cfi_amd_pri_extened_query_structure_t)
+ num_of_banks * sizeof (uint8_t));
if (!pri_vendor_tbl)
{
write1 (0, CFI_CMD_READ_ARRAY1);
write1 (0, CFI_CMD_READ_ARRAY2);
urj_error_set (URJ_ERROR_OUT_OF_MEMORY, "calloc(%zd,%zd) fails",
(size_t) 1,
sizeof (urj_flash_cfi_amd_pri_extened_query_structure_t)
+ num_of_banks * sizeof (uint8_t));
return URJ_STATUS_FAIL;
}
if (major_version > '1'
|| (major_version == '1' && minor_version >= '0'))
{
pri_vendor_tbl->major_version = major_version;
pri_vendor_tbl->minor_version = minor_version;
pri_vendor_tbl->address_sensitive_unlock =
read1 (ADDRESS_SENSITIVE_UNLOCK_OFFSET);
pri_vendor_tbl->erase_suspend = read1 (ERASE_SUSPEND_OFFSET);
pri_vendor_tbl->sector_protect = read1 (SECTOR_PROTECT_OFFSET);
pri_vendor_tbl->sector_temporary_unprotect =
read1 (SECTOR_TEMPORARY_UNPROTECT_OFFSET);
pri_vendor_tbl->sector_protect_scheme =
read1 (SECTOR_PROTECT_SCHEME_OFFSET);
pri_vendor_tbl->simultaneous_operation =
read1 (SIMULTANEOUS_OPERATION_OFFSET);
pri_vendor_tbl->burst_mode_type =
read1 (BURST_MODE_TYPE_OFFSET);
pri_vendor_tbl->page_mode_type =
read1 (PAGE_MODE_TYPE_OFFSET);
}
if (major_version > '1'
|| (major_version == '1' && minor_version >= '1'))
{
tmp = read1 (ACC_MIN_OFFSET);
pri_vendor_tbl->acc_min =
((tmp >> 4) & 0xF) * 1000 + (tmp & 0xF) * 100;
tmp = read1 (ACC_MAX_OFFSET);
pri_vendor_tbl->acc_max =
((tmp >> 4) & 0xF) * 1000 + (tmp & 0xF) * 100;
pri_vendor_tbl->top_bottom_sector_flag =
read1 (TOP_BOTTOM_SECTOR_FLAG_OFFSET);
}
if (major_version > '1'
|| (major_version == '1' && minor_version >= '2'))
pri_vendor_tbl->program_suspend =
read1 (PROGRAM_SUSPEND_OFFSET);
if (major_version > '1'
|| (major_version == '1' && minor_version >= '3'))
{
if (pri_vendor_tbl->simultaneous_operation)
pri_vendor_tbl->bank_organization =
read1 (BANK_ORGANIZATION_OFFSET);
else
pri_vendor_tbl->bank_organization = 0;
for (i = 0; i < pri_vendor_tbl->bank_organization; i++)
pri_vendor_tbl->bank_region_info[i] =
read1 (BANK_REGION_INFO_OFFSET +
i * sizeof (uint8_t));
}
if (major_version > '1'
|| (major_version == '1' && minor_version >= '4'))
{
pri_vendor_tbl->unlock_bypass = read1 (UNLOCK_BYPASS_OFFSET);
tmp = read1 (SECSI_SECTOR_SIZE_OFFSET);
pri_vendor_tbl->secsi_sector_size = tmp ? (1 << tmp) : 0;
tmp = read1 (EMBEDDED_HWRST_TIMEOUT_MAX_OFFSET);
pri_vendor_tbl->embedded_hwrst_timeout_max =
tmp ? (1 << tmp) : 0;
tmp = read1 (NON_EMBEDDED_HWRST_TIMEOUT_MAX_OFFSET);
pri_vendor_tbl->non_embedded_hwrst_timeout_max =
tmp ? (1 << tmp) : 0;
tmp = read1 (ERASE_SUSPEND_TIMEOUT_MAX_OFFSET);
pri_vendor_tbl->erase_suspend_timeout_max =
tmp ? (1 << tmp) : 0;
tmp = read1 (PROGRAM_SUSPEND_TIMEOUT_MAX_OFFSET);
pri_vendor_tbl->program_suspend_timeout_max =
tmp ? (1 << tmp) : 0;
}
cfi->identification_string.pri_vendor_tbl = (void *) pri_vendor_tbl;
#undef A
#define A(off) (adr + (off) * ba * ma)
/* Reverse the order of erase block region information for top boot devices. */
if ((major_version > '1'
|| (major_version == '1' && minor_version >= '1'))
&& pri_vendor_tbl->top_bottom_sector_flag == 0x3)
{
uint32_t y, z;
uint32_t n = cfi->device_geometry.number_of_erase_regions;
for (i = 0; i < n / 2; i++)
{
z = cfi->device_geometry.erase_block_regions[i].
erase_block_size;
y = cfi->device_geometry.erase_block_regions[i].
number_of_erase_blocks;
cfi->device_geometry.erase_block_regions[i].
erase_block_size =
cfi->device_geometry.erase_block_regions[n - i - 1].
erase_block_size;
cfi->device_geometry.erase_block_regions[i].
number_of_erase_blocks =
cfi->device_geometry.erase_block_regions[n - i - 1].
number_of_erase_blocks;
cfi->device_geometry.erase_block_regions[n - i - 1].
erase_block_size = z;
cfi->device_geometry.erase_block_regions[n - i - 1].
number_of_erase_blocks = y;
}
}
}
void
casewritem(void)
{
write1(0, 1);
}
void
casewritec(void)
{
write1(1, 0);
}
bool MoveToMemory(BYTE *buffer, U16 size, long count, long offset, U16 handle)
{ // buffer is a pointer to local memory
// Always start moving from the beginning of buffer
// offset is the number of units from the start of the allocated "Memory"
// to start moving the contents of buffer to
// size is the size of the unit, count is the number of units to move
// Returns true if successful, false if failure
BYTE diskbuf[DISKWRITELEN];
long start; // offset to first location to move to
long tomove; // number of bytes to move
U16 numwritten;
start = (long)offset * size;
tomove = (long)count * size;
if (debugflag == debug_flags::display_memory_statistics)
if (CheckBounds(start, tomove, handle))
return false; // out of bounds, don't do it
bool success = false;
switch (handletable[handle].Nowhere.stored_at)
{
case NOWHERE: // MoveToMemory
DisplayHandle(handle);
break;
case MEMORY: // MoveToMemory
#if defined(_WIN32)
_ASSERTE(handletable[handle].Linearmem.size >= size*count + start);
#endif
memcpy(handletable[handle].Linearmem.memory + start, buffer, size*count);
success = true; // No way to gauge success or failure
break;
case DISK: // MoveToMemory
rewind(handletable[handle].Disk.file);
fseek(handletable[handle].Disk.file, start, SEEK_SET);
while (tomove > DISKWRITELEN)
{
memcpy(diskbuf, buffer, (U16)DISKWRITELEN);
numwritten = (U16)write1(diskbuf, (U16)DISKWRITELEN, 1, handletable[handle].Disk.file);
if (numwritten != 1)
{
WhichDiskError(3);
goto diskerror;
}
tomove -= DISKWRITELEN;
buffer += DISKWRITELEN;
}
memcpy(diskbuf, buffer, (U16)tomove);
numwritten = (U16)write1(diskbuf, (U16)tomove, 1, handletable[handle].Disk.file);
if (numwritten != 1)
{
WhichDiskError(3);
break;
}
success = true;
diskerror:
break;
} // end of switch
if (!success && debugflag == debug_flags::display_memory_statistics)
DisplayHandle(handle);
return success;
}
int main(int ac,char **av)
{
struct sockaddr_in peeraddr;
int addrlen=sizeof(struct sockaddr_in);
char *remote_name=nil;
char *remote_port=nil;
int c;
int s; /* socket to remote*/
struct hostent *hp;
struct servent *sp;
struct sockaddr_in server;
FILE *f;
time_t now;
char *log_file=nil;
char *tmp=nil;
syslog(LOG_INFO,"iftelnetd: Starting...");
debug=0;
while ((c = getopt(ac,av,"dl:h:p:")) != EOF)
switch (c) {
case 'd':
debug=1;
break;
case 'l':
log_file=strdup(optarg);
break;
case 'h':
remote_name=strdup(optarg);
break;
case 'p':
remote_port=strdup(optarg);
break;
default:
;
syslog(LOG_ERR,"iftelnetd: Wrong number of args!");
syslog(LOG_ERR,"iftelnetd: Usage:");
syslog(LOG_ERR,"iftelnetd: iftelnetd [-h remote_addr] [-p remote_port] [-l logfile] [-d]");
syslog(LOG_ERR,"iftelnetd: Aborting.");
if(log_file) free(log_file);
if(remote_name) free(remote_name);
if(remote_port) free(remote_port);
return 1;
break;
}
if(!remote_name)
{
syslog(LOG_WARNING,"iftelnetd: Remote addr not set. Assuming 'localhost'");
remote_name=strdup("localhost");
}
if(!remote_port)
{
syslog(LOG_WARNING,"iftelnetd: Remote port not set. Assuming 'fido'");
remote_port=strdup("fido");
}
if(getpeername(0,(struct sockaddr*)&peeraddr,&addrlen) == 0)
{
tmp=strdup(inet_ntoa(peeraddr.sin_addr));
syslog(LOG_INFO,"iftelnetd: incoming TCP connection from %s",
tmp ? tmp : "Unknown"
);
syslog(LOG_INFO,"iftelnetd: Rerouting to %s:%s",
remote_name,
remote_port);
}
if(log_file)
{
now=time(nil);
if((f=fopen(log_file,"a"))!=nil)
{
fprintf(f,"%s\t%s\n",
ctime(&now),
tmp ? tmp : "Unknown"
);
fclose(f);
}
free(log_file);
}
if(tmp) free(tmp);
if((sp=getservbyname(remote_port,"tcp"))==NULL)
{
syslog(LOG_ERR,"iftelnetd: Can't find service: %s",remote_port);
syslog(LOG_ERR,"iftelnetd: Aborting.");
free(remote_name);
free(remote_port);
return 1;
}
if((s=socket(AF_INET,SOCK_STREAM,0))==-1)
{
syslog(LOG_ERR,"iftelnetd: Can't create Internet domain socket");
syslog(LOG_ERR,"iftelnetd: Aborting.");
free(remote_name);
free(remote_port);
return 1;
}
if((hp=gethostbyname(remote_name))==NULL)
{
syslog(LOG_ERR,"iftelnetd: %s - Unknown host",remote_name);
syslog(LOG_ERR,"iftelnetd: Aborting.");
free(remote_name);
free(remote_port);
return;
}
memset(&server,0,sizeof(server));
memcpy((char *)&server.sin_addr,hp->h_addr,hp->h_length);
server.sin_family=hp->h_addrtype;
server.sin_port = sp->s_port;
if(connect(s,(struct sockaddr *)&server,sizeof(server)) == -1)
{
syslog(LOG_ERR, "iftelnetd: Can't connect %s",remote_name);
syslog(LOG_ERR, "iftelnetd: Aborting.");
free(remote_name);
free(remote_port);
return;
}
init_telnet();
write1(VERSION_S "\r\n" ,strlen(VERSION_S)+2);
com_gw(s);
free(remote_name);
free(remote_port);
close(s);
syslog(LOG_INFO,"iftelnetd: Done.");
}
inline void writeChar(char c) { write1(&c); }
inline void writeUChar(unsigned char c) { write1((char*)&c); }
/*-------------------------------------------------------------------------*/
void
replyn (int32 handle, int keep, int num, ...)
/* Compose and send to the driver a replymessage for <handle> with
* the <num> data arguments concatenated as body. If <keep> is true,
* a _KEEP_HANDLE message is composed.
*
* Each data argument is a tuple (char *data, int len).
*/
{
char reply[ERQ_MAX_REPLY];
char *p;
int total;
va_list va;
/* Determine the size of the header */
total = (keep ? 12 : 8);
p = reply+total;
/* Catenate the data arguments */
va_start(va, num);
while (num-- > 0 && total < ERQ_MAX_REPLY)
{
char *data;
int len;
data = va_arg(va, char *);
len = va_arg(va, int);
if (total + len > ERQ_MAX_REPLY)
{
fprintf(stderr, "%s Too much data in replyn(): %d bytes omitted.\n"
, time_stamp(), total + len - ERQ_MAX_REPLY);
len = ERQ_MAX_REPLY - total;
}
memcpy(p, data, len);
p += len;
total += len;
}
va_end(va);
if (num > 0)
{
fprintf(stderr, "%s Too much data in replyn(): Remaining %d "
"data blocks omitted.\n"
, time_stamp(), num);
}
/* Create the header */
write_32(reply, total);
if (keep)
{
write_32(reply+4, ERQ_HANDLE_KEEP_HANDLE);
write_32(reply+8, handle);
}
else
{
write_32(reply+4, handle);
}
/* Send the reply */
write1(reply, total);
} /* replyn() */
TVerdict CTestSyscalls::doTestStepL()
{
int err;
if(TestStepName() == KCreat)
{
INFO_PRINTF1(_L("Creat():"));
err = Creat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen1)
{
INFO_PRINTF1(_L("open1():"));
err = open1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen2)
{
INFO_PRINTF1(_L("open2():"));
err = open2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen3)
{
INFO_PRINTF1(_L("open3():"));
err = open3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen4)
{
INFO_PRINTF1(_L("open4():"));
err = open4();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen5)
{
INFO_PRINTF1(_L("open5():"));
err = open5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen6)
{
INFO_PRINTF1(_L("open6():"));
err = open6();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpenTruncate1)
{
INFO_PRINTF1(_L("OpenTruncate1:"));
err = OpenTruncate1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpenTruncate2)
{
INFO_PRINTF1(_L("OpenTruncate2:"));
err = OpenTruncate2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen7)
{
INFO_PRINTF1(_L("open7():"));
err = open7();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpenInAppendMode)
{
INFO_PRINTF1(_L("OpenInAppendMode():"));
err = OpenInAppendMode();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite1)
{
INFO_PRINTF1(_L("write1():"));
err = write1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite2)
{
INFO_PRINTF1(_L("write2():"));
err = write2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite3)
{
INFO_PRINTF1(_L("write3():"));
err = write3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite5)
{
INFO_PRINTF1(_L("write5():"));
err = write5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread1)
{
INFO_PRINTF1(_L("read1():"));
err = read1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread2)
{
INFO_PRINTF1(_L("read2():"));
err = read2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread3)
{
INFO_PRINTF1(_L("read3():"));
err = read3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread4)
{
INFO_PRINTF1(_L("read4():"));
err = read4();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpendir)
{
INFO_PRINTF1(_L("Opendir():"));
err = Opendir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KClosedir)
{
INFO_PRINTF1(_L("Closedir():"));
err = Closedir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KReaddir)
{
INFO_PRINTF1(_L("Readdir():"));
err = Readdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseek)
{
INFO_PRINTF1(_L("Lseek():"));
err = Lseek();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseek1)
{
INFO_PRINTF1(_L("Lseek1():"));
err = Lseek1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KAccess)
{
INFO_PRINTF1(_L("Access():"));
err = Access();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KAccess1)
{
INFO_PRINTF1(_L("Access1():"));
err = Access1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KDup)
{
INFO_PRINTF1(_L("Dup():"));
err = Dup();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KDup2)
{
INFO_PRINTF1(_L("Dup2():"));
err = Dup2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename)
{
INFO_PRINTF1(_L("Rename():"));
err = Rename();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename1)
{
INFO_PRINTF1(_L("Rename1():"));
err = Rename1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod)
{
INFO_PRINTF1(_L("Chmod():"));
err = Chmod();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod1)
{
INFO_PRINTF1(_L("Chmod1():"));
err = Chmod1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod_dir)
{
INFO_PRINTF1(_L("Chmod_dir():"));
err = Chmod_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFChmod)
{
INFO_PRINTF1(_L("FChmod():"));
err = FChmod();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFChmod_dir)
{
INFO_PRINTF1(_L("FChmod_dir():"));
err = FChmod_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KExit)
{
INFO_PRINTF1(_L("Exit():"));
err = Exit();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KClose)
{
INFO_PRINTF1(_L("Close():"));
err = Close();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir)
{
INFO_PRINTF1(_L("Mkdir():"));
err = Mkdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMk_dir)
{
INFO_PRINTF1(_L("Mk_dir():"));
err = Mk_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir)
{
INFO_PRINTF1(_L("Rmdir():"));
err = Rmdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRm_dir)
{
INFO_PRINTF1(_L("Rm_dir():"));
err = Rm_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir1)
{
INFO_PRINTF1(_L("Rmdir1():"));
err = Rmdir1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir_Chdir)
{
INFO_PRINTF1(_L("Rmdir_Chdir():"));
err = Rmdir_Chdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFsync)
{
INFO_PRINTF1(_L("Fsync():"));
err = Fsync();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtimes)
{
INFO_PRINTF1(_L("Utimes():"));
err = Utimes();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtime)
{
INFO_PRINTF1(_L("Utime():"));
err = Utime();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChdir)
{
INFO_PRINTF1(_L("Chdir():"));
err = Chdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFcntl)
{
INFO_PRINTF1(_L("Fcntl():"));
err = Fcntl();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KIoctl)
{
INFO_PRINTF1(_L("Ioctl():"));
err = Ioctl();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFstat)
{
INFO_PRINTF1(_L("Fstat():"));
err = Fstat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat)
{
INFO_PRINTF1(_L("Stat():"));
err = Stat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat1)
{
INFO_PRINTF1(_L("Stat1():"));
err = Stat1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat2)
{
INFO_PRINTF1(_L("Stat2():"));
err = Stat2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat3)
{
INFO_PRINTF1(_L("Stat3():"));
err = Stat3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KGetpid)
{
INFO_PRINTF1(_L("Getpid():"));
err = Getpid();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KClock)
{
INFO_PRINTF1(_L("Clock():"));
err = Clock();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTime)
{
INFO_PRINTF1(_L("Time():"));
err = Time();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWaitPid)
{
INFO_PRINTF1(_L("WaitPid():"));
err = WaitPid();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KReadV)
{
INFO_PRINTF1(_L("ReadV():"));
err = ReadV();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWriteV)
{
INFO_PRINTF1(_L("WriteV():"));
err = WriteV();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KSleep)
{
INFO_PRINTF1(_L("Sleep():"));
err = Sleep();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KSeekDir)
{
INFO_PRINTF1(_L("SeekDir():"));
err = SeekDir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRewindDir)
{
INFO_PRINTF1(_L("RewindDir():"));
err = RewindDir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTelldir)
{
INFO_PRINTF1(_L("Telldir():"));
err = Telldir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTestClock)
{
INFO_PRINTF1(_L("TestClock():"));
err = TestClock();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KCreat2)
{
INFO_PRINTF1(_L("Creat2():"));
err = Creat2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen8)
{
INFO_PRINTF1(_L("open8():"));
err = open8();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTestStat)
{
INFO_PRINTF1(_L("KTestStat():"));
err = TestStat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseekttytest1)
{
INFO_PRINTF1(_L("Lseekttytest1():"));
err = Lseekttytest1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseekttytest2)
{
INFO_PRINTF1(_L("Lseekttytest2():"));
err = Lseekttytest2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWaitPidtest)
{
INFO_PRINTF1(_L("WaitPidtest():"));
err = WaitPidtest();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWaittest)
{
INFO_PRINTF1(_L("Waittest():"));
err = Waittest();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpen_FileDes_Test)
{
INFO_PRINTF1(_L("Open_FileDes_Test():"));
err = Open_FileDes_Test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopenuid)
{
INFO_PRINTF1(_L("openuid():"));
err = openuid();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir1)
{
INFO_PRINTF1(_L("Mkdir1():"));
err = Mkdir1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir2)
{
INFO_PRINTF1(_L("Mkdir2():"));
err = Mkdir2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename2)
{
INFO_PRINTF1(_L("Rename2():"));
err = Rename2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ktestfsync)
{
INFO_PRINTF1(_L("testfsync():"));
err = testfsync();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ktestrename)
{
INFO_PRINTF1(_L("testrename():"));
err = testrename();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ktestopenvalidate)
{
INFO_PRINTF1(_L("testopenvalidate():"));
err = testopenvalidate();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ksync_safe)
{
INFO_PRINTF1(_L("sync_safe():"));
err = sync_safe();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFstat1)
{
INFO_PRINTF1(_L("Fstat1():"));
err = Fstat1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtimes1)
{
INFO_PRINTF1(_L("Utimes1():"));
err = Utimes1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir_test1)
{
INFO_PRINTF1(_L("Mkdir_test1():"));
err = Mkdir_test1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod_test)
{
INFO_PRINTF1(_L("Chmod_test():"));
err = Chmod_test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChdir1)
{
INFO_PRINTF1(_L("Chdir1():"));
err = Chdir1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir2)
{
INFO_PRINTF1(_L("Rmdir2():"));
err = Rmdir2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename_test)
{
INFO_PRINTF1(_L("Rename_test():"));
err = Rename_test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename3)
{
INFO_PRINTF1(_L("Rename3():"));
err = Rename3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KCreat1)
{
INFO_PRINTF1(_L("Creat1():"));
err = Creat1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KReadV1)
{
INFO_PRINTF1(_L("ReadV1():"));
err = ReadV1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtimes2)
{
INFO_PRINTF1(_L("Utimes2():"));
err = Utimes2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat_test)
{
INFO_PRINTF1(_L("Stat_test():"));
err = Stat_test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir_test2)
{
INFO_PRINTF1(_L("Mkdir_test2():"));
err = Mkdir_test2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod2)
{
INFO_PRINTF1(_L("Chmod2():"));
err = Chmod2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChdir2)
{
INFO_PRINTF1(_L("Chdir2():"));
err = Chdir2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename4)
{
INFO_PRINTF1(_L("Rename4():"));
err = Rename4();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename5)
{
INFO_PRINTF1(_L("Rename5():"));
err = Rename5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir3)
{
INFO_PRINTF1(_L("Rmdir3():"));
err = Rmdir3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread5)
{
INFO_PRINTF1(_L("read5():"));
err = read5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
return TestStepResult();
}
void
casewrite(void)
{
write1(0, 0);
}
int
main(int argc, char *argv[])
{
int pid, i;
if(argc != 3){
fprintf(stderr, "Usage: test-lab-2-a dir1 dir2\n");
exit(1);
}
sprintf(d1, "%s/d%d", argv[1], getpid());
if(mkdir(d1, 0777) != 0){
fprintf(stderr, "test-lab-2-a: failed: mkdir(%s): %s\n",
d1, strerror(errno));
exit(1);
}
sprintf(d2, "%s/d%d", argv[2], getpid());
if(access(d2, 0) != 0){
fprintf(stderr, "test-lab-2-a: failed: access(%s) after mkdir %s: %s\n",
d2, d1, strerror(errno));
exit(1);
}
setbuf(stdout, 0);
for(i = 0; i < sizeof(big)-1; i++)
big[i] = 'x';
for(i = 0; i < sizeof(huge)-1; i++)
huge[i] = '0';
//addddddddddddd
printf("Concurrent creates: ");
pid = fork();
if(pid < 0){
perror("test-lab-2-a: fork");
exit(1);
}
if(pid == 0){
createn(d2, "xx", 20, false);
exit(0);
}
createn(d1, "yy", 20, false);
sleep(10);
reap(pid);
dircheck(d1, 40);
checkn(d1, "xx", 20);
checkn(d2, "yy", 20);
unlinkn(d1, "xx", 20);
unlinkn(d1, "yy", 20);
printf("OK\n");
printf("Concurrent create/delete: ");
createn(d1, "x1", 20, false);
createn(d2, "x2", 20, false);
pid = fork();
if(pid < 0){
perror("test-lab-2-a: fork");
exit(1);
}
if(pid == 0){
unlinkn(d2, "x1", 20);
createn(d1, "x3", 20, false);
exit(0);
}
createn(d1, "x4", 20, false);
reap(pid);
unlinkn(d2, "x2", 20);
unlinkn(d2, "x4", 20);
unlinkn(d2, "x3", 20);
dircheck(d1, 0);
printf("OK\n");
//additional
printf("Create then read: ");
create1(d1, "f1", "aaa");
check1(d2, "f1", "aaa");
check1(d1, "f1", "aaa");
printf("OK\n");
printf("Unlink: ");
unlink1(d2, "f1");
create1(d1, "fx1", "fxx"); /* checknot f1 fails w/o these */
unlink1(d1, "fx1");
checknot(d1, "f1");
checknot(d2, "f1");
create1(d1, "f2", "222");
unlink1(d2, "f2");
checknot(d1, "f2");
checknot(d2, "f2");
create1(d1, "f3", "333");
check1(d2, "f3", "333");
check1(d1, "f3", "333");
unlink1(d1, "f3");
create1(d2, "fx2", "22"); /* checknot f3 fails w/o these */
unlink1(d2, "fx2");
checknot(d2, "f3");
checknot(d1, "f3");
printf("OK\n");
printf("Append: ");
create1(d2, "f1", "aaa");
append1(d1, "f1", "bbb");
append1(d2, "f1", "ccc");
check1(d1, "f1", "aaabbbccc");
check1(d2, "f1", "aaabbbccc");
printf("OK\n");
printf("Readdir: ");
dircheck(d1, 1);
dircheck(d2, 1);
unlink1(d1, "f1");
dircheck(d1, 0);
dircheck(d2, 0);
create1(d2, "f2", "aaa");
create1(d1, "f3", "aaa");
dircheck(d1, 2);
dircheck(d2, 2);
unlink1(d2, "f2");
dircheck(d2, 1);
dircheck(d1, 1);
unlink1(d2, "f3");
dircheck(d1, 0);
dircheck(d2, 0);
printf("OK\n");
printf("Many sequential creates: ");
createn(d1, "aa", 10, false);
createn(d2, "bb", 10, false);
dircheck(d2, 20);
checkn(d2, "bb", 10);
checkn(d2, "aa", 10);
checkn(d1, "aa", 10);
checkn(d1, "bb", 10);
unlinkn(d1, "aa", 10);
unlinkn(d2, "bb", 10);
printf("OK\n");
printf("Write 20000 bytes: ");
create1(d1, "bf", big);
check1(d1, "bf", big);
check1(d2, "bf", big);
unlink1(d1, "bf");
printf("OK\n");
printf("Concurrent creates: ");
pid = fork();
if(pid < 0){
perror("test-lab-2-a: fork");
exit(1);
}
if(pid == 0){
createn(d2, "xx", 20, false);
exit(0);
}
createn(d1, "yy", 20, false);
sleep(10);
reap(pid);
dircheck(d1, 40);
checkn(d1, "xx", 20);
checkn(d2, "yy", 20);
unlinkn(d1, "xx", 20);
unlinkn(d1, "yy", 20);
printf("OK\n");
printf("Concurrent creates of the same file: ");
pid = fork();
if(pid < 0){
perror("test-lab-2-a: fork");
exit(1);
}
if(pid == 0){
createn(d2, "zz", 20, true);
exit(0);
}
createn(d1, "zz", 20, true);
sleep(4);
dircheck(d1, 20);
reap(pid);
checkn(d1, "zz", 20);
checkn(d2, "zz", 20);
unlinkn(d1, "zz", 20);
printf("OK\n");
printf("Concurrent create/delete: ");
createn(d1, "x1", 20, false);
createn(d2, "x2", 20, false);
pid = fork();
if(pid < 0){
perror("test-lab-2-a: fork");
exit(1);
}
if(pid == 0){
unlinkn(d2, "x1", 20);
createn(d1, "x3", 20, false);
exit(0);
}
createn(d1, "x4", 20, false);
reap(pid);
unlinkn(d2, "x2", 20);
unlinkn(d2, "x4", 20);
unlinkn(d2, "x3", 20);
dircheck(d1, 0);
printf("OK\n");
printf("Concurrent creates, same file, same server: ");
pid = fork();
if(pid < 0){
perror("test-lab-2-a: fork");
exit(1);
}
if(pid == 0){
createn(d1, "zz", 20, true);
exit(0);
}
createn(d1, "zz", 20, true);
sleep(2);
dircheck(d1, 20);
reap(pid);
checkn(d1, "zz", 20);
unlinkn(d1, "zz", 20);
printf("OK\n");
printf("Concurrent writes to different parts of same file: ");
create1(d1, "www", huge);
pid = fork();
if(pid < 0){
perror("test-lab-2-a: fork");
exit(1);
}
if(pid == 0){
write1(d2, "www", 65536, 64, '2');
exit(0);
}
write1(d1, "www", 0, 64, '1');
reap(pid);
checkread(d1, "www", 0, 64, '1');
checkread(d2, "www", 0, 64, '1');
checkread(d1, "www", 65536, 64, '2');
checkread(d2, "www", 65536, 64, '2');
printf("OK\n");
printf("test-lab-2-a: Passed all tests.\n");
exit(0);
return(0);
}
void Fwrite(CL_FORM *base, int nargs)
{
BOOL supl_flags[11];
static CL_FORM * keylist[] =
{
SYMBOL(Slisp, 491), /* STREAM */
SYMBOL(Slisp, 492), /* ESCAPE */
SYMBOL(Slisp, 467), /* RADIX */
SYMBOL(Slisp, 493), /* BASE */
SYMBOL(Slisp, 494), /* CIRCLE */
SYMBOL(Slisp, 495), /* PRETTY */
SYMBOL(Slisp, 496), /* LEVEL */
SYMBOL(Slisp, 88), /* LENGTH */
SYMBOL(Slisp, 268), /* CASE */
SYMBOL(Slisp, 497), /* GENSYM */
SYMBOL(Slisp, 400), /* ARRAY */
};
keysort(ARG(1), nargs - 1, 11, keylist, supl_flags, FALSE);
if(NOT(supl_flags[0]))
{
COPY(SYMVAL(Slisp, 61), ARG(1)); /* *STANDARD-OUTPUT* */
}
if(NOT(supl_flags[1]))
{
COPY(SYMVAL(Slisp, 472), ARG(2)); /* *PRINT-ESCAPE* */
}
if(NOT(supl_flags[2]))
{
COPY(SYMVAL(Slisp, 477), ARG(3)); /* *PRINT-RADIX* */
}
if(NOT(supl_flags[3]))
{
COPY(SYMVAL(Slisp, 469), ARG(4)); /* *PRINT-BASE* */
}
if(NOT(supl_flags[4]))
{
COPY(SYMVAL(Slisp, 471), ARG(5)); /* *PRINT-CIRCLE* */
}
if(NOT(supl_flags[5]))
{
COPY(SYMVAL(Slisp, 476), ARG(6)); /* *PRINT-PRETTY* */
}
if(NOT(supl_flags[6]))
{
COPY(SYMVAL(Slisp, 475), ARG(7)); /* *PRINT-LEVEL* */
}
if(NOT(supl_flags[7]))
{
COPY(SYMVAL(Slisp, 474), ARG(8)); /* *PRINT-LENGTH* */
}
if(NOT(supl_flags[8]))
{
COPY(SYMVAL(Slisp, 470), ARG(9)); /* *PRINT-CASE* */
}
if(NOT(supl_flags[9]))
{
COPY(SYMVAL(Slisp, 473), ARG(10)); /* *PRINT-GENSYM* */
}
if(NOT(supl_flags[10]))
{
COPY(SYMVAL(Slisp, 468), ARG(11)); /* *PRINT-ARRAY* */
}
write1(ARG(0));
}
