============================================================================================
제    목 : Making Your Own Linux Shell
작성일자 : 2002. 10. 12
수정일자 : 2002. 12. 01
문서버젼 : ver 0.0.1
라이센스 : GPL
배경지식 : C Language, 파이프, 리다이렉션, 파싱
============================================================================================


=======================================================
* 준비물 
- i386이상
- 리눅스 머신 
- binutils, gcc, vi

* test 환경
- os : debian linux (2.4.18)
- processor : pentium IV 1.7Ghz
- ram : 512MB
- VMWare 3.0(윈도우 머신위에 vmware 를 올리고 그위에 Linux)

* 참조문헌 : 
	ADVANCED UNIX PROGRAMMING (Marc J. Rochkind - prentice hall)
	Advanced Programming in the Unix Environment
	(W.Richard Stevens  - Addison wesley)
	GNU C REFERENCE GUIDE 
	核心 Unix Programming (홍릉과학출판사) 
	

쉘은 그냥 사용하기위한 용도로만 썼었지 결코 만들어본적이 
없었기 때문에 호기심에 시작해서 리눅스의 여러가지 개념들을
많이 알게된거 같습니다. 그래서 문서가 조금 이상하더라도
이상한 내용은 바로 메일로 씹어주세요.
제가 검증 후 바로 고쳐서 업데이트 하겠습니다.

=======================================================


1. Linux Shell 만들기 

1-1) Shell 에는 무엇이 필요할까 ?

우선 Login shell 개념은 아직은 추가하지 않을 생각이며, 
만들기 시작할 쉘은 아주 간단한 개념을 익히기 위한 쉘이 될것이다.

쉘에는 무엇이 필요할지 우선 생각을 해보니,

	- 쉘 프롬프트 출력
		( debian:~root#)
   
   - 사용자 입력 
   	(find / | grep myshell > find.txt)
   
   - 입력 라인 파싱
   	(find, |, grep, myshell, >, find.txt)

	- redirection and pipe 그리고 creat file
		(redirection, creat file : ls > file.txt
		 pipe : ls | more)
		 
	- 명령어 실행 
		(exec 계열 시스템콜 사용)

	- background or foreground 프로세스제어
		(mysqld&)


1-2) 그외에 어떤것들이 필요할까 ?

	- 터미널 제어 받아오기
	- 파일명 또는 디렉토리이름 자동완성 기능 (tab)
	- 사용자 입력 history
	... 등등


2. Shell 의 부분 개념정리 및 소스코드 작성하기

2-1) 쉘 프롬프트 출력 개념
	여러가지 쉘마다 다르겠지만 쉘이름(bash), hostname(osx86), path(root),
	그리고 권한지시자(# or $) 정도가 들어가게 된다.
	쉘이름이나 hostname 은 거의 고정적이겠지만 path 는 수시로 바뀌게 되고,
	권한 지시자도 신경써야 될테지만 프롬프트 출력문도 함수로 구현해두면 
	편할것이다.

	
2-2) 쉘 프롬프트 출력 소스

	간단히 쉘이름정도만 신경써서 해보자. 
	(쉘이름 : 디렉토리)
	
======================================================================
!source : print_prompt.c

#include <stdio.h>

#define MAX_PATH	100
#define LF			10

int print_prompt()
{
	char *buffer = (char *)malloc(MAX_PATH); 
	char *value = (char *)getcwd (buffer, MAX_PATH); 

	if (value != 0)	fprintf(stdout,"jsh:%s>",buffer);
	free (buffer); 
	
	return 0;
}

int main()
{
	char c;
	while((c=getchar())!=EOF)		
		if(c==LF)	print_prompt();

	return 0;
}

======================================================================

이렇게 작업하시고, 이제 컴파일하고 실행화일로 만들어야 겠죠.

	#gcc -o jsh jsh.c

error 나 warning 없는 깔끔한 입력창이 됩니다 ^^;

	#./jsh
	
이렇게 실행해주시면 ...

jsh:/root> 

사용자 입력 가능한 형태가 되죠 ...

소스를 간단히 보면 getcwd 라는 함수가 다 합니다. -_-;;

current working directory 의 약자인가 봅니다. 

첫번째 인자에 char 버퍼를 주고, 두번째 인자에 버퍼 크기를 주면 

현재 작업 디렉토리가 반환되게 되죠.

보통 쉘에서 pwd 랑 비슷한가요 ? (이건 present working directory 의 약자일까요 -_-;;)

GNU C 라이브러리 레퍼런스 가이드인가에 보면 getcwd 함수가 char *를 반환한다고
해서 -_- 걍 썻더니만, warning 이 뜨더군요. 그래서 char * 로 다시 형변환해주고
썼음당... 


2-3). 사용자 입력과 파싱
사용자 입력과 파싱이 쉘에서 큰 부분을 차지하게 되죠 ... 
사용자가 만약 bash 에서 

