FILE *freopen(const char *filename, const char *mode, FILE *stream)
{
int sys_flags;
int flags;
int fd;
if(_set_open_flags(mode, &sys_flags, &flags) || (fd = open(filename, sys_flags)) < 0)
{
return (FILE*)0;
}
#if STDIO_SEM
_kern_sem_acquire(stream->sid, 1);
#endif // STDIO_SEM
_flush(stream);
close(stream->fd);
stream->fd = fd;
stream->rpos = stream->buf_pos = 0;
stream->flags = flags;
#if STDIO_SEM
_kern_sem_release(stream->sid, 1);
#endif // STDIO_SEM
return stream;
}
int nettest1(void)
{
int err;
sockaddr addr;
fd = socket_create(SOCK_PROTO_TCP, 0);
printf("created socket, fd %d\n", fd);
if(fd < 0)
return 0;
memset(&addr, 0, sizeof(addr));
addr.addr.len = 4;
addr.addr.type = ADDR_TYPE_IP;
// addr.port = 19;
// NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(63,203,215,73);
// addr.port = 23;
// NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(192,168,0,3);
addr.port = 6667;
NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(209,131,227,242);
err = socket_connect(fd, &addr);
printf("socket_connect returns %d\n", err);
if(err < 0)
return err;
exit_sem = _kern_sem_create(0, "exit");
_kern_thread_resume_thread(_kern_thread_create_thread("read_thread", &read_thread, NULL));
_kern_thread_resume_thread(_kern_thread_create_thread("write_thread", &write_thread, NULL));
for(;;)
_kern_sem_acquire(exit_sem, 1);
return 0;
}
FILE *__create_FILE_struct(int fd, int flags)
{
FILE *f;
/* Allocate the FILE*/
f = (FILE *)calloc(sizeof(FILE),1);
if(!f)
return (FILE *)0;
/* Allocate the buffer*/
f->buf = (unsigned char *)malloc( BUFSIZ * sizeof(char));
if(!f->buf)
{
free(f);
return (FILE *)0;
}
#if STDIO_SEM
char name[32];
/* Create a semaphore*/
snprintf(name, sizeof(name), "%d :FILE", fd);
f->sid = _kern_sem_create(1, name);
if(f->sid < 0)
{
free(f->buf);
free(f);
return (FILE *)0;
}
#endif // STDIO_SEM
/* Fill in FILE values*/
f->rpos = 0;
f->buf_pos = 0;
f->buf_size = BUFSIZ ;
f->fd = fd;
f->flags = flags;
f->buf_mode = _IOFBF;
/* Setup list*/
f->next = __open_file_stack_top;
/* Put the FILE in the list*/
#if STDIO_SEM
_kern_sem_acquire(__open_file_stack_sem_id, 1);
__open_file_stack_top = f;
_kern_sem_release(__open_file_stack_sem_id, 1);
#else
__open_file_stack_top = f;
#endif // STDIO_SEM
return f;
}
int main(void)
{
int err;
int stage = 0;
err = start_console(&theconsole, &stage);
if(err < 0) {
int console_fd = open("/dev/console", 0);
if(console_fd >= 0) {
char buf[128];
sprintf(buf, "consoled: error %d at stage %d starting console\n", err, stage);
write(console_fd, buf, strlen(buf));
}
return err;
}
// we're a session leader
setsid();
// move our stdin and stdout to the console
dup2(theconsole.tty_slave_fd, 0);
dup2(theconsole.tty_slave_fd, 1);
dup2(theconsole.tty_slave_fd, 2);
for(;;) {
proc_id shell_process;
int retcode;
char *argv[3];
#if 1
argv[0] = "/boot/bin/shell";
argv[1] = "-s";
argv[2] = "/boot/loginscript";
shell_process = start_process("/boot/bin/shell", "shell", argv, 3, &theconsole);
#else
argv[0] = "/boot/bin/vmstat";
shell_process = start_process("/boot/bin/vmstat", "vmstat", argv, 1, &theconsole);
#endif
_kern_proc_wait_on_proc(shell_process, &retcode);
}
_kern_sem_acquire(theconsole.wait_sem, 1);
return 0;
}
static int __delete_FILE_struct(int fd)
{
FILE *fNode, *fPrev;
/* Search for the FILE for the file descriptor */
fPrev = (FILE*)0;
fNode = __open_file_stack_top;
while(fNode != (FILE*)0)
{
if(fNode->fd == fd)
{
break;
}
fPrev = fNode;
fNode = fNode->next;
}
/* If it wasn't found return EOF*/
if(fNode == (FILE*)0)
{
printf("Error: __delete_FILE_struct");
return EOF;
}
#if STDIO_SEM
/* Wait for the lock */
sem_id sid;
sid = fNode->sid;
_kern_sem_acquire(sid, 1);
#endif
/* free the FILE space/semaphore*/
close(fNode->fd);
free(fNode->buf);
//free(fNode);
#if STDIO_SEM
/* Do we need to release before we delete? */
_kern_sem_release(sid, 1);
_kern_sem_delete(sid);
#endif
#if STDIO_SEM
/* Remove it from the list*/
if(fNode == __open_file_stack_top)
{
_kern_sem_acquire(__open_file_stack_sem_id, 1);
__open_file_stack_top = __open_file_stack_top->next;
_kern_sem_release(__open_file_stack_sem_id, 1);
}
else
{
_kern_sem_acquire(__open_file_stack_sem_id, 1);
fPrev->next = fNode->next;
_kern_sem_release(__open_file_stack_sem_id, 1);
}
#else
/* Remove it from the list*/
if(fNode == __open_file_stack_top)
__open_file_stack_top = __open_file_stack_top->next;
else
fPrev->next = fNode->next;
#endif
/* Free the space*/
free(fNode);
return 0;
}
int main(int argc, char **argv)
{
char **spawn_argv;
int spawn_argc;
int i;
proc_id pid;
thread_id tid;
if(argc < 2) {
printf("%s: not enough arguments\n", argv[0]);
return -1;
}
// we're a session leader
setsid();
// build an array of args to pass anything we start up
spawn_argc = argc - 1;
spawn_argv = (char **)malloc(sizeof(char *) * spawn_argc);
if(spawn_argv == NULL)
return -1;
for(i = 0; i < spawn_argc; i++) {
spawn_argv[i] = argv[i + 1];
}
// register for SIGCHLD signals
signal(SIGCHLD, &sigchld_handler);
// debug_fd = open("/dev/console", 0);
debug_fd = -1;
wait_sem = _kern_sem_create(0, "telnetd wait sem");
if(wait_sem < 0)
return -1;
tty_master_fd = open("/dev/tty/master", 0);
if(tty_master_fd < 0)
return -2;
tty_num = ioctl(tty_master_fd, _TTY_IOCTL_GET_TTY_NUM, NULL, 0);
if(tty_num < 0)
return -3;
{
struct tty_flags flags;
ioctl(tty_master_fd, _TTY_IOCTL_GET_TTY_FLAGS, &flags, sizeof(flags));
flags.input_flags |= TTY_FLAG_CRNL;
ioctl(tty_master_fd, _TTY_IOCTL_SET_TTY_FLAGS, &flags, sizeof(flags));
}
{
char temp[128];
sprintf(temp, "/dev/tty/slave/%d", tty_num);
tty_slave_fd = open(temp, 0);
if(tty_slave_fd < 0)
return -4;
}
// move the stdin and stdout out of the way
socket_fd = dup(0); // assume stdin, stdout, and stderr are the same socket
close(0);
close(1);
close(2);
// set the endpoints to the tty slave endpoint
dup2(tty_slave_fd, 0);
dup2(tty_slave_fd, 1);
dup2(tty_slave_fd, 2);
close(tty_slave_fd);
// send some options over to the other side
send_opts();
// now start the app
pid = _kern_proc_create_proc(spawn_argv[0], spawn_argv[0], spawn_argv, spawn_argc, 5, PROC_FLAG_NEW_PGROUP);
if(pid < 0)
return -1;
tid = _kern_thread_create_thread("telnet reader", &telnet_reader, NULL);
_kern_thread_set_priority(tid, 30);
_kern_thread_resume_thread(tid);
tid = _kern_thread_create_thread("telnet writer", &telnet_writer, NULL);
_kern_thread_set_priority(tid, 30);
_kern_thread_resume_thread(tid);
_kern_sem_acquire(wait_sem, 1);
return 0;
}
