update: userprog (tee, tsh, sleep, hex2bin)
This commit is contained in:
+2
-15
@@ -60,7 +60,6 @@ int parse_cmd(char *cmd, char *argv[]) {
|
||||
int handle_pipe(char *argv[]) {
|
||||
int pipe_idx = -1;
|
||||
|
||||
// 1. 첫 번째 파이프 기호(|) 찾기
|
||||
for (int i = 0; argv[i] != NULL; i++) {
|
||||
if (strcmp(argv[i], "|") == 0) {
|
||||
pipe_idx = i;
|
||||
@@ -68,28 +67,23 @@ int handle_pipe(char *argv[]) {
|
||||
}
|
||||
}
|
||||
|
||||
// 파이프가 없으면 0 반환 (호출자가 일반 execvp 실행)
|
||||
if (pipe_idx == -1) return 0;
|
||||
|
||||
// 2. 명령어 쪼개기
|
||||
argv[pipe_idx] = NULL; // 파이프 기호를 NULL로 바꿔서 왼쪽 끊음
|
||||
argv[pipe_idx] = NULL;
|
||||
char **left_cmd = &argv[0];
|
||||
char **right_cmd = &argv[pipe_idx + 1];
|
||||
|
||||
// 오른쪽 명령어가 없으면 에러 (예: "ls |")
|
||||
if (right_cmd[0] == NULL) {
|
||||
printf("gmsh: syntax error near unexpected token `|'\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// 3. 파이프 생성
|
||||
int fds[2];
|
||||
if (pipe(fds) == -1) {
|
||||
perror("pipe");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// 4. 왼쪽 자식 (Writer)
|
||||
pid_t pid1 = fork();
|
||||
if (pid1 == 0) {
|
||||
close(fds[0]);
|
||||
@@ -102,22 +96,16 @@ int handle_pipe(char *argv[]) {
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// 5. 오른쪽 자식 (Reader + Recursion Manager)
|
||||
pid_t pid2 = fork();
|
||||
if (pid2 == 0) {
|
||||
close(fds[1]);
|
||||
dup2(fds[0], STDIN_FILENO); // 입력 연결
|
||||
dup2(fds[0], STDIN_FILENO);
|
||||
close(fds[0]);
|
||||
|
||||
// [핵심] 오른쪽 명령어에 또 파이프가 있는지 확인!
|
||||
// 재귀 호출: 만약 파이프가 또 있다면 handle_pipe가 다시 fork를 뜨고 처리함
|
||||
if (handle_pipe(right_cmd) == 1) {
|
||||
// 재귀 호출 내부에서 자식들을 다 만들고 기다린 후 리턴했음.
|
||||
// 이 중간 관리자 프로세스는 할 일을 다 했으므로 종료.
|
||||
exit(0);
|
||||
}
|
||||
else {
|
||||
// 파이프가 더 이상 없으면 그냥 실행
|
||||
handle_redirection((const char**) right_cmd);
|
||||
execvp(right_cmd[0], right_cmd);
|
||||
perror("execvp right");
|
||||
@@ -125,7 +113,6 @@ int handle_pipe(char *argv[]) {
|
||||
}
|
||||
}
|
||||
|
||||
// 6. 부모 프로세스
|
||||
close(fds[0]);
|
||||
close(fds[1]);
|
||||
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
TARGET = hex2bin
|
||||
SRCS = hex2bin.c
|
||||
CC = gcc
|
||||
CFLAGS = -static -Wall
|
||||
|
||||
OUT_BIN ?= $(TARGET)
|
||||
|
||||
all: $(OUT_BIN)
|
||||
|
||||
$(OUT_BIN): $(SRCS)
|
||||
@echo " [CC] Compiling to $(OUT_BIN)..."
|
||||
$(CC) $(CFLAGS) -o $@ $^
|
||||
|
||||
clean:
|
||||
rm -f $(TARGET)
|
||||
@@ -0,0 +1,13 @@
|
||||
#include <stdio.h>
|
||||
|
||||
// 사용법: echo "41 42 43" | hex2bin
|
||||
int main() {
|
||||
int byte;
|
||||
// 16진수(%x)로 정수를 읽어서
|
||||
while (scanf("%x", &byte) == 1) {
|
||||
// char(바이트) 형태로 stdout에 씀
|
||||
unsigned char c = (unsigned char)byte;
|
||||
fwrite(&c, 1, 1, stdout);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
TARGET = sleep
|
||||
SRCS = sleep.c
|
||||
CC = gcc
|
||||
CFLAGS = -static -Wall
|
||||
|
||||
OUT_BIN ?= $(TARGET)
|
||||
|
||||
all: $(OUT_BIN)
|
||||
|
||||
$(OUT_BIN): $(SRCS)
|
||||
@echo " [CC] Compiling to $(OUT_BIN)..."
|
||||
$(CC) $(CFLAGS) -o $@ $^
|
||||
|
||||
clean:
|
||||
rm -f $(TARGET)
|
||||
@@ -0,0 +1,41 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <signal.h>
|
||||
#include <ctype.h>
|
||||
|
||||
// 숫자인지 확인하는 헬퍼 함수
|
||||
int is_number(const char *str) {
|
||||
while (*str) {
|
||||
if (!isdigit(*str)) return 0;
|
||||
str++;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
if (argc != 2) {
|
||||
fprintf(stderr, "Usage: sleep <seconds>\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (!is_number(argv[1])) {
|
||||
fprintf(stderr, "sleep: invalid time interval '%s'\n", argv[1]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
unsigned int seconds = (unsigned int)atoi(argv[1]);
|
||||
|
||||
// sleep() 시스템 콜 호출
|
||||
// 리눅스 커널에서 프로세스 상태를 TASK_INTERRUPTIBLE로 변경하고 스케줄링에서 뺍니다.
|
||||
// 시그널(Ctrl+C)이 오면 sleep은 즉시 깨어나고 남은 시간을 반환합니다.
|
||||
unsigned int left = sleep(seconds);
|
||||
|
||||
// 만약 시그널에 의해 깨어났다면? (예: SIGINT)
|
||||
// 쉘이 이미 처리했겠지만, 프로그램 입장에서는 남은 시간을 확인할 수 있습니다.
|
||||
if (left > 0) {
|
||||
printf("Sleep interrupted! %u seconds remaining.\n", left);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
TARGET = tee
|
||||
SRCS = tee.c
|
||||
CC = gcc
|
||||
CFLAGS = -static -Wall
|
||||
|
||||
OUT_BIN ?= $(TARGET)
|
||||
|
||||
all: $(OUT_BIN)
|
||||
|
||||
$(OUT_BIN): $(SRCS)
|
||||
@echo " [CC] Compiling to $(OUT_BIN)..."
|
||||
$(CC) $(CFLAGS) -o $@ $^
|
||||
|
||||
clean:
|
||||
rm -f $(TARGET)
|
||||
@@ -0,0 +1,103 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <ctype.h> // isprint
|
||||
|
||||
#define BUF_SIZE 4096
|
||||
|
||||
// Hexdump 헬퍼 함수
|
||||
// offset_base: 전체 스트림에서의 현재 위치 (0x0000, 0x0010 ...)
|
||||
void print_hexdump(const unsigned char *buf, ssize_t len, size_t offset_base) {
|
||||
for (size_t i = 0; i < len; i += 16) {
|
||||
// 1. 오프셋 출력
|
||||
fprintf(stderr, "%08zx: ", offset_base + i);
|
||||
|
||||
// 2. 16진수 출력
|
||||
for (size_t j = 0; j < 16; j++) {
|
||||
if (i + j < len)
|
||||
fprintf(stderr, "%02x ", buf[i + j]);
|
||||
else
|
||||
fprintf(stderr, " "); // 패딩
|
||||
}
|
||||
|
||||
fprintf(stderr, " |");
|
||||
|
||||
// 3. ASCII 출력
|
||||
for (size_t j = 0; j < 16; j++) {
|
||||
if (i + j < len) {
|
||||
unsigned char c = buf[i + j];
|
||||
// 출력 가능한 문자면 출력, 아니면 점(.)
|
||||
fprintf(stderr, "%c", isprint(c) ? c : '.');
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "|\n");
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
int *fds = (int *)malloc(sizeof(int) * argc);
|
||||
int fd_count = 0;
|
||||
|
||||
// 모드 플래그
|
||||
int mode_stderr = 0; // --stderr (Raw 출력)
|
||||
int mode_hexdump = 0; // --hexdump (Hex 출력)
|
||||
|
||||
// 1. 인자 파싱
|
||||
for (int i = 1; i < argc; i++) {
|
||||
if (strcmp(argv[i], "--stderr") == 0) {
|
||||
mode_stderr = 1;
|
||||
continue;
|
||||
}
|
||||
if (strcmp(argv[i], "--hexdump") == 0) {
|
||||
mode_hexdump = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
// 일반 파일 열기
|
||||
int fd = open(argv[i], O_WRONLY | O_CREAT | O_TRUNC, 0644);
|
||||
if (fd < 0) {
|
||||
perror(argv[i]);
|
||||
continue;
|
||||
}
|
||||
fds[fd_count++] = fd;
|
||||
}
|
||||
|
||||
// 2. 데이터 처리 루프
|
||||
unsigned char buf[BUF_SIZE]; // unsigned로 변경
|
||||
ssize_t n;
|
||||
size_t total_bytes = 0; // 전체 스트림 오프셋 추적용
|
||||
|
||||
while ((n = read(STDIN_FILENO, buf, BUF_SIZE)) > 0) {
|
||||
// (A) STDOUT 출력 (필수: 파이프 연결 유지)
|
||||
if (write(STDOUT_FILENO, buf, n) != n) {
|
||||
perror("write stdout");
|
||||
break;
|
||||
}
|
||||
|
||||
// (B) STDERR 처리 (디버깅용)
|
||||
if (mode_hexdump) {
|
||||
// Hexdump 모드면 예쁘게 포맷팅해서 stderr로
|
||||
print_hexdump(buf, n, total_bytes);
|
||||
} else if (mode_stderr) {
|
||||
// 그냥 stderr 모드면 Raw 데이터를 stderr로
|
||||
if (write(STDERR_FILENO, buf, n) != n) { /* ignore */ }
|
||||
}
|
||||
|
||||
// (C) 파일 출력
|
||||
for (int i = 0; i < fd_count; i++) {
|
||||
if (write(fds[i], buf, n) != n) {
|
||||
perror("write file");
|
||||
}
|
||||
}
|
||||
|
||||
total_bytes += n;
|
||||
}
|
||||
|
||||
for (int i = 0; i < fd_count; i++) {
|
||||
close(fds[i]);
|
||||
}
|
||||
free(fds);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
TARGET = tsh
|
||||
SRCS = tsh.c
|
||||
CC = gcc
|
||||
CFLAGS = -static -Wall
|
||||
|
||||
OUT_BIN ?= $(TARGET)
|
||||
|
||||
all: $(OUT_BIN)
|
||||
|
||||
$(OUT_BIN): $(SRCS)
|
||||
@echo " [CC] Compiling to $(OUT_BIN)..."
|
||||
$(CC) $(CFLAGS) -o $@ $^
|
||||
|
||||
clean:
|
||||
rm -f $(TARGET)
|
||||
@@ -0,0 +1,767 @@
|
||||
/*
|
||||
* tsh - A tiny shell program with job control
|
||||
*
|
||||
* Minseong Gwak(곽민성), gmspweber, 20230840
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <signal.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
#include <errno.h>
|
||||
|
||||
/* Misc manifest constants */
|
||||
#define MAXLINE 1024 /* max line size */
|
||||
#define MAXARGS 128 /* max args on a command line */
|
||||
#define MAXJOBS 16 /* max jobs at any point in time */
|
||||
#define MAXJID 1<<16 /* max job ID */
|
||||
|
||||
/* Job states */
|
||||
#define UNDEF 0 /* undefined */
|
||||
#define FG 1 /* running in foreground */
|
||||
#define BG 2 /* running in background */
|
||||
#define ST 3 /* stopped */
|
||||
|
||||
/*
|
||||
* Jobs states: FG (foreground), BG (background), ST (stopped)
|
||||
* Job state transitions and enabling actions:
|
||||
* FG -> ST : ctrl-z
|
||||
* ST -> FG : fg command
|
||||
* ST -> BG : bg command
|
||||
* BG -> FG : fg command
|
||||
* At most 1 job can be in the FG state.
|
||||
*/
|
||||
|
||||
/* Global variables */
|
||||
extern char **environ; /* defined in libc */
|
||||
char prompt[] = "tsh> "; /* command line prompt (DO NOT CHANGE) */
|
||||
int verbose = 0; /* if true, print additional output */
|
||||
int nextjid = 1; /* next job ID to allocate */
|
||||
char sbuf[MAXLINE]; /* for composing sprintf messages */
|
||||
|
||||
struct job_t { /* The job struct */
|
||||
pid_t pid; /* job PID */
|
||||
int jid; /* job ID [1, 2, ...] */
|
||||
int state; /* UNDEF, BG, FG, or ST */
|
||||
char cmdline[MAXLINE]; /* command line */
|
||||
};
|
||||
struct job_t jobs[MAXJOBS]; /* The job list */
|
||||
/* End global variables */
|
||||
|
||||
|
||||
/* Function prototypes */
|
||||
|
||||
/* Here are the functions that you will implement */
|
||||
void eval(char *cmdline);
|
||||
int builtin_cmd(char **argv);
|
||||
void do_bgfg(char **argv);
|
||||
void waitfg(pid_t pid);
|
||||
|
||||
void sigchld_handler(int sig);
|
||||
void sigtstp_handler(int sig);
|
||||
void sigint_handler(int sig);
|
||||
|
||||
/* Here are helper routines that we've provided for you */
|
||||
int parseline(const char *cmdline, char **argv);
|
||||
void sigquit_handler(int sig);
|
||||
|
||||
void clearjob(struct job_t *job);
|
||||
void initjobs(struct job_t *jobs);
|
||||
int maxjid(struct job_t *jobs);
|
||||
int addjob(struct job_t *jobs, pid_t pid, int state, char *cmdline);
|
||||
int deletejob(struct job_t *jobs, pid_t pid);
|
||||
pid_t fgpid(struct job_t *jobs);
|
||||
struct job_t *getjobpid(struct job_t *jobs, pid_t pid);
|
||||
struct job_t *getjobjid(struct job_t *jobs, int jid);
|
||||
int pid2jid(pid_t pid);
|
||||
void listjobs(struct job_t *jobs);
|
||||
|
||||
void usage(void);
|
||||
void unix_error(char *msg);
|
||||
void app_error(char *msg);
|
||||
typedef void handler_t(int);
|
||||
handler_t *Signal(int signum, handler_t *handler);
|
||||
|
||||
/*
|
||||
* main - The shell's main routine
|
||||
*/
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
char c;
|
||||
char cmdline[MAXLINE];
|
||||
int emit_prompt = 1; /* emit prompt (default) */
|
||||
|
||||
/* Redirect stderr to stdout (so that driver will get all output
|
||||
* on the pipe connected to stdout) */
|
||||
dup2(1, 2);
|
||||
|
||||
/* Parse the command line */
|
||||
while ((c = getopt(argc, argv, "hvp")) != EOF) {
|
||||
switch (c) {
|
||||
case 'h': /* print help message */
|
||||
usage();
|
||||
break;
|
||||
case 'v': /* emit additional diagnostic info */
|
||||
verbose = 1;
|
||||
break;
|
||||
case 'p': /* don't print a prompt */
|
||||
emit_prompt = 0; /* handy for automatic testing */
|
||||
break;
|
||||
default:
|
||||
usage();
|
||||
}
|
||||
}
|
||||
|
||||
/* Install the signal handlers */
|
||||
|
||||
/* These are the ones you will need to implement */
|
||||
Signal(SIGINT, sigint_handler); /* ctrl-c */
|
||||
Signal(SIGTSTP, sigtstp_handler); /* ctrl-z */
|
||||
Signal(SIGCHLD, sigchld_handler); /* Terminated or stopped child */
|
||||
|
||||
/* This one provides a clean way to kill the shell */
|
||||
Signal(SIGQUIT, sigquit_handler);
|
||||
|
||||
/* Initialize the job list */
|
||||
initjobs(jobs);
|
||||
|
||||
/* Execute the shell's read/eval loop */
|
||||
while (1) {
|
||||
|
||||
/* Read command line */
|
||||
if (emit_prompt) {
|
||||
printf("%s", prompt);
|
||||
fflush(stdout);
|
||||
}
|
||||
if ((fgets(cmdline, MAXLINE, stdin) == NULL) && ferror(stdin))
|
||||
app_error("fgets error");
|
||||
if (feof(stdin)) { /* End of file (ctrl-d) */
|
||||
fflush(stdout);
|
||||
exit(0);
|
||||
}
|
||||
|
||||
/* Evaluate the command line */
|
||||
eval(cmdline);
|
||||
fflush(stdout);
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
exit(0); /* control never reaches here */
|
||||
}
|
||||
|
||||
/*
|
||||
* eval - Evaluate the command line that the user has just typed in
|
||||
*
|
||||
* If the user has requested a built-in command (quit, jobs, bg or fg)
|
||||
* then execute it immediately. Otherwise, fork a child process and
|
||||
* run the job in the context of the child. If the job is running in
|
||||
* the foreground, wait for it to terminate and then return. Note:
|
||||
* each child process must have a unique process group ID so that our
|
||||
* background children don't receive SIGINT (SIGTSTP) from the kernel
|
||||
* when we type ctrl-c (ctrl-z) at the keyboard.
|
||||
*/
|
||||
void eval(char *cmdline)
|
||||
{
|
||||
char* argv[MAXARGS];
|
||||
char buf[MAXLINE];
|
||||
int bg;
|
||||
pid_t pid;
|
||||
sigset_t mask_all, mask_SIGCHLD, prev;
|
||||
|
||||
strcpy(buf, cmdline);
|
||||
bg = parseline(buf, argv);
|
||||
if(argv[0] == NULL) return;
|
||||
|
||||
sigfillset(&mask_all);
|
||||
sigemptyset(&mask_SIGCHLD); sigaddset(&mask_SIGCHLD, SIGCHLD);
|
||||
|
||||
if(!builtin_cmd(argv))
|
||||
{
|
||||
sigprocmask(SIG_BLOCK, &mask_SIGCHLD, &prev);
|
||||
//Non-builtin command processing
|
||||
if((pid = fork()) == 0)
|
||||
{
|
||||
sigprocmask(SIG_SETMASK, &prev, NULL);
|
||||
setpgrp();
|
||||
|
||||
if(execve(argv[0], argv, environ) < 0)
|
||||
{
|
||||
printf("%s: Command not found\n", argv[0]);
|
||||
exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
sigprocmask(SIG_BLOCK, &mask_all, NULL);
|
||||
if(!bg) addjob(jobs, pid, FG, cmdline);
|
||||
else
|
||||
{
|
||||
addjob(jobs, pid, BG, cmdline);
|
||||
printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
|
||||
}
|
||||
sigprocmask(SIG_SETMASK, &prev, NULL);
|
||||
|
||||
if(!bg) waitfg(pid);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* parseline - Parse the command line and build the argv array.
|
||||
*
|
||||
* Characters enclosed in single quotes are treated as a single
|
||||
* argument. Return true if the user has requested a BG job, false if
|
||||
* the user has requested a FG job.
|
||||
*/
|
||||
int parseline(const char *cmdline, char **argv)
|
||||
{
|
||||
static char array[MAXLINE]; /* holds local copy of command line */
|
||||
char *buf = array; /* ptr that traverses command line */
|
||||
char *delim; /* points to first space delimiter */
|
||||
int argc; /* number of args */
|
||||
int bg; /* background job? */
|
||||
|
||||
strcpy(buf, cmdline);
|
||||
buf[strlen(buf)-1] = ' '; /* replace trailing '\n' with space */
|
||||
while (*buf && (*buf == ' ')) /* ignore leading spaces */
|
||||
buf++;
|
||||
|
||||
/* Build the argv list */
|
||||
argc = 0;
|
||||
if (*buf == '\'') {
|
||||
buf++;
|
||||
delim = strchr(buf, '\'');
|
||||
}
|
||||
else {
|
||||
delim = strchr(buf, ' ');
|
||||
}
|
||||
|
||||
while (delim) {
|
||||
argv[argc++] = buf;
|
||||
*delim = '\0';
|
||||
buf = delim + 1;
|
||||
while (*buf && (*buf == ' ')) /* ignore spaces */
|
||||
buf++;
|
||||
|
||||
if (*buf == '\'') {
|
||||
buf++;
|
||||
delim = strchr(buf, '\'');
|
||||
}
|
||||
else {
|
||||
delim = strchr(buf, ' ');
|
||||
}
|
||||
}
|
||||
argv[argc] = NULL;
|
||||
|
||||
if (argc == 0) /* ignore blank line */
|
||||
return 1;
|
||||
|
||||
/* should the job run in the background? */
|
||||
if ((bg = (*argv[argc-1] == '&')) != 0) {
|
||||
argv[--argc] = NULL;
|
||||
}
|
||||
return bg;
|
||||
}
|
||||
|
||||
/*
|
||||
* builtin_cmd - If the user has typed a built-in command then execute
|
||||
* it immediately.
|
||||
*/
|
||||
int builtin_cmd(char **argv)
|
||||
{
|
||||
if(strcmp(argv[0], "quit") == 0) exit(0);
|
||||
if(strcmp(argv[0], "jobs") == 0)
|
||||
{
|
||||
sigset_t mask_all, prev;
|
||||
sigfillset(&mask_all);
|
||||
sigprocmask(SIG_BLOCK, &mask_all, &prev);
|
||||
|
||||
listjobs(jobs);
|
||||
|
||||
sigprocmask(SIG_SETMASK, &prev, NULL);
|
||||
return 1;
|
||||
}
|
||||
if(strcmp(argv[0], "fg") == 0 || strcmp(argv[0], "bg") == 0)
|
||||
{
|
||||
do_bgfg(argv);
|
||||
return 1;
|
||||
}
|
||||
return 0; /* not a builtin command */
|
||||
}
|
||||
|
||||
/*
|
||||
* do_bgfg - Execute the builtin bg and fg commands
|
||||
*/
|
||||
void do_bgfg(char **argv)
|
||||
{
|
||||
int argc = 0;
|
||||
while(argv[argc] != NULL) argc++;
|
||||
if(argc == 1)
|
||||
{
|
||||
printf("%s command requires PID or %%jobid argument\n", argv[0]);
|
||||
return;
|
||||
}
|
||||
if(argc != 2) return;
|
||||
sigset_t mask_all, prev;
|
||||
sigfillset(&mask_all);
|
||||
sigprocmask(SIG_BLOCK, &mask_all, &prev);
|
||||
|
||||
//find the job of given argument
|
||||
struct job_t* job = NULL; int pid = 0;
|
||||
if(argv[1][0] == '%')
|
||||
{
|
||||
char* end;
|
||||
int jid = strtol(argv[1]+1, &end, 10);
|
||||
|
||||
if(end == argv[1]+1 || *end != '\0' || errno == ERANGE)
|
||||
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
|
||||
else if((job = getjobjid(jobs, jid)) == NULL)
|
||||
printf("%s: No such job\n", argv[1]);
|
||||
}
|
||||
else
|
||||
{
|
||||
char* end;
|
||||
pid_t pid = strtol(argv[1], &end, 10);
|
||||
|
||||
if(end == argv[1] || *end != '\0' || errno == ERANGE)
|
||||
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
|
||||
else if((job = getjobpid(jobs, pid)) == NULL)
|
||||
printf("(%s): No such process\n", argv[1]);
|
||||
}
|
||||
|
||||
if(job)
|
||||
{
|
||||
pid = job->pid;
|
||||
if(strcmp(argv[0], "fg") == 0)
|
||||
{
|
||||
if(job->state == ST)
|
||||
{
|
||||
kill(-job->pid, SIGCONT);
|
||||
job->state = FG;
|
||||
}
|
||||
else if(job->state == BG) job->state = FG;
|
||||
}
|
||||
if(strcmp(argv[0], "bg") == 0)
|
||||
{
|
||||
if(job->state == ST)
|
||||
{
|
||||
kill(-job->pid, SIGCONT);
|
||||
job->state = BG;
|
||||
}
|
||||
else if(job->state == BG);
|
||||
printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
|
||||
}
|
||||
}
|
||||
|
||||
sigprocmask(SIG_SETMASK, &prev, NULL);
|
||||
|
||||
if(pid && strcmp(argv[0], "fg") == 0) waitfg(pid);
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* waitfg - Block until process pid is no longer the foreground process
|
||||
*/
|
||||
void waitfg(pid_t pid)
|
||||
{
|
||||
sigset_t mask_SIGCHLD, prev;
|
||||
sigemptyset(&mask_SIGCHLD);
|
||||
sigaddset(&mask_SIGCHLD, SIGCHLD);
|
||||
|
||||
sigprocmask(SIG_BLOCK, &mask_SIGCHLD, &prev);
|
||||
while(fgpid(jobs) == pid) sigsuspend(&prev);
|
||||
sigprocmask(SIG_SETMASK, &prev, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
/*****************
|
||||
* Signal handlers
|
||||
*****************/
|
||||
|
||||
/*
|
||||
* sigchld_handler - The kernel sends a SIGCHLD to the shell whenever
|
||||
* a child job terminates (becomes a zombie), or stops because it
|
||||
* received a SIGSTOP or SIGTSTP signal. The handler reaps all
|
||||
* available zombie children, but doesn't wait for any other
|
||||
* currently running children to terminate.
|
||||
*/
|
||||
void sigchld_handler(int sig)
|
||||
{
|
||||
int olderrno = errno;
|
||||
sigset_t mask_all, prev;
|
||||
pid_t pid; int status;
|
||||
char msg[100];
|
||||
const char* TER = "terminated ";
|
||||
const char* STP = "stopped ";
|
||||
const char* STR = "by signal ";
|
||||
|
||||
sigfillset(&mask_all);
|
||||
while((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0)
|
||||
{
|
||||
sigprocmask(SIG_BLOCK, &mask_all, &prev);
|
||||
int jid = pid2jid(pid);
|
||||
|
||||
if(WIFEXITED(status)) deletejob(jobs, pid);
|
||||
else
|
||||
{
|
||||
int by = 0, isExited = 0;
|
||||
if(WIFSIGNALED(status))
|
||||
{
|
||||
deletejob(jobs, pid);
|
||||
by = WTERMSIG(status);
|
||||
isExited = 1;
|
||||
}
|
||||
else if(WIFSTOPPED(status))
|
||||
{
|
||||
struct job_t *bg = getjobpid(jobs, pid);
|
||||
bg->state = ST;
|
||||
by = WSTOPSIG(status);
|
||||
isExited = 0;
|
||||
}
|
||||
|
||||
|
||||
int k = 0, j;
|
||||
msg[k++] = 'J'; msg[k++] = 'o'; msg[k++] = 'b'; msg[k++] = ' ';
|
||||
msg[k++] = '[';
|
||||
{
|
||||
int num = jid;
|
||||
int c = 0, cc;
|
||||
if(num == 0) msg[k++] = '0';
|
||||
else
|
||||
{
|
||||
if(num < 0) msg[k++] = '-', num = -num;
|
||||
while(num != 0) msg[k++] = '0'+num%10, num /= 10, c++;
|
||||
cc = c/2;
|
||||
|
||||
while(cc)
|
||||
{
|
||||
char tmp = msg[k-cc];
|
||||
msg[k-cc] = msg[k-c+cc-1];
|
||||
msg[k-c+cc-1] = tmp;
|
||||
cc--;
|
||||
}
|
||||
}
|
||||
}
|
||||
msg[k++] = ']'; msg[k++] = ' '; msg[k++] = '(';
|
||||
{
|
||||
int num = pid;
|
||||
int c = 0, cc;
|
||||
if(num == 0) msg[k++] = '0';
|
||||
else
|
||||
{
|
||||
if(num < 0) msg[k++] = '-', num = -num;
|
||||
while(num != 0) msg[k++] = '0'+num%10, num /= 10, c++;
|
||||
cc = c/2;
|
||||
|
||||
while(cc)
|
||||
{
|
||||
char tmp = msg[k-cc];
|
||||
msg[k-cc] = msg[k-c+cc-1];
|
||||
msg[k-c+cc-1] = tmp;
|
||||
cc--;
|
||||
}
|
||||
}
|
||||
}
|
||||
msg[k++] = ')'; msg[k++] = ' ';
|
||||
|
||||
if(isExited)
|
||||
{
|
||||
j = 0;
|
||||
while(TER[j]) msg[k++] = TER[j++];
|
||||
}
|
||||
else
|
||||
{
|
||||
j = 0;
|
||||
while(STP[j]) msg[k++] = STP[j++];
|
||||
}
|
||||
|
||||
j = 0;
|
||||
while(STR[j]) msg[k++] = STR[j++];
|
||||
|
||||
{
|
||||
int num = by;
|
||||
int c = 0, cc;
|
||||
if(num == 0) msg[k++] = '0';
|
||||
else
|
||||
{
|
||||
if(num < 0) msg[k++] = '-', num = -num;
|
||||
while(num != 0) msg[k++] = '0'+num%10, num /= 10, c++;
|
||||
cc = c/2;
|
||||
|
||||
while(cc)
|
||||
{
|
||||
char tmp = msg[k-cc];
|
||||
msg[k-cc] = msg[k-c+cc-1];
|
||||
msg[k-c+cc-1] = tmp;
|
||||
cc--;
|
||||
}
|
||||
}
|
||||
}
|
||||
msg[k++] = '\n'; msg[k] = 0;
|
||||
|
||||
j = write(1, msg, k);
|
||||
}
|
||||
sigprocmask(SIG_SETMASK, &prev, NULL);
|
||||
}
|
||||
errno = olderrno;
|
||||
}
|
||||
|
||||
/*
|
||||
* sigint_handler - The kernel sends a SIGINT to the shell whenver the
|
||||
* user types ctrl-c at the keyboard. Catch it and send it along
|
||||
* to the foreground job.
|
||||
*/
|
||||
void sigint_handler(int sig)
|
||||
{
|
||||
int olderrno = errno;
|
||||
sigset_t mask_all, prev;
|
||||
sigfillset(&mask_all);
|
||||
sigprocmask(SIG_BLOCK, &mask_all, &prev);
|
||||
|
||||
pid_t pid = fgpid(jobs);
|
||||
if(pid > 0) kill(-pid, SIGINT);
|
||||
|
||||
sigprocmask(SIG_SETMASK, &prev, NULL);
|
||||
|
||||
errno = olderrno;
|
||||
}
|
||||
|
||||
/*
|
||||
* sigtstp_handler - The kernel sends a SIGTSTP to the shell whenever
|
||||
* the user types ctrl-z at the keyboard. Catch it and suspend the
|
||||
* foreground job by sending it a SIGTSTP.
|
||||
*/
|
||||
void sigtstp_handler(int sig)
|
||||
{
|
||||
int olderrno = errno;
|
||||
sigset_t mask_all, prev;
|
||||
sigfillset(&mask_all);
|
||||
sigprocmask(SIG_BLOCK, &mask_all, &prev);
|
||||
|
||||
pid_t pid = fgpid(jobs);
|
||||
if(pid > 0) kill(-pid, SIGTSTP);
|
||||
|
||||
sigprocmask(SIG_SETMASK, &prev, NULL);
|
||||
errno = olderrno;
|
||||
}
|
||||
|
||||
/*********************
|
||||
* End signal handlers
|
||||
*********************/
|
||||
|
||||
/***********************************************
|
||||
* Helper routines that manipulate the job list
|
||||
**********************************************/
|
||||
|
||||
/* clearjob - Clear the entries in a job struct */
|
||||
void clearjob(struct job_t *job) {
|
||||
job->pid = 0;
|
||||
job->jid = 0;
|
||||
job->state = UNDEF;
|
||||
job->cmdline[0] = '\0';
|
||||
}
|
||||
|
||||
/* initjobs - Initialize the job list */
|
||||
void initjobs(struct job_t *jobs) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MAXJOBS; i++)
|
||||
clearjob(&jobs[i]);
|
||||
}
|
||||
|
||||
/* maxjid - Returns largest allocated job ID */
|
||||
int maxjid(struct job_t *jobs)
|
||||
{
|
||||
int i, max=0;
|
||||
|
||||
for (i = 0; i < MAXJOBS; i++)
|
||||
if (jobs[i].jid > max)
|
||||
max = jobs[i].jid;
|
||||
return max;
|
||||
}
|
||||
|
||||
/* addjob - Add a job to the job list */
|
||||
int addjob(struct job_t *jobs, pid_t pid, int state, char *cmdline)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (pid < 1)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < MAXJOBS; i++) {
|
||||
if (jobs[i].pid == 0) {
|
||||
jobs[i].pid = pid;
|
||||
jobs[i].state = state;
|
||||
jobs[i].jid = nextjid++;
|
||||
if (nextjid > MAXJOBS)
|
||||
nextjid = 1;
|
||||
strcpy(jobs[i].cmdline, cmdline);
|
||||
if(verbose){
|
||||
printf("Added job [%d] %d %s\n", jobs[i].jid, jobs[i].pid, jobs[i].cmdline);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
printf("Tried to create too many jobs\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* deletejob - Delete a job whose PID=pid from the job list */
|
||||
int deletejob(struct job_t *jobs, pid_t pid)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (pid < 1)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < MAXJOBS; i++) {
|
||||
if (jobs[i].pid == pid) {
|
||||
clearjob(&jobs[i]);
|
||||
nextjid = maxjid(jobs)+1;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* fgpid - Return PID of current foreground job, 0 if no such job */
|
||||
pid_t fgpid(struct job_t *jobs) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MAXJOBS; i++)
|
||||
if (jobs[i].state == FG)
|
||||
return jobs[i].pid;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* getjobpid - Find a job (by PID) on the job list */
|
||||
struct job_t *getjobpid(struct job_t *jobs, pid_t pid) {
|
||||
int i;
|
||||
|
||||
if (pid < 1)
|
||||
return NULL;
|
||||
for (i = 0; i < MAXJOBS; i++)
|
||||
if (jobs[i].pid == pid)
|
||||
return &jobs[i];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* getjobjid - Find a job (by JID) on the job list */
|
||||
struct job_t *getjobjid(struct job_t *jobs, int jid)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (jid < 1)
|
||||
return NULL;
|
||||
for (i = 0; i < MAXJOBS; i++)
|
||||
if (jobs[i].jid == jid)
|
||||
return &jobs[i];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* pid2jid - Map process ID to job ID */
|
||||
int pid2jid(pid_t pid)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (pid < 1)
|
||||
return 0;
|
||||
for (i = 0; i < MAXJOBS; i++)
|
||||
if (jobs[i].pid == pid) {
|
||||
return jobs[i].jid;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* listjobs - Print the job list */
|
||||
void listjobs(struct job_t *jobs)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MAXJOBS; i++) {
|
||||
if (jobs[i].pid != 0) {
|
||||
printf("[%d] (%d) ", jobs[i].jid, jobs[i].pid);
|
||||
switch (jobs[i].state) {
|
||||
case BG:
|
||||
printf("Running ");
|
||||
break;
|
||||
case FG:
|
||||
printf("Foreground ");
|
||||
break;
|
||||
case ST:
|
||||
printf("Stopped ");
|
||||
break;
|
||||
default:
|
||||
printf("listjobs: Internal error: job[%d].state=%d ",
|
||||
i, jobs[i].state);
|
||||
}
|
||||
printf("%s", jobs[i].cmdline);
|
||||
}
|
||||
}
|
||||
}
|
||||
/******************************
|
||||
* end job list helper routines
|
||||
******************************/
|
||||
|
||||
|
||||
/***********************
|
||||
* Other helper routines
|
||||
***********************/
|
||||
|
||||
/*
|
||||
* usage - print a help message
|
||||
*/
|
||||
void usage(void)
|
||||
{
|
||||
printf("Usage: shell [-hvp]\n");
|
||||
printf(" -h print this message\n");
|
||||
printf(" -v print additional diagnostic information\n");
|
||||
printf(" -p do not emit a command prompt\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/*
|
||||
* unix_error - unix-style error routine
|
||||
*/
|
||||
void unix_error(char *msg)
|
||||
{
|
||||
fprintf(stdout, "%s: %s\n", msg, strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/*
|
||||
* app_error - application-style error routine
|
||||
*/
|
||||
void app_error(char *msg)
|
||||
{
|
||||
fprintf(stdout, "%s\n", msg);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Signal - wrapper for the sigaction function
|
||||
*/
|
||||
handler_t *Signal(int signum, handler_t *handler)
|
||||
{
|
||||
struct sigaction action, old_action;
|
||||
|
||||
action.sa_handler = handler;
|
||||
sigemptyset(&action.sa_mask); /* block sigs of type being handled */
|
||||
action.sa_flags = SA_RESTART; /* restart syscalls if possible */
|
||||
|
||||
if (sigaction(signum, &action, &old_action) < 0)
|
||||
unix_error("Signal error");
|
||||
return (old_action.sa_handler);
|
||||
}
|
||||
|
||||
/*
|
||||
* sigquit_handler - The driver program can gracefully terminate the
|
||||
* child shell by sending it a SIGQUIT signal.
|
||||
*/
|
||||
void sigquit_handler(int sig)
|
||||
{
|
||||
printf("Terminating after receipt of SIGQUIT signal\n");
|
||||
exit(1);
|
||||
}
|
||||
Reference in New Issue
Block a user