bash > ls

과 같은 명령만 입력한다면 얼마나 좋겠습니까 ?

bash > ls | more > test.txt
bash > ls -al | more >> test.txt

위와 같이 입력한다면 이런 경우는 어떻게 처리할까요 ... 
그때부터 복잡해지기 시작합니다. 파이프와 리다이렉션 등의
처리와 함께 물리기 때문이겠죠. 


2-4). 사용자 입력과 파싱 구현

우리가 해야될일은 각 문자들이 왔을때 그를 분리해내는 일입니다.

아래의 코드를 보면서 해보도록 하죠 ...
======================================================================
!source : getsymb.c

#include <stdio.h>

typedef enum 
{S_WORD, S_BAR, S_AMP, S_SEMI, S_GT, S_GTGT, S_LT, S_NL, S_EOF} SYMBOL;

typedef enum {NEUTRAL, GTGT, INQUOTE, INWORD} STATUS;

SYMBOL getsymb(char *word)
{
// 변수정의 부분 
   STATUS state;
   int c;
   char *w;		


   state = NEUTRAL;		// 상태초기화
   w = word;		// word 와 pointer 로 물려 함수가 끝나도 word 에 값을 보존할수 있게
   					//	사용하게 됩니다. 


   while ((c = getchar()) != EOF) 
   {
      switch (state) 
      {     
      	// 처음에 상태를 NEUTRAL 로 초기화 했으므로 NEUTRAL 로 
     	  	case NEUTRAL :
       		switch (c) 
       		{
       			// 쉘에 ; & | < \n 이같은 명령을 내리면 할일이 없겠죠. 함수 리턴합니다.
	         	case ';' : return S_SEMI;
		         case '&' : return S_AMP;
		         case '|' : return S_BAR;
		         case '<' : return S_LT;
		         case '\n': return S_NL;
		         
		         // 공백문자나 탭 일 경우는 다시 문자를 입력 받습니다.
		         case ' ' :
		         case '\t': continue;
		         
		         case '>' : 				// 리다이렉션(stdout to stdin 일경우) 
		         	state = GTGT;		// >>(GTGT) 상태가 될수 있으므로 state 를 바꾸고
						continue;			// 다음 문자입력
					
		         case '"' : 				// " 가 입력될경우 문자열로 간주하고
		         	state = INQUOTE;	// INQUOTE 상태가 되고 
			         continue;			// 다음문자 입력
					
		         default  : 
		         	state = INWORD;	// 그외 문자가 입력될경우 INWORD 상태로 처리되고,
			         *w++ = c;			// 문자를 w 가 가리키는곳에 저장하고 w 주소를 1증가
			         continue;			// 다음문자 입력
				}
			
			case GTGT:						// 하나의 > 가 입력되어 있는경우 GTGT 상태가되는데 
		      if (c == '>') return S_GTGT;	// > 하나가 더 추가될경우 S_GTGT 를 리턴한다.
		      ungetc(c, stdin);		
		      return S_GT;    			// 아닌경우는 S_GT 리턴

		   case INQUOTE:
		      switch (c) 
		      {
		         case '\\' : 			// 문자열에서 \\ 문자가 입력되면 
		         	*w++ = getchar();	// 문자입력 받고, w 주소증가
		            continue;			// 다시 문자 입력

		         case '"'  : 			// INQUOTE 상태에서 " 하나가 더 입력되면 
		         	*w = '\0';			// 종료문자를 넘기고 
		            return S_WORD;		// S_WORD 를 리턴

      		   default   : 
      		   	*w++ = c;			// 그외의 문자가 들어올경우에는 w 에 저장후 주소증가
		            continue;			// 문자 입력
		      }    
	      
	      case INWORD:
		      switch (c) 
		      {
		      	// INWORD 상태에서 ; & | < > \n ' ' \t 문자일 경우에는 
		         case ';' :
		         case '&' :
		         case '|' :
		         case '<' :
		         case '>' :
		         case '\n':
		         case ' ' :
		         case '\t': 
		         	ungetc(c, stdin);		
		 		      *w = '\0';				// 종료문자 추가하고 
		            return S_WORD;			// S_WORD 리턴

		         default  : 
		         	*w++ = c;				// 다른 문자인경우에는 문자저장하고 w 주소증가
			         continue;				// 문자 입력으로 계속
		      }

		}

	}
   return S_EOF;
}

