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; }