OS之子进程简单模拟shell解释环境(再次)

最新推荐文章于 2024-04-19 12:51:59 发布

qq1223386926

最新推荐文章于 2024-04-19 12:51:59 发布

阅读量454

点赞数

分类专栏： OS 文章标签： os LinuxC

本文链接：https://blog.csdn.net/qq123386926/article/details/50505493

版权

OS 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

(1)当输入一条指令后，将指令拆分成独立的符号；

(2)如果指令的最后一个符号是’&’，则(4)子进程执行指令的时候，父进程将不会wait()子进程执行完毕，继续接收下一条指令进行解释；

(3)History指令由主程序使用循环队列进行维护，最多只记录10条历史指令；'!!'执行最近执行过的指令，'! + 数字'执行对应的历史指令；

(4)如果是非history指令，fork()一个子进程，调用execvp()进行解释执行；

一、主程序

/*
** FILE: osh.c
** NOTE: 2016-01-11 created by Jack Liu
** DESC: 
*/
#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>
#include<signal.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"history.h"

#define MAX_HISTORY 10 

/* how many stokens */
int stoken_cmd_num( char *cpCmd );
/* split the command into stokens */
char **stoken_cmd( char *cpCmd, int *iTokenNum );
/* remember the command */
int do_history( char *cpCmd, PHISTORY_LIST pHistory );
/* when children terminate, recycle it */
void child_fun( int sig );

int
main( void )
{
    char caCmd[ MAX_CMD ];
    char **cppCmdStokens;
    pid_t pid;
    int  iTokenNum;
    int  iConcurrent;
    struct sigaction newSigAct, oldSigAct;
    HISTORY_LIST history;

    newSigAct.sa_handler = child_fun; 
    if( sigaction( SIGCHLD, &newSigAct, &oldSigAct ) < 0 )
    {
        perror( "sigaction" );
        return -1;
    }

    if( history_init( &history, MAX_HISTORY ) < 0 )
    {
        fprintf( stderr, "fail to init history list\n" );
        return -1;
    }

    while( 1 )
    {
        int i = 0;
        iConcurrent = 0;
        printf( "osh>" );

        /*
        ** get the input command 
        */
        if( fgets( caCmd, MAX_CMD, stdin ) == NULL )
        {   /* the user want to exit, ctrl + D */
            putchar( '\n' );
            break;
        }
        if( caCmd[ strlen( caCmd ) - 1 ] == '\n' )
            caCmd[ strlen( caCmd ) - 1 ] = '\0';

        if( caCmd[ 0 ] == '\0' )  /* just input enter, ignore it */
            continue;

        /*
        ** record the command
        */
        if( do_history( caCmd, &history ) < 0 )
            continue;

        /*
        ** split the command
        */
        if( strcmp( caCmd, "exit" ) == 0 )
        {   /* the user want to exit, input exit */
            break;
        }

        cppCmdStokens = stoken_cmd( caCmd, &iTokenNum );
        if( cppCmdStokens == NULL )
        {
            fprintf( stderr, "couldn't recognize: %s\n", caCmd );
            continue;
        }

        /*
        ** fork a child to exec the command
        ** or 
        ** print the history commands
        */
        if( cppCmdStokens[ iTokenNum - 2 ][ strlen( cppCmdStokens[ iTokenNum - 2 ] ) - 1 ] == '&' )
        {
            iConcurrent = 1;    /* concurrent the command */
            /*
            ** clear the '&' character
            */
            cppCmdStokens[ iTokenNum - 2 ][ strlen( cppCmdStokens[ iTokenNum - 2 ] ) - 1 ] = '\0';
            if( cppCmdStokens[ iTokenNum - 2 ][ 0 ] == '\0' )
            {   /* '&' occupy a stoken, clear the stoken */
                free( cppCmdStokens[ iTokenNum - 2 ] );
                cppCmdStokens[ iTokenNum - 2 ] = NULL;
            }
        }

        if( strcmp( cppCmdStokens[ 0 ], "history" ) == 0 )
        {
            history_print( &history );
        }
        else
        {
            if( ( pid = fork() ) < 0 )
            {
                fprintf( stderr, "fail to exec: %s\n", caCmd );
                continue;
            }
            else if( pid == 0 )
            {   /* child */
                execvp( cppCmdStokens[ 0 ], cppCmdStokens );
                fprintf( stderr, "fail to exec: %s\n", caCmd );
                exit( -1 );
            }
        }

        i = 0;
        /*
        ** clear stokens
        */
        while( cppCmdStokens[ i ] )
            free( cppCmdStokens[ i++ ] );
        free( cppCmdStokens );

        if( !iConcurrent ) /* wait the child to exec */
            waitpid( pid, NULL, 0 );
    }
    history_clear( &history );
    return 0;
}