int main()
{
	char word[200];			// getsymb 함수에서 w 로 장난을 치면 결과는 word 에 저장된다.
	
	while(1)
		switch(getsymb(word))
		{
			// 결과 출력문
			case S_WORD :
				printf("S_WORD<%s>\n", word);
				break;
			case S_BAR :
				printf("S_BAR\n");
				break;
			case S_AMP :
				printf("S_AMP\n");
				break;
			case S_SEMI :
				printf("S_SEMI\n");
				break;
			case S_GT :
				printf("S_GT\n");
				break;
			case S_GTGT :
				printf("S_GTGT\n");
				break;
			case S_LT :
				printf("S_LT\n");
				break;
			case S_LN :
				printf("S_LN\n");
				break;
			case S_EOF :
				printf("S_EOF\n");
				exit(0);
		}
		
	return 0;
}
======================================================================
	
일단 욜라 긴데, 별것 없습니다. 전부 CASE 처리일뿐이죠 ...

우선 두라인을 먼저 보죠 ...

////////////////////////////////////////////////////////////////////////
typedef enum 
{S_WORD, S_BAR, S_AMP, S_SEMI, S_GT, S_GTGT, S_LT, S_NL, S_EOF} SYMBOL;

/*
 SYMBOL 은 입력된 심벌의 종류 입니다. 문자인가(S_WORD), 파이프를 위한 바인가,
(S_BAR), 종료 심벌인 세미콜론인가(S_SEMI), 리다이렉션을 위한 > 인가(S_GT),
그 반대인< 인가 (S_LT), 리다이렉션 APPEND 를 위한 >> 인가(S_GTGT), 
뉴라인 문자인가(S_NL), 끝을 나타내는 EOF 인가(S_EOF)
*/


typedef enum {NEUTRAL, GTGT, INQUOTE, INWORD} STATUS;
/* 
 STATUS 는 문장의 오류가 찾기위한 상태 코드들 입니다.
 NEUTRAL 은 보통의 경우이죠.
 GTGT 는 > 가 입력된 이후를 위한 상태코드 입니다.
 INQUOTE 는 쿼터(") 안에 들어와 있을경우 문자열 입력 상태 코드입니다.
 INWORD 는 이어지는 문자들을 위한 상태 코드입니다.
*/
////////////////////////////////////////////////////////////////////////

나머지는 소스코드내에 주석처리를 했습니다.

INQUOTE 상태나 INWORD 상태는 계속된 문자입력을 받게되죠 
GTGT 상태는 처음에 > 하나가 입력되었을경우 GTGT 상태가되고, 
이어서 하나가 더 입력될경우 S_GTGT 를 RETURN 하고,
아니라면 S_GT 를 리턴하게 됩니다.

그리고 MAIN 에서 출력을 하게 되죠 

컴파일하고 실행을 해볼까요 ...


#compile 
	gcc -o getsymb getsymb.c

#execution
	./getsymb


이제 입력을 해볼까요 ... ;)
============================
ls -al | more > test.txt
S_WORD <ls>
S_WORD <-al>
S_BAR
S_WORD <more>
S_GT
S_WORD <test.txt>
T_NL
============================
이제 다른걸 해볼까요 ...

============================
ls >> test.txt
S_WORD <ls>
S_GTGT	
S_WORD <test.txt>
T_NL
============================

============================
cat < test.txt
S_WORD <cat>
S_LT	
S_WORD <test.txt>
T_NL
============================

잘 짤리죠 -_-  음냥 이건 이정도로 하죠...


2-5). 리다이렉션과 파이프 라인

리눅스에는 pipe 라인이라는 개념이 존재합니다.

프로세스간에 스트림을 열어주어 서로 통신할수 있게 하는것이더군요.

(저도 이걸 몰라서 한참을 헤멧다는 -_-;;; 처음 보다보니 -_-;;)

결국 pipe 는 프로세스간 통신을 하기위한 스트림이었고,

redirection 은 프로세스에서 file 로의 데이터 출력 또는 
file 에서 프로세스로의 데이터 출력 이었습니다.

따라서 pipe 같은 경우

	ls | more 
	
과 같은 경우이고, 

redirection 은 

	ls > test.txt 
	
와 같은 경우죠 ...

BAR 로 파일에 쓰면 안되더군요 ^^;

	ls | test.txt 
	
삐익 -_-;; 안됩니다...


우선 간단히 ls 명령과 more 명령사이에 파이프를 생성해 ls 의 출력을

more 의 입력으로 넘겨주는 작업을 해봅시다.


================================================================
!source : pipetest.c

#include <stdio.h>
#include <unistd.h>

int main()
{
	int pfd[2];
	
	if(pipe(pfd)==-1)		perror("pipe");
	switch(fork())
	{
		case	-1 : perror("fork");
		case	0	: 
			if(close(1)==-1)	perror("close");
			if(dup(pfd[1]) != 0)	perror("dup");
			if(close(pfd[0]) == -1 || close(pfd[1]) == -1)	perror("close2");
			execlp("ls", "ls", NULL);
			perror("execlp");
	}
	
	switch(fork())
	{
		case	-1 : perror ("fork");
		case	0	: 
			if(close(0) == -1)	perror("close3");
			if(dup(pfd[0]) != 0)	perror("dup2");
			if(close(pfd[0]) == -1 || close(pfd[1]) == -1)	perror("close4");
			execlp("more", "more", NULL);
			perror("execlp");
	}
	
	if(close(pfd[0]) == -1 || close(pfd[1]) == -1)	perror("close5");
	while(wait(NULL) != -1);
	return 0;
}
================================================================

