static int
is_runlog_version_0(struct rldb_file_cnts *cs)
{
unsigned char buf[RUN_HEADER_SIZE + 16];
int r, n;
time_t v1, v2, v3, v4;
memset(buf, 0, sizeof(buf));
if (sf_lseek(cs->run_fd, 0, SEEK_SET, "run") == (off_t) -1) return -1;
if ((r = sf_read(cs->run_fd, buf, RUN_HEADER_SIZE, "run")) < 0) return -1;
if (r != RUN_HEADER_SIZE) return 0;
if (buf[r - 1] != '\n') {
//fprintf(stderr, "record improperly terminated\n");
return 0;
}
for (r = 0; r < RUN_HEADER_SIZE - 1; r++) {
if (buf[r] < ' ' || buf[r] >= 127) {
//fprintf(stderr, "invalid character at pos %d: %d", r, buf[r]);
return 0;
}
}
r = sscanf(buf, " %ld %ld %ld %ld %n", &v1, &v2, &v3, &v4, &n);
if (r != 4 || buf[n]) {
//fprintf(stderr, "cannot parse header <%s>\n", buf);
return 0;
}
return 1;
}
int main(int argc, char **argv){
int sockfd = 0;
struct sockaddr_in servaddr;
if(argc != 3) {
err_quit("Usage: a.out <IPAddress>>");
}
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
err_sys("Socket eroror");
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(atoi(argv[2]));
// Convert dotted IP Address to network byte order.
if(inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {
err_quit("inet_pton error for %s", argv[1]);
}
if(connect(sockfd, (SA *)&servaddr, sizeof(servaddr)) < 0) {
err_sys("Connect error");
}
sf_read(sockfd);
sf_write(sockfd);
}
/*! SPI FLASH test !*/
void sf_test(void)
{
uint8_t datas[6502];
int kd;
int flag;
int i;
kb_init();
sp_init();
sp_puts("SPI FLASH Test\r\n");
sf_init();
for(i = 0; i < 6502; i++) datas[i] = i;
for(;;)
{
kb_scan();
kd = kb_get(KB_DOWN);
if(kd & KEY_0)
{
sp_puts("SPI FLASH write datas ... ");
sf_write(0x8051, datas, 6502);
sp_puts("OK\r\n");
}
if(kd & KEY_1)
{
for(i = 0; i < 6502; i++) datas[i] = 0;
sp_puts("SPI FLASH read datas ... ");
sf_read(0x8051, datas, 6502);
sp_puts("OK\r\n");
sp_puts("SPI FLASH verify datas ... ");
flag = 0;
for(i = 0; i < 6502; i++)
{
if(datas[i] != i)
{
flag = 1;
break;
}
}
if(flag == 0) sp_puts("SUCCESS\r\n");
else sp_puts("FAILED\r\n");
}
}
}
int sys_read(void)
{
int fd, len;
char *p;
int s;
fd = argint(0);
argstr(1, &p);
len = argint(2);
if(fd == 0){ // get data from stdin
return stdin_read(p, len);
} else {
return sf_read(fd, p, len);
}
}
static int
run_read_record_v0(
struct rldb_file_cnts *cs,
char *buf,
int size)
{
int rsz;
int i;
if ((rsz = sf_read(cs->run_fd, buf, size, "run")) < 0) return -1;
if (rsz != size) ERR_R("short read: %d", rsz);
for (i = 0; i < size - 1; i++) {
if (buf[i] >= 0 && buf[i] < ' ') break;
}
if (i < size - 1) ERR_R("bad characters in record");
if (buf[size - 1] != '\n') ERR_R("record improperly terminated");
return 0;
}
static int
is_runlog_version_1(struct rldb_file_cnts *cs)
{
struct run_header_v1 header_v1;
struct stat stbuf;
int r;
memset(&header_v1, 0, sizeof(header_v1));
if (sf_lseek(cs->run_fd, 0, SEEK_SET, "run") == (off_t) -1) return -1;
if ((r = sf_read(cs->run_fd, &header_v1, sizeof(header_v1), "run")) < 0)
return -1;
if (r != sizeof(header_v1)) return 0;
if (header_v1.version != 1) return 0;
if (fstat(cs->run_fd, &stbuf) < 0) return -1;
if (stbuf.st_size < sizeof(header_v1)) return 0;
stbuf.st_size -= sizeof(header_v1);
if (stbuf.st_size % sizeof(struct run_entry_v1) != 0) return 0;
return 1;
}
/* pass_on()
* Is the work loop of the logger. Selects on the pipe to the to_erl
* program erlang. If input arrives from to_erl it is passed on to
* erlang.
*/
static void pass_on(pid_t childpid)
{
int len;
fd_set readfds;
fd_set writefds;
fd_set* writefds_ptr;
struct timeval timeout;
time_t last_activity;
char buf[BUFSIZ];
char log_alive_buffer[ALIVE_BUFFSIZ+1];
int lognum;
int rfd, wfd=0, lfd=0;
int maxfd;
int ready;
int got_some = 0; /* from to_erl */
/* Open the to_erl pipe for reading.
* We can't open the writing side because nobody is reading and
* we'd either hang or get an error.
*/
if ((rfd = sf_open(fifo2, O_RDONLY|DONT_BLOCK_PLEASE, 0)) < 0) {
ERRNO_ERR1(LOG_ERR,"Could not open FIFO '%s' for reading.", fifo2);
exit(1);
}
#ifdef DEBUG
status("run_erl: %s opened for reading\n", fifo2);
#endif
/* Open the log file */
lognum = find_next_log_num();
lfd = open_log(lognum, O_RDWR|O_APPEND|O_CREAT|O_SYNC);
/* Enter the work loop */
while (1) {
int exit_status;
maxfd = MAX(rfd, mfd);
maxfd = MAX(wfd, maxfd);
FD_ZERO(&readfds);
FD_SET(rfd, &readfds);
FD_SET(mfd, &readfds);
FD_ZERO(&writefds);
if (outbuf_size() == 0) {
writefds_ptr = NULL;
} else {
FD_SET(wfd, &writefds);
writefds_ptr = &writefds;
}
time(&last_activity);
timeout.tv_sec = log_alive_minutes*60; /* don't assume old BSD bug */
timeout.tv_usec = 0;
ready = select(maxfd + 1, &readfds, writefds_ptr, NULL, &timeout);
if (ready < 0) {
if (errno == EINTR) {
if (waitpid(childpid, &exit_status, WNOHANG) == childpid) {
/*
* The Erlang emulator has terminated. Give us some more
* time to write out any pending data before we terminate too.
*/
alarm(5);
}
FD_ZERO(&readfds);
FD_ZERO(&writefds);
} else {
/* Some error occured */
ERRNO_ERR0(LOG_ERR,"Error in select.");
exit(1);
}
} else {
time_t now;
if (waitpid(childpid, &exit_status, WNOHANG) == childpid) {
alarm(5);
FD_ZERO(&readfds);
FD_ZERO(&writefds);
}
/* Check how long time we've been inactive */
time(&now);
if(!ready || now - last_activity > log_activity_minutes*60) {
/* Either a time out: 15 minutes without action, */
/* or something is coming in right now, but it's a long time */
/* since last time, so let's write a time stamp this message */
struct tm *tmptr;
if (log_alive_in_gmt) {
tmptr = gmtime(&now);
} else {
tmptr = localtime(&now);
}
if (!strftime(log_alive_buffer, ALIVE_BUFFSIZ, log_alive_format,
tmptr)) {
strn_cpy(log_alive_buffer, sizeof(log_alive_buffer),
"(could not format time in 256 positions "
"with current format string.)");
}
log_alive_buffer[ALIVE_BUFFSIZ] = '\0';
sn_printf(buf, sizeof(buf), "\n===== %s%s\n",
ready?"":"ALIVE ", log_alive_buffer);
write_to_log(&lfd, &lognum, buf, strlen(buf));
}
}
/*
* Write any pending output first.
*/
if (FD_ISSET(wfd, &writefds)) {
int written;
char* buf = outbuf_first();
len = outbuf_size();
written = sf_write(wfd, buf, len);
if (written < 0 && errno == EAGAIN) {
/*
* Nothing was written - this is really strange because
* select() told us we could write. Ignore.
*/
} else if (written < 0) {
/*
* A write error. Assume that to_erl has terminated.
*/
clear_outbuf();
sf_close(wfd);
wfd = 0;
} else {
/* Delete the written part (or all) from the buffer. */
outbuf_delete(written);
}
}
/*
* Read master pty and write to FIFO.
*/
if (FD_ISSET(mfd, &readfds)) {
#ifdef DEBUG
status("Pty master read; ");
#endif
if ((len = sf_read(mfd, buf, BUFSIZ)) <= 0) {
sf_close(rfd);
if(wfd) sf_close(wfd);
sf_close(mfd);
unlink(fifo1);
unlink(fifo2);
if (len < 0) {
if(errno == EIO)
ERROR0(LOG_ERR,"Erlang closed the connection.");
else
ERRNO_ERR0(LOG_ERR,"Error in reading from terminal");
exit(1);
}
exit(0);
}
write_to_log(&lfd, &lognum, buf, len);
/*
* Save in the output queue.
*/
if (wfd) {
outbuf_append(buf, len);
}
}
/*
* Read from FIFO, write to master pty
*/
if (FD_ISSET(rfd, &readfds)) {
#ifdef DEBUG
status("FIFO read; ");
#endif
if ((len = sf_read(rfd, buf, BUFSIZ)) < 0) {
sf_close(rfd);
if(wfd) sf_close(wfd);
sf_close(mfd);
unlink(fifo1);
unlink(fifo2);
ERRNO_ERR0(LOG_ERR,"Error in reading from FIFO.");
exit(1);
}
if(!len) {
/* to_erl closed its end of the pipe */
sf_close(rfd);
rfd = sf_open(fifo2, O_RDONLY|DONT_BLOCK_PLEASE, 0);
if (rfd < 0) {
ERRNO_ERR1(LOG_ERR,"Could not open FIFO '%s' for reading.", fifo2);
exit(1);
}
got_some = 0; /* reset for next session */
}
else {
if(!wfd) {
/* Try to open the write pipe to to_erl. Now that we got some data
* from to_erl, to_erl should already be reading this pipe - open
* should succeed. But in case of error, we just ignore it.
*/
if ((wfd = sf_open(fifo1, O_WRONLY|DONT_BLOCK_PLEASE, 0)) < 0) {
status("Client expected on FIFO %s, but can't open (len=%d)\n",
fifo1, len);
sf_close(rfd);
rfd = sf_open(fifo2, O_RDONLY|DONT_BLOCK_PLEASE, 0);
if (rfd < 0) {
ERRNO_ERR1(LOG_ERR,"Could not open FIFO '%s' for reading.", fifo2);
exit(1);
}
wfd = 0;
}
else {
#ifdef DEBUG
status("run_erl: %s opened for writing\n", fifo1);
#endif
}
}
if (!got_some && wfd && buf[0] == '\014') {
char wbuf[30];
int wlen = sn_printf(wbuf,sizeof(wbuf),"[run_erl v%u-%u]\n",
RUN_ERL_HI_VER, RUN_ERL_LO_VER);
outbuf_append(wbuf,wlen);
}
got_some = 1;
/* Write the message */
#ifdef DEBUG
status("Pty master write; ");
#endif
len = extract_ctrl_seq(buf, len);
if(len==1 && buf[0] == '\003') {
kill(childpid,SIGINT);
}
else if (len>0 && write_all(mfd, buf, len) != len) {
ERRNO_ERR0(LOG_ERR,"Error in writing to terminal.");
sf_close(rfd);
if(wfd) sf_close(wfd);
sf_close(mfd);
exit(1);
}
}
#ifdef DEBUG
status("OK\n");
#endif
}
}
} /* pass_on() */
void sf_write(int sockfd) {
char buff[MAXLINE + 1];
snprintf(buff, sizeof(buff), "HELO attu.ict.ad.dit.ie\r\n");
Write(sockfd, buff, strlen(buff));
sf_read(sockfd);
}