Wikibooks

コマンドインタープリタ

  1. コマンドインタープリタ ハンドブック

はじめに

編集

本書は、コマンドインタープリタの設計、実装、運用に関わる技術者を対象としたハンドブックです。基礎的な概念から実装の詳細まで、体系的な知識の提供を目指しています。

序章: コマンドインタープリタの歴史と進化

編集

コンピュータとの対話式インターフェースの歴史は、現代のコマンドインタープリタの設計思想を深く理解する上で欠かせません。この章では、その進化の過程を辿ります。

黎明期のコンピュータインターフェース

編集

1960年代初頭、コンピュータとのインタラクションは主にパンチカードを通じて行われていました。これは効率的とは言えず、即座のフィードバックを得ることは困難でした。この課題に対する解決策として、対話式のコマンドインタープリタが発展していきます。

Multicsの革新

編集

1964年に始まったMulticsプロジェクトは、現代のコマンドインタープリタの基礎となる多くの概念を生み出しました。Louis Pouzinが設計したMulticsシェルは、以下のような革新的な機能を備えていました： 

# Multicsシェルの特徴的な構文例
command arg1 arg2 >output_file    # 出力のリダイレクト
do_something ; do_other           # コマンドの連続実行

これらの機能の多くは、現代のシェルにも受け継がれています。

UNIXシェルの誕生

編集

Ken ThompsonがMulticsの概念をベースにUNIXを開発する際、Thompson shellを作成しました。これは後のBourne shell（sh）の基礎となり、現代のシェルの原型を形作りました。 

# Bourne shellで導入された制御構文
if [ "$1" = "test" ]; then
    echo "Test mode"
fi

現代のシェルへの進化

編集

現代のシェルは、過去の革新を踏まえつつ、新しい機能を追加しています。例えば、bashは以下のような高度な機能を提供します： 

# 配列の使用例
declare -A map
map[key]="value"
echo ${map[key]}

# プロセス置換
diff <(ls dir1) <(ls dir2)

第1章: コマンドインタープリタの基礎

編集

コマンドインタープリタは、ユーザーとオペレーティングシステムの間を取り持つ重要な役割を担っています。

コマンドインタープリタの基本構造

編集

一般的なコマンドインタープリタは、以下のような処理サイクルを持ちます：

  1. プロンプトの表示
  2. コマンドライン入力の受付
  3. 入力の解析
  4. コマンドの実行
  5. 結果の表示

これを実現するための基本的な実装例を見てみましょう： 

while (1) {
    display_prompt();
    char* command = read_command();
    if (command == NULL)
        break;
    
    parse_and_execute(command);
    free(command);
}

コマンドの種類と実行プロセス

編集

コマンドインタープリタが処理するコマンドには、主に以下の種類があります：

  1. ビルトインコマンド: インタープリタに組み込まれた内部コマンド
  2. 外部コマンド: 独立した実行ファイルとして存在するコマンド
  3. シェル関数: ユーザーが定義した関数
  4. エイリアス: コマンドの別名定義

以下は、コマンドタイプの判別と実行を行う基本的な実装例です： 

int execute_command(char *command_name, char **args) {
    // ビルトインコマンドの確認
    if (is_builtin(command_name)) {
        return execute_builtin(command_name, args);
    }
    
    // パスの検索
    char *full_path = find_in_path(command_name);
    if (full_path == NULL) {
        fprintf(stderr, "Command not found: %s\n", command_name);
        return -1;
    }
    
    // 子プロセスでの実行
    pid_t pid = fork();
    if (pid == 0) {  // 子プロセス
        execv(full_path, args);
        exit(1);  // execvが失敗した場合
    }
    
    // 親プロセスは子の終了を待つ
    int status;
    waitpid(pid, &status, 0);
    return status;
}

第2章: コマンドの解析と実行プロセス

編集

コマンドライン解析

編集

コマンドライン解析は、入力された文字列を意味のある要素に分解し、実行可能な形式に変換するプロセスです。このプロセスは以下の段階で行われます：

  1. レキシカル解析：入力を字句（トークン）に分割
  2. 構文解析：字句を文法規則に従って解釈
  3. セマンティック解析：コマンドの意味解釈と実行準備
typedef struct {
    char **tokens;
    int token_count;
    int redirections[3];  // 標準入力、出力、エラー出力
} ParsedCommand;