파이프는 
         -------------
         |           ▼
	processA       processB
         ▲           |
         -------------

와 같이 통신이 가능합니다. 

우리 소스에서 보시면,

	int pfd[2];			// 파이프를 위한 파일 디스크립터를 두개 선언
	if(pipe(pfd)==-1)		perror("pipe");		// 파이프 작동 

이 경우 pfd[2] 중에서 pfd[1] 에 입력을 하게되면 pipe 에 데이터를 넣는 의미가 되며,
pfd[0]에서는 pfd[1]과 연결이 되어 pfd[1]에서부터 데이터를 읽어오게 되죠.

	pfd[1] -------> pfd[0]

와 같이 되겠죠. 그리고 나서 fork 로 프로세스를 하나 생성하겠죠.


fork 를 한번 호출하게 되면 두번의 return
(하나는 child 에 0 을 parent에 child의 process id) 을 하게 됩니다.

여튼 fork 는 따로 설명할 계획이 없구요 ... 문서 버젼 업 할때 할지도 모르겠군요.

case 0 (child process) 인 경우 

///////////////////////////////////////////////////////////////////////////
		case	0	: 
			if(close(1)==-1)	perror("close");
			if(dup(pfd[1]) != 0)	perror("dup");
			if(close(pfd[0]) == -1 || close(pfd[1]) == -1)	perror("close2");
			execlp("ls", "ls", NULL);
			perror("execlp");
///////////////////////////////////////////////////////////////////////////

close(1) 에서 1의 의미는 뭔지 아시죠 ... ;)
STDIN_FILENO 와 STDOUT_FILENO 가 unistd.h 에 정의 되어 있습니다.

===================================================
!file : include/unistd.h
....
/* Standard file descriptors. */
#define STDIN_FILENO		0	/* 표준입력 */
#define STDOUT_FILENO		1	/* 표준출력 */
#define STDERR_FILENO		2	/* 표준 ERROR 출력 */
....
===================================================

뭔지 아시겠죠.

따라서 첫번째 child 의 표준 출력을 닫아 버리겠다는겁니다.

	if(dup(pfd[1]) != 0)	perror("dup");

그리고 dup 가 나오죠 ...
dup 는 return 값으로 pfd[1] 와 같은 화일을 가리키는 
새로운 file descriptor 를 반환하게 되고, 
pfd[0]와 1을 닫게되죠. ls 에게 pfd[0]는 의미가 없습니다.
more 이 pfd[0]로 출력하게 될테니까요 ...

	execlp("ls", "ls", NULL);

그리고 나서 execlp 명령을 통해 ls 명령을 실행합니다.


이제는 두번째 child 를 생성합니다.
///////////////////////////////////////////////////////////////////////////
case	0	: 
	if(close(0) == -1)	perror("close3");
	if(dup(pfd[0]) != 0)	perror("dup2");
	if(close(pfd[0]) == -1 || close(pfd[1]) == -1)	perror("close4");
	execlp("more", "more", NULL);
	perror("execlp");
///////////////////////////////////////////////////////////////////////////

close(0) 은 표준 입력을 닫겠다는 소립니다... 다른 잡것들이 
끼면 안되니까요 ... 오직 두번째 child 는 pfd[0]가 가리키는
파일과의 통신만 하면 됩니다.
이해가시죠 ... 이번에는 표준입력과 관련된 작업을 해주고,
 
			execlp("more", "more", NULL);
			
마찬가지로 more 명령을 실행합니다.
이제 ls 와 more 간에 통신을 해볼까요 ...

#compile
	gcc -o pipetest pipetest.c
	
#execution
	./pipetest
	
a
b
c
d
e
f
g
h
<--more-->

실행하기전에 파일이 많아야 됩니다. -_-;;

ls | more 의 명령을 실행한것처럼 되게되죠 ... 

왜 그러냐면 
		
		ls -write-> pfd[1] --> pfd[0] <-read- more

와 같이 되기 때문이죠 ...

이제 우리가 앞에서 작성한 token 과 이러한 pipe 개념을 잘
섞어주면 됩니다. 

여튼 파이프에 대해 자세히 보시고 싶은분은 fs/pipe.c 를 참조하세요


3. Minish 을 모델로 Shell 만들어보기 

지금까지 이해한 개념만으로도 기본쉘을 충분히 구현할수가 있습니다.

마지막으로 한가지가 남았군요. 

사용자 입력으로 생성된 토큰을 잘라내었고, pipe 개념을 이용해

