PUBLIC VOID SpGetenv()
{
BUFFER_DECLARATIONS;
BYTE *Name;
DEBUG(( "SP.GETENV" ));
INIT_BUFFERS;
Name = &DataBuffer[0];
GET_SLICE( Size, Name ); *(Name+Size)=0; DEBUG(( "\"%s\"", Name ));
if( *Name == 0 )
{
PUT_BYTE( SP_ERROR );
}
else
{
if( ( Name=(BYTE *)getenv( Name ) ) == NULL )
{
PUT_BYTE( SP_ERROR );
}
else
{
DEBUG(( "\"%s\"", Name ));
PUT_BYTE( SP_SUCCESS );
Size = strlen( Name );
PUT_SLICE( Size, Name );
}
}
REPLY;
}
/*
* close an open GIF image
*/
int gifout_close_image()
{
/* make sure there's an image open */
if (!image_open)
return GIFLIB_ERR_NIO;
/* flush any remaining code */
if (old_code != NULL_CODE)
PUT_CODE(old_code);
/* output end of info code */
PUT_CODE(eoi_code);
/* flush any extra bits */
while (work_bits > 0)
{
PUT_BYTE(work_data & 0xFF);
work_data >>= 8;
work_bits -= 8;
}
/* flush any extra bytes */
if (buf_idx > 0)
write_data_block(buf_idx, buf, outs);
/* trailing zero byte */
putc(0, outs);
/* mark image as closed */
image_open = 0;
/* done! */
return GIFLIB_SUCCESS;
}
static int indent( ctl* control, SSHORT level)
{
level *= 3;
while (--level >= 0)
PUT_BYTE(' ');
return 0;
}
PUBLIC VOID SpTime()
{
BUFFER_DECLARATIONS;
long Time, UTCTime;
DEBUG(( "SP.TIME" ));
INIT_BUFFERS;
#ifdef MSC
tzset();
time( &UTCTime );
Time = UTCTime - timezone;
PUT_BYTE( SP_SUCCESS );
PUT_INT32( Time );
PUT_INT32( UTCTime );
REPLY;
#endif
#ifdef SUN
UTCTime = time(NULL);
Time = UTCTime + (localtime(&UTCTime))->tm_gmtoff;
PUT_BYTE( SP_SUCCESS );
PUT_INT32( Time );
PUT_INT32( UTCTime );
REPLY;
#endif
#ifdef HELIOS
time( &Time );
UTCTime = 0L;
PUT_BYTE( SP_SUCCESS );
PUT_INT32( Time );
PUT_INT32( UTCTime );
REPLY;
#endif
#ifdef VMS
time( &Time );
UTCTime = 0L;
PUT_BYTE( SP_SUCCESS );
PUT_INT32( Time );
PUT_INT32( UTCTime );
REPLY;
#endif
}
static int print_string( ctl* control, SSHORT offset)
{
SSHORT n = print_byte(control);
while (--n >= 0)
print_char(control, offset);
PUT_BYTE(' ');
return 0;
}
int PRETTY_print_cdb( UCHAR* blr, FPTR_PRINT_CALLBACK routine, void* user_arg, SSHORT language)
{
ctl ctl_buffer;
ctl* control = &ctl_buffer;
if (!routine)
{
routine = gds__default_printer;
user_arg = NULL;
}
control->ctl_routine = routine;
control->ctl_user_arg = user_arg;
control->ctl_blr = control->ctl_blr_start = blr;
control->ctl_ptr = control->ctl_buffer;
control->ctl_language = language;
SSHORT level = 0;
indent(control, level);
const SSHORT i = BLR_BYTE;
SCHAR temp[32];
if (*control->ctl_blr)
sprintf(temp, "gds__dpb_version%d, ", i);
else
sprintf(temp, "gds__dpb_version%d", i);
blr_format(control, temp);
SSHORT offset = 0;
print_line(control, offset);
SSHORT parameter;
while (parameter = BLR_BYTE)
{
const char* p;
if (parameter > FB_NELEM(cdb_table) || !(p = cdb_table[parameter]))
{
return error(control, 0, "*** cdb parameter %d is undefined ***\n", parameter);
}
indent(control, level);
blr_format(control, p);
PUT_BYTE(',');
int length = print_byte(control);
if (length)
{
do {
print_char(control, offset);
} while (--length);
}
print_line(control, offset);
}
return 0;
}
static void print_blr_line(void* arg, SSHORT offset, const char* line)
{
ctl* control = static_cast<ctl*>(arg);
bool comma = false;
char c;
indent(control, control->ctl_level);
while (c = *line++)
{
PUT_BYTE(c);
if (c == ',')
comma = true;
else if (c != ' ')
comma = false;
}
if (!comma)
PUT_BYTE(',');
print_line(control, offset);
}
PUBLIC VOID SpSystem()
{
BUFFER_DECLARATIONS;
BYTE *Command;
INT32 Status;
DEBUG(( "SP.SYSTEM" ));
INIT_BUFFERS;
#ifndef UNKNOWN_HOST
Command = &DataBuffer[0];
GET_SLICE( Size, Command ); *(Command+Size)=0; DEBUG(( "\"%s\"", Command ));
Status = system( Command );
DEBUG(( "status %ld", Status ));
PUT_BYTE( SP_SUCCESS );
PUT_INT32( Status );
REPLY;
#else
PUT_BYTE( SP_UNIMPLEMENTED );
REPLY;
#endif
}
int callerid_generate(unsigned char *buf, const char *number, const char *name, int flags, int callwaiting, format_t codec)
{
int bytes = 0;
int x, sum;
int len;
/* Initial carriers (real/imaginary) */
float cr = 1.0;
float ci = 0.0;
float scont = 0.0;
char msg[256];
len = callerid_genmsg(msg, sizeof(msg), number, name, flags);
if (!callwaiting) {
/* Wait a half a second */
for (x = 0; x < 4000; x++)
PUT_BYTE(0x7f);
/* Transmit 30 0x55's (looks like a square wave) for channel seizure */
for (x = 0; x < 30; x++)
PUT_CLID(0x55);
}
/* Send 150ms of callerid marks */
for (x = 0; x < 150; x++)
PUT_CLID_MARKMS;
/* Send 0x80 indicating MDMF format */
PUT_CLID(0x80);
/* Put length of whole message */
PUT_CLID(len);
sum = 0x80 + strlen(msg);
/* Put each character of message and update checksum */
for (x = 0; x < len; x++) {
PUT_CLID(msg[x]);
sum += msg[x];
}
/* Send 2's compliment of sum */
PUT_CLID(256 - (sum & 255));
/* Send 50 more ms of marks */
for (x = 0; x < 50; x++)
PUT_CLID_MARKMS;
return bytes;
}
PUBLIC int SpExit()
{
BUFFER_DECLARATIONS;
long Status;
DEBUG(( "SP.EXIT" ));
INIT_BUFFERS;
GET_INT32( Status );
DEBUG(( "%ld", Status ));
if( Status == 999999999 )
Status = TERMINATE_OK_EXIT;
else if( Status == -999999999 )
Status = TERMINATE_FAIL_EXIT;
else
Status = TERMINATE_OTHER_STATUS;
DEBUG(( "exit with %d", (int)Status ));
PUT_BYTE( SP_SUCCESS );
REPLY ( (int)Status );
}
void config_vifs_from_file(void)
{
FILE *f;
char linebuf[LINE_BUFSIZ];
char *w, *s;
struct ifconf ifc;
int option;
char ifbuf[BUFSIZ];
u_int8 *data_ptr;
int error_flag;
int line_num;
error_flag = FALSE;
line_num = 0;
if ((f = fopen(configfilename, "r")) == NULL) {
if (errno != ENOENT) logit(LOG_WARNING, errno, "can't open %s",
configfilename);
return;
}
/* TODO: HARDCODING!!! */
cand_rp_adv_message.buffer =
(u_int8 *)malloc(4 + sizeof(pim_encod_uni_addr_t)
+ 255*sizeof(pim_encod_grp_addr_t));
cand_rp_adv_message.prefix_cnt_ptr = cand_rp_adv_message.buffer;
/* By default, if no group_prefix configured, then prefix_cnt == 0
* implies group_prefix = 224.0.0.0 and masklen = 4.
*/
*cand_rp_adv_message.prefix_cnt_ptr = 0;
cand_rp_adv_message.insert_data_ptr = cand_rp_adv_message.buffer;
/* TODO: XXX: HARDCODING!!! */
cand_rp_adv_message.insert_data_ptr += (4 + 6);
ifc.ifc_buf = ifbuf;
ifc.ifc_len = sizeof(ifbuf);
if (ioctl(udp_socket, SIOCGIFCONF, (char *)&ifc) < 0)
logit(LOG_ERR, errno, "ioctl SIOCGIFCONF");
while (fgets(linebuf, sizeof(linebuf), f) != NULL) {
if (strlen(linebuf) >= (LINE_BUFSIZ - 1)) {
logit(LOG_WARNING, 0,
"line length must be shorter than %d in %s:%d",
LINE_BUFSIZ, configfilename, line_num);
error_flag = TRUE;
} else {
line_num++;
}
s = linebuf;
w = next_word(&s);
option = wordToOption(w);
switch(option) {
case EMPTY:
continue;
break;
case PHYINT:
parse_phyint(s);
break;
case CANDIDATE_RP:
parse_candidateRP(s);
break;
case RP_ADDRESS:
parse_rp_address(s);
break;
case GROUP_PREFIX:
parse_group_prefix(s);
break;
case BOOTSTRAP_RP:
parseBSR(s);
break;
case REG_THRESHOLD:
parse_reg_threshold(s);
break;
case DATA_THRESHOLD:
parse_data_threshold(s);
break;
case DEFAULT_SOURCE_METRIC:
parse_default_source_metric(s);
break;
case DEFAULT_SOURCE_PREFERENCE:
parse_default_source_preference(s);
break;
default:
logit(LOG_WARNING, 0, "unknown command '%s' in %s:%d",
w, configfilename, line_num);
error_flag = TRUE;
}
}
if (error_flag) {
/*
* XXX: let's be pedantic even about warnings. If this is a problem,
* comment out this logit(LOG_ERR).
*/
logit(LOG_ERR, 0, "Syntax Error in %s", configfilename);
}
cand_rp_adv_message.message_size = cand_rp_adv_message.insert_data_ptr
- cand_rp_adv_message.buffer;
if (cand_rp_flag != FALSE) {
/* Prepare the RP info */
my_cand_rp_holdtime = 2.5 * my_cand_rp_adv_period;
/* TODO: HARDCODING! */
data_ptr = cand_rp_adv_message.buffer + 1;
PUT_BYTE(my_cand_rp_priority, data_ptr);
PUT_HOSTSHORT(my_cand_rp_holdtime, data_ptr);
PUT_EUADDR(my_cand_rp_address, data_ptr);
}
fclose(f);
}
int capi2_checkuser2(int fd,
char *user,
char *passwd)
{
#define CCHECK_ERR -1
int ev;
struct {
CAPI_control_req_t req;
char buffer[256];
} r;
struct {
CAPI_control_conf_ex_t conf;
char buffer[256];
} a;
union CAPI_primitives *cmsg = (union CAPI_primitives *)&a;
int len;
int chall_len = 0;
char *chall = NULL;
struct userdata *data;
md5context_t md5Context;
memset(&r.req, 0, sizeof(r.req));
if (user == NULL) {
return 0; /* OK no authentication desired */
}
if (passwd == NULL) {
passwd = "";
}
PUT_WORD( r.req.len , sizeof(r.req));
PUT_WORD( r.req.appl , fd);
PUT_WORD( r.req.PRIM_type , CAPI_CONTROL_REQ);
PUT_WORD( r.req.messid , 0);
PUT_WORD( r.req.contrl , 0);
PUT_WORD( r.req.type , CTRL_GETCHALLENGE);
PUT_BYTE( r.req.structlen , 0);
if ((ev = capi2_put_message( fd, (char *)&r)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_put_message rn=0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if ((ev = capi2_wait_for_signal(fd, MAXRTT)) != 0) {
cTRACE(1, fprintf(stderr, "capi2_wait_for_signal 0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if ((ev = capi2_get_message( fd, &cmsg, (union CAPI_primitives *)&a, NULL, 0)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_get_message rn=0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if (GET_PRIMTYPE(cmsg) == CAPI_CONTROL_CONF
&& GET_WORD(a.conf.type) == CTRL_GETCHALLENGE /* get random number */
&& a.conf.structlen
) {
chall_len = (size_t)a.conf.structlen;
chall = a.buffer; /* random number computed by the brick */
} else {
cTRACE( 1, fprintf( stderr, "CAPI_CONTROL_CONF failed\n"));
capi2_errno = CAPI2_E_REG_OS_RESOURCE_ERROR;
return CCHECK_ERR;
}
/*
* calculate hash value;
* see RFC 1321 for a description of the MD5 algorithm
*/
MD5Init(&md5Context);
MD5Update (&md5Context, (unsigned char *) user, strlen(user));
MD5Update (&md5Context, chall, chall_len);
MD5Update (&md5Context, (unsigned char *) passwd, strlen(passwd));
MD5Final (&md5Context);
PUT_WORD( r.req.appl , fd);
PUT_WORD( r.req.PRIM_type , CAPI_CONTROL_REQ);
PUT_WORD( r.req.messid , 0);
PUT_WORD( r.req.contrl , 0);
PUT_WORD( r.req.type , CTRL_SETUSER);
/* copy user and hash value */
data = (struct userdata *)&r.req.structlen;
data->length = strlen(user);
memcpy( data->data, user, data->length);
data = (struct userdata *)&data->data[data->length];
data->length = CAPI_MD5_HASH_LEN;
memcpy( data->data, md5Context.digest, CAPI_MD5_HASH_LEN); /* hash value to be compared */
data = (struct userdata *)&data->data[data->length]; /* on the other side */
len = (char *)data - (char *)&r;
PUT_WORD( r.req.len, len );
if ((ev = capi2_put_message( fd, (char *)&r)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_put_message rn=0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if ((ev = capi2_wait_for_signal(fd, MAXRTT)) != 0) {
cTRACE(1, fprintf(stderr, "capi2_wait_for_signal 0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if ((ev = capi2_get_message( fd, &cmsg, (union CAPI_primitives *)&a, NULL, 0)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_get_message rn=0x%x\n", ev));
capi2_errno = ev;
return CCHECK_ERR;
}
if (GET_PRIMTYPE(cmsg) == CAPI_CONTROL_CONF
&& GET_WORD(a.conf.type) == CTRL_SETUSER
&& GET_WORD(a.conf.info) == 1
) {
return 0; /* OK authentication passed */
}
cTRACE( 1, fprintf( stderr, "CAPI_CONTROL_CONF failed, invalid authentication"));
capi2_errno = CAPI2_E_REG_EXT_EQUIPMENT_NOT_SUPPORTED;
return CCHECK_ERR;
}
static int print_dyn_verb( ctl* control, SSHORT level)
{
const SSHORT offset = control->ctl_blr - control->ctl_blr_start;
const UCHAR dyn_operator = BLR_BYTE;
const char* p;
const int size = FB_NELEM(dyn_table);
if (dyn_operator > size || dyn_operator <= 0 || !(p = dyn_table[dyn_operator])) {
return error(control, offset, "*** dyn operator %d is undefined ***\n", (int) dyn_operator);
}
indent(control, level);
blr_format(control, p);
PUT_BYTE(',');
PUT_BYTE(' ');
++level;
int length;
switch (dyn_operator)
{
case isc_dyn_drop_difference:
case isc_dyn_begin_backup:
case isc_dyn_end_backup:
return 0;
case isc_dyn_begin:
case isc_dyn_mod_database:
print_line(control, offset);
while (NEXT_BYTE != isc_dyn_end)
PRINT_DYN_VERB;
PRINT_DYN_VERB;
return 0;
case isc_dyn_view_blr:
case isc_dyn_fld_validation_blr:
case isc_dyn_fld_computed_blr:
case isc_dyn_trg_blr:
case isc_dyn_fld_missing_value:
case isc_dyn_prc_blr:
case isc_dyn_fld_default_value:
length = print_word(control);
print_line(control, offset);
if (length)
{
control->ctl_level = level;
fb_print_blr(control->ctl_blr, length, print_blr_line, control, control->ctl_language);
control->ctl_blr += length;
}
return 0;
case isc_dyn_scl_acl:
// case isc_dyn_log_check_point_length:
// case isc_dyn_log_num_of_buffers:
// case isc_dyn_log_buffer_size:
// case isc_dyn_log_group_commit_wait:
case isc_dyn_idx_inactive:
length = print_word(control);
while (length--)
print_byte(control);
print_line(control, offset);
return 0;
case isc_dyn_view_source:
case isc_dyn_fld_validation_source:
case isc_dyn_fld_computed_source:
case isc_dyn_description:
case isc_dyn_prc_source:
case isc_dyn_fld_default_source:
length = print_word(control);
while (length--)
print_char(control, offset);
print_line(control, offset);
return 0;
case isc_dyn_del_exception:
if (length = print_word(control))
do {
print_char(control, offset);
} while (--length);
return 0;
case isc_dyn_fld_not_null:
case isc_dyn_sql_object:
// case isc_dyn_drop_log:
// case isc_dyn_drop_cache:
// case isc_dyn_def_default_log:
// case isc_dyn_log_file_serial:
// case isc_dyn_log_file_raw:
// case isc_dyn_log_file_overflow:
case isc_dyn_single_validation:
case isc_dyn_del_computed:
case isc_dyn_del_default:
case isc_dyn_del_validation:
case isc_dyn_idx_statistic:
case isc_dyn_foreign_key_delete:
case isc_dyn_foreign_key_update:
case isc_dyn_foreign_key_cascade:
case isc_dyn_foreign_key_default:
case isc_dyn_foreign_key_null:
case isc_dyn_foreign_key_none:
print_line(control, offset);
return 0;
case isc_dyn_end:
print_line(control, offset);
return 0;
}
if (length = print_word(control))
do {
print_char(control, offset);
} while (--length);
print_line(control, offset);
switch (dyn_operator)
{
case isc_dyn_def_database:
case isc_dyn_def_dimension:
case isc_dyn_def_exception:
case isc_dyn_def_file:
// case isc_dyn_def_log_file:
// case isc_dyn_def_cache_file:
case isc_dyn_def_filter:
case isc_dyn_def_function:
case isc_dyn_def_function_arg:
case isc_dyn_def_generator:
case isc_dyn_def_global_fld:
case isc_dyn_def_idx:
case isc_dyn_def_local_fld:
case isc_dyn_def_rel:
case isc_dyn_def_procedure:
case isc_dyn_def_parameter:
case isc_dyn_def_security_class:
case isc_dyn_def_shadow:
case isc_dyn_def_sql_fld:
case isc_dyn_def_trigger:
case isc_dyn_def_trigger_msg:
case isc_dyn_def_view:
case isc_dyn_delete_database:
case isc_dyn_delete_dimensions:
case isc_dyn_delete_filter:
case isc_dyn_delete_function:
case isc_dyn_delete_global_fld:
case isc_dyn_delete_idx:
case isc_dyn_delete_local_fld:
case isc_dyn_delete_rel:
case isc_dyn_delete_procedure:
case isc_dyn_delete_parameter:
case isc_dyn_delete_security_class:
case isc_dyn_delete_trigger:
case isc_dyn_delete_trigger_msg:
case isc_dyn_delete_shadow:
case isc_dyn_mod_exception:
case isc_dyn_mod_global_fld:
case isc_dyn_mod_idx:
case isc_dyn_mod_local_fld:
case isc_dyn_mod_procedure:
case isc_dyn_mod_rel:
case isc_dyn_mod_security_class:
case isc_dyn_mod_trigger:
case isc_dyn_mod_trigger_msg:
case isc_dyn_rel_constraint:
case isc_dyn_mod_view:
case isc_dyn_grant:
case isc_dyn_revoke:
case isc_dyn_view_relation:
case isc_dyn_def_sql_role:
while (NEXT_BYTE != isc_dyn_end)
PRINT_DYN_VERB;
PRINT_DYN_VERB;
return 0;
}
return 0;
}
/************************************************************************
* *
* capi2_register2 *
* *
***********************************************************************/
int rcapi_register(int msgsize,
int level3cnt,
int datablkcnt,
int datablklen,
char *datablock,
rcapi_host_t *host,
rcapi_auth_t *auth)
{
int ev, fd = -1;
CAPI_register_req_t req;
struct {
CAPI_register_conf_t conf;
char buffer[256];
} a;
union CAPI_primitives *cmsg;
memset(&req, 0, sizeof(req));
memset(&a, 0, sizeof(a));
if ((fd = rcapi_open(host)) == -1) {
cTRACE( 1, perror("capi2_open"));
capi2_errno = CAPI2_E_REG_CAPI_NOT_INSTALLED;
goto error;
}
if(auth != NULL) {
if (capi2_checkuser2(fd, auth->user ,auth->passwd) < 0) return -1;
}
PUT_WORD( req.len , sizeof(req));
PUT_WORD( req.appl , fd);
PUT_WORD( req.PRIM_type , CAPI_REGISTER_REQ);
PUT_WORD( req.messid , 0);
PUT_WORD( req.nmess , msgsize);
PUT_WORD( req.nconn , level3cnt);
PUT_WORD( req.ndblock , datablkcnt);
PUT_WORD( req.dblocksiz , datablklen);
PUT_BYTE( req.version , 2); /* CAPI 2.0 */
if ((ev = capi2_put_message( fd, (char *)&req)) != 0) {
cTRACE( 1, fprintf( stderr, "capi2_put_message rn=0x%x", ev));
capi2_errno = ev;
goto error;
}
while ((ev = capi2_get_message( fd, &cmsg, (union CAPI_primitives *)&a,
NULL, 0)) != 0) {
if (ev != CAPI2_E_MSG_QUEUE_EMPTY) break;
}
if (ev) { capi2_errno = ev; goto error; }
if (GET_PRIMTYPE(cmsg) == CAPI_REGISTER_CONF
&& GET_WORD(a.conf.info) == 0
) {
return fd;
}
error:
cTRACE( 1, fprintf( stderr, "capi2_register_req failed\n"));
capi2_close(fd);
return -1;
}
PUBLIC VOID SpGetkey()
{
#if (BOARD_ID == UDP)
/* the udp version of iserver requires that the link is kept active,
if it is inactive for X seconds the transputer will reset itself.
Therefore this function polls the keyboard & sends an ACTIVE frame
every X seconds to keep the transputer alive. */
BUFFER_DECLARATIONS;
BYTE c;
int timeval1,timeval2,finished;
#ifdef VMS
struct CHARACTERISTICS {
short Count;
char ch;
char res1;
long res2;
} Chars;
#endif
DEBUG(( "SP.GETKEY {udp}" ));
INIT_BUFFERS;
finished = FALSE;
time (&timeval1);
while (!finished) {
time (&timeval2);
/* if 10 seconds elapsed, check link still active */
if ((timeval2-timeval1) >= QUIETTIMEOUT) {
if (TestLink(TheLink) != SUCCEEDED) {
finished = TRUE;
PUT_BYTE( SP_ERROR );
break;
} else {
time (&timeval1);
};
};
#ifdef MSC
if (kbhit()) {
c = getch();
PUT_BYTE( SP_SUCCESS );
PUT_BYTE( c );
finished = TRUE;
};
#endif
#ifdef SUN
if ( TermMode == ORG_MODE ) {
CurMode.c_iflag &= ~ICRNL;
CurMode.c_lflag &= ~(ICANON | ECHO);
CurMode.c_cc[VTIME] = 1;
CurMode.c_cc[VMIN] = 0;
ioctl( 0, TCSETS, &CurMode );
TermMode = POLL_MODE;
} else {
if ( TermMode == GET_MODE ) {
CurMode.c_cc[VTIME] = 1;
CurMode.c_cc[VMIN] = 0;
ioctl( 0, TCSETS, &CurMode );
TermMode = POLL_MODE;
};
};
if (read(0, &c, 1) != 0) {
PUT_BYTE( SP_SUCCESS );
PUT_BYTE( c );
finished = TRUE;
};
#endif
#ifdef VMS
(void)SYS$QIOW( 0, InputChan, (IO$_SENSEMODE | IO$M_TYPEAHDCNT ), &iosb_desc, 0, 0, &Chars, sizeof(struct CHARACTERISTICS), 0, 0, 0, 0 ) ;
if (Chars.Count > 0) {
(void)SYS$QIOW( 0, InputChan, (IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR ), &iosb_desc, 0, 0, &c, 1, 0, 0L, 0, 0 );
PUT_BYTE( SP_SUCCESS );
PUT_BYTE( c );
finished = TRUE;
};
#endif
#ifdef HELIOS
if ( TermMode == ORG_MODE ) {
RemoveAttribute(&CurAttributes,ConsoleEcho);
AddAttribute(&CurAttributes,ConsoleRawInput);
AddAttribute(&CurAttributes,ConsoleBreakInterrupt);
SetAttributes(InputStream,&CurAttributes);
TermMode = POLL_MODE;
}
if ( Read( InputStream, &c, 1, OneSec/10 ) == 1 ) {
PUT_BYTE( SP_SUCCESS );
PUT_BYTE( c );
finished = TRUE;
};
#endif
}; /* end of while */
DEBUG(("key was %c",c));
REPLY;
#else
BUFFER_DECLARATIONS;
BYTE c;
DEBUG(( "SP.GETKEY {non-udp}" ));
INIT_BUFFERS;
c = GetAKey();
DEBUG(("key was %c",c));
PUT_BYTE( SP_SUCCESS );
PUT_BYTE( c );
REPLY;
#endif
}
PUBLIC VOID SpPollkey()
{
BUFFER_DECLARATIONS;
char c;
#ifdef VMS
struct CHARACTERISTICS {
short Count;
char ch;
char res1;
long res2;
} Chars;
#endif
DEBUG(( "SP.POLLKEY" ));
INIT_BUFFERS;
#ifdef MSC
if ( kbhit() )
{
c = getch();
PUT_BYTE( SP_SUCCESS );
PUT_BYTE( c );
}
else
{
PUT_BYTE( SP_ERROR );
}
#endif
#ifdef SUN
if ( TermMode == ORG_MODE )
{
CurMode.c_iflag &= ~ICRNL;
CurMode.c_lflag &= ~(ICANON | ECHO);
CurMode.c_cc[VTIME] = 1;
CurMode.c_cc[VMIN] = 0;
ioctl( 0, TCSETS, &CurMode );
TermMode = POLL_MODE;
}
else
if ( TermMode == GET_MODE )
{
CurMode.c_cc[VTIME] = 1;
CurMode.c_cc[VMIN] = 0;
ioctl( 0, TCSETS, &CurMode );
TermMode = POLL_MODE;
}
if ( read(0, &c, 1) == 0 )
{
PUT_BYTE( SP_ERROR );
}
else
{
PUT_BYTE( SP_SUCCESS );
PUT_BYTE( c );
}
#endif
#ifdef VMS
(void)SYS$QIOW( 0, InputChan, (IO$_SENSEMODE | IO$M_TYPEAHDCNT ), &iosb_desc, 0, 0, &Chars, sizeof(struct CHARACTERISTICS), 0, 0, 0, 0 ) ;
if ( Chars.Count > 0 )
{
(void)SYS$QIOW( 0, InputChan, (IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR ), &iosb_desc, 0, 0, &c, 1, 0, 0L, 0, 0 );
PUT_BYTE( SP_SUCCESS );
PUT_BYTE( c );
}
else
{
PUT_BYTE( SP_ERROR );
}
#endif
#ifdef HELIOS
if ( TermMode == ORG_MODE )
{
RemoveAttribute(&CurAttributes,ConsoleEcho);
AddAttribute(&CurAttributes,ConsoleRawInput);
AddAttribute(&CurAttributes,ConsoleBreakInterrupt);
SetAttributes(InputStream,&CurAttributes);
TermMode = POLL_MODE;
}
if ( Read( InputStream, &c, 1, OneSec/10 ) == 1 )
{
PUT_BYTE( SP_SUCCESS );
PUT_BYTE( c );
}
else
{
PUT_BYTE( SP_ERROR );
}
#endif
REPLY;
}
TEST( Types, basic_byte_put ) {
util::Buffer b(1);
b.resize(1);
PUT_BYTE(0x01, b.buffer());
ASSERT_EQ( "01", b.asHexa() );
}
SCSAPI_VOID telemetry_frame_end(const scs_event_t /*event*/, const void *const /*event_info*/, const scs_context_t /*context*/)
{
if (!serial_port.is_valid())
return;
const unsigned long now = GetTickCount();
const unsigned long diff = now - last_update;
if (diff < 50)
return;
last_update = now;
const float speed_mph = telemetry.speed * METERS_PER_SEC_TO_MILES_PER_HOUR;
const float speed_kph = telemetry.speed * METERS_PER_SEC_TO_KM_PER_HOUR;
const float fuel_ratio = telemetry.fuel / telemetry.fuel_capacity;
unsigned idx = 0;
memset(packet, 0, PACKET_MAX_SIZE);
#define PUT_BYTE(X) packet[idx++] = (unsigned char)(X)
#define PUT_BYTE_FLOAT(X) packet[idx++] = (unsigned char)(float_to_byte(X))
#define GETFLTOPT(X) (option_file.get_option_float(X, 1.0f))
// Packet header
PUT_BYTE(PACKET_SYNC);
PUT_BYTE(PACKET_VER);
// Convert data for output by servos
// Adjust the constant values to map to servo range
PUT_BYTE_FLOAT(fabs(telemetry.speed) * GETFLTOPT("factor_speed")); // Absolute value for when reversing
PUT_BYTE_FLOAT(telemetry.engine_rpm * GETFLTOPT("factor_engine_rpm"));
PUT_BYTE_FLOAT(telemetry.brake_air_pressure * GETFLTOPT("factor_brake_air_pressure"));
PUT_BYTE_FLOAT(telemetry.brake_temperature * GETFLTOPT("factor_brake_temperature"));
PUT_BYTE_FLOAT(fuel_ratio * GETFLTOPT("factor_fuel_ratio")); // Fuel level
PUT_BYTE_FLOAT(telemetry.oil_pressure * GETFLTOPT("factor_oil_pressure"));
PUT_BYTE_FLOAT(telemetry.oil_temperature * GETFLTOPT("factor_oil_temperature"));
PUT_BYTE_FLOAT(telemetry.water_temperature * GETFLTOPT("factor_water_temperature"));
PUT_BYTE_FLOAT(telemetry.battery_voltage * GETFLTOPT("factor_battery_voltage"));
// Pack data for LEDs into bytes
// Truck lights
PUT_BYTE(PACKBOOL(
0, telemetry.light_parking,
telemetry.light_lblinker, telemetry.light_rblinker,
telemetry.light_low_beam, telemetry.light_high_beam,
telemetry.light_brake, telemetry.light_reverse));
// Warning lights
PUT_BYTE(PACKBOOL(
telemetry.parking_brake, telemetry.motor_brake,
telemetry.brake_air_pressure_warning, telemetry.brake_air_pressure_emergency,
telemetry.fuel_warning, telemetry.battery_voltage_warning,
telemetry.oil_pressure_warning, telemetry.water_temperature_warning));
// Enabled flags
PUT_BYTE(PACKBOOL(
0,0,0,0,0, 0,
telemetry.electric_enabled, telemetry.engine_enabled));
// Build string for LCD display
std::stringstream ss;
ss.width(3);
ss << abs(int(speed_mph));
ss << " MPH";
ss << " G ";
if (telemetry.engine_gear > 0)
{
ss << "D";
ss.width(2);
ss << telemetry.engine_gear;
}
else if (telemetry.engine_gear == 0)
{
ss << "N ";
}
else
{
ss << "R";
ss.width(2);
ss << abs(telemetry.engine_gear);
}
ss << "\n";
ss.width(3);
ss << abs(int(speed_kph));
ss << " KPH";
ss << " F ";
ss.width(3);
ss << int(fuel_ratio * 100.0f) << "%";
ss.width(3);
ss << abs(int(speed_kph));
std::string display_str(ss.str());
// Write length of string
PUT_BYTE(display_str.size());
// Followed by string
display_str.copy((char*)&packet[idx], PACKET_MAX_SIZE - idx);
idx += display_str.size();
serial_port.write(packet, idx);
}
int ast_callerid_vmwi_generate(unsigned char *buf, int active, int type, format_t codec,
const char* name, const char* number, int flags)
{
char msg[256];
int len = 0;
int sum;
int x;
int bytes = 0;
float cr = 1.0;
float ci = 0.0;
float scont = 0.0;
if (type == CID_MWI_TYPE_MDMF_FULL) {
/* MDMF Message waiting with date, number, name and MWI parameter */
msg[0] = 0x82;
/* put date, number info at the right place */
len = callerid_genmsg(msg+2, sizeof(msg)-2, number, name, flags);
/* length of MDMF CLI plus Message Waiting Structure */
msg[1] = len+3;
/* Go to the position to write to */
len = len+2;
/* "Message Waiting Parameter" */
msg[len++] = 0x0b;
/* Length of IE is one */
msg[len++] = 1;
/* Active or not */
if (active)
msg[len++] = 0xff;
else
msg[len++] = 0x00;
} else if (type == CID_MWI_TYPE_MDMF) {
/* MDMF Message waiting only */
/* same as above except that the we only put MWI parameter */
msg[len++] = 0x82;
/* Length is 3 */
msg[len++] = 3;
/* IE is "Message Waiting Parameter" */
msg[len++] = 0x0b;
/* Length of IE is one */
msg[len++] = 1;
/* Active or not */
if (active)
msg[len++] = 0xff;
else
msg[len++] = 0x00;
} else {
/* SDMF Message waiting */
msg[len++] = 0x6;
/* Length is 3 */
msg[len++] = 3;
if (active) {
msg[len++] = 0x42;
msg[len++] = 0x42;
msg[len++] = 0x42;
} else {
msg[len++] = 0x6f;
msg[len++] = 0x6f;
msg[len++] = 0x6f;
}
}
sum = 0;
for (x = 0; x < len; x++)
sum += msg[x];
sum = (256 - (sum & 255));
msg[len++] = sum;
/* Wait a half a second */
for (x = 0; x < 4000; x++)
PUT_BYTE(0x7f);
/* Transmit 30 0x55's (looks like a square wave) for channel seizure */
for (x = 0; x < 30; x++)
PUT_CLID(0x55);
/* Send 170ms of callerid marks */
for (x = 0; x < 170; x++)
PUT_CLID_MARKMS;
for (x = 0; x < len; x++) {
PUT_CLID(msg[x]);
}
/* Send 50 more ms of marks */
for (x = 0; x < 50; x++)
PUT_CLID_MARKMS;
return bytes;
}
void config_vifs_from_file(void)
{
FILE *f;
char linebuf[LINE_BUFSIZ];
char *w, *s;
struct ifconf ifc;
int option;
char ifbuf[BUFSIZ];
u_int8 *data_ptr;
int error_flag;
error_flag = FALSE;
lineno = 0;
if ((f = fopen(config_file, "r")) == NULL) {
if (errno != ENOENT)
logit(LOG_WARNING, errno, "Cannot open %s", config_file);
return;
}
/* TODO: HARDCODING!!! */
cand_rp_adv_message.buffer = calloc(1, 4 + sizeof(pim_encod_uni_addr_t) +
255 * sizeof(pim_encod_grp_addr_t));
if (!cand_rp_adv_message.buffer)
logit(LOG_ERR, errno, "Ran out of memory in config_vifs_from_file()");
cand_rp_adv_message.prefix_cnt_ptr = cand_rp_adv_message.buffer;
/* By default, if no group_prefix configured, then prefix_cnt == 0
* implies group_prefix = 224.0.0.0 and masklen = 4.
*/
*cand_rp_adv_message.prefix_cnt_ptr = 0;
cand_rp_adv_message.insert_data_ptr = cand_rp_adv_message.buffer;
/* TODO: XXX: HARDCODING!!! */
cand_rp_adv_message.insert_data_ptr += (4 + 6);
ifc.ifc_buf = ifbuf;
ifc.ifc_len = sizeof(ifbuf);
if (ioctl(udp_socket, SIOCGIFCONF, (char *)&ifc) < 0)
logit(LOG_ERR, errno, "Failed querying kernel network interfaces");
while (fgets(linebuf, sizeof(linebuf), f) != NULL) {
if (strlen(linebuf) >= (LINE_BUFSIZ - 1)) {
WARN("Line length must be shorter than %d", LINE_BUFSIZ);
error_flag = TRUE;
}
lineno++;
s = linebuf;
w = next_word(&s);
option = parse_option(w);
switch (option) {
case CONF_EMPTY:
continue;
break;
case CONF_PHYINT:
parse_phyint(s);
break;
case CONF_CANDIDATE_RP:
parse_candidateRP(s);
break;
case CONF_RP_ADDRESS:
parse_rp_address(s);
break;
case CONF_GROUP_PREFIX:
parse_group_prefix(s);
break;
case CONF_BOOTSTRAP_RP:
parseBSR(s);
break;
case CONF_COMPAT_THRESHOLD:
parse_compat_threshold(s);
break;
case CONF_SPT_THRESHOLD:
parse_spt_threshold(s);
break;
case CONF_DEFAULT_SOURCE_METRIC:
parse_default_source_metric(s);
break;
case CONF_DEFAULT_SOURCE_PREFERENCE:
parse_default_source_preference(s);
break;
case CONF_DEFAULT_IGMP_QUERY_INTERVAL:
parse_default_igmp_query_interval(s);
break;
case CONF_DEFAULT_IGMP_QUERIER_TIMEOUT:
parse_default_igmp_querier_timeout(s);
break;
default:
logit(LOG_WARNING, 0, "%s:%u - Unknown command '%s'", config_file, lineno, w);
error_flag = TRUE;
}
}
if (error_flag)
logit(LOG_ERR, 0, "%s:%u - Syntax error", config_file, lineno);
cand_rp_adv_message.message_size = cand_rp_adv_message.insert_data_ptr - cand_rp_adv_message.buffer;
if (cand_rp_flag != FALSE) {
/* Prepare the RP info */
my_cand_rp_holdtime = 2.5 * my_cand_rp_adv_period;
/* TODO: HARDCODING! */
data_ptr = cand_rp_adv_message.buffer + 1;
PUT_BYTE(my_cand_rp_priority, data_ptr);
PUT_HOSTSHORT(my_cand_rp_holdtime, data_ptr);
PUT_EUADDR(my_cand_rp_address, data_ptr);
}
/* If no IGMP querier timeout was set, calculate from query interval */
if (!default_igmp_querier_timeout)
default_igmp_querier_timeout = QUERIER_TIMEOUT(default_igmp_query_interval);
IF_DEBUG(DEBUG_IGMP) {
logit(LOG_INFO, 0, "IGMP query interval : %u sec", default_igmp_query_interval);
logit(LOG_INFO, 0, "IGMP querier timeout : %u sec", default_igmp_querier_timeout);
}
fclose(f);
}
static int print_sdl_verb( ctl* control, SSHORT level)
{
const char* p;
SSHORT offset = control->ctl_blr - control->ctl_blr_start;
const UCHAR sdl_operator = BLR_BYTE;
if (sdl_operator > FB_NELEM(sdl_table) || sdl_operator <= 0 || !(p = sdl_table[sdl_operator]))
{
return error(control, offset, "*** SDL operator %d is undefined ***\n", (int) sdl_operator);
}
indent(control, level);
blr_format(control, p);
PUT_BYTE(',');
PUT_BYTE(' ');
++level;
int n = 0;
switch (sdl_operator)
{
case isc_sdl_begin:
print_line(control, offset);
while (NEXT_BYTE != isc_sdl_end)
PRINT_SDL_VERB;
PRINT_SDL_VERB;
return 0;
case isc_sdl_struct:
n = print_byte(control);
while (n--)
{
print_line(control, offset);
indent(control, level + 1);
offset = control->ctl_blr - control->ctl_blr_start;
print_blr_dtype(control, true);
}
break;
case isc_sdl_scalar:
print_byte(control);
case isc_sdl_element:
n = print_byte(control);
print_line(control, offset);
while (n--)
PRINT_SDL_VERB;
return 0;
case isc_sdl_field:
case isc_sdl_relation:
print_string(control, offset);
break;
case isc_sdl_fid:
case isc_sdl_rid:
case isc_sdl_short_integer:
print_word(control);
break;
case isc_sdl_variable:
case isc_sdl_tiny_integer:
print_byte(control);
break;
case isc_sdl_long_integer:
print_long(control);
break;
case isc_sdl_add:
case isc_sdl_subtract:
case isc_sdl_multiply:
case isc_sdl_divide:
print_line(control, offset);
PRINT_SDL_VERB;
PRINT_SDL_VERB;
return 0;
case isc_sdl_negate:
print_line(control, offset);
PRINT_SDL_VERB;
return 0;
case isc_sdl_do3:
n++;
case isc_sdl_do2:
n++;
case isc_sdl_do1:
n += 2;
print_byte(control);
print_line(control, offset);
while (n--)
PRINT_SDL_VERB;
return 0;
}
print_line(control, offset);
return 0;
}
void RUN_5010(int UNIT)
{
static int flag_reader_open=0;
static int RDFILE;
static int RE;
static unsigned long CAW;
static unsigned long ar;
static int i;
static long OFF_PREV;
static long OFF_NEXT;
static long LEN_BLOCK;
static long OFF_NOW;
static char PR=0x11;
static int BLOCK_SIZE;
static char BUFER[20000];
static char far*bufer;
static unsigned int RET;
static unsigned int COUNT_CC;
static unsigned int count_cc;
/********************************************************************
Байт состояния устройства
0 - не используется
1 - модификатор состояния если возбужден одновременно с битом ЗАНЯТО
2 - контроллер кончил Возбуждается в следующих случаях
а) в конце любой операции при выполнении которой был
выдан сигнал КОНТРОЛЛЕР ЗАНЯТ
б) в конце любой операции управления при выполнении которой были
обнаружены ОШИБКА В УСТРОЙСТВЕ или ОСОБЫЙ СЛУЧАЙ В УСТРОЙСТВЕ
3 - Занято Если возбужден одновременно с модификатором состояния
то контроллер занят Если возбужденн а модификатор состояния нет
- занято устройство
4 - Канал кончил Для команд управления возбуждается сразу после поступления
команды для команд чтения и записи - в конце передачи данных
5 - УВВ кончило Означает что устройство завершило операцию
Сигнал выдается так-же когда устройство переходит
из состояния НЕ ГОТОВО в состояние ГОТОВО
6 - Ошибка в устройстве, Возбуждается всякий раз когда
а) возбужден любой бит байта 0 уточненного состояния
б) возбужден бит 4 байта 1 уточненного состояния
в) контролер завершил свою работу начав
выполнение команды ПЕРЕМОТКА И РАЗГРУЗКА
7 - Особый случай в устройстве Возбуждается если
при выполнении команды ЗАПИСЬ WTM ERG пройден отражающий
маркер конца ленты EOT
Байт 0
0 - команда отвергнута Недопустимая команда или команды ЗАПИСЬ
WTM ERG выдана для защищенного файла
1 - требуется вмешательство (бит 1 байта 1 равен 0)
2 - ошибка в выходной информационной шине
3 - ошибка в оборудовании бит 7 байт 3 и 1 5 6 7 байта 4 не все равны 0
4 - ошибка в данных биты 0-4 байта 4 не все равны 0
5 - переполнение возможно при выполнении операции ЧТЕНИЕ
ЗАПИСЬ ОБРАТНОЕ ЧТЕНИЕ передача данных прекращается
6 - нулевое число слов возбуждается при выполнении записи
если операция прервана (например HIO) до того как мог быть
записан первый байт Движение ленты не было
7 - не используется
Байт 1
0 - помеха при работе в режиме NRZ обнаружены сигналы помех
в межблочном промежутке при работе в режиме PE бит всегда 0
1 - готово устройство находится в состоянии готово
2 - если этот бит возбужден а бит 1 сброшен то лентопротяжного устройства
нет если одновременно с этим битом бит 1 возбужден
но сброшен бит занято то устройство находится в состоянии не готово
если одновременно с этим битом возбужден бит 1 и бит
занято то выполняется перемотка
3 - головка установлена для работы с 7-дорожечной лентой
4 - лента находится в точке загрузки
5 - лента находится в состоянии записи это означает
что последнее движение ленты относилось к командам
запись ERG ?WTM
6 - лента защищена (снято кольцо защиты)
7 - при режиме NRZ не используется
Байт 2
При режиме PE не используется
Байт 3
Байт 4
Байт 5
********************************************************************/
if (IO_STATUS[UNIT][8]==0)
{
// IO_STATUS[UNIT][9]=
// open(&NAME_FILE_IO_DEVICE[UNIT][0],O_RDWR|O_BINARY);
IO_STATUS[UNIT][8]=1;
IO_STATUS[UNIT][5]=0;
OFFSET_IO_DEVICE[UNIT]=0l;
IO_STATUS[UNIT][3]=0x48;
}
bufer=BUFER;
switch(CSW_COD[UNIT])
{
case 0x02: /* ЧТЕНИЕ
лента перемещается до следующего IBG данные
передаются в канал
*/
//tt(UNIT);
COUNT_CC=CSW_COUNT[UNIT];
asm pusha;
asm push ds;
asm mov cx,COUNT_CC;
asm lds dx,bufer;
asm mov ah,2;
asm int 0x61;
asm pop ds;
asm mov count_cc,cx;
RET=_AX;
asm popa;
IO_STATUS[UNIT][1]=U4|U5;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
goto R1;
}
if (RET&0x0084) /* ОШИБКА */
{
IO_STATUS[UNIT][2]=U4;
IO_STATUS[UNIT][1]|=U6;
goto R1;
}
if (RET&0x0008) /* TM */
{IO_STATUS[UNIT][1]|=U7;
}
else
{if (RET&0x8000)
{BLOCK_SIZE=COUNT_CC;
}
else
{BLOCK_SIZE=COUNT_CC-count_cc;
}
MOVE_MEM_TO_360(BUFER,CSW_ADRESS[UNIT],COUNT_CC);
CSW_COUNT[UNIT]-=COUNT_CC;
}
R1:
//tt(UNIT);
break;
case 0x0c: /* ОБРАТНОЕ ЧТЕНИЕ
лента движется в обратном направлении до IBG
данные передаются в канал
*/
tt(UNIT);
break;
case 0x04: /* УТОЧНИТЬ СОСТОЯНИЕ
шесть байтов информации уточненного состояния
передаются в канал
байты уточненного состояния сбрасываются в начале
каждой операции чтения или записи а также
в начале каждой операции управления которая требует
движения ленты
*/
IO_STATUS[UNIT][2]=0;
IO_STATUS[UNIT][3]=0x40;
for(i=0,ar=CSW_ADRESS[UNIT];i<2;i++,ar++)
{
PUT_BYTE(ar,IO_STATUS[UNIT][i+2]);
}
IO_STATUS[UNIT][2]=0;
IO_STATUS[UNIT][3]=0;
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
tt(UNIT);
break;
case 0x01: /* ЗАПИСЬ
лента движется в прямом направлении
запись производится пока канал посылает данные
по окончании передачи на ленте формируется IBG
размер блока не должен быть меньше 18 байт
*/
MOVE_360_TO_MEM(CSW_ADRESS[UNIT],BUFER,CSW_COUNT[UNIT]);
COUNT_CC=CSW_COUNT[UNIT];
asm pusha;
asm push ds;
asm mov cx,COUNT_CC;
asm lds dx,bufer;
asm mov ah,1;
asm int 0x61;
asm pop ds;
asm mov count_cc,cx;
RET=_AX;
asm popa;
IO_STATUS[UNIT][1]=U4|U5;
CSW_COUNT[UNIT]=0;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
goto W1;
}
if (RET&0x0084) /* ОШИБКА */
{
IO_STATUS[UNIT][2]=U4;
IO_STATUS[UNIT][1]|=U6;
goto W1;
}
if (RET&0x0040) /* ЗАЩИТА ЗАПИСИ*/
{
IO_STATUS[UNIT][2]=U0;
IO_STATUS[UNIT][1]|=U6;
goto W1;
}
W1:
tt(UNIT);
break;
case 0x07: /* ПЕРЕМОТКА REW
Лента перемещается к началу т.е. к точке загрузки
как только начинается перемотка вырабатывается
сигнал УВВ кончило
когда перемотка заканчивается вырабатывается
второй сигнал УВВ кончило
*/
asm pusha;
asm push ds;
asm mov ah,9;
asm int 0x61;
asm pop ds;
RET=_AX;
asm popa;
IO_STATUS[UNIT][3]=0x48;
IO_STATUS[UNIT][1]=U4|U5;
CSW_COUNT[UNIT]=0;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
}
tt(UNIT);
break;
case 0x0f: /* ПЕРЕМОТКА И РАЗГРУЗКА RUN
то же что и ПЕРЕМОТКА кроме того лента разгружается
*/
asm pusha;
asm push ds;
asm mov ah,9;
asm int 0x61;
asm pop ds;
RET=_AX;
asm popa;
IO_STATUS[UNIT][3]=0x48;
IO_STATUS[UNIT][1]=U4|U5;
CSW_COUNT[UNIT]=0;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
}
tt(UNIT);
break;
case 0x17: /* СТЕРЕТЬ УЧАСТОК EBG
Это операция записи но без передачи данных
в результатте создается удлиненный IBG
*/
asm pusha;
asm push ds;
asm mov cx,0xffff;
asm mov ah,8;
asm int 0x61;
asm pop ds;
RET=_AX;
asm popa;
tt(UNIT);
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
goto W2;
}
if (RET&0x0084) /* ОШИБКА */
{
IO_STATUS[UNIT][3]=U0;
IO_STATUS[UNIT][1]|=U6;
goto W2;
}
if (RET&0x0040) /* ЗАЩИТА ЗАПИСИ*/
{
IO_STATUS[UNIT][2]=U0;
IO_STATUS[UNIT][1]|=U6;
goto W2;
}
W2: tt(UNIT);
break;
case 0x1f: /* ЗАПИСЬ МАРКИ ЛЕНТЫ WTM
Записывается специальный короткий блок
называемый маркой ленты
как и для любого другого блока ему предшествует
и за ним следует IBG
*/
asm pusha;
asm push ds;
asm mov ah,3;
asm int 0x61;
asm pop ds;
RET=_AX;
asm popa;
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
goto W3;
}
if (RET&0x0084) /* ОШИБКА */
{
IO_STATUS[UNIT][2]=U4;
IO_STATUS[UNIT][1]|=U6;
goto W3;
}
if (RET&0x0040) /* ЗАЩИТА ЗАПИСИ*/
{
IO_STATUS[UNIT][2]=U0;
IO_STATUS[UNIT][1]|=U6;
goto W3;
}
W3:
tt(UNIT);
break;
case 0x27: /* ШАГ НАЗАД НА БЛОК BSB
лента движется назад до следующего IBG
*/
asm pusha;
asm push ds;
asm mov ah,7;
asm int 0x61;
asm pop ds;
RET=_AX;
asm popa;
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
}
if (RET&0x0008) /* TM */
{IO_STATUS[UNIT][1]|=U7;
}
tt(UNIT);
break;
case 0x2f: /* ШАГ НАЗАД НА ФАЙЛ BSF
Лента движется назад за следующую
марку ленты если марка не найдена лента устанавливается в точке
загрузки
*/
asm pusha;
asm push ds;
asm mov ah,5;
asm int 0x61;
asm pop ds;
RET=_AX;
asm popa;
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
}
tt(UNIT);
break;
case 0x37: /* ШАГ ВПЕРЕД НА БОЛК FSB
*/
asm pusha;
asm push ds;
asm mov ah,6;
asm int 0x61;
asm pop ds;
RET=_AX;
asm popa;
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
}
if (RET&0x0008) /* TM */
{IO_STATUS[UNIT][1]|=U7;
}
tt(UNIT);
break;
case 0x3f: /* ШАГ ВПЕРЕД НА ФАЙЛ FSF
*/
asm pusha;
asm push ds;
asm mov ah,4;
asm int 0x61;
asm pop ds;
RET=_AX;
asm popa;
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
if (RET&0x0002) /* НЕ ГОТОВО */
{
IO_STATUS[UNIT][2]=U1;
IO_STATUS[UNIT][1]|=U6;
}
tt(UNIT);
break;
case 0xc3: /* УСТАНОВИТЬ РЕЖИМ 1600 PE PE
*/
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
break;
case 0xcb: /* УСТАНОВИТЬ РЕЖИМ 800 NZR NRZ
*/
IO_STATUS[UNIT][1]=U4|U5;
CSW_COUNT[UNIT]=0;
break;
case 0xdb: /* ЗАПРОС TIE
*/
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
tt(UNIT);
break;
case 0x03: /* NOP */
//CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
tt(UNIT);
break;
default:
tt(UNIT);
break;
}
}
void RUN_DASD(int UNIT)
{
static int flag_reader_open=0;
static int RDFILE;
static int RE;
static unsigned long CAW;
static char BUFER[8000];
static unsigned long ar;
static int i,j;
static unsigned int CYL,TRK,RR;
static unsigned long OFFSET_TRK;
static unsigned long OFFSET_RR;
static char FF_00[5];
static char ID_R0[512];
static char C_ID_R0_KEY[512];
static int COUNT_CC,count_cc;
static char KEY[256];
static char C_KEY[256];
static int LEN_KEY,LEN_DATA;
static int KEY_CMP,KEY_FIND,KEY_MT,KEY_READ,KEY_READ_MT,all_read,KEY_READ_R0;
static char far * AREA_KEY;
static unsigned int LEN_ALL_DATA;
static unsigned int COUNT_CC_WRITE;
static unsigned char BYTE_PR_OUT[10];
/************************************************************************
ТРЕК:
метка начала оборота #####
<<<<>>>>
собственный адрес 0 - байт признаков 0 - БАЙТ ПРИЗНАКОВ
1-2 - номер цилиндра 1-2 -ЦИЛИНДР
3-4 - номер головки 3-4 -ГОЛОВКА
5-6 - циклическая проверка #####
<<<<>>>>
R0 0 -ПРИЗНАК
FF-больше нет
поле счетчика 0 - признаки 0 -R0 ПРИЗНАКИ
1-2 цилиндр 1-2 -R0 ЦИЛИНДР
3-4 головка 3-4 -R0 ГОЛОВКА
5 - номер записи 5 -R0 RN
6 - длина ключа ==0 6 -R0 ДЛИНА КЛЮЧА
7-8 -длина данных ==8 байт 7-8 -R0 ДЛИНА ДАННЫХ
9-10-циклическря проверка #####
поле данных 0-7
<<<<>>>>
0 -ПРИЗНАК
FF-больше нет
адресный маркер
0-специальный байт #####
1-2 циклическая проверка #####
R1
поле счетчика 0 - признаки 0 -RX
1-2 цилиндр 1-2 -RX
3-4 головка 3-4 -RX
5 - номер записи 5 -RX
6 - длина ключа 6 -RX
7-8 -длина данных 7-8 -RX
9-10-циклическря проверка #####
поле ключа
X...X-содержимое
CC-циклическая проверка #####
поле данных
X...X-содежание
CC-циклическая проверка #####
*************************************************************************/
if (IO_STATUS[UNIT][8]==0)
{
IO_STATUS[UNIT][9]=
open(&NAME_FILE_IO_DEVICE[UNIT][0],O_RDWR|O_BINARY);
IO_STATUS[UNIT][8]=1;
IO_STATUS[UNIT][5]=0;
OFFSET_IO_DEVICE[UNIT]=0l;
}
switch(CSW_COD[UNIT])
{
case 0x07: /* УСТАНОВКА SEEK */
CYL=(GET_BYTE(CSW_ADRESS[UNIT]+2)<<8)+GET_BYTE(CSW_ADRESS[UNIT]+3);
TRK=(GET_BYTE(CSW_ADRESS[UNIT]+4)<<8)+GET_BYTE(CSW_ADRESS[UNIT]+5);
SEEK_00:
DASD[UNIT][DASD_CUR_CYL]=CYL;
//if (CYL>=0xaf) tt(UNIT);
SEEK_01:
IO_STATUS[UNIT][2]=0; /* уточнить состояние==0*/
IO_STATUS[UNIT][3]=0;
DASD[UNIT][DASD_CUR_TRK]=TRK;
if (CSW_COUNT[UNIT]>6) {;}
else if (CSW_COUNT[UNIT]<6) {;}
else CSW_COUNT[UNIT]=0;
DASD[UNIT][DASD_CUR_RR]=0;
OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
OFFSET_IO_DEVICE[UNIT]=OFFSET_TRK;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT]+5l,SEEK_SET);
//read(IO_STATUS[UNIT][9],ID_R0,5);
OFFSET_IO_DEVICE[UNIT]+=5l/*=tell(IO_STATUS[UNIT][9])*/;
IO_STATUS[UNIT][1]=U4|U5;
OLD_OPERATION[UNIT]=0;
//tt(UNIT);
break;
case 0x0b: /* УСТАНОВКА ЦИЛИНДРА SEEK CYLINDER */
CYL=(GET_BYTE(CSW_ADRESS[UNIT]+2)<<8)+GET_BYTE(CSW_ADRESS[UNIT]+3);
TRK=DASD[UNIT][DASD_CUR_TRK];
goto SEEK_00;
break;
case 0x1b: /* УСТАНОВКА ГОЛОВКИ SEEK HEAD
команды установки передают из основной памяти 6 байт
0-1 ячейка (всегда 0)
2-3 цилиндр
4-5 головка
*/
TRK=(GET_BYTE(CSW_ADRESS[UNIT]+4)<<8)+GET_BYTE(CSW_ADRESS[UNIT]+5);
goto SEEK_01;
break;
case 0x39: /* ПОИСК ПО СОБСТВЕННОМУ АДРЕСУ НА РАВНО
*/
OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
OFFSET_IO_DEVICE[UNIT]=OFFSET_TRK;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
read(IO_STATUS[UNIT][9],ID_R0,5);
MOVE_360_TO_MEM(CSW_ADRESS[UNIT],C_ID_R0_KEY,CSW_COUNT[UNIT]);
if (CSW_COUNT[UNIT]<4) {COUNT_CC=CSW_COUNT[UNIT];CSW_COUNT[UNIT]=0;}
else COUNT_CC=4;
CSW_COUNT[UNIT]-=4;
IO_STATUS[UNIT][1]=U4|U5;
if (memcmp(&ID_R0[1],C_ID_R0_KEY,COUNT_CC)==0)
{IO_STATUS[UNIT][1]|=(U1);
/* модификатор состояния
устройство кончило
*/
OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
DASD[UNIT][DASD_CUR_RR]=0;
}
else
{IO_STATUS[UNIT][1]|=U6;
IO_STATUS[UNIT][BYTE_IO_U_1]=0x08;
}
// tt(UNIT);
break;
case 0x31: /* ПОИСК ПО ИДЕНТИФИКАТОРУ НА РАВНО
*/
if (CSW_COUNT[UNIT]<5) COUNT_CC=CSW_COUNT[UNIT];
else COUNT_CC=5;
KEY_CMP=CC_EQ;
KEY_FIND=FIND_ID;
KEY_MT=NORMAL_FIND;
FIND_00:
IO_STATUS[UNIT][2]=0; /* уточнить состояние==0*/
IO_STATUS[UNIT][3]=0;
MOVE_360_TO_MEM(CSW_ADRESS[UNIT],C_ID_R0_KEY,COUNT_CC);
FIND_NEXT_RR:
CIKL_DD1:
if ( OLD_OPERATION[UNIT]==READ_COUNT ||
(OLD_OPERATION[UNIT]==FIND_ID && KEY_FIND==FIND_KEY) ||
OLD_OPERATION[UNIT]==END_OF_CYL
)
lseek(IO_STATUS[UNIT][9],OLD_OFFSET_IO_DEVICE[UNIT],SEEK_SET);
else
if ((OLD_OPERATION[UNIT]==WRITE_DATA) /*||
(KEY_FIND==FIND_ID) /*||
(OLD_OPERATION[UNIT]==(READ_COUNT|READ_KEY|READ_DATA))*/
)
{OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
OFFSET_IO_DEVICE[UNIT]=OFFSET_TRK;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT]+5l,SEEK_SET);
//read(IO_STATUS[UNIT][9],ID_R0,5);
OFFSET_IO_DEVICE[UNIT]+=5l/*=tell(IO_STATUS[UNIT][9])*/;
}
else lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
NEXT_FND_FND:
OFFSET_RR=tell(IO_STATUS[UNIT][9]);
OLD_OFFSET_IO_DEVICE[UNIT]=OFFSET_RR;
read(IO_STATUS[UNIT][9],FF_00,1);
if (FF_00[0]==0x11)
{
switch(KEY_FIND)
{
case FIND_ID:read(IO_STATUS[UNIT][9],ID_R0,9);
AREA_KEY=&ID_R0[1];
count_cc=COUNT_CC;
break;
case FIND_KEY:read(IO_STATUS[UNIT][9],ID_R0,9);
LEN_KEY=ID_R0[6];
if (LEN_KEY) read(IO_STATUS[UNIT][9],KEY,LEN_KEY);
else for(i=LEN_KEY;i<COUNT_CC;i++) KEY[i]=0;
lseek(IO_STATUS[UNIT][9],OFFSET_RR+10l,SEEK_SET);
AREA_KEY=&KEY[0];
count_cc=COUNT_CC;
break;
}
if (
((KEY_CMP==CC_EQ)&&(memcmp(AREA_KEY,C_ID_R0_KEY,count_cc)==0))||
((KEY_CMP==CC_GT)&&(memcmp(AREA_KEY,C_ID_R0_KEY,count_cc)> 0))||
((KEY_CMP==CC_GE)&&(memcmp(AREA_KEY,C_ID_R0_KEY,count_cc)>=0))
)
{IO_STATUS[UNIT][1]=(U1|U4|U5);
/* модификатор состояния
устройство кончило
*/
CYL=(ID_R0[1]<<8)+ID_R0[2];
TRK=(ID_R0[3]<<8)+ID_R0[4];
RR= ID_R0[5];
DASD[UNIT][DASD_CUR_CYL]=CYL;
DASD[UNIT][DASD_CUR_TRK]=TRK;
DASD[UNIT][DASD_CUR_RR] =RR;
OFFSET_IO_DEVICE[UNIT]=OFFSET_RR;
OLD_OPERATION[UNIT]=KEY_FIND;
}
else
{LEN_KEY=ID_R0[6];
if (LEN_KEY)
{//read(IO_STATUS[UNIT][9],KEY,LEN_KEY);
lseek(IO_STATUS[UNIT][9],(unsigned long)LEN_KEY,SEEK_CUR);
}
LEN_DATA=(ID_R0[7]<<8)+ID_R0[8];
if (LEN_DATA)
{//read(IO_STATUS[UNIT][9],BUFER,LEN_DATA);
lseek(IO_STATUS[UNIT][9],(unsigned long)LEN_DATA,SEEK_CUR);
}
OFFSET_RR=tell(IO_STATUS[UNIT][9]);
//if (KEY_FIND==FIND_ID)
// {goto NEXT_FND_FND;
// }
read(IO_STATUS[UNIT][9],FF_00,1);
if (FF_00[0]==0x11)
{OFFSET_IO_DEVICE[UNIT]=OFFSET_RR;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
OLD_OPERATION[UNIT]=KEY_FIND;
;/*normal record*/
}
else
{OLD_OPERATION[UNIT]=0;
if (KEY_MT==MT_FIND)
{if ((DASD_MASK[UNIT] & 0x18)==0x18)
{ /*******запрещен преход на следующий TRK******/
IO_STATUS[UNIT][BYTE_IO_U_1]=0x04;
IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
}
else
{ /*******переход на следующий TRK**************/
if (++DASD[UNIT][DASD_CUR_TRK] ==DASD[UNIT][DASD_TRK])
{ /* END OF CYL */
IO_STATUS[UNIT][BYTE_IO_U_1]=0x20;
IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
}
else
{ /* NEXT TRK */
OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
OFFSET_IO_DEVICE[UNIT]=OFFSET_TRK;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT]+5l,SEEK_SET);
//read(IO_STATUS[UNIT][9],ID_R0,5);
OFFSET_IO_DEVICE[UNIT]+=5l/*=tell(IO_STATUS[UNIT][9])*/;
}
}
}
if (KEY_MT==NORMAL_FIND)
{
OLD_OPERATION[UNIT]=END_OF_CYL;
OLD_OFFSET_IO_DEVICE[UNIT]=OFFSET_RR;
// IO_STATUS[UNIT][1]=(U4|U5|U6);
// IO_STATUS[UNIT][BYTE_IO_U_1]=0x08;
}
}
}
}
else
{OLD_OPERATION[UNIT]=0;
if (KEY_MT==MT_FIND)
{if ((DASD_MASK[UNIT] & 0x18)==0x18)
{ /*******запрещен преход на следующий TRK******/
IO_STATUS[UNIT][BYTE_IO_U_1]=0x04;
IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
}
else
{ /*******переход на следующий TRK**************/
if (++DASD[UNIT][DASD_CUR_TRK] ==DASD[UNIT][DASD_TRK])
{ /* END OF CYL */
IO_STATUS[UNIT][BYTE_IO_U_1]=0x20;
IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
}
else
{ /* NEXT TRK */
OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
OFFSET_IO_DEVICE[UNIT]=OFFSET_TRK;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT]+5l,SEEK_SET);
//read(IO_STATUS[UNIT][9],ID_R0,5);
OFFSET_IO_DEVICE[UNIT]+=5l/*=tell(IO_STATUS[UNIT][9])*/;
}
}
}
if (KEY_MT==NORMAL_FIND)
{
IO_STATUS[UNIT][1]=(U4|U5|U6);
IO_STATUS[UNIT][BYTE_IO_U_1]=0x08;
}
}
CSW_COUNT[UNIT]-=COUNT_CC;
//tt(UNIT);
break;
case 0x51: /* ПОИСК ПО ИДЕНТИФИКАТОРУ НА БОЬШЕ
*/
if (CSW_COUNT[UNIT]<5) COUNT_CC=CSW_COUNT[UNIT];
else COUNT_CC=5;
KEY_CMP=CC_GT;
KEY_FIND=FIND_ID;
KEY_MT=NORMAL_FIND;
goto FIND_00;
break;
case 0x71: /* ПОИСК ПО ИДЕНТИФИКАТОРУ НА БОЛЬШЕ ИЛИ РАВНО
*/
if (CSW_COUNT[UNIT]<5) COUNT_CC=CSW_COUNT[UNIT];
else COUNT_CC=5;
KEY_CMP=CC_GE;
KEY_FIND=FIND_ID;
KEY_MT=NORMAL_FIND;
goto FIND_00;
break;
case 0x29: /* ПОИСК ПО КЛЮЧУ НА РАВНО
*/
COUNT_CC=CSW_COUNT[UNIT];
KEY_CMP=CC_EQ;
KEY_FIND=FIND_KEY;
KEY_MT=NORMAL_FIND;
goto FIND_00;
break;
case 0x49: /* ПОИСК ПО КЛЮЧУ НА БОЛЬШЕ
*/
COUNT_CC=CSW_COUNT[UNIT];
KEY_CMP=CC_GT;
KEY_FIND=FIND_KEY;
KEY_MT=NORMAL_FIND;
goto FIND_00;
break;
case 0x69: /* ПОИСК ПО КЛЮЧУ НА БОЛЬШЕ ИЛИ РАВНО
*/
COUNT_CC=CSW_COUNT[UNIT];
KEY_CMP=CC_GE;
KEY_FIND=FIND_KEY;
KEY_MT=NORMAL_FIND;
goto FIND_00;
break;
case 0x2d: /* ПОИСК ПО КЛЮЧУ И ДАННЫМ НА РАВНО
*/
tt(UNIT);
break;
case 0x4d: /* ПОИСК ПО КЛЮЧУ И ДАННЫМ НА БОЛЬШЕ
*/
tt(UNIT);
break;
case 0x6d: /* ПОИСК ПО КЛЮЧУ И ДАННЫМ НА БОЛЬШЕ ИЛИ РАВНО
*/
tt(UNIT);
break;
case 0xb9: /* МТ-ПОИСК ПО СОБСТВЕННОМУ АДРЕСУ НА РАВНО
*/
tt(UNIT);
break;
case 0xb1: /* МТ-ПОИСК ПО ИДЕНТИФИКАТОРУ НА РАВНО
*/
if (CSW_COUNT[UNIT]<5) COUNT_CC=CSW_COUNT[UNIT];
else COUNT_CC=5;
KEY_CMP=CC_EQ;
KEY_FIND=FIND_ID;
KEY_MT=MT_FIND;
goto FIND_00;
break;
case 0xd1: /* МТ-ПОИСК ПО ИДЕНТИФИКАТОРУ НА БОЛЬШЕ
*/
if (CSW_COUNT[UNIT]<5) COUNT_CC=CSW_COUNT[UNIT];
else COUNT_CC=5;
KEY_CMP=CC_GT;
KEY_FIND=FIND_ID;
KEY_MT=MT_FIND;
goto FIND_00;
break;
case 0xf1: /* МТ-ПОИСК ПО ИДЕНТИФИКАТОРУ НА БОЛЬШЕ ИЛИ РАВНО
*/
if (CSW_COUNT[UNIT]<5) COUNT_CC=CSW_COUNT[UNIT];
else COUNT_CC=5;
KEY_CMP=CC_GE;
KEY_FIND=FIND_ID;
KEY_MT=MT_FIND;
goto FIND_00;
break;
case 0xa9: /* МТ-ПОИСК ПО КЛЮЧУ НА РАВНО
*/
COUNT_CC=CSW_COUNT[UNIT];
KEY_CMP=CC_EQ;
KEY_FIND=FIND_KEY;
KEY_MT=MT_FIND;
goto FIND_00;
break;
case 0xc9: /* МТ-ПОИСК ПО КЛЮЧУ НА БОЛЬШЕ
*/
COUNT_CC=CSW_COUNT[UNIT];
KEY_CMP=CC_GT;
KEY_FIND=FIND_KEY;
KEY_MT=MT_FIND;
goto FIND_00;
break;
case 0xe9: /* МТ-ПОИСК ПО КЛЮЧУ НА БОЛЬШЕ ИЛИ РАВНО
*/
COUNT_CC=CSW_COUNT[UNIT];
KEY_CMP=CC_GE;
KEY_FIND=FIND_KEY;
KEY_MT=MT_FIND;
goto FIND_00;
break;
case 0xad: /* МТ-ПОИСК ПО КЛЮЧУ И ДАННЫМ НА РАВНО
*/
tt(UNIT);
break;
case 0xcd: /* МТ-ПОИСК ПО КДЮЧУ И ДАННЫМ НА БОЛЬШЕ
*/
tt(UNIT);
break;
case 0xed: /* МТ-ПОТСК ПО КЛЮЧУ И ДАННЫМ НА БОЛЬШЕ ИЛИ РАВНО
*/
tt(UNIT);
break;
case 0x12: /* ЧТЕНИЕ СЧЕТЧИКА
*/
KEY_READ_R0=NOT_READ_R0;
KEY_READ_MT=READ_NORMAL;
KEY_READ=READ_COUNT;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
break;
case 0x92: /* МТ-ЧТЕНИЕ СЧЕТЧИКА
*/
KEY_READ_R0=NOT_READ_R0;
KEY_READ_MT=READ_MT;
KEY_READ=READ_COUNT;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
break;
case 0x1e: /* ЧТЕНИЕ СЧЕТЧИКА УЛЮЧА М ДАННЫХ
*/
KEY_READ_R0=NOT_READ_R0;
KEY_READ_MT=READ_NORMAL;
KEY_READ=READ_COUNT|READ_KEY|READ_DATA;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
break;
case 0x9e: /* МТ-ЧТЕНИЕ СЧЕТЧИКА КЛЮЧА И ДАННЫХ
*/
KEY_READ_R0=NOT_READ_R0;
KEY_READ_MT=READ_MT;
KEY_READ=READ_COUNT|READ_KEY|READ_DATA;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
break;
case 0x0e: /* ЧТЕНИЕ КЛЮЧА И ДАННЫХ
*/
KEY_READ_R0=NOT_READ_R0;
KEY_READ_MT=READ_NORMAL;
KEY_READ=READ_DATA|READ_KEY;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
break;
case 0x8e: /* МТ-ЧТЕНИЕ КЛЮЧА И ДАННЫХ
*/
KEY_READ_R0=NOT_READ_R0;
KEY_READ_MT=READ_MT;
KEY_READ=READ_DATA|READ_KEY;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
break;
case 0x06: /* ЧТЕНИЕ ДАННЫХ
*/
KEY_READ_R0=NOT_READ_R0;
KEY_READ_MT=READ_NORMAL;
KEY_READ=READ_DATA;
COUNT_CC=CSW_COUNT[UNIT];
READ: IO_STATUS[UNIT][2]=0; /* уточнить состояние==0*/
IO_STATUS[UNIT][3]=0;
if (
((OLD_OPERATION[UNIT]==READ_COUNT) &&
((KEY_READ==(READ_KEY|READ_DATA))|| (KEY_READ==READ_DATA)
)
)
) lseek(IO_STATUS[UNIT][9],OLD_OFFSET_IO_DEVICE[UNIT],SEEK_SET);
else lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
READ0:
OFFSET_RR=tell(IO_STATUS[UNIT][9]);
OLD_OFFSET_IO_DEVICE[UNIT]=OFFSET_RR;
read(IO_STATUS[UNIT][9],FF_00,1);
if (FF_00[0]==0x11)
{
read(IO_STATUS[UNIT][9],ID_R0,9);
LEN_KEY=ID_R0[6];
if (LEN_KEY) read(IO_STATUS[UNIT][9],KEY,LEN_KEY);
LEN_DATA=(ID_R0[7]<<8)+ID_R0[8];
if (LEN_DATA) read(IO_STATUS[UNIT][9],BUFER,LEN_DATA);
if (KEY_READ==READ_COUNT && OLD_OPERATION[UNIT]==FIND_ID)
{OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
OLD_OPERATION[UNIT]=0;
goto READ0;
}
if (KEY_READ==READ_COUNT)
{if (ID_R0[5]==0) goto READ0;/* R0 NOT READ */
if (COUNT_CC<=8) count_cc=CSW_COUNT[UNIT];
else count_cc=8;
if ((CSW_MOD[UNIT]&0x10)==0)
MOVE_MEM_TO_360(&ID_R0[1],CSW_ADRESS[UNIT],count_cc);
}
if (KEY_READ==(READ_COUNT|READ_KEY|READ_DATA))
{if (ID_R0[5]==0 && KEY_READ_R0==NOT_READ_R0) goto READ0;/* R0 NOT READ */
if (ID_R0[5]!=0 && KEY_READ_R0==READ_R0) goto READ0;
if (COUNT_CC<8) count_cc=COUNT_CC;
else count_cc=8;
if ((CSW_MOD[UNIT]&0x10)==0)
MOVE_MEM_TO_360(&ID_R0[1],CSW_ADRESS[UNIT],count_cc);
all_read=count_cc;
if ((COUNT_CC-all_read)<LEN_KEY) count_cc=COUNT_CC-all_read;
else count_cc=LEN_KEY;
if ((CSW_MOD[UNIT]&0x10)==0)
MOVE_MEM_TO_360(KEY,CSW_ADRESS[UNIT]+all_read,count_cc);
all_read+=count_cc;
if ((COUNT_CC-all_read)<LEN_DATA) count_cc=COUNT_CC-all_read;
else count_cc=LEN_DATA;
if ((CSW_MOD[UNIT]&0x10)==0)
MOVE_MEM_TO_360(BUFER,CSW_ADRESS[UNIT]+all_read,count_cc);
all_read+=count_cc;
count_cc=all_read;
}
if (KEY_READ==(READ_KEY|READ_DATA))
{if (ID_R0[5]==0) goto READ0;/* R0 NOT READ */
all_read=0;
if ((COUNT_CC-all_read)<LEN_KEY) count_cc=COUNT_CC-all_read;
else count_cc=LEN_KEY;
if ((CSW_MOD[UNIT]&0x10)==0)
MOVE_MEM_TO_360(KEY,CSW_ADRESS[UNIT],count_cc);
all_read+=count_cc;
if ((COUNT_CC-all_read)<LEN_DATA) count_cc=COUNT_CC-all_read;
else count_cc=LEN_DATA;
if ((CSW_MOD[UNIT]&0x10)==0)
MOVE_MEM_TO_360(BUFER,CSW_ADRESS[UNIT]+all_read,count_cc);
all_read+=count_cc;
count_cc=all_read;
}
if (KEY_READ==(READ_DATA))
{
if (COUNT_CC<=LEN_DATA) count_cc=COUNT_CC;
else count_cc=LEN_DATA;
if ((CSW_MOD[UNIT]&0x10)==0)
MOVE_MEM_TO_360(BUFER,CSW_ADRESS[UNIT],count_cc);
}
CSW_COUNT[UNIT]-=count_cc;
IO_STATUS[UNIT][1]=U4|U5;
if ((KEY_READ==(READ_DATA)) ||
(KEY_READ==(READ_KEY|READ_DATA))
)
{
if (LEN_DATA==0) IO_STATUS[UNIT][1]|=U7;
}
//OLD_OFFSET_IO_DEVICE[UNIT]=OFFSET_IO_DEVICE[UNIT];
OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
OLD_OPERATION[UNIT]=KEY_READ;
read(IO_STATUS[UNIT][9],FF_00,1);
if (FF_00[0]==0x11) DASD[UNIT][DASD_CUR_RR]++;
}
else
{OLD_OPERATION[UNIT]=0;
if (KEY_READ_MT==READ_MT)
{
if ((DASD_MASK[UNIT] & 0x18)==0x18)
{ /*******запрещен преход на следующий TRK******/
IO_STATUS[UNIT][BYTE_IO_U_1]=0x04;
IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
}
else
{ /*******переход на следующий TRK**************/
if (++DASD[UNIT][DASD_CUR_TRK] ==DASD[UNIT][DASD_TRK])
{ /* END OF CYL */
IO_STATUS[UNIT][BYTE_IO_U_1]=0x20;
IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
}
else
{ /* NEXT TRK */
OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
lseek(IO_STATUS[UNIT][9],OFFSET_TRK/*+5l*/,SEEK_SET);
read(IO_STATUS[UNIT][9],ID_R0,5);
OFFSET_IO_DEVICE[UNIT]=/*OFFSET_TRK+5l*/tell(IO_STATUS[UNIT][9]);
DASD[UNIT][DASD_CUR_RR]=0;
goto READ;
}
}
}
else
{IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
IO_STATUS[UNIT][BYTE_IO_U_1]=0x08;
}
}
// tt(UNIT);
break;
case 0x86: /* МТ-ЧТЕНИЕ ДАННЫХ
*/
KEY_READ_R0=NOT_READ_R0;
KEY_READ_MT=READ_MT;
KEY_READ=READ_DATA;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
//tt(UNIT);
break;
case 0x16: /* ЧТЕНИЕ R0
*/
OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
OFFSET_IO_DEVICE[UNIT]=OFFSET_TRK;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
read(IO_STATUS[UNIT][9],ID_R0,5);
OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
KEY_READ_R0=READ_R0;
KEY_READ_MT=READ_NORMAL;
KEY_READ=READ_COUNT|READ_KEY|READ_DATA;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
break;
case 0x96: /* МТ-ЧТЕНИЕ R0
*/
OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
OFFSET_IO_DEVICE[UNIT]=OFFSET_TRK;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
read(IO_STATUS[UNIT][9],ID_R0,5);
OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
KEY_READ_R0=READ_R0;
KEY_READ_MT=READ_MT;
KEY_READ=READ_COUNT|READ_KEY|READ_DATA;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
break;
case 0x1a: /* ЧТЕНИЕ СОБСТВЕННОГО АДРЕСА
*/
OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
OFFSET_IO_DEVICE[UNIT]=OFFSET_TRK;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
read(IO_STATUS[UNIT][9],ID_R0,5);
if ((CSW_MOD[UNIT]&0x10)==0)
MOVE_MEM_TO_360(ID_R0,CSW_ADRESS[UNIT],CSW_COUNT[UNIT]);
OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
OLD_OPERATION[UNIT]=0;
//tt(UNIT);
break;
case 0x9a: /* МТ-ЧТЕНИЕ СОБСТВЕННОГО АДРЕСА
*/
tt(UNIT);
break;
case 0x02: /* ЧТЕНИЕ НАЧАЛЬНОЙ ЗАГРУЗКИ ПРОГРАММЫ
*/
DASD[UNIT][DASD_CUR_CYL]=0;
DASD[UNIT][DASD_CUR_TRK]=0;
DASD[UNIT][DASD_CUR_RR]=0;
OFFSET_TRK=(long)(
DASD[UNIT][DASD_CUR_CYL]*
DASD[UNIT][DASD_TRK]+
DASD[UNIT][DASD_CUR_TRK]
)*(long)(DASD[UNIT][DASD_LEN]);
OFFSET_IO_DEVICE[UNIT]=OFFSET_TRK;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
read(IO_STATUS[UNIT][9],ID_R0,5);
C_ID_R0_KEY[0]=0;
C_ID_R0_KEY[1]=0;
C_ID_R0_KEY[2]=0;
C_ID_R0_KEY[3]=0;
C_ID_R0_KEY[4]=1;
COUNT_CC=5;
OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
CIKL_DD2:OFFSET_RR=tell(IO_STATUS[UNIT][9]);
read(IO_STATUS[UNIT][9],FF_00,1);
if (FF_00[0]==0x11)
{
read(IO_STATUS[UNIT][9],ID_R0,9);
if (memcmp(&ID_R0[1],C_ID_R0_KEY,COUNT_CC)==0)
{IO_STATUS[UNIT][1]=(U1|U4|U5);
/* модификатор состояния
устройство кончило
*/
CYL=(ID_R0[1]<<8)+ID_R0[2];
TRK=(ID_R0[3]<<8)+ID_R0[4];
RR= ID_R0[5];
DASD[UNIT][DASD_CUR_CYL]=CYL;
DASD[UNIT][DASD_CUR_TRK]=TRK;
DASD[UNIT][DASD_CUR_RR] =RR;
OFFSET_IO_DEVICE[UNIT]=OFFSET_RR;
KEY_READ_R0=NOT_READ_R0;
KEY_READ_MT=READ_NORMAL;
KEY_READ=READ_DATA;
COUNT_CC=CSW_COUNT[UNIT];
goto READ;
}
else
{LEN_KEY=ID_R0[6];
if (LEN_KEY)
{read(IO_STATUS[UNIT][9],KEY,LEN_KEY);
//lseek(IO_STATUS[UNIT][9],(unsigned long)LEN_KEY,SEEK_CUR);
}
LEN_DATA=(ID_R0[7]<<8)+ID_R0[8];
if (LEN_DATA)
{read(IO_STATUS[UNIT][9],BUFER,LEN_DATA);
//lseek(IO_STATUS[UNIT][9],(unsigned long)LEN_DATA,SEEK_CUR);
}
goto CIKL_DD2;
}
}
else
{IO_STATUS[UNIT][1]=(U4|U5|U6);
IO_STATUS[UNIT][BYTE_IO_U_1]=0x08;
}
tt(UNIT);
break;
case 0x19: /* ЗАПИСЬ СОБСТВЕННОГО АДРЕСА
*/
tt(UNIT);
break;
case 0x15: /* ЗАПИСЬ R0
*/
tt(UNIT);
break;
case 0x1d: /* ЗАПИСЬ СЧЕТЧИКА КЛЮЧА И ДАННЫХ
*/
BYTE_PR_OUT[0]=0x11;
WR_C_K_D:
IO_STATUS[UNIT][2]=0; /* уточнить состояние==0*/
IO_STATUS[UNIT][3]=0;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
read(IO_STATUS[UNIT][9],FF_00,1);
if (FF_00[0]==0x11)
{
read(IO_STATUS[UNIT][9],ID_R0,9);
LEN_KEY=ID_R0[6];
if (LEN_KEY) read(IO_STATUS[UNIT][9],KEY,LEN_KEY);
LEN_DATA=(ID_R0[7]<<8)+ID_R0[8];
if (LEN_DATA) read(IO_STATUS[UNIT][9],BUFER,LEN_DATA);
}
else
{
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
}
FF_00[0]=0x11;
OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
write(IO_STATUS[UNIT][9],FF_00,1);
write(IO_STATUS[UNIT][9],BYTE_PR_OUT,1);
LEN_ALL_DATA=0;
for(i=0;i<9;i++) ID_R0[i]=BUFER[i];
LEN_KEY=ID_R0[6];
LEN_DATA=(ID_R0[7]<<8)+ID_R0[8];
COUNT_CC=9+LEN_KEY+LEN_DATA;
WR1D:
MOVE_360_TO_MEM(CSW_ADRESS[UNIT],BUFER,CSW_COUNT[UNIT]);
write(IO_STATUS[UNIT][9],BUFER,CSW_COUNT[UNIT]);
LEN_ALL_DATA+=CSW_COUNT[UNIT];
if(CSW_MOD[UNIT] & 0x80) /* цепочка данных */
{
CH_DATA(UNIT);
//tt(UNIT);
goto WR1D;
}
IO_STATUS[UNIT][BYTE_IO]=U4|U5;
CSW_COUNT[UNIT]=0;
OLD_OPERATION[UNIT]=WRITE_DATA;
//tt(UNIT);
break;
case 0x01: /* ЗАПИСЬ СПЕЦИАЛЬНОГО СЧЕТЧИКА КЛЮЧА И ДАННЫХ
*/
BYTE_PR_OUT[0]=0x51;
goto WR_C_K_D;
//tt(UNIT);
break;
case 0x05: /* ЗАПИСЬ ДАННЫХ
*/
IO_STATUS[UNIT][2]=0; /* уточнить состояние==0*/
IO_STATUS[UNIT][3]=0;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
read(IO_STATUS[UNIT][9],FF_00,1);
if (FF_00[0]==0x11)
{
read(IO_STATUS[UNIT][9],ID_R0,9);
LEN_KEY=ID_R0[6];
LEN_DATA=(ID_R0[7]<<8)+ID_R0[8];
if (LEN_KEY) read(IO_STATUS[UNIT][9],KEY,LEN_KEY);
MOVE_360_TO_MEM(CSW_ADRESS[UNIT],BUFER,CSW_COUNT[UNIT]);
if (LEN_DATA>CSW_COUNT[UNIT])
for(i=CSW_COUNT[UNIT];i<LEN_DATA;i++)
BUFER[i]=0;
write(IO_STATUS[UNIT][9],BUFER,LEN_DATA);
//if(CSW_MOD[UNIT] & 0x80) /* цепочка данных */
// {
// CH_DATA(UNIT);
// tt(UNIT);
// goto WR1D;
// }
OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
IO_STATUS[UNIT][BYTE_IO]=U4|U5;
CSW_COUNT[UNIT]=0;
}
else
{
IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
IO_STATUS[UNIT][BYTE_IO_U_1]=0x10;
}
OLD_OPERATION[UNIT]=WRITE_DATA;
//tt(UNIT);
break;
case 0x0d: /* ЗАПИСЬ КЛЮЧА И ДАННЫХ
*/
IO_STATUS[UNIT][2]=0; /* уточнить состояние==0*/
IO_STATUS[UNIT][3]=0;
lseek(IO_STATUS[UNIT][9],OFFSET_IO_DEVICE[UNIT],SEEK_SET);
read(IO_STATUS[UNIT][9],FF_00,1);
if (FF_00[0]==0x11)
{
read(IO_STATUS[UNIT][9],ID_R0,9);
LEN_KEY=ID_R0[6];
LEN_DATA=(ID_R0[7]<<8)+ID_R0[8];
MOVE_360_TO_MEM(CSW_ADRESS[UNIT],BUFER,CSW_COUNT[UNIT]);
if (LEN_KEY+LEN_DATA>CSW_COUNT[UNIT])
for(i=CSW_COUNT[UNIT];i<LEN_KEY+LEN_DATA;i++)
BUFER[i]=0;
write(IO_STATUS[UNIT][9],BUFER,LEN_KEY+LEN_DATA);
OFFSET_IO_DEVICE[UNIT]=tell(IO_STATUS[UNIT][9]);
IO_STATUS[UNIT][BYTE_IO]=U4|U5;
CSW_COUNT[UNIT]=0;
}
else
{
IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
IO_STATUS[UNIT][BYTE_IO_U_1]=0x10;
}
OLD_OPERATION[UNIT]=WRITE_DATA;
//tt(UNIT);
break;
case 0x11: /* СТЕРЕТЬ
*/
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][BYTE_IO]=U4|U5;
tt(UNIT);
break;
case 0x17: /* НОП
*/
case 0x03: /* НОП
*/
//CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][BYTE_IO]=U4|U5;
//IO_STATUS[UNIT][0]=S0;
//tt(UNIT);
break;
case 0x1f: /* УСТАНОВИТЬ МАСКУ ФАЙЛА
*/
ar=CSW_ADRESS[UNIT];
DASD_MASK[UNIT]=GET_BYTE(ar);
CSW_COUNT[UNIT]=0;
OLD_OPERATION[UNIT]=0;
IO_STATUS[UNIT][BYTE_IO]=U4|U5;
// tt(UNIT);
break;
case 0x13: /* УСТАНОВКА В НАЧАЛЬНОЕ ПОЛОЖЕНИЕ
*/
DASD[UNIT][DASD_CUR_CYL]=0;
DASD[UNIT][DASD_CUR_TRK]=0;
DASD[UNIT][DASD_CUR_RR]=0;
OFFSET_IO_DEVICE[UNIT]=0;
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][BYTE_IO]=U4|U5;
OLD_OPERATION[UNIT]=0;
tt(UNIT);
break;
case 0x04: /* УТОЧНИТЬ СОСТОЯНИЕ
*/
for(i=0,ar=CSW_ADRESS[UNIT];i<6;i++,ar++)
{
PUT_BYTE(ar,IO_STATUS[UNIT][i+2]);IO_STATUS[UNIT][i+2]=0;
}
IO_STATUS[UNIT][1]=U4|U5;
IO_STATUS[UNIT][2]=0;
IO_STATUS[UNIT][3]=0;
CSW_COUNT[UNIT]=0;
if (RQ_TRACE) printf("\n 04 command ");
//tt(UNIT);
break;
case 0xb4: /* ЗАРЕЗЕРВИРОВАТЬ УСТРОЙСТВО
*/
tt(UNIT);
break;
case 0x94: /* ОСВОБОДИТЬ УСТРОЙСТВО
*/
tt(UNIT);
break;
default:
IO_STATUS[UNIT][BYTE_IO_U_0]=0x80; /* недорустимая команда */
IO_STATUS[UNIT][BYTE_IO_U_1]=0x10;
IO_STATUS[UNIT][BYTE_IO]=U4|U5|U6;
tt(UNIT);
break;
}
}
void config_vifs_from_file(void)
{
FILE *fp;
char linebuf[LINE_BUFSIZ];
char *w, *s;
int option;
uint8_t *data_ptr;
int error_flag;
error_flag = FALSE;
lineno = 0;
/* TODO: HARDCODING!!! */
cand_rp_adv_message.buffer = calloc(1, 4 + sizeof(pim_encod_uni_addr_t) +
255 * sizeof(pim_encod_grp_addr_t));
if (!cand_rp_adv_message.buffer)
logit(LOG_ERR, errno, "Ran out of memory in config_vifs_from_file()");
cand_rp_adv_message.prefix_cnt_ptr = cand_rp_adv_message.buffer;
/* By default, if no group-prefix configured, then prefix_cnt == 0
* implies group-prefix = 224.0.0.0 and masklen = 4.
*/
*cand_rp_adv_message.prefix_cnt_ptr = 0;
cand_rp_adv_message.insert_data_ptr = cand_rp_adv_message.buffer;
/* TODO: XXX: HARDCODING!!! */
cand_rp_adv_message.insert_data_ptr += (4 + 6);
fp = fopen(config_file, "r");
if (!fp) {
logit(LOG_WARNING, errno, "Cannot open configuration file %s", config_file);
fallback_config();
goto nofile;
}
while (fgets(linebuf, sizeof(linebuf), fp)) {
if (strlen(linebuf) >= (LINE_BUFSIZ - 1)) {
WARN("Line length must be shorter than %d", LINE_BUFSIZ);
error_flag = TRUE;
}
lineno++;
s = linebuf;
w = next_word(&s);
option = parse_option(w);
switch (option) {
case CONF_EMPTY:
continue;
break;
case CONF_PHYINT:
parse_phyint(s);
break;
case CONF_CANDIDATE_RP:
parse_rp_candidate(s);
break;
case CONF_RP_ADDRESS:
parse_rp_address(s);
break;
case CONF_GROUP_PREFIX:
parse_group_prefix(s);
break;
case CONF_BOOTSTRAP_RP:
parse_bsr_candidate(s);
break;
case CONF_COMPAT_THRESHOLD:
parse_compat_threshold(s);
break;
case CONF_SPT_THRESHOLD:
parse_spt_threshold(s);
break;
case CONF_DEFAULT_ROUTE_METRIC:
parse_default_route_metric(s);
break;
case CONF_DEFAULT_ROUTE_DISTANCE:
parse_default_route_distance(s);
break;
case CONF_IGMP_QUERY_INTERVAL:
parse_igmp_query_interval(s);
break;
case CONF_IGMP_QUERIER_TIMEOUT:
parse_igmp_querier_timeout(s);
break;
case CONF_HELLO_INTERVAL:
parse_hello_interval(s);
break;
default:
logit(LOG_WARNING, 0, "%s:%u - Unknown command '%s'", config_file, lineno, w);
error_flag = TRUE;
}
}
fclose(fp);
nofile:
/* A static RP address is needed for SSM. We use a link-local
* address. It is not required to be configured on any interface. */
strncpy(linebuf, "169.254.0.1 232.0.0.0/8\n", sizeof(linebuf));
s = linebuf;
parse_rp_address(s);
if (error_flag)
logit(LOG_ERR, 0, "%s:%u - Syntax error", config_file, lineno);
cand_rp_adv_message.message_size = cand_rp_adv_message.insert_data_ptr - cand_rp_adv_message.buffer;
if (cand_rp_flag != FALSE) {
/* Prepare the RP info */
my_cand_rp_holdtime = 2.5 * my_cand_rp_adv_period;
/* TODO: HARDCODING! */
data_ptr = cand_rp_adv_message.buffer + 1;
PUT_BYTE(my_cand_rp_priority, data_ptr);
PUT_HOSTSHORT(my_cand_rp_holdtime, data_ptr);
PUT_EUADDR(my_cand_rp_address, data_ptr);
}
/* If no IGMP querier timeout was set, calculate from query interval */
if (!igmp_querier_timeout)
igmp_querier_timeout = QUERIER_TIMEOUT(igmp_query_interval);
IF_DEBUG(DEBUG_IGMP) {
logit(LOG_INFO, 0, "IGMP query interval : %u sec", igmp_query_interval);
logit(LOG_INFO, 0, "IGMP querier timeout : %u sec", igmp_querier_timeout);
}
}
void RUN_7920_NET(int UNIT)
{
static int flag_reader_open=0;
static int RDFILE;
static int RE;
static unsigned long CAW;
static char BUFER[80];
static unsigned long ar;
static int i;
static char CHAR;
/****************************************************************
команда чтения буфера
1 байт ИНДИКАТОР ВНИМАНИЯ
7D клавиша ввод
F1 клавиша F1
..
F9 клавиша F9
7A клавиша F10
7B F11
7C F12
6C PD1
6E PD2
6B PD3
6D CLEAR
2 байта АДРЕС КУРСОРА
1 байт НАЧАЛО ПОЛЯ
1 байт СИМВОЛ АТРИБУТ
ТЕКСТ
.....
*****************************************************************
чтение модифицированного
1 байт ИНДИКАТОР ВНИМАНИЯ
2 байта АДРЕС КУРСОРА
1 байт УАБ
1 байт адрес атрибута
АЛФАВИТНО ЦИФРОВЫЕ ДАННЫЕ (НУЛИ ПОДАВЛЯЮТСЯ)
*****************************************************************
запись и стирание запись
****************************************************************/
switch(CSW_COD[UNIT])
{
case 0x01:
/* ЗАПИСЬ */
RUN_7920_WR_NET(CSW_ADRESS[UNIT],CSW_COUNT[UNIT],UNIT);
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
//tt(UNIT);
break;
case 0x05: /* СТИРАНИЕ_ЗАПИСЬ*/
RUN_7920_CLWR_NET(CSW_ADRESS[UNIT],CSW_COUNT[UNIT],UNIT);
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
//tt(UNIT);
break;
case 0x02: /* ЧИТАТЬ БУФЕР */
RUN_7920_RD_NET(CSW_ADRESS[UNIT],CSW_COUNT[UNIT],UNIT);
IO_STATUS[UNIT][1]=U4|U5;
//tt(UNIT);
break;
case 0x06: /* ЧИТАТЬ МОДИФИЦИРУЕМОЕ */
RUN_7920_RDMD_NET(CSW_ADRESS[UNIT],CSW_COUNT[UNIT],UNIT);
IO_STATUS[UNIT][1]=U4|U5;
//tt(UNIT);
break;
case 0x07: /* КОПИРОВАТЬ */
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
tt(UNIT);
break;
case 0x1f: /* СТЕРЕТЬ ВСЕ НЕЗАЩИЩЕННОЕ */
RUN_7920_CLNZ_NET(CSW_ADRESS[UNIT],CSW_COUNT[UNIT],UNIT);
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
tt(UNIT);
break;
case 0x0b:
//putchar(7);
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
//tt(UNIT);
break;
case 0x03: /* X X */
IO_STATUS[UNIT][1]=U4|U5;
tt(UNIT);
break;
case 0x04: /* УТОЧНИТЬ СОСТОЯНИЕ */
for(i=0,ar=CSW_ADRESS[UNIT];i<1;i++,ar++)
{
PUT_BYTE(ar,IO_STATUS[UNIT][2]);
}
IO_STATUS[UNIT][2]=0;
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
tt(UNIT);
break;
default:
CSW_COUNT[UNIT]=0;
IO_STATUS[UNIT][1]=U4|U5;
tt(UNIT);
break;
}
}