ParsedCommand* parse_command_line(const char *input) {
    ParsedCommand *cmd = malloc(sizeof(ParsedCommand));
    
    // 空白文字でトークンを分割
    char *token = strtok(input, " \t\n");
    while (token != NULL) {
        // リダイレクションの処理
        if (token[0] == '>') {
            handle_redirection(cmd, token);
        } else {
            add_token(cmd, token);
        }
        token = strtok(NULL, " \t\n");
    }
    
    return cmd;
}

環境変数の管理

編集

環境変数は、コマンドインタープリタの動作に重要な影響を与えます。以下は環境変数を管理するための基本的な実装例です： 

typedef struct {
    char *name;
    char *value;
    struct EnvVar *next;
} EnvVar;

EnvVar *env_list = NULL;

void set_env_var(const char *name, const char *value) {
    EnvVar *var = find_env_var(name);
    if (var) {
        // 既存の変数を更新
        free(var->value);
        var->value = strdup(value);
    } else {
        // 新しい変数を追加
        var = malloc(sizeof(EnvVar));
        var->name = strdup(name);
        var->value = strdup(value);
        var->next = env_list;
        env_list = var;
    }
}

第3章: シェルスクリプティング

編集

シェルスクリプトは、コマンドインタープリタの機能を活用してプログラミングを行うための仕組みです。

制御構文の実装

編集

基本的な制御構文（if、for、while等）の実装例を見てみましょう： 

typedef enum {
    NODE_COMMAND,
    NODE_IF,
    NODE_WHILE,
    NODE_FOR
} NodeType;

typedef struct Node {
    NodeType type;
    union {
        struct {
            char **args;
            int arg_count;
        } command;
        struct {
            struct Node *condition;
            struct Node *then_clause;
            struct Node *else_clause;
        } if_stmt;
    } data;
} Node;

int execute_if_statement(Node *node) {
    int condition_result = execute_node(node->data.if_stmt.condition);
    if (condition_result == 0) {
        return execute_node(node->data.if_stmt.then_clause);
    } else if (node->data.if_stmt.else_clause) {
        return execute_node(node->data.if_stmt.else_clause);
    }
    return 0;
}

関数の実装

編集

シェル関数は、コマンドの再利用性を高める重要な機能です。以下に関数管理の基本実装を示します： 

typedef struct {
    char *name;
    Node *body;
    char **parameters;
    int param_count;
} ShellFunction;

// 関数テーブルの実装
typedef struct {
    ShellFunction **functions;
    int capacity;
    int size;
} FunctionTable;

FunctionTable* create_function_table() {
    FunctionTable *table = malloc(sizeof(FunctionTable));
    table->capacity = 16;
    table->size = 0;
    table->functions = malloc(sizeof(ShellFunction*) * table->capacity);
    return table;
}

int register_function(FunctionTable *table, const char *name, Node *body, 
                     char **params, int param_count) {
    ShellFunction *func = malloc(sizeof(ShellFunction));
    func->name = strdup(name);
    func->body = body;
    func->parameters = params;
    func->param_count = param_count;
    
    // テーブルが満杯の場合は拡張
    if (table->size >= table->capacity) {
        table->capacity *= 2;
        table->functions = realloc(table->functions, 
                                 sizeof(ShellFunction*) * table->capacity);
    }
    
    table->functions[table->size++] = func;
    return 0;
}

第4章: 入出力の処理

編集

パイプラインの実装

編集

パイプラインは、複数のコマンドを連結して実行するための重要な機能です： 

typedef struct {
    ParsedCommand **commands;
    int command_count;
} Pipeline;