프로세스간 통신하는 법도 익혔습니다.

어떻게 연결해서 쓰는지에 대한 내용이 없었죠.


3-1). minish 소스 코드의 구성

아래 코드는 minish 이라는 아주 작은 테스트용 shell source 코드 입니다.

참고하시라고 넣어놨습니다. 
(Unix Programming 이었던가 하는 홍릉출판사 책참조)

Main	: minish.c
Sub		: execcmd.c exsimcmd.c getsymb.c shenv.c shutil.c fdredir.c 
Header	: minish.h

* 우선 minish 에서 사용할 변수와 전처리구문의 정의
============================================================================
!source : minish.h
#define ERROR    (-1)
#define MAXFNAME 10
#define MAXARG   10
#define MAXWORD  20
#define MAXFD    20
#define MAXVAR   50
#define MAXNAME  20

#ifndef MAXSIG
	#define MAXSIG   19
#endif

#define TRUE			1
#define FALSE			0

#define BADFD			(-2)
#define lowbyte(w)		((w) & 0377)
#define highbyte(w)		lowbyte((w) >> 8)

typedef int BOOLEAN;
typedef enum {S_WORD, S_BAR, S_AMP, S_SEMI, S_GT, S_GTGT,
				S_LT, S_NL, S_EOF} SYMBOL;

SYMBOL execcmd();
int exsimcmd();
void fdredir();
char *envget();
int envinit();
BOOLEAN envupdate();
void envprint();
void envexport();
void envass();
void envset();
void sigigno();
void sigrest();
void fatal();
void syserr();
void prnstate();
============================================================================


* main 역할을 하는 프로그램
============================================================================
!source : minish.c

#include <stdio.h>
#include "minish.h"

main()
{

	char *prompt;

	int pid, fd;
	SYMBOL term;

	sigigno();

	if (!envinit())	fatal("cannot initialize environment.");

	if ((prompt = envget("PS2")) == NULL)	prompt = "> ";
	printf("%s", prompt);

	while (TRUE) {
		term = execcmd(&pid, FALSE, NULL);
		if (term != S_AMP && pid != 0)	waitfor(pid);
		if (term == S_NL)	printf("%s", prompt);

		for (fd=3; fd<MAXFD; fd++)	close(fd);
	}
}
============================================================================


* 사용자 입력으로부터 토큰을 구분
============================================================================
!source : getsymb.c

#include <stdio.h>
#include "minish.h"

typedef enum {NEUTRAL, GTGT, INQUOTE, INWORD} STATUS;
SYMBOL getsymb(word)
char *word;
{
	STATUS state;
	int c;
	char *w;
	
	state = NEUTRAL;
	w = word;

	while ((c = getchar()) != EOF) 
	{
		switch (state) 
		{
			case NEUTRAL :
				switch (c) 
				{
					case ';' : return S_SEMI;
					case '&' : return S_AMP;
					case '|' : return S_BAR;
					case '<' : return S_LT;
					case '\n': return S_NL;
					case ' ' :
					case '\t': continue;
					case '>' : 
						state = GTGT;
						continue;
					case '"' : 
						state = INQUOTE;
						continue;

					default  : 
						state = INWORD;
						*w++ = c;
						continue;
				}

			case GTGT:
				if (c == '>') return S_GTGT;
				ungetc(c, stdin);
				return S_GT;

			case INQUOTE:
				switch (c) 
				{
					case '\\' : 
						*w++ = getchar();
						continue;
					case '"'  : 
						*w = '\0';
						return S_WORD;
					default   : 
						*w++ = c;
						continue;
				}

			case INWORD:
				switch (c ) 
				{
					case ';' :
					case '&' :
					case '|' :
					case '<' :
					case '>' :
					case '\n':
					case ' ' :
					case '\t': 
						ungetc(c, stdin);
						*w = '\0';
						return S_WORD;

					default  : 
						*w++ = c;
						continue;
				}
		}
	}

   return S_EOF;
}
============================================================================


* 분리된 토큰을 이용한 명령어 실행
============================================================================
!source : execcmd.c 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "minish.h"

SYMBOL execcmd(int *waitpid, BOOLEAN makepipe, int *pipefdp)