int
stoken_cmd_num( char *cpCmd )
{
    char caTmpCmd[ MAX_CMD ];
    char *cpIndex;
    int  iNum = 0;
    if( cpCmd == NULL )
    {
        fprintf( stderr, "Illegal cmd\n" );
        return -1;
    }
    strncpy( caTmpCmd, cpCmd, MAX_CMD );

    cpIndex = strtok( caTmpCmd, " " );
    while( cpIndex )
    {
        iNum++;
        cpIndex = strtok( NULL, " " );
    }

    return iNum;
}

char **
stoken_cmd( char *cpCmd, int *iTokenNum )
{
    char caTmpCmd[ MAX_CMD ];
    char *cpIndex;
    char *cpStoken;
    char **cppStokens;
    int  iNum;
    if( cpCmd == NULL )
    {
        fprintf( stderr, "Illegal command line\n" );
        return NULL;
    }
    strncpy( caTmpCmd, cpCmd, MAX_CMD );
    if( ( iNum = stoken_cmd_num( cpCmd ) ) > 0 )
    {
        /*
        ** the last element is NULL
        */
        *iTokenNum = iNum + 1;
        cppStokens = malloc( sizeof( char * ) * ( iNum + 1 ) );
        if( cppStokens == NULL )
        {
            perror( "malloc" );
            return NULL;
        }
    }
    else
    {
        fprintf( stderr, "Illegal command line\n" );
        return NULL;
    }
    memset( cppStokens, 0x00, sizeof( char * ) * ( iNum + 1 ) );

    /*
    ** begin to split
    */
    iNum = 0;
    cpIndex = strtok( caTmpCmd, " " );
    while( cpIndex )
    {
        if( ( cpStoken = malloc( strlen( cpIndex ) + 1 ) ) == NULL )
        {
            int i;
            for( i = 0; i < iNum; i++ )
                free( cppStokens[ i ] );
            free( cppStokens );
            perror( "malloc" );
            return NULL;
        }
        memset( cpStoken, 0x00, strlen( cpIndex ) + 1 );
        strcpy( cpStoken, cpIndex ); 
        cppStokens[ iNum++ ] = cpStoken;
        cpIndex = strtok( NULL, " " );
    }
    cppStokens[ iNum ] = NULL; 

    return cppStokens;
}

int 
do_history( char *cpCmd, PHISTORY_LIST pHistory )
{
    PHISTORY_RECORD pRecord;
    int iIndex = -1;
    char caTmpCmd[ MAX_CMD ] = { 0 };
    if( cpCmd[ 0 ] == '!' )
    {
        memcpy( caTmpCmd, cpCmd + 1, strlen( cpCmd ) ); /* include the NULL-terminated */
        if( strcmp( caTmpCmd, "!" ) != 0 )
            iIndex = atoi( caTmpCmd );
        else
            iIndex = 1; 

        if( iIndex <= 0 || iIndex > pHistory->iLen )
        {
            fprintf( stderr, "no such history command\n" );
            return -1;
        }

        pRecord = history_index( pHistory, iIndex );
        if( pRecord == NULL )
        {
            fprintf( stderr, "no such history command\n" );
            return -1;
        }
        strcpy( cpCmd, pRecord->cpCmd );
    }
    else
    {   /* record the command */
        pRecord = history_get_record( cpCmd );
        history_pushback( pHistory, pRecord );
    }

    return 0;
}

void
child_fun( int sig )
{
    waitpid( -1, NULL, WNOHANG ); 
}

二、history队列维护头文件

/*
** FILE: history.h
** NOTE: 2016-01-11 created by Jack Liu
** DESC: manage the historic commands up to 10
*/
#ifndef COM_JACKLIU_HISTORY_H
#define COM_JACKLIU_HISTORY_H

#define MAX_CMD 512

typedef struct history_record
{
    char cpCmd[ MAX_CMD ];
    struct history_record *prev;
    struct history_record *next;
} HISTORY_RECORD, *PHISTORY_RECORD; 

typedef struct history_list
{
    PHISTORY_RECORD front;
    PHISTORY_RECORD rear;
    int iLen;
    int iMax;
} HISTORY_LIST, *PHISTORY_LIST;