int execute_pipeline(Pipeline *pipeline) {
    int pipes[MAX_PIPELINE_COMMANDS-1][2];
    pid_t pids[MAX_PIPELINE_COMMANDS];
    
    // パイプの作成
    for (int i = 0; i < pipeline->command_count - 1; i++) {
        if (pipe(pipes[i]) < 0) {
            perror("pipe creation failed");
            return -1;
        }
    }
    
    // コマンドの実行
    for (int i = 0; i < pipeline->command_count; i++) {
        pids[i] = fork();
        if (pids[i] == 0) {
            // 子プロセスでの入出力設定
            if (i > 0) {  // 最初以外のコマンド
                dup2(pipes[i-1][0], STDIN_FILENO);
            }
            if (i < pipeline->command_count-1) {  // 最後以外のコマンド
                dup2(pipes[i][1], STDOUT_FILENO);
            }
            
            // 不要なパイプをクローズ
            for (int j = 0; j < pipeline->command_count-1; j++) {
                close(pipes[j][0]);
                close(pipes[j][1]);
            }
            
            execvp(pipeline->commands[i]->tokens[0], 
                  pipeline->commands[i]->tokens);
            exit(1);
        }
    }
    
    // 親プロセスでパイプをクローズ
    for (int i = 0; i < pipeline->command_count-1; i++) {
        close(pipes[i][0]);
        close(pipes[i][1]);
    }
    
    // 全コマンドの終了を待つ
    for (int i = 0; i < pipeline->command_count; i++) {
        waitpid(pids[i], NULL, 0);
    }
    
    return 0;
}

リダイレクション処理

編集

ファイルリダイレクションの実装例を示します： 

int setup_redirections(ParsedCommand *cmd) {
    // 入力リダイレクション
    if (cmd->redirections[0] >= 0) {
        dup2(cmd->redirections[0], STDIN_FILENO);
        close(cmd->redirections[0]);
    }
    
    // 出力リダイレクション
    if (cmd->redirections[1] >= 0) {
        dup2(cmd->redirections[1], STDOUT_FILENO);
        close(cmd->redirections[1]);
    }
    
    // エラー出力リダイレクション
    if (cmd->redirections[2] >= 0) {
        dup2(cmd->redirections[2], STDERR_FILENO);
        close(cmd->redirections[2]);
    }
    
    return 0;
}

第5章: 高度な機能の実装

編集

コマンド履歴の管理

編集

履歴機能の基本実装を示します： 

typedef struct {
    char **entries;
    int capacity;
    int size;
    int current;
} History;

History* create_history(int capacity) {
    History *hist = malloc(sizeof(History));
    hist->entries = malloc(sizeof(char*) * capacity);
    hist->capacity = capacity;
    hist->size = 0;
    hist->current = -1;
    return hist;
}

void add_to_history(History *hist, const char *command) {
    if (hist->size < hist->capacity) {
        hist->entries[hist->size] = strdup(command);
        hist->size++;
    } else {
        // 最も古いエントリを削除
        free(hist->entries[0]);
        memmove(hist->entries, hist->entries + 1, 
                sizeof(char*) * (hist->capacity - 1));
        hist->entries[hist->capacity - 1] = strdup(command);
    }
    hist->current = hist->size - 1;
}

タブ補完の実装

編集

タブ補完は現代のシェルに不可欠な機能です。以下に基本的な実装を示します： 

typedef struct {
    char *prefix;
    char **matches;
    int match_count;
} Completion;

Completion* find_completions(const char *partial_word) {
    Completion *comp = malloc(sizeof(Completion));
    comp->prefix = strdup(partial_word);
    comp->matches = NULL;
    comp->match_count = 0;
    
    // 現在のディレクトリをスキャン
    DIR *dir = opendir(".");
    struct dirent *entry;
    
    while ((entry = readdir(dir)) != NULL) {
        if (strncmp(entry->d_name, partial_word, strlen(partial_word)) == 0) {
            comp->matches = realloc(comp->matches, 
                                  sizeof(char*) * (comp->match_count + 1));
            comp->matches[comp->match_count++] = strdup(entry->d_name);
        }
    }
    
    closedir(dir);
    return comp;
}

第6章: セキュリティと権限管理

編集

セキュアな環境変数の処理

編集

環境変数の安全な処理は、セキュリティ上重要です： 

char* get_secure_env(const char *name) {
    char *value = getenv(name);
    if (!value) return NULL;
    
    // 環境変数の値の検証
    if (strlen(value) > MAX_ENV_LENGTH) {
        fprintf(stderr, "Warning: Environment variable too long\n");
        return NULL;
    }
    
    // 危険な文字のチェック
    if (strpbrk(value, ";&|`$")) {
        fprintf(stderr, "Warning: Potentially dangerous characters in env\n");
        return NULL;
    }
    
    return strdup(value);
}

権限の確認と制御

編集

特権操作を安全に行うための実装例： 

typedef struct {
    uid_t real_uid;
    uid_t effective_uid;
    gid_t real_gid;
    gid_t effective_gid;
} SecurityContext;