BOOLEAN makepipe;
{
	SYMBOL symbol, term;
	int argc, sourcefd, destfd;
	int pid, pipefd[2];
	char *argv[MAXARG+1], sourcefile[MAXFNAME];
	char destfile[MAXFNAME];
	char word[MAXWORD];
	BOOLEAN append;

	argc = 0;			
	sourcefd = 0;		
	destfd = 1;			

	
	while (TRUE) 
	{
		switch (symbol = getsymb(word))		
		{
			case S_WORD :					
				if (argc == MAXARG) 
				{
					fprintf(stderr, "Too many args.\n");
					break;
				}

				argv[argc] = (char *) malloc(strlen(word)+1);
				
				if (argv[argc] == NULL) 
				{
					fprintf(stderr, "Out of arg memory.\n");
					break;
				}

				strcpy(argv[argc], word);
				argc++;
				continue;

			case S_LT   : 
				if (makepipe) 
				{
					fprintf(stderr, "Extra <.\n");
					break;
				}


				if (getsymb(sourcefile) != S_WORD) 
				{
					fprintf(stderr, "Illegal <.\n");
					break;
				}

				sourcefd = BADFD;
				continue;

			case S_GT   :
			case S_GTGT : 
				if (destfd != 1) 
				{
					fprintf(stderr, "Extra > or >>.\n");
					break;
				}

				if (getsymb(destfile) != S_WORD) 
				{
					fprintf(stderr, "Illegal > or >>.\n");
					break;
				}

				destfd = BADFD;
				append = (symbol == S_GTGT);
				continue;

			case S_BAR  :
			case S_AMP  :
			case S_SEMI :
			case S_NL   : 
				argv[argc] = NULL;
				if (symbol == S_BAR) 
				{
					if (destfd != 1) 
					{
						fprintf(stderr, "> or >> conflicts with |.\n");
						break;
					}
					term = execcmd(waitpid, TRUE, &destfd);
				} else
					term = symbol;

				if (makepipe) 
				{
					if (pipe(pipefd) == ERROR)	syserr("pipe");
					*pipefdp = pipefd[1];
					sourcefd = pipefd[0];
				}

				pid = exsimcmd(argc, argv, sourcefd, sourcefile,
								destfd, destfile,append, term == S_AMP);

				if (symbol != S_BAR)	*waitpid = pid;
				if (argc == 0 && (symbol != S_NL || sourcefd > 1))
					fprintf(stderr, "Missing command.\n");

				while (--argc >= 0)	free(argv[argc]);

				return term;

			case S_EOF : 
				exit(0);
		} 
	}    
}
============================================================================


* 심벌 커맨드의 실행
============================================================================
!source : exsimcmd.c 

#include <stdio.h>
#include <unistd.h>
#include "minish.h"
int exsimcmd(ac, av, sourcefd, sourcefile,
			destfd, destfile, append, backgrnd)
int ac;
char *av[];
int sourcefd;
char *sourcefile;
int destfd;
char *destfile;
BOOLEAN append;
BOOLEAN backgrnd;
{
	int pid;

	if (ac == 0 || shellcmd(ac, av, sourcefd, destfd))	return 0;

	pid = fork();
	switch (pid) {
		case ERROR : 
			fprintf(stderr, "Cannot create new process.\n");
			return 0;
		case 0 :     
			if (!backgrnd)	sigrest();
			
			if (!envupdate())	fatal("Cannot update environment.\n");
			fdredir(sourcefd, sourcefile, destfd, destfile,
					append, backgrnd);
			execvp(av[0], av);
			fprintf(stderr, "Cannot execute %s\n", av[0]);
			exit(0);

		default :    
			if (sourcefd > 0 && close(sourcefd) == ERROR)
				syserr("close sourcefd");

			if (destfd > 1 && close(destfd) == ERROR)
				syserr("close destfd");

			if (backgrnd)	printf("%d\n", pid);
			
			return pid;
	}
}
============================================================================


* file descriptor 리다이렉션
============================================================================
!source : fdredir.c

#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include "minish.h"

void fdredir(sourcefd, sourcefile, destfd, destfile,
			append, backgrnd)
int sourcefd;
char *sourcefile;
int destfd;
char *destfile;
BOOLEAN append;
BOOLEAN backgrnd;
{
	int flags, fd;

	if (sourcefd == 0 && backgrnd) 
	{
		strcpy(sourcefile, "/dev/null");
		sourcefd = BADFD;
	}

	if (sourcefd != 0) 
	{
		if (close(0) == ERROR) syserr("close");
		if (sourcefd > 0) 
		{
			if (dup(sourcefd) != 0)	fatal("dup");
		}
		else if (open(sourcefile, O_RDONLY, 0) == ERROR)
		{
			fprintf(stderr, "Cannot open %s\n", sourcefile);
			exit(0);
		}
	}
   
	if (destfd != 1) 
	{
		if (close(1) == ERROR) syserr("close");
		if (destfd > 1) 
		{
			if (dup(destfd) != 1)	fatal("dup");
		}else
		{
			flags = O_WRONLY | O_CREAT;
			if (!append)	flags |= O_TRUNC;
			if (open(destfile, flags, 0666) == ERROR) 
			{
				fprintf(stderr, "Cannot create %s\n", destfile);
				exit(0);
			}
			if (append)	
				if (lseek(1, 0L, 2) == ERROR) syserr("lseek");
		}
	}

   for (fd =3; fd < MAXFD; fd++) close(fd);
   return;
}
============================================================================


