byte huge *getdump (long *size,void (* func)(double))
/***********
* Describe : принять дамп памяти прибора в память ЭВМ
* Params : word *size - размер принятых данных (в байтах), меньше чем
* : размер выделенной памяти, так как он выровнен
* : на границу 1024 байта
* : PFV func - функция для отображения считывания, ей
* : передаем процент считанной информации
* Return : byte huge* - указатель на буфер, куда записаны данные
* Call : input,waitstart,setaddr,getKbyte,bioscom
***********/
{ /* i-текущий адрес */
unsigned long volume,i_long;
uint i=0,Imax=1024; /* Imax-макс. адрес */
byte empty,bufer[1024]; /* */
int err=0,rpt=0; /* */
byte huge *ppm=NULL,huge *cur=NULL; /* указатель на буфер */
// считываем базовый адрес порта
base_addr = *((unsigned far *)((unsigned far *)0x00400000L+connect_port));
if (base_addr==0) // СОМ1 в 40:00 СОМ2 в 42:00
{printf("\nCOM-%d is absent!",connect_port);
return 0;
}
// bioscom (0,SETTINGS,connect_port); /* инициализируем COM */
outportb (base_addr+3,0x83); // 8byt 1stop N
outportb (base_addr,12); // скорость обмена 115200/12=9600
outportb (base_addr+1,0);
outportb (base_addr+3,0x03); // конец установки скорости
empty = inportb (base_addr+4);
outportb (base_addr+4,0); // Запрет прерывания от порта
for (i_long=0L;i_long<Imax;i_long+=512L,cur=(byte huge *)cur+1024,i=(uint)i_long)
{
if (func!=NULL) /* */
func ((double)((double)i_long/(double)Imax)); /* рисуем прогресс */
sleep (1);
do /* */
{ /* */
setaddr(i); /* посылаем адрес начала */
err=waitstart(); /* ждем строки "STRT" */
if (err==0) /* если не ошибка то */
err=input(&empty); /* принимаем пустой байт */
if (err==0) /* если не ошибка и если */
if (i==0) /* первый Кбайт то */
err=getKbyte(bufer); /* принимаем в буфер */
else /* иначе */
{
err=getKbyte(cur); /* принимаем в назначение */
if (*bufer!=*ppm)
{
printf ("\n There is problem, count = %u",(uint)i);
abort ();
}
}
if (err != 0) /* если ошибка */
{ /* */
rpt++; /* число повторов */
if (rpt>REPEATS) /* */
{ /* */
if (ppm!=NULL) /* освобождаем память */
farfree ((byte far *)ppm); /* если выделена */
printf("\nCommunication ERROR %X",(unsigned)err);
return (NULL); /* возвращаем ошибка */
} /* */
} /* */
} /* */
while (err!=0); /* */
/* */
if (i==0) /* если первый Кбайт */
{ /* то */
Imax = (uint)bufer[8]+bufer[9]*256; /* вычисляем Imax */
*size = (long)Imax*2L; /* размер в байтах */
volume = (unsigned long)(*size)+1024; /* выделяем 128 Кбайт */
ppm=(byte huge*) farcalloc(volume,sizeof(byte));/* выделяем память */
cur = ppm;
if (ppm==NULL)
{
printf ("\n Imax = %u, size = %ld",Imax,(*size));
printf ("\n No enough memory! Function GETDUMP. ");
printf ("\n %ul bytes free. ",farcoreleft());
abort ();
}
reportmemory(getmaxx(),getmaxy()-textheight("X")-5);
memcpy ((byte *)ppm,bufer,1024); /* копируем из буфера */
} /* */
} /* */
if (func!=NULL) /* */
func ((double)1.0); /* рисуем прогресс */
return ((byte huge*) ppm); /* */
} /* */
int setopt(int argc, char** argv, struct options * opt) {
int c;
short ver = 4;
opt->sin_src_mask.sin_addr.s_addr = htonl(0xff000000);
opt->wait = 10;
opt->file = NULL;
opt->pps = 1;
while ((c = getopt(argc, argv, "v:s:d:m:w:f:p:")) != -1)
switch (c) {
case 's' :
setaddr(optarg,&(opt->sin_src));
break;
case 'm' :
setaddr(optarg,&(opt->sin_src_mask));
break;
case 'd' :
setaddr(optarg,&(opt->sin_dst));
break;
case 'v' :
ver = atoi(optarg);
break;
case 'w' :
opt->wait = atoi(optarg);
break;
case 'f':
opt->file = malloc(sizeof(char)*strlen(optarg)+1);
memcpy(opt->file,optarg,strlen(optarg)+1);
break;
case 'p':
opt->pps = atoi(optarg);
}
}
//========================================================
//显示汉字
//========================================================
void putstring(char a,char b,char *n) //汉字
{
idata char i,*p;
printu(n);
while(*n!=0)
{
p=q+12*(*n-32);
setpage(a+1);
setaddr(b);
for(i=0;i<6;i++)
{x(*p);
p++;}
setpage(a);
setaddr(b);
for(i=6;i<12;i++)
{x(*p);
p++;}
b = b+7;
if((b + 7) > 127)
{
b = 0;
if(a < 2 ) break;
else a -= 2;
}
n++;
}
}
static void
proc_reg_resp(struct msg_ac_reg_resp_t *msg, int len, int proto)
{
sys_debug("Receive ac reg response packet\n");
if(len < sizeof(*msg)) {
sys_err("Receive error msg ac reg response packet\n");
return;
}
/* md5sum3 = packet + random1 + password */
if(chap_msg_cmp_md5((void *)msg, sizeof(*msg),
get_random(msg->header.mac))) {
sys_err("ac reg response packet chap error\n");
return;
}
strncpy(sysstat.acuuid, msg->header.acuuid, UUID_LEN);
memcpy(sysstat.dmac, msg->header.mac, ETH_ALEN);
if(msg->acaddr.sin_addr.s_addr)
sysstat.server = msg->acaddr;
if(msg->apaddr.sin_addr.s_addr)
setaddr((void *)&msg->apaddr);
pr_ipv4(&msg->acaddr);
/* if have connect to remote ac, close it.
* and connect to local ac */
if(sysstat.sock >= 0)
close(sysstat.sock);
ac_reconnect();
sysstat.isreg = 1;
}
sockinetaddr::sockinetaddr(const VXIchar *moduleName, VXIlogInterface *pVXILog,
VXIunsigned diagTagBase, const char* hn,
const char* sn, const char* pn)
: sockAddr (moduleName, pVXILog, diagTagBase)
{
setaddr(hn);
setport(sn, pn);
}
/*
* Complete configuration for phase 1 interface using RTMP information.
*/
static int rtmp_config( struct rtmp_head *rh, struct interface *iface)
{
extern int stabletimer;
int cc;
/*
* If we're configuring a phase 2 interface, don't complete
* configuration with RTMP.
*/
if ( iface->i_flags & IFACE_PHASE2 ) {
LOG(log_info, logtype_atalkd, "rtmp_config ignoring data" );
return 0;
}
/*
* Check our seed information, and reconfigure.
*/
if ( rh->rh_net != iface->i_addr.sat_addr.s_net ) {
if (( iface->i_flags & IFACE_SEED ) &&
rh->rh_net != iface->i_caddr.sat_addr.s_net) {
LOG(log_error, logtype_atalkd, "rtmp_config net mismatch %u != %u",
ntohs( rh->rh_net ),
ntohs( iface->i_addr.sat_addr.s_net ));
return 1;
}
iface->i_addr.sat_addr.s_net = rh->rh_net;
/*
* It is possible that we will corrupt our route database
* by just forcing this change. XXX
*/
iface->i_rt->rt_firstnet = iface->i_rt->rt_lastnet = rh->rh_net;
setaddr( iface, IFACE_PHASE1, iface->i_addr.sat_addr.s_net,
iface->i_addr.sat_addr.s_node, rh->rh_net, rh->rh_net );
stabletimer = UNSTABLE;
}
/* add addr to loopback route */
if ((cc = looproute( iface, RTMP_ADD )) < 0 )
return -1;
if (cc) {
LOG(log_error, logtype_atalkd, "rtmp_config: can't route %u.%u to loopback: %s",
ntohs( iface->i_addr.sat_addr.s_net ),
iface->i_addr.sat_addr.s_node,
strerror(errno) );
}
LOG(log_info, logtype_atalkd, "rtmp_config configured %s", iface->i_name );
iface->i_flags |= IFACE_CONFIG;
if ( iface == ciface ) {
ciface = ciface->i_next;
bootaddr( ciface );
}
return 0;
}
sockinetaddr::sockinetaddr(const VXIchar *moduleName, VXIlogInterface *pVXILog,
VXIunsigned diagTagBase, const char* host_name,
int port_no)
: sockAddr (moduleName, pVXILog, diagTagBase)
// port_no is in host byte order
{
setaddr(host_name);
sin_port = htons(port_no);
}
bool UdpEndPoint::open(const SockAddr& sockaddr,
int backlog,
auto_ptr<base::net::HandlerCreatorStrategyBase> handler_stg,
auto_ptr<base::net::FilterCreatorStrategyBase> sp_filter_stg,
ErrorCode* ec)
{
int fd = ::socket(sockaddr.getType(), SOCK_DGRAM, 0);
if (-1 == fd)
RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false);
ScopedFD spfd(fd);
if (sockaddr.getType() == AF_UNIX)
{
const sockaddr_un& un = sockaddr.as<sockaddr_un>();
unlink(un.sun_path); // in case it already exists
}
SocketHelper::setNonBlocking(fd, ec);
SocketHelper::setReusable(fd, ec);
if (-1 == ::bind(fd, sockaddr.raw(), sockaddr.size()))
RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false);
boost::shared_ptr<Handler> newhandler;
if (0 == sockaddr.getPort())
{
struct sockaddr_in addr;
socklen_t len = sizeof(addr);
if (-1 == getsockname(fd, (struct sockaddr *)&addr, &len))
RETURN_NET_ERROR_WITH(ec, errno, "", false);
SockAddr setaddr(ntohs(addr.sin_port));
handler_stg->create(fd, setaddr, sp_reactor_impl_, newhandler);
}
else
handler_stg->create(fd, sockaddr, sp_reactor_impl_, newhandler);
if (!newhandler)
RETURN_NET_ERROR_WITH(ec, errno, "create handler failed" << sockaddr, false);
newhandler->setConnected();
if (sp_filter_stg.get())
newhandler->setFilter(auto_ptr<Filter>(sp_filter_stg->create(false, newhandler.get())));
HandlerScoper<Handler> handler_scoper(newhandler);
spfd.release();
if (!sp_reactor_impl_->registerHandler(newhandler, MASK_READ, ec))
return false;
handler_scoper.release();
setUdpHandler(newhandler);
return true;
}
static void
omap_clock_init(void)
{
// sets pixel clock to 72MHz
// sys_clk = 26.0 Mhz
// DPLL4 = sys_clk * 432 / 13 = 864
// DSS1_ALWON_FCLK = 864 / 6 = 144
// Pixel clock (DISPC_DIVISOR) = 144 / 2 = 72Mhz
// and also VENC clock = 864 / 16 = 54MHz
// The clock multiplier/divider cannot be changed
// without affecting other system clocks - do don't.
// pll4 clock multiplier/divider
setaddr(CM_CLKSEL2_PLL, (432 << 8) | 12);
// tv clock divider, dss1 alwon fclk divider
setaddr(CM_CLKSEL_DSS, (16 << 8) | 6);
// core/peripheral PLL to 1MHz
setaddr(CM_CLKEN_PLL, 0x00370037);
}
//========================================================
//清屏子函数 fill ROM with 0 or 1
//========================================================
void ClearScreen( int a)
{
idata int z1,z2;
if(a!=0) a=0xff;
for(z1=0;z1<8;z1++)
{
setpage(z1);
setaddr(0);
for(z2=0;z2<128;z2++)
{
LCD_IO_DATA =a;
senddata();
}
}
}
void
adddynsym(Sym *s)
{
Sym *d, *str;
int t;
char *name;
vlong off;
if(s->dynid >= 0)
return;
if(s->dynimpname == nil)
diag("adddynsym: no dynamic name for %s", s->name);
if(iself) {
s->dynid = nelfsym++;
d = lookup(".dynsym", 0);
/* name */
name = s->dynimpname;
if(name == nil)
name = s->name;
adduint32(d, addstring(lookup(".dynstr", 0), name));
/* value */
if(s->type == SDYNIMPORT)
adduint32(d, 0);
else
addaddr(d, s);
/* size */
adduint32(d, 0);
/* type */
t = STB_GLOBAL << 4;
if(s->dynexport && (s->type&SMASK) == STEXT)
t |= STT_FUNC;
else
t |= STT_OBJECT;
adduint8(d, t);
adduint8(d, 0);
/* shndx */
if(!s->dynexport && s->dynimpname != nil)
adduint16(d, SHN_UNDEF);
else {
switch(s->type) {
default:
case STEXT:
t = 11;
break;
case SRODATA:
t = 12;
break;
case SDATA:
t = 13;
break;
case SBSS:
t = 14;
break;
}
adduint16(d, t);
}
} else if(HEADTYPE == Hdarwin) {
// Mach-O symbol nlist32
d = lookup(".dynsym", 0);
name = s->dynimpname;
if(name == nil)
name = s->name;
if(d->size == 0 && ndynexp > 0) { // pre-allocate for dynexps
symgrow(d, ndynexp*12);
}
if(s->dynid <= -100) { // pre-allocated, see cmd/ld/go.c:^sortdynexp()
s->dynid = -s->dynid-100;
off = s->dynid*12;
} else {
off = d->size;
s->dynid = off/12;
}
// darwin still puts _ prefixes on all C symbols
str = lookup(".dynstr", 0);
setuint32(d, off, str->size);
off += 4;
adduint8(str, '_');
addstring(str, name);
if(s->type == SDYNIMPORT) {
setuint8(d, off, 0x01); // type - N_EXT - external symbol
off++;
setuint8(d, off, 0); // section
off++;
} else {
setuint8(d, off, 0x0f);
off++;
switch(s->type) {
default:
case STEXT:
setuint8(d, off, 1);
break;
case SDATA:
setuint8(d, off, 2);
break;
case SBSS:
setuint8(d, off, 4);
break;
}
off++;
}
setuint16(d, off, 0); // desc
off += 2;
if(s->type == SDYNIMPORT)
setuint32(d, off, 0); // value
else
setaddr(d, off, s);
off += 4;
} else if(HEADTYPE != Hwindows) {
diag("adddynsym: unsupported binary format");
}
}
static inline void cpuParse(unsigned char opc) {
int cmd = opcodes[opc];
int addr = modes[opc];
int c;
switch (cmd) {
case adc:
wval=(unsigned short)a+getaddr(addr)+((p&FLAG_C)?1:0);
setflags(FLAG_C, wval&0x100);
a=(unsigned char)wval;
setflags(FLAG_Z, !a);
setflags(FLAG_N, a&0x80);
setflags(FLAG_V, (!!(p&FLAG_C)) ^ (!!(p&FLAG_N)));
break;
case and_:
bval=getaddr(addr);
a&=bval;
setflags(FLAG_Z, !a);
setflags(FLAG_N, a&0x80);
break;
case asl:
wval=getaddr(addr);
wval<<=1;
setaddr(addr,(unsigned char)wval);
setflags(FLAG_Z,!wval);
setflags(FLAG_N,wval&0x80);
setflags(FLAG_C,wval&0x100);
break;
case bcc:
branch(!(p&FLAG_C));
break;
case bcs:
branch(p&FLAG_C);
break;
case bne:
branch(!(p&FLAG_Z));
break;
case beq:
branch(p&FLAG_Z);
break;
case bpl:
branch(!(p&FLAG_N));
break;
case bmi:
branch(p&FLAG_N);
break;
case bvc:
branch(!(p&FLAG_V));
break;
case bvs:
branch(p&FLAG_V);
break;
case bit:
bval=getaddr(addr);
setflags(FLAG_Z,!(a&bval));
setflags(FLAG_N,bval&0x80);
setflags(FLAG_V,bval&0x40);
break;
case brk:
pc=0; /* Just quit the emulation */
break;
case clc:
setflags(FLAG_C,0);
break;
case cld:
setflags(FLAG_D,0);
break;
case cli:
setflags(FLAG_I,0);
break;
case clv:
setflags(FLAG_V,0);
break;
case cmp:
bval=getaddr(addr);
wval=(unsigned short)a-bval;
setflags(FLAG_Z,!wval);
setflags(FLAG_N,wval&0x80);
setflags(FLAG_C,a>=bval);
break;
case cpx:
bval=getaddr(addr);
wval=(unsigned short)x-bval;
setflags(FLAG_Z,!wval);
setflags(FLAG_N,wval&0x80);
setflags(FLAG_C,x>=bval);
break;
case cpy:
bval=getaddr(addr);
wval=(unsigned short)y-bval;
setflags(FLAG_Z,!wval);
setflags(FLAG_N,wval&0x80);
setflags(FLAG_C,y>=bval);
break;
case dec:
bval=getaddr(addr);
bval--;
setaddr(addr,bval);
setflags(FLAG_Z,!bval);
setflags(FLAG_N,bval&0x80);
break;
case dex:
x--;
setflags(FLAG_Z,!x);
setflags(FLAG_N,x&0x80);
break;
case dey:
y--;
setflags(FLAG_Z,!y);
setflags(FLAG_N,y&0x80);
break;
case eor:
bval=getaddr(addr);
a^=bval;
setflags(FLAG_Z,!a);
setflags(FLAG_N,a&0x80);
break;
case inc:
bval=getaddr(addr);
bval++;
setaddr(addr,bval);
setflags(FLAG_Z,!bval);
setflags(FLAG_N,bval&0x80);
break;
case inx:
x++;
setflags(FLAG_Z,!x);
setflags(FLAG_N,x&0x80);
break;
case iny:
y++;
setflags(FLAG_Z,!y);
setflags(FLAG_N,y&0x80);
break;
case jmp:
wval=getmem(pc++);
wval|=256*getmem(pc++);
switch (addr) {
case abs:
pc=wval;
break;
case ind:
pc=getmem(wval);
pc|=256*getmem(wval+1);
break;
}
break;
case jsr:
push((pc+1)>>8);
push((pc+1));
wval=getmem(pc++);
wval|=256*getmem(pc++);
pc=wval;
break;
case lda:
a=getaddr(addr);
setflags(FLAG_Z,!a);
setflags(FLAG_N,a&0x80);
break;
case ldx:
x=getaddr(addr);
setflags(FLAG_Z,!x);
setflags(FLAG_N,x&0x80);
break;
case ldy:
y=getaddr(addr);
setflags(FLAG_Z,!y);
setflags(FLAG_N,y&0x80);
break;
case lsr:
bval=getaddr(addr); wval=(unsigned char)bval;
wval>>=1;
setaddr(addr,(unsigned char)wval);
setflags(FLAG_Z,!wval);
setflags(FLAG_N,wval&0x80);
setflags(FLAG_C,bval&1);
break;
case nop:
break;
case ora:
bval=getaddr(addr);
a|=bval;
setflags(FLAG_Z,!a);
setflags(FLAG_N,a&0x80);
break;
case pha:
push(a);
break;
case php:
push(p);
break;
case pla:
a=pop();
setflags(FLAG_Z,!a);
setflags(FLAG_N,a&0x80);
break;
case plp:
p=pop();
break;
case rol:
bval=getaddr(addr);
c=!!(p&FLAG_C);
setflags(FLAG_C,bval&0x80);
bval<<=1;
bval|=c;
setaddr(addr,bval);
setflags(FLAG_N,bval&0x80);
setflags(FLAG_Z,!bval);
break;
case ror:
bval=getaddr(addr);
c=!!(p&FLAG_C);
setflags(FLAG_C,bval&1);
bval>>=1;
bval|=128*c;
setaddr(addr,bval);
setflags(FLAG_N,bval&0x80);
setflags(FLAG_Z,!bval);
break;
case rti:
/* Treat RTI like RTS */
case rts:
wval=pop();
wval|=pop()<<8;
pc=wval+1;
break;
case sbc:
bval=getaddr(addr)^0xff;
wval=(unsigned short)a+bval+((p&FLAG_C)?1:0);
setflags(FLAG_C, wval&0x100);
a=(unsigned char)wval;
setflags(FLAG_Z, !a);
setflags(FLAG_N, a>127);
setflags(FLAG_V, (!!(p&FLAG_C)) ^ (!!(p&FLAG_N)));
break;
case sec:
setflags(FLAG_C,1);
break;
case sed:
setflags(FLAG_D,1);
break;
case sei:
setflags(FLAG_I,1);
break;
case sta:
putaddr(addr,a);
break;
case stx:
putaddr(addr,x);
break;
case sty:
putaddr(addr,y);
break;
case tax:
x=a;
setflags(FLAG_Z, !x);
setflags(FLAG_N, x&0x80);
break;
case tay:
y=a;
setflags(FLAG_Z, !y);
setflags(FLAG_N, y&0x80);
break;
case tsx:
x=s;
setflags(FLAG_Z, !x);
setflags(FLAG_N, x&0x80);
break;
case txa:
a=x;
setflags(FLAG_Z, !a);
setflags(FLAG_N, a&0x80);
break;
case txs:
s=x;
break;
case tya:
a=y;
setflags(FLAG_Z, !a);
setflags(FLAG_N, a&0x80);
break;
case slo:
bval = getaddr(addr);
setflags(FLAG_C, bval >> 7);
bval <<= 1;
setaddr(addr, bval);
a |= bval;
setflags(FLAG_Z, !a);
setflags(FLAG_N, a&0x80);
break;
case axs:
x = (x & a) - getaddr(addr);
setflags(FLAG_Z, a == 0);
setflags(FLAG_N, a > 127);
break;
case lax:
a = x = getaddr(addr);
setflags(FLAG_Z, a == 0);
setflags(FLAG_N, a & 0x80);
break;
default:
break;
}
}
int main(int argc, char** argv)
{
unsigned char addr;
unsigned char data[5];
char device_name[20];
int opt;
int bus = 0;
int n = 0;
char mode = 'b';
int num;
char format = 'x';
uint8_t array_byte[128];
const char *fmt_byte;
const char *fmt_short;
const char *fmt_long;
char *base_name;
while ((opt = getopt(argc, argv, "d:f:m:r:wh")) != -1) {
switch (opt) {
case 'f':
format = optarg[0];
break;
case 'd':
bus = atoi(optarg);
break;
case 'm':
mode = optarg[0];
break;
case 'r':
n = atoi(optarg);
break;
case 'h':
default:
base_name = basename(argv[0]);
fprintf(stderr, "Usage: %s [-d I2CBUS] [[-r N] [-m MODE] [-f FORMAT]] ADDRESS [VAL1 VAL2 ...]\n"
" %s 0x20 0x00\n"
" %s 0x20 -r 1 -m s -f d\n"
" I2CBUS is an integer\n"
" N is an integer the number of element to be read\n"
" MODE is b|s|l - byte|short|long\n"
" FORMAT is x|d|u - hex|signed|unsigned\n",
base_name, base_name, base_name);
return -1;
}
}
//fprintf(stderr, "bus=%d; mode=%c; n=%d; optind=%d\n", bus, mode, n, optind);
if ( format == 'x' ) {
fmt_byte = "0x%02X";
fmt_short = "0x%04X";
fmt_long = "0x%08lX";
}
else if ( format == 'd' ) {
fmt_byte = "%d";
fmt_short = "%d";
fmt_long = "%ld";
}
else {
fmt_byte = "%u";
fmt_short = "%u";
fmt_long = "%lu";
}
if ( mode == 's' ) {
n *= 2;
}
else if ( mode == 'l' ) {
n *= 4;
}
else if ( mode == 'c' ) {
}
if ( optind >= argc ) {
fprintf(stderr, "Expected ADDRESS\n");
return -1;
}
addr = _atoi(argv[optind++]);
//fprintf(stderr, "addr=0x%02X\n", addr);
num = 0;
for (;optind < argc; optind++) {
if ( num >= 128 )
break;
array_byte[num++] = (uint8_t)_atoi(argv[optind]);
}
//fprintf(stderr, "num=%d\n", num);
sprintf(device_name, "/dev/i2c-%u", bus);
fd = open(device_name,O_RDWR);
if ( fd < 0 ) {
fprintf(stderr, "Couldn't open %s!\n", device_name);
return -2;
}
setaddr(addr);
if ( num ) {
if ( write(fd, array_byte, num) < 0 ) {
fprintf(stderr, "Unable to write!\n");
close(fd);
return -2;
}
}
if ( n ) {
int i;
n = n < 128 ? n : 128;
read(fd, array_byte, n);
if ( mode == 'c' ) {
for ( i = 0; i < n; i++ ) {
char c;
c = array_byte[i];
printf("%c", iscntrl(c) ? '.' : c);
}
}
else if ( mode == 's' ) {
union {
uint16_t u16;
uint8_t arr[2];
} w;
for ( i = 0; i < n; i += 2 ) {
w.arr[0] = array_byte[i];
w.arr[1] = array_byte[i + 1];
if ( i != 0 )
printf(" ");
if ( format == 'd' )
printf(fmt_short, (int16_t)le16toh(w.u16));
else
printf(fmt_short, (uint16_t)le16toh(w.u16));
}
}
else if ( mode == 'l' ) {
union {
uint32_t u32;
uint8_t arr[4];
} w;
for ( i = 0; i < n; i += 4 ) {
w.arr[0] = array_byte[i];
w.arr[1] = array_byte[i + 1];
w.arr[2] = array_byte[i + 2];
w.arr[3] = array_byte[i + 3];
if ( i != 0 )
printf(" ");
if ( format == 'd' )
printf(fmt_long, (int32_t)le32toh(w.u32));
else
printf(fmt_long, (uint32_t)le32toh(w.u32));
}
}
else {
for ( i = 0; i < n; i++ ) {
if ( i != 0 )
printf(" ");
if ( format == 'd' )
printf(fmt_byte, (int8_t)array_byte[i]);
else
printf(fmt_byte, array_byte[i]);
}
}
printf("\n");
}
close(fd);
return 0;
}
bool handler__set(globals_t * vars, char **argv, unsigned argc)
{
unsigned block, seconds = 1;
char *delay = NULL;
char *end;
bool cont = false;
struct setting {
char *matchids;
char *value;
unsigned seconds;
} *settings = NULL;
assert(argc != 0);
assert(argv != NULL);
assert(vars != NULL);
if (argc < 2) {
show_error("expected an argument, type `help set` for details.\n");
return false;
}
/* supporting `set` for bytearray will cause annoying syntax problems... */
if ((vars->options.scan_data_type == BYTEARRAY)
||(vars->options.scan_data_type == STRING))
{
show_error("`set` is not supported for bytearray or string, use `write` instead.\n");
return false;
}
/* check if there are any matches */
if (vars->num_matches == 0) {
show_error("no matches are known.\n");
return false;
}
/* --- parse arguments into settings structs --- */
settings = calloca(argc - 1, sizeof(struct setting));
/* parse every block into a settings struct */
for (block = 0; block < argc - 1; block++) {
/* first seperate the block into matches and value, which are separated by '=' */
if ((settings[block].value = strchr(argv[block + 1], '=')) == NULL) {
/* no '=' found, whole string must be the value */
settings[block].value = argv[block + 1];
} else {
/* there is a '=', value+1 points to value string. */
/* use strndupa() to copy the matchids into a new buffer */
settings[block].matchids =
strndupa(argv[block + 1],
(size_t) (settings[block].value++ - argv[block + 1]));
}
/* value points to the value string, possibly with a delay suffix */
/* matchids points to the match-ids (possibly multiple) or NULL */
/* now check for a delay suffix (meaning continuous mode), eg 0xff/10 */
if ((delay = strchr(settings[block].value, '/')) != NULL) {
char *end = NULL;
/* parse delay count */
settings[block].seconds = strtoul(delay + 1, &end, 10);
if (*(delay + 1) == '\0') {
/* empty delay count, eg: 12=32/ */
show_error("you specified an empty delay count, `%s`, see `help set`.\n", settings[block].value);
return false;
} else if (*end != '\0') {
/* parse failed before end, probably trailing garbage, eg 34=9/16foo */
show_error("trailing garbage after delay count, `%s`.\n", settings[block].value);
return false;
} else if (settings[block].seconds == 0) {
/* 10=24/0 disables continous mode */
show_info("you specified a zero delay, disabling continuous mode.\n");
} else {
/* valid delay count seen and understood */
show_info("setting %s every %u seconds until interrupted...\n", settings[block].matchids ? settings[block]. matchids : "all", settings[block].seconds);
/* continuous mode on */
cont = true;
}
/* remove any delay suffix from the value */
settings[block].value =
strndupa(settings[block].value,
(size_t) (delay - settings[block].value));
} /* if (strchr('/')) */
} /* for(block...) */
/* --- setup a longjmp to handle interrupt --- */
if (INTERRUPTABLE()) {
/* control returns here when interrupted */
// settings is allocated with alloca, do not free it
// free(settings);
detach(vars->target);
ENDINTERRUPTABLE();
return true;
}
/* --- execute the parsed setting structs --- */
while (true) {
uservalue_t userval;
/* for every settings struct */
for (block = 0; block < argc - 1; block++) {
/* check if this block has anything to do this iteration */
if (seconds != 1) {
/* not the first iteration (all blocks get executed first iteration) */
/* if settings.seconds is zero, then this block is only executed once */
/* if seconds % settings.seconds is zero, then this block must be executed */
if (settings[block].seconds == 0
|| (seconds % settings[block].seconds) != 0)
continue;
}
/* convert value */
if (!parse_uservalue_number(settings[block].value, &userval)) {
show_error("bad number `%s` provided\n", settings[block].value);
goto fail;
}
/* check if specific match(s) were specified */
if (settings[block].matchids != NULL) {
char *id, *lmatches = NULL;
unsigned num = 0;
/* create local copy of the matchids for strtok() to modify */
lmatches = strdupa(settings[block].matchids);
/* now seperate each match, spearated by commas */
while ((id = strtok(lmatches, ",")) != NULL) {
match_location loc;
/* set to NULL for strtok() */
lmatches = NULL;
/* parse this id */
num = strtoul(id, &end, 0x00);
/* check that succeeded */
if (*id == '\0' || *end != '\0') {
show_error("could not parse match id `%s`\n", id);
goto fail;
}
/* check this is a valid match-id */
loc = nth_match(vars->matches, num);
if (loc.swath) {
value_t v;
value_t old;
void *address = remote_address_of_nth_element(loc.swath, loc.index /* ,MATCHES_AND_VALUES */);
/* copy val onto v */
/* XXX: valcmp? make sure the sizes match */
old = data_to_val(loc.swath, loc.index /* ,MATCHES_AND_VALUES */);
zero_value(&v);
v.flags = old.flags = loc.swath->data[loc.index].match_info;
uservalue2value(&v, &userval);
show_info("setting *%p to %#"PRIx64"...\n", address, v.int64_value);
/* set the value specified */
fix_endianness(vars, &v);
if (setaddr(vars->target, address, &v) == false) {
show_error("failed to set a value.\n");
goto fail;
}
} else {
/* match-id > than number of matches */
show_error("found an invalid match-id `%s`\n", id);
goto fail;
}
}
} else {
matches_and_old_values_swath *reading_swath_index = (matches_and_old_values_swath *)vars->matches->swaths;
int reading_iterator = 0;
/* user wants to set all matches */
while (reading_swath_index->first_byte_in_child) {
/* Only actual matches are considered */
if (flags_to_max_width_in_bytes(reading_swath_index->data[reading_iterator].match_info) > 0)
{
void *address = remote_address_of_nth_element(reading_swath_index, reading_iterator /* ,MATCHES_AND_VALUES */);
/* XXX: as above : make sure the sizes match */
value_t old = data_to_val(reading_swath_index, reading_iterator /* ,MATCHES_AND_VALUES */);
value_t v;
zero_value(&v);
v.flags = old.flags = reading_swath_index->data[reading_iterator].match_info;
uservalue2value(&v, &userval);
show_info("setting *%p to %#"PRIx64"...\n", address, v.int64_value);
fix_endianness(vars, &v);
if (setaddr(vars->target, address, &v) == false) {
show_error("failed to set a value.\n");
goto fail;
}
}
/* Go on to the next one... */
++reading_iterator;
if (reading_iterator >= reading_swath_index->number_of_bytes)
{
reading_swath_index = local_address_beyond_last_element(reading_swath_index /* ,MATCHES_AND_VALUES */);
reading_iterator = 0;
}
}
} /* if (matchid != NULL) else ... */
} /* for(block) */
if (cont) {
sleep(1);
} else {
break;
}
seconds++;
} /* while(true) */
ENDINTERRUPTABLE();
return true;
fail:
ENDINTERRUPTABLE();
return false;
}