int check_command_permission(const char *command_path, SecurityContext *ctx) {
    struct stat st;
    
    if (stat(command_path, &st) != 0) {
        return -1;
    }
    
    // setuid/setgidビットのチェック
    if (st.st_mode & (S_ISUID || S_ISGID)) {
        // 特別な処理が必要
        if (ctx->effective_uid != 0) {
            fprintf(stderr, "Warning: Elevated privileges required\n");
            return -1;
        }
    }
    
    // 実行権限のチェック
    if (ctx->effective_uid == st.st_uid) {
        return (st.st_mode & S_IXUSR) ? 0 : -1;
    } else if (ctx->effective_gid == st.st_gid) {
        return (st.st_mode & S_IXGRP) ? 0 : -1;
    } else {
        return (st.st_mode & S_IXOTH) ? 0 : -1;
    }
}

第7章: デバッグとトラブルシューティング

編集

デバッグ機能の実装

編集
デバッグモードの基本実装：
typedef struct {
    int debug_level;
    FILE *debug_output;
    int trace_commands;
    int show_parse_tree;
} DebugContext;

void debug_log(DebugContext *ctx, int level, const char *format, ...) {
    if (level <= ctx->debug_level) {
        va_list args;
        va_start(args, format);
        
        fprintf(ctx->debug_output, "[DEBUG:%d] ", level);
        vfprintf(ctx->debug_output, format, args);
        fprintf(ctx->debug_output, "\n");
        
        va_end(args);
        fflush(ctx->debug_output);
    }
}

void trace_command_execution(DebugContext *ctx, ParsedCommand *cmd) {
    if (!ctx->trace_commands) return;
    
    fprintf(ctx->debug_output, "Executing command: ");
    for (int i = 0; cmd->tokens[i]; i++) {
        fprintf(ctx->debug_output, "%s ", cmd->tokens[i]);
    }
    fprintf(ctx->debug_output, "\n");
}

第8章: 実装例と応用

編集

シンプルなシェルの実装

編集

これまでの要素を組み合わせた基本的なシェルの実装例： 

typedef struct {
    History *history;
    FunctionTable *functions;
    DebugContext debug;
    SecurityContext security;
} Shell;

Shell* create_shell() {
    Shell *shell = malloc(sizeof(Shell));
    shell->history = create_history(1000);
    shell->functions = create_function_table();
    
    // デバッグコンテキストの初期化
    shell->debug.debug_level = 0;
    shell->debug.debug_output = stderr;
    shell->debug.trace_commands = 0;
    shell->debug.show_parse_tree = 0;
    
    // セキュリティコンテキストの初期化
    shell->security.real_uid = getuid();
    shell->security.effective_uid = geteuid();
    shell->security.real_gid = getgid();
    shell->security.effective_gid = getegid();
    
    return shell;
}

int shell_main_loop(Shell *shell) {
    char *line;
    while ((line = readline("$ ")) != NULL) {
        if (strlen(line) > 0) {
            add_to_history(shell->history, line);
            
            ParsedCommand *cmd = parse_command_line(line);
            if (cmd) {
                trace_command_execution(&shell->debug, cmd);
                execute_command(cmd, &shell->security);
                free_parsed_command(cmd);
            }
        }
        free(line);
    }
    return 0;
}

プラグインシステムの実装

編集

拡張性のあるプラグインシステムの実装例を示します： 

typedef struct {
    char *name;
    void *handle;
    int (*initialize)(Shell *shell);
    int (*cleanup)(Shell *shell);
    struct Plugin *next;
} Plugin;

typedef struct {
    Plugin *plugins;
    char *plugin_dir;
} PluginManager;

PluginManager* create_plugin_manager(const char *plugin_dir) {
    PluginManager *manager = malloc(sizeof(PluginManager));
    manager->plugins = NULL;
    manager->plugin_dir = strdup(plugin_dir);
    return manager;
}

int load_plugin(PluginManager *manager, const char *plugin_name) {
    char path[PATH_MAX];
    snprintf(path, PATH_MAX, "%s/%s.so", manager->plugin_dir, plugin_name);
    
    void *handle = dlopen(path, RTLD_NOW);
    if (!handle) {
        fprintf(stderr, "Failed to load plugin: %s\n", dlerror());
        return -1;
    }
    
    Plugin *plugin = malloc(sizeof(Plugin));
    plugin->name = strdup(plugin_name);
    plugin->handle = handle;
    plugin->initialize = dlsym(handle, "plugin_initialize");
    plugin->cleanup = dlsym(handle, "plugin_cleanup");
    
    // プラグインリストに追加
    plugin->next = manager->plugins;
    manager->plugins = plugin;
    
    return 0;
}