* 환경변수 설정및 프로그램 내 기초함수 구현
============================================================================
!source : envsh.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "minish.h"

extern char **environ;

static struct slot {
	char *name;
	char *value;
	BOOLEAN export;
} envsym[MAXVAR];

static struct slot *slfind(name)
char *name;
{
	int i;
	struct slot *v;
	
	v = NULL;

	for (i = 0; i < MAXVAR; i++)
		if (envsym[i].name == NULL) 
		{
			if (v == NULL) v = &envsym[i];
		}
		else if (strcmp(envsym[i].name, name) == 0) 
		{
			v = &envsym[i];
			break;
		}

	return v;
}


static BOOLEAN assign(p, s)
char **p;
char *s;
{
	int size;

	size = strlen(s) + 1;

	if (*p == NULL) 
	{
		if ((*p = (char *) malloc(size)) == NULL)
			return FALSE;
	}
	else if ((*p = (char *) realloc(*p, size)) == NULL)
		return FALSE;

	strcpy(*p, s);
	return TRUE;
}

BOOLEAN set(name, value)
char *name;
char *value;
{
	struct slot *v;
	BOOLEAN b;

	if ((v = slfind(name)) == NULL)
		return FALSE;

	b = assign(&v->name, name) && assign(&v->value, value);
	return b;
}

BOOLEAN export(name)
char *name;
{
	struct slot *v;

	if ((v = slfind(name)) == NULL)	return FALSE;

	if (v->name == NULL)
		if (!assign(&v->name, name) || !assign(&v->value, ""))
			return FALSE;

	v->export = TRUE;
	return TRUE;
}


char *envget(name)
char *name;
{
	struct slot *v;

	if ((v = slfind(name)) == NULL || v-> name == NULL)
		return NULL;

	return v->value;
}


BOOLEAN envinit()
{
	int i, leng;
	char name[MAXNAME];

	for (i = 0; environ[i] != NULL; i++) 
	{
		leng = strcspn(environ[i], "=");
		strncpy(name, environ[i], leng);
		name[leng] = '\0';
		
		if (!set(name, &environ[i][leng+1]) || !export(name))
			return FALSE;
	}
	return TRUE;
}


void envass(ac, av)
int ac;
char *av[];
{
	char *name, *value;
	if (ac != 1)	printf("Extra args.\n");
	else 
	{
		name = strtok(av[0], "=");
		value = strtok(NULL, "\1"); /* alles uebrige */
		if (!set(name, value))	fprintf(stderr, "Cannot set.\n");
	}
}


void envexport(ac, av)
int ac;
char *av[];
{
	int i;

	if (ac == 1) 
	{
		envset(ac, av);
		return;
	}

	for (i = 1; i < ac; i++)
		if (!export(av[i])) 
		{
			fprintf(stderr, "Cannot export %s\n", av[i]);
			return;
		}
}


void envset(ac, av)
int ac;
char *av[];
{
	if (ac != 1)	printf("Extra args.\n");
	else			envprint();

	return;
}


void envprint()
{
	int i;

	for (i = 0; i < MAXVAR; i++)
		if (envsym[i].name != NULL)
			printf("%3s %s=%s\n", envsym[i].export ? "[E]" : "",
					envsym[i].name, envsym[i].value);

	return;
}


BOOLEAN envupdate()
{
	int i, envi, nvlen;
	struct slot *w;

	static BOOLEAN updated = FALSE;

	if (!updated)
		if ((environ = (char **) malloc((MAXVAR+1) *
			sizeof(char *))) == NULL)
		return FALSE;

	envi = 0;

	for (i = 0; i < MAXVAR; i++) 
	{
		w = &envsym[i];

		if (w->name == NULL || !w->export)	continue;		
		nvlen = strlen(w->name) + strlen(w->value) + 2;

		if (!updated) 
		{
			if ((environ[envi] = (char *) malloc(nvlen)) == NULL)
				return FALSE;
		} else 
			if ((environ[envi] = (char *) realloc(environ[envi], nvlen)) == NULL)
				return FALSE;
		sprintf(environ[envi], "%s=%s", w->name, w->value);
		envi++;   
   }

   environ[envi] = NULL;
   updated = TRUE;
   return TRUE;
}
============================================================================


* 쉘 유틸
============================================================================
!source : shutil.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include "minish.h"

#ifndef BADSIG
	#define BADSIG (void (*)) (-1)
#endif

#ifndef BSD
#ifndef OS2
	extern sys_nerr;
	extern char *sys_errlist[];
#endif
#endif

void fatal(message)
char *message;
{
	fprintf(stderr, "Error: %s\n", message);
	exit(1);
}


void syserr(message)
char *message;
{
	fprintf(stderr, "Error: %s (%d", message, errno);

	if (errno > 0 && errno < sys_nerr)
		fprintf(stderr, "; %s)\n", sys_errlist[errno]);
	else
		fprintf(stderr, ")\n");

	exit(1);
}