int history_init( PHISTORY_LIST list, int iMax );
PHISTORY_RECORD history_get_record( char *cpCmd );
int history_pushback( PHISTORY_LIST list, PHISTORY_RECORD record ); 
PHISTORY_RECORD history_pop( PHISTORY_LIST list );
PHISTORY_RECORD history_front( PHISTORY_LIST list );
PHISTORY_RECORD history_index( PHISTORY_LIST list, int iIndex );
int history_print( PHISTORY_LIST list );
int history_clear( PHISTORY_LIST list );

#endif

三、history队列维护实现

/*
** FILE: history.c
** NOTE: 2016-01-11 created by Jack Liu
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "history.h"

int
history_init( PHISTORY_LIST list, int iMax )
{
    if( list == NULL )
    {
        fprintf( stderr, "history operation: init error, list argument illegal\n" );
        return -1;
    }
    list->front = list->rear = NULL;
    list->iLen = 0;
    list->iMax = iMax;

    return 0;
}

PHISTORY_RECORD
history_get_record( char *cpCmd )
{
    PHISTORY_RECORD pRecord;

    pRecord = malloc( sizeof( HISTORY_RECORD ) );
    if( pRecord == NULL )
    {
        perror( "malloc" );
        return NULL;
    }
    memset( pRecord, 0x00, sizeof( HISTORY_RECORD ) );

    strcpy( pRecord->cpCmd, cpCmd );
    return pRecord;
}

int
history_pushback( PHISTORY_LIST list, PHISTORY_RECORD pRecord )
{
    if( list == NULL || pRecord == NULL )
    {
        fprintf( stderr, "illegal operation: list is empty\n" );
        return -1;
    }

    if( list->rear == NULL )
    {   /* first record */
        list->front = pRecord;
        pRecord->prev = pRecord->next = NULL;
    }
    else
    {
        list->rear->next = pRecord;
        pRecord->prev = list->rear;
        pRecord->next = NULL;
    }
    list->rear = pRecord;
    list->iLen++;
    if( list->iLen > list->iMax )
    {
        PHISTORY_RECORD pToFree = list->front;
        list->front = list->front->next;
        list->front->prev = NULL;
        free( pToFree );
        list->iLen = list->iMax;
    }

    return 0;
}

PHISTORY_RECORD
history_pop( PHISTORY_LIST list )
{
    PHISTORY_RECORD pRecord;
    if( list == NULL )
    {
        fprintf( stderr, "history operation: list is illegal\n" );
        return NULL;
    }

    if( list->rear == NULL )
        return NULL; /* the history list is emtpy */

    pRecord = list->rear;
    list->rear = list->rear->prev;

    if( list->rear == NULL ) /* now list is empty */
        list->front = NULL;
    else
        list->rear->next = NULL;

    return pRecord;
}

PHISTORY_RECORD
history_front( PHISTORY_LIST list )
{
    PHISTORY_RECORD pRecord;
    if( list == NULL )
    {
        fprintf( stderr, "history operation: list is illegal\n" );
        return NULL;
    }

    if( list->front == NULL )
        return NULL;     /* history list is empty */

    pRecord = list->front;
    list->front = list->front->next;

    if( list->front == NULL ) /* now list is empty */
        list->rear = NULL;
    else
        list->front->prev = NULL;

    return pRecord;
}

PHISTORY_RECORD
history_index( PHISTORY_LIST list, int iIndex )
{
    PHISTORY_RECORD pRecord;
    int i;
    if( list == NULL )
    {
        fprintf( stderr, "history operation: list is illegal\n" );
        return NULL;
    }

    if( list->front == NULL )
    {
        fprintf( stderr, "history operation: list is emtpy\n" );
        return NULL;
    }

    if( iIndex > list->iLen )
    {
        fprintf( stderr, "no such history command\n" );
        return NULL;
    }

    i = 1;
    pRecord = list->rear;
    while( ++i <= iIndex )
        pRecord = pRecord->prev; 

    return pRecord;
}

int
history_print( PHISTORY_LIST list )
{
    PHISTORY_RECORD pRecord;
    int i;
    if( list == NULL )
    {
        fprintf( stderr, "history operation: history list is empty\n" );
        return -1;
    }

    i = list->iLen;
    pRecord = list->front;
    while( i > 0 )
    {
        printf( "%02d %s\n", i--, pRecord->cpCmd ); 
        pRecord = pRecord->next;
    }


    return 0;
}

int
history_clear( PHISTORY_LIST list )
{
    if( list != NULL )
    {
        PHISTORY_RECORD pRecord;
        while( ( pRecord = history_front( list ) ) )
            free( pRecord );
    }

    return 0;
}

四、源代码

http://download.csdn.net/detail/qq123386926/9401186