附録A: よく使用されるコマンドリファレンス

編集

以下の表に、基本的なビルトインコマンドの実装例を示します：

コマンド 説明 実装の注意点
cd ディレクトリ変更 相対/絶対パスの処理、環境変数の更新
pwd 現在のディレクトリ表示 シンボリックリンクの解決
export 環境変数の設定 変数名の検証、値のエスケープ
source スクリプトの読み込み 再帰的な読み込みの制限 
// cdコマンドの実装例
// cdコマンドの正しい実装例
int builtin_cd(int argc, char **argv) {
    const char *path;
    
    // 引数がない場合は$HOMEを使用
    if (argc < 2) {
        path = getenv("HOME");
        if (path == NULL) {
            fprintf(stderr, "cd: HOME not set\n");
            return 1;
        }
    } else {
        path = argv[1];
    }
    
    // chdir()システムコールを呼び出し
    // これによりカーネルのプロセス構造体内のcwdが更新される
    if (chdir(path) != 0) {
        // エラー処理: perror()はerrnoに基づいてエラーメッセージを出力
        perror("cd");
        return 1;
    }

    return 0;
}

/*
 * 注意点:
 * 1. chdirシステムコールは、カーネルの中のプロセス構造体（task_struct）の
 *    fs_struct内のpwd（現在の作業ディレクトリ）を直接更新します。
 * 2. シェルが環境変数PWDを使用している場合は、それは単なるユーザー空間での
 *    利便性のためであり、実際のプロセスの作業ディレクトリとは異なります。
 * 3. システムコールによってカーネル内で管理される実際のcwdと、
 *    環境変数PWDは別物であることを理解することが重要です。
 */

附録B: 設定ファイルの例

編集

典型的な設定ファイルのパース処理： 

typedef struct {
    char *prompt;
    int history_size;
    char *history_file;
    int tab_width;
    bool color_enabled;
} ShellConfig;

ShellConfig* read_config_file(const char *path) {
    ShellConfig *config = malloc(sizeof(ShellConfig));
    FILE *fp = fopen(path, "r");
    if (!fp) return NULL;
    
    char line[1024];
    while (fgets(line, sizeof(line), fp)) {
        char *key = strtok(line, "=");
        char *value = strtok(NULL, "\n");
        if (!key || !value) continue;
        
        // 先頭と末尾の空白を除去
        while (isspace(*key)) key++;
        while (isspace(*value)) value++;
        char *end = value + strlen(value) - 1;
        while (end > value && isspace(*end)) *end-- = '\0';
        
        if (strcmp(key, "prompt") == 0) {
            config->prompt = strdup(value);
        } else if (strcmp(key, "history_size") == 0) {
            config->history_size = atoi(value);
        }
        // その他の設定項目...
    }
    
    fclose(fp);
    return config;
}

附録C: トラブルシューティングガイド

編集
一般的な問題と解決方法：
  1. メモリリーク対策
void cleanup_shell(Shell *shell) {
    // ヒストリのクリーンアップ
    for (int i = 0; i < shell->history->size; i++) {
        free(shell->history->entries[i]);
    }
    free(shell->history->entries);
    free(shell->history);
    
    // 関数テーブルのクリーンアップ
    for (int i = 0; i < shell->functions->size; i++) {
        ShellFunction *func = shell->functions->functions[i];
        free(func->name);
        free_node(func->body);
        free(func->parameters);
        free(func);
    }
    free(shell->functions->functions);
    free(shell->functions);
    
    free(shell);
}

附録D: 参考文献とリソース

編集
  1. POSIX Shell Command Language Specification
  2. Advanced Programming in the UNIX Environment (W. Richard Stevens)
  3. Unix Shell Programming (Yashwant Kanetkar)
  4. The Linux Programming Interface (Michael Kerrisk)

これらの文献は、シェルの実装に関する詳細な情報を提供しています。特に、POSIXの仕様書は標準的な動作を理解する上で重要です。

"https://ja.wikibooks.org/w/index.php?title=コマンドインタープリタ&oldid=267715" より作成