static void (* oldint)();
static void (* oldquit)();

void sigigno()
{
	static BOOLEAN first = TRUE;

	if (first) 
	{
		first = FALSE;
		oldint = signal(SIGINT, SIG_IGN);
		oldquit = signal(SIGQUIT, SIG_IGN);
		
		if (oldint == BADSIG || oldquit == BADSIG)
			syserr("signal");
	}
	else if (signal(SIGINT, SIG_IGN) == BADSIG ||
		signal(SIGQUIT, SIG_IGN) == BADSIG)

	syserr("signal");
}


void sigrest()
{
	if (signal(SIGINT, oldint) == BADSIG ||
		signal(SIGQUIT, oldquit) == BADSIG)		syserr("signal");
}


void waitfor(pid)
int pid;
{
	int wpid, status;

	while ((wpid = wait(&status)) != pid && wpid != ERROR)
		prnstate(wpid, status);

	if (wpid == pid)	prnstate(0, status);
}


#ifndef OS2

void prnstate(pid, status)
int pid;
int status;
{
	int k;

	if (status != 0 && pid != 0)
		printf("Process %d: ", pid);

	if (lowbyte(status) == 0) 
	{
		if ((k = highbyte(status)) != 0)
			printf("Exit code %d\n", k);
	}
	else 
	{
		if ((k = status & 0177) <= MAXSIG)
			printf("%s", sys_siglist[k]);
		else
			printf("Signal #%d", k);

		if ((status & 0200) == 0200)
			printf(" - core dumped");

		printf("\n");
	}
	return;
}
#endif


#ifdef OS2
void prnstate(pid, status)
int pid;
int status;
{
	int k;
	
	static char *sigmess[] = 
	{
		"",
		"Hangup",
		"Interrupt",
		"Quit",
		"Illegal instruction",
		"Trace trap",
		"IOT instruction",
		"EMT instruction",
		"Floating point exception",
		"Kill",
		"Bus error",
		"Segmentation violation",
		"Bad arg to system call",
		"Write on pipe",
		"Alarm clock",
		"Terminate signal",
		"User signal 1",
		"User signal 2",
		"Death of child",
		"Power fail"  };
		
		if (status != 0 && pid != 0)
			printf("Process %d: ", pid);

		if (lowbyte(status) == 0) 
		{
			if ((k = highbyte(status)) != 0)
				printf("Exit code %d\n", k);
		}
		else 
		{
			if ((k = status & 0177) <= MAXSIG)
				printf("%s", sigmess[k]);
			else
				printf("Signal #%d", k);

			if ((status & 0200) == 0200)
				printf(" - core dumped");
			printf("\n");
		}
	return;
}
#endif


BOOLEAN shellcmd(ac, av, sourcefd, destfd)
int ac;
char *av[];
int sourcefd;
int destfd;
{
	char *path;

	if (strchr(av[0], '=') != NULL)	envass(ac, av);
	else if (strcmp(av[0], "export") == 0)	envexport(ac, av);
	else if (strcmp(av[0], "set") == 0)		envset(ac, av);
	else if (strcmp(av[0], "cd") == 0) 
	{
		if (ac > 1)	path = av[1];
		else if ((path = envget("HOME")) == NULL)
			path = ".";
		if (chdir(path) == ERROR)
			fprintf(stderr, "%s: bad directory.\n", path);
	}else if (strcmp(av[0], "exit") == 0) 
	{
		exit(0);
	} else	return FALSE;

	if (sourcefd != 0 || destfd != 1)
		fprintf(stderr, "Ilegal redirection or pipeline.\n");

	return TRUE;
}
============================================================================


# makefile
===============================================================
all:   minish

minish.o:	minish.c minish.h
	gcc -c minish.c

shutil.o:	shutil.c minish.h
	gcc -c shutil.c

shenv.o:	shenv.c minish.h
	gcc -c shenv.c

getsymb.o:	getsymb.c minish.h
	gcc -c getsymb.c

execcmd.o:	execcmd.c minish.h
	gcc -c execcmd.c

fdredir.o:	fdredir.c minish.h
	gcc -c fdredir.c

exsimcmd.o:	exsimcmd.c minish.h
	gcc -c exsimcmd.c

minish:		minish.o shutil.o getsymb.o execcmd.o fdredir.o \
			exsimcmd.o shenv.o
	gcc -o minish minish.o shutil.o getsymb.o execcmd.o \
			fdredir.o exsimcmd.o shenv.o
===============================================================

# make
	make all

# execute
	minish

테스트 작업을 해보고, 종료시 exit 를 입력해주세요.
그럼 원래 사용하던 쉘로 돌아갑니다.


postscript. 너무 미흡한것 같습니다만 ... 스스로 찾아서 해보는것도 ...