int main(int argc, char *argv[])
{
int i;
setbuf(stdout, NULL);
for(i = 1; i < argc; i++)
do_cmd(argv[i]);
exit(EXIT_SUCCESS);
}
static int
vxlan_exists(int sock)
{
struct ifvxlancfg cfg;
bzero(&cfg, sizeof(cfg));
return (do_cmd(sock, VXLAN_CMD_GET_CONFIG, &cfg, sizeof(cfg), 0) != -1);
}
static void
vxlan_status(int s)
{
struct ifvxlancfg cfg;
char src[NI_MAXHOST], dst[NI_MAXHOST];
char srcport[NI_MAXSERV], dstport[NI_MAXSERV];
struct sockaddr *lsa, *rsa;
int vni, mc, ipv6;
bzero(&cfg, sizeof(cfg));
if (do_cmd(s, VXLAN_CMD_GET_CONFIG, &cfg, sizeof(cfg), 0) < 0)
return;
vni = cfg.vxlc_vni;
lsa = &cfg.vxlc_local_sa.sa;
rsa = &cfg.vxlc_remote_sa.sa;
ipv6 = rsa->sa_family == AF_INET6;
/* Just report nothing if the network identity isn't set yet. */
if (vni >= VXLAN_VNI_MAX)
return;
if (getnameinfo(lsa, lsa->sa_len, src, sizeof(src),
srcport, sizeof(srcport), NI_NUMERICHOST | NI_NUMERICSERV) != 0)
src[0] = srcport[0] = '\0';
if (getnameinfo(rsa, rsa->sa_len, dst, sizeof(dst),
dstport, sizeof(dstport), NI_NUMERICHOST | NI_NUMERICSERV) != 0)
dst[0] = dstport[0] = '\0';
if (!ipv6) {
struct sockaddr_in *sin = (struct sockaddr_in *)rsa;
mc = IN_MULTICAST(ntohl(sin->sin_addr.s_addr));
} else {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)rsa;
mc = IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr);
}
printf("\tvxlan vni %d", vni);
printf(" local %s%s%s:%s", ipv6 ? "[" : "", src, ipv6 ? "]" : "",
srcport);
printf(" %s %s%s%s:%s", mc ? "group" : "remote", ipv6 ? "[" : "",
dst, ipv6 ? "]" : "", dstport);
if (verbose) {
printf("\n\t\tconfig: ");
printf("%slearning portrange %d-%d ttl %d",
cfg.vxlc_learn ? "" : "no", cfg.vxlc_port_min,
cfg.vxlc_port_max, cfg.vxlc_ttl);
printf("\n\t\tftable: ");
printf("cnt %d max %d timeout %d",
cfg.vxlc_ftable_cnt, cfg.vxlc_ftable_max,
cfg.vxlc_ftable_timeout);
}
putchar('\n');
}
static void
do_bridgeflag(int sock, const char *ifs, int flag, int set)
{
struct ifbreq req;
strlcpy(req.ifbr_ifsname, ifs, sizeof(req.ifbr_ifsname));
if (do_cmd(sock, BRDGGIFFLGS, &req, sizeof(req), 0) < 0)
err(1, "unable to get bridge flags");
if (set)
req.ifbr_ifsflags |= flag;
else
req.ifbr_ifsflags &= ~flag;
if (do_cmd(sock, BRDGSIFFLGS, &req, sizeof(req), 1) < 0)
err(1, "unable to set bridge flags");
}
static void handle_satn(ESPState *s)
{
uint8_t buf[32];
int len;
len = get_cmd(s, buf);
if (len)
do_cmd(s, buf);
}
static void stop_wpa_client( void )
{
if ( ps_exist(WPA_PID) ) {
kill_pidfile(WPA_PID, 15);
unlink(WPA_PID);
} else {
do_cmd(IFCONFIG, WLAN_PORT, "0.0.0.0", "down", NULL);
}
}
int main(void)
{
double omega = (2.0*M_PI*SIN_FREQ*SAMP_TIME)/1.0E9;
RTIME until;
RT_TASK *task;
lsampl_t data[NCHAN*2];
long k, sinewave, retval = 0;
signal(SIGKILL, endme);
signal(SIGTERM, endme);
start_rt_timer(0);
task = rt_task_init_schmod(nam2num("MYTASK"), 1, 0, 0, SCHED_FIFO, 0xF);
printf("COMEDI CMD TEST BEGINS: SAMPLING FREQ: %d, RUN TIME: %d.\n", SAMP_FREQ, RUN_TIME);
if (init_board()) {;
printf("Board initialization failed.\n");
return 1;
}
do_cmd();
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
until = rt_get_cpu_time_ns() + (long long)RUN_TIME*1000000000;
for (k = 0; k < SAMP_FREQ*RUN_TIME && !end; k++) {
sinewave = (long)(maxdata/4*sin(k*omega));
data[0] = (lsampl_t)( sinewave + maxdata/2);
data[1] = (lsampl_t)(- sinewave + maxdata/2);
while (rt_comedi_command_data_write(dev, subdev, NCHAN, data) != NCHAN) {
rt_sleep(nano2count(SAMP_TIME/2));
}
if (k == TRIGSAMP) {
rt_comedi_trigger(dev, subdev);
}
}
while (until > rt_get_cpu_time_ns()) {
rt_sleep(nano2count(100000));
}
comedi_cancel(dev, subdev);
comedi_close(dev);
comedi_data_write(dev, subdev, 0, 0, AREF_GROUND, 2048);
comedi_data_write(dev, subdev, 1, 0, AREF_GROUND, 2048);
printf("COMEDI TEST ENDS.\n");
if (retval < 0) {
printf("rt_comedi_wait_timed overruns: %d\n", abs(retval));
}
stop_rt_timer();
rt_make_soft_real_time();
rt_task_delete(task);
return 0;
}
int
main(int argc, char *argv[])
{
int i;
for (i = 1; i < argc; i++)
do_cmd(argv[i]); /* once for each command-line arg */
exit(0);
}
static SANE_Status
power_down(struct scanner *s)
{
SANE_Status ret = SANE_STATUS_GOOD;
unsigned char cmd[] = {0x21, 0x02, 0x00, 0x0a, 0x00};
unsigned char buf[6];
size_t bytes = sizeof(buf);
int i;
DBG (10, "power_down: start\n");
for(i=0;i<5;i++){
ret = do_cmd(
s, 0,
cmd, sizeof(cmd),
NULL, 0,
buf, &bytes
);
if(ret != SANE_STATUS_GOOD){
break;
}
}
#if 0
unsigned char cmd[] = {0x35, 0x01, 0x00, 0xff};
unsigned char buf[5];
size_t bytes = sizeof(buf);
DBG (10, "power_down: start\n");
ret = do_cmd(
s, 0,
cmd, sizeof(cmd),
NULL, 0,
buf, &bytes
);
#endif
DBG (10, "power_down: finish %d\n",ret);
return ret;
}
int main(void)
{
lb_init(&lb);
event_init();
motor_init();
uart_init(); // init USART
enc_init();
i2c_init();
adc_init();
kalman_init();
sei(); // enable interrupts
// Wait a second at startup
_delay_ms(1000);
// send initial string
printf_P(PSTR("Hello world!\n"));
imu_init();
for (;/*ever*/;)
{
// ADCSRA |= (1<<ADSC); // Set start conversion bit and wait for conversion to finish
// while(ADCSRA&(1<<ADSC));
// OCR1AL = ADCH; // Set ADC reading to timer 0 compare
if(event_pending())
{
event_action();
}
else // No pending operation, do low priority tasks
{
// dequeue receive buffer if any bytes waiting
while (uart_avail())
{
char c = uart_getc();
if (lb_append(&lb, c) == LB_BUFFER_FULL)
{
lb_init(&lb); // Clear line
printf_P(PSTR("\nMax line length exceeded\n"));
}
// Process command if line buffer is ready ...
if (lb_line_ready(&lb))
{
strcpy(cmd_string,lb_gets(&lb));
do_cmd(cmd_string);
lb_init(&lb);
}
}
}
// Process command if line buffer is terminated by a line feed or carriage return
}
return 0;
}
static void
setbridge_flushall(const char *val, int d, int s, const struct afswtch *afp)
{
struct ifbreq req;
memset(&req, 0, sizeof(req));
req.ifbr_ifsflags = IFBF_FLUSHALL;
if (do_cmd(s, BRDGFLUSH, &req, sizeof(req), 1) < 0)
err(1, "BRDGFLUSH");
}
int
main(int argc,char **argv)
{
int i;
for(i=1;i<argc;i++){
do_cmd(argv[i]);
}
exit(0);
}
int main (int argc, char *argv[])
{
int i;
setbuf (stdout, NULL);
for (i = 1; i < argc; i++) {
do_cmd (argv[i]); /* once for each command-line arg */
}
exit (0);
}
static int myping()
{
char cmd[100];
filterstdout(pingfilter);
strcpy(cmd,"ping -c 3 10.0.0.3");
do_cmd(cmd);
filterstdout(0);
printf("%d %d %d%%\n",transmitted,received,loss);
return 0;
}
static void fcrtest(int argc,char *argv[])
{
int i;
char buf[100];
printf("test spi");
sprintf(buf,"spi_read_w25x_id");
do_cmd(buf);
sprintf(buf,"spi_read_w25x_id");
do_cmd(buf);
printf("test i2c");
sprintf(buf,"i2cs 0");
do_cmd(buf);
for(i=0;i<5;i++)
{
delay(1000*1000);
sprintf(buf,"d1 0 10");
do_cmd(buf);
}
}
static void
unsetbridge_span(const char *val, int d, int s, const struct afswtch *afp)
{
struct ifbreq req;
memset(&req, 0, sizeof(req));
strlcpy(req.ifbr_ifsname, val, sizeof(req.ifbr_ifsname));
if (do_cmd(s, BRDGDELS, &req, sizeof(req), 1) < 0)
err(1, "BRDGDELS %s", val);
}
static void
bridge_status(int s)
{
struct ifbropreq ifbp;
struct ifbrparam param;
u_int16_t pri;
u_int8_t ht, fd, ma, hc, pro;
u_int8_t lladdr[ETHER_ADDR_LEN];
u_int16_t bprio;
u_int32_t csize, ctime;
if (do_cmd(s, BRDGGCACHE, ¶m, sizeof(param), 0) < 0)
return;
csize = param.ifbrp_csize;
if (do_cmd(s, BRDGGTO, ¶m, sizeof(param), 0) < 0)
return;
ctime = param.ifbrp_ctime;
if (do_cmd(s, BRDGPARAM, &ifbp, sizeof(ifbp), 0) < 0)
return;
pri = ifbp.ifbop_priority;
pro = ifbp.ifbop_protocol;
ht = ifbp.ifbop_hellotime;
fd = ifbp.ifbop_fwddelay;
hc = ifbp.ifbop_holdcount;
ma = ifbp.ifbop_maxage;
PV2ID(ifbp.ifbop_bridgeid, bprio, lladdr);
printf("\tid %s priority %u hellotime %u fwddelay %u\n",
ether_ntoa((struct ether_addr *)lladdr), pri, ht, fd);
printf("\tmaxage %u holdcnt %u proto %s maxaddr %u timeout %u\n",
ma, hc, stpproto[pro], csize, ctime);
PV2ID(ifbp.ifbop_designated_root, bprio, lladdr);
printf("\troot id %s priority %d ifcost %u port %u\n",
ether_ntoa((struct ether_addr *)lladdr), bprio,
ifbp.ifbop_root_path_cost, ifbp.ifbop_root_port & 0xfff);
bridge_interfaces(s, "\tmember: ");
return;
}
static int esp_do_dma(ESPState *s)
{
int len, len2;
int to_device;
to_device = (s->ti_size < 0);
len = s->dma_left;
if (s->do_cmd) {
s->dma_memory_read(s->dma_opaque, &s->cmdbuf[s->cmdlen], len);
s->ti_size = 0;
s->cmdlen = 0;
s->do_cmd = 0;
do_cmd(s, s->cmdbuf);
return 1;
}
if (s->async_len == 0) {
/* Defer until data is available. */
return 1;
}
if (len > s->async_len) {
len = s->async_len;
}
len2 = len;
if (to_device) {
len = s->dma_memory_read(s->dma_opaque, s->async_buf, len2);
} else {
len = s->dma_memory_write(s->dma_opaque, s->async_buf, len2);
}
if (len < 0)
len = len2;
s->dma_left -= len;
s->async_buf += len;
s->async_len -= len;
if (to_device)
s->ti_size += len;
else
s->ti_size -= len;
if (s->async_len == 0) {
scsiesp_req_continue(s->current_req);
/* If there is still data to be read from the device then
complete the DMA operation immediately. Otherwise defer
until the scsi layer has completed. */
if (to_device || s->dma_left != 0 || s->ti_size == 0) {
return 1;
}
}
if (len2 > len && s->dma_left > 0)
return 0;
/* Partially filled a scsi buffer. Complete immediately. */
esp_dma_done(s);
return 1;
}
int main(int argc, char *argv[])
{
int i;
setbuf(stdout, NULL);
for(i = 1; i < argc; i++)
{
do_cmd(argv[i]);
}
exit(0);
}
int main(int argc, char *argv[])
{
int i;
//void setbuf(FILE *stream, char *buf);
setbuf(stdout, NULL);
for(i = 1; i < argc; i++){
do_cmd(argv[i]);
}
exit(0);
}
int main(int argc, char *argv[])
{
int i = 0;
setbuf(stdout, NULL); //why set unbuffered ?
for (i = 1; i < argc; i++)
{
do_cmd(argv[i]);
}
exit(0);
}
static void
setvxlan_flush(const char *val, int d, int s, const struct afswtch *afp)
{
struct ifvxlancmd cmd;
bzero(&cmd, sizeof(cmd));
if (d != 0)
cmd.vxlcmd_flags |= VXLAN_CMD_FLAG_FLUSH_ALL;
if (do_cmd(s, VXLAN_CMD_FLUSH, &cmd, sizeof(cmd), 1) < 0)
err(1, "VXLAN_CMD_FLUSH");
}
static void esp_do_dma(ESPState *s)
{
uint32_t len;
int to_device;
to_device = (s->ti_size < 0);
len = s->dma_left;
if (s->do_cmd) {
DPRINTF("command len %d + %d\n", s->cmdlen, len);
s->dma_memory_read(s->dma_opaque, &s->cmdbuf[s->cmdlen], len);
s->ti_size = 0;
s->cmdlen = 0;
s->do_cmd = 0;
do_cmd(s, s->cmdbuf);
return;
}
if (s->async_len == 0) {
/* Defer until data is available. */
return;
}
if (len > s->async_len) {
len = s->async_len;
}
if (to_device) {
s->dma_memory_read(s->dma_opaque, s->async_buf, len);
} else {
s->dma_memory_write(s->dma_opaque, s->async_buf, len);
}
s->dma_left -= len;
s->async_buf += len;
s->async_len -= len;
if (to_device)
s->ti_size += len;
else
s->ti_size -= len;
if (s->async_len == 0) {
if (to_device) {
// ti_size is negative
s->current_dev->info->write_data(s->current_dev, 0);
} else {
s->current_dev->info->read_data(s->current_dev, 0);
/* If there is still data to be read from the device then
complete the DMA operation immediately. Otherwise defer
until the scsi layer has completed. */
if (s->dma_left == 0 && s->ti_size > 0) {
esp_dma_done(s);
}
}
} else {
/* Partially filled a scsi buffer. Complete immediately. */
esp_dma_done(s);
}
}
int boot_run_from_menu(Menu_Item* pItem)
{
char cmd[1025];
//#define MENU_DEBUG
#ifdef MENU_DEBUG
int stat;
#endif
if (pItem == NULL)
{
return -1;
}
if(pItem->args[0] != '\0')
{
#ifdef NOTEBOOK
sprintf(cmd, "g -S %s", pItem->args);
#else
sprintf(cmd,"g %s", pItem->args);
#endif
#ifdef MENU_DEBUG
printf("%s\n",cmd);
stat=do_cmd(cmd);
printf("go command return %d\n",stat);
if(stat)
#else
printf("Boot with parameters: %s\n", pItem->args);
if(do_cmd(cmd))
#endif
return -1;
}
else
{
printf("No arguments pass to kernel in current menu item.\n");
return -1;
}
return 0;
}
int SD_ReadSector(uint32_t sector, void *buffer)
{
uint32_t params[3], result;
params[0] = (uint32_t)buffer;
params[1] = SECTOR_SIZE;
params[2] = sector;
result = do_cmd(SD_READ_CMD | ((uint32_t)params << 8));
if (result != 0) {
DPRINTF("SD_READ_CMD failed: %d\n", result);
return -1;
}
return 0;
}
static void handle_satn(ESPState *s)
{
uint8_t buf[32];
int len;
if (s->dma && !s->dma_enabled) {
s->dma_cb = handle_satn;
return;
}
len = get_cmd(s, buf);
if (len)
do_cmd(s, buf);
}
void
tolocal(int argc, char **argv)
{
char *bp, *host, *src, *suser;
arglist alist;
int i;
memset(&alist, '\0', sizeof(alist));
alist.list = NULL;
for (i = 0; i < argc - 1; i++) {
if (!(src = colon(argv[i]))) { /* Local to local. */
freeargs(&alist);
addargs(&alist, "%s", _PATH_CP);
if (iamrecursive)
addargs(&alist, "-r");
if (pflag)
addargs(&alist, "-p");
addargs(&alist, "--");
addargs(&alist, "%s", argv[i]);
addargs(&alist, "%s", argv[argc-1]);
if (do_local_cmd(&alist))
++errs;
continue;
}
*src++ = 0;
if (*src == 0)
src = ".";
if ((host = strrchr(argv[i], '@')) == NULL) {
host = argv[i];
suser = NULL;
} else {
*host++ = 0;
suser = argv[i];
if (*suser == '\0')
suser = pwd->pw_name;
}
host = cleanhostname(host);
xasprintf(&bp, "%s -f %s%s",
cmd, *src == '-' ? "-- " : "", src);
if (do_cmd(host, suser, bp, &remin, &remout) < 0) {
free(bp);
++errs;
continue;
}
free(bp);
sink(1, argv + argc - 1);
(void) close(remin);
remin = remout = -1;
}
}
void recv_process(int sock)
{
struct sockaddr_in addr;
static char buff[BUFFER_SIZE];
int len = sizeof(addr);
int recv_len;
do
{
memset(buff, 0, BUFFER_SIZE);
recv_len = recvfrom(sock, buff, BUFFER_SIZE, 0, (struct sockaddr *)&addr, &len);
// printf("recv return !\n");
if(recv_len > 0)
{
buff[recv_len] = '\0';
struct recv_pak * p = (struct recv_pak *)buff;
if(recv_len > 100)
{
int i=0;
for(i=0;cmd[i];++i)
{
if(strncmp(p->cmd, cmd[i], strlen(cmd[i])) == 0)
{
syslog(LOG_INFO,"%s loop\n",cmd[i]);
break;
}
}
addr.sin_port = htons(atoi(p->callback_port));
syslog(LOG_INFO,"Recv from %s %d length:%d:%s--%s\n", inet_ntoa(addr.sin_addr),ntohs(addr.sin_port),recv_len,p->cmd,p->callback_port);
if(cmd[i])
{
do_cmd(p->cmd,sock,(struct sockaddr *)&addr);
// puts(result_p);
// sendto(sock, result_p, strlen(result_p), 0, (struct sockaddr *)&addr, sizeof(addr));
}
else
{
syslog(LOG_ERR,"Unsupported Command!\n");
}
}
//if server send a command the pak length will more than 100,else the pak is heartbeat pak--'Pong'!
else
{
update_status_file();
syslog(LOG_INFO,"Recv from %s %d length:%d:%s\n", inet_ntoa(addr.sin_addr),ntohs(addr.sin_port),recv_len,p->cmd);
}
}
}while(recv_len>0);
perror("sock has closed");
close(sock);
}
static void
setbridge_timeout(const char *arg, int d, int s, const struct afswtch *afp)
{
struct ifbrparam param;
u_long val;
if (get_val(arg, &val) < 0 || (val & ~0xffffffff) != 0)
errx(1, "invalid value: %s", arg);
param.ifbrp_ctime = val & 0xffffffff;
if (do_cmd(s, BRDGSTO, ¶m, sizeof(param), 1) < 0)
err(1, "BRDGSTO %s", arg);
}
void
main()
{
char buf[128];
buf[0] = '0';
printf("\nsboot: MVME147 bootstrap program\n");
while (1) {
printf(">>> ");
gets(buf);
do_cmd(buf);
}
/* not reached */
}
