+++ /dev/null
-#ifndef _BSD_SOURCE
-#define _BSD_SOURCE
-#endif
-#ifndef _XOPEN_SOURCE
-#define _XOPEN_SOURCE 500
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <getopt.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/uio.h>
-#include <sys/statvfs.h>
-#include <fcntl.h>
-#include <dirent.h>
-#include <unistd.h>
-#include <ctype.h>
-#include <sys/uio.h>
-#include <sys/queue.h>
-
-#include "xtio.h"
-#include "mount.h"
-#include "test.h"
-#include "test_driver.h"
-
-
-struct queue_t;
-
-typedef struct cmd_tree_t {
- char *res_name;
- char *val;
- int arg_count;
- struct queue_t *children;
-} cmd_tree;
-
-struct queue_t {
- char *val;
- cmd_tree *cmd;
- struct queue_t *next;
-};
-
-struct cmd_t cmd_list[] = {
- {"alloc", get_buffer, usage_get_buffer},
- {"chdir", test_do_chdir, usage_chdir},
- {"checkbuf", do_checkbuf, usage_checkbuf},
- {"chmod", test_do_chmod, usage_chmod},
- {"chown", test_do_chown, usage_chown},
- {"clear", test_do_clear, usage_clear},
- {"close", test_do_close, usage_close},
- {"cmpstr", cmp_bufs, usage_cmpbufs},
- {"creat", test_do_creat, usage_creat},
- {"debug", test_do_setdebug, usage_setdebug},
- {"dup", test_do_dup, usage_dup},
- {"dup2", test_do_dup2, usage_dup2},
- {"endian", get_endian, usage_endian},
- {"exit", test_do_exit, usage_exit},
- {"fcntl", test_do_fcntl, usage_fcntl},
- {"fdatasync", test_do_fdatasync, usage_fdatasync},
- {"fill", test_do_fillbuff, usage_do_fillbuff},
- {"free", free_buffer, usage_free_buffer},
- {"fstat", test_do_fstat, usage_fstat},
- {"fstatvfs", test_do_fstatvfs, usage_fstatvfs},
- {"fsync", test_do_fsync, usage_fsync},
- {"ftruncate", test_do_ftruncate, usage_ftruncate},
- {"getcwd", test_do_getcwd, usage_getcwd},
- {"getdirentries", test_do_getdirentries, usage_getdirentries},
- {"init", test_do_init, usage_init},
- {"init_iovec", test_do_init_iovec, usage_init_iovec},
- {"init_xtvec", test_do_init_xtvec, usage_init_xtvec},
- {"ioctl", test_do_ioctl, usage_ioctl},
- {"iodone", test_do_iodone, usage_iodone},
- {"iowait", test_do_iowait, usage_iowait},
- {"ipread", test_do_ipread, usage_ipread},
- {"ipreadv", test_do_ipreadv, usage_ipreadv},
- {"ipwrite", test_do_ipwrite, usage_ipwrite},
- {"ipwritev", test_do_ipwritev, usage_ipwritev},
- {"iread", test_do_iread, usage_iread},
- {"ireadv", test_do_ireadv, usage_ireadv},
- {"ireadx", test_do_ireadx, usage_ireadx},
- {"iwrite", test_do_iwrite, usage_iwrite},
- {"iwritev", test_do_iwritev, usage_iwritev},
- {"iwritex", test_do_iwritex, usage_iwritex},
- {"list", test_do_list, usage_list},
- {"lseek", test_do_lseek, usage_lseek},
- {"lstat", test_do_lstat, usage_lstat},
- {"mkdir", test_do_mkdir, usage_mkdir},
- {"mknod", test_do_mknod, usage_mknod},
- {"mount", test_do_mount, usage_mount},
- {"open", test_do_open, usage_open},
- {"printbuf", test_do_printbuf, usage_do_printbuf},
- {"printline", test_do_printline, usage_printline},
- {"pread", test_do_pread, usage_pread},
- {"preadv", test_do_preadv, usage_preadv},
- {"pwritev", test_do_pwritev, usage_pwritev},
- {"pwrite", test_do_pwrite, usage_pwrite},
- {"quit", test_do_exit, usage_exit},
- {"read", test_do_read, usage_read},
- {"readv", test_do_readv, usage_readv},
- {"readx", test_do_readx, usage_readx},
- {"rmdir", test_do_rmdir, usage_rmdir},
- {"setbuf", do_setbuf, usage_setbuf},
- {"sizeof", get_sizeof, usage_sizeof},
- /* {"setoutput", test_do_setoutput, usage_setoutput}, */
- {"stat", test_do_stat, usage_stat},
- {"statvfs", test_do_statvfs, usage_statvfs},
- {"symlink", test_do_symlink, usage_symlink},
- {"truncate", test_do_truncate, usage_truncate},
- {"umask", test_do_umask, usage_umask},
- {"umount", test_do_umount, usage_umount},
- {"unlink", test_do_unlink, usage_unlink},
- {"write", test_do_write, usage_write},
- {"writev", test_do_writev, usage_writev},
- {"writex", test_do_writex, usage_writex},
- {NULL, NULL, NULL}
-};
-
-int run_cmd(cmd_tree *cmd_arg);
-cmd_tree* build_tree(char **cmd, int *length, int total);
-/*
- * ##################################################
- * # Memory functions #
- * # Intended to allow users to gain access to #
- * # buffers of memory to be manipulated later #
- * ##################################################
- */
-
-void * alloc_buff32(unsigned int size, int align)
-{
- void* buf;
- long buf_ptr;
-
- /*
- if ((err = memalign(&buf, align, size)) != 0) {
- perror("memalign");
- return 0;
- }
- */
- size += align;
- buf = malloc(size);
- align--;
- DBG(3, fprintf(outfp, "Buf is at %p\n", (void *)buf));
- buf_ptr = (long)buf + ((long)buf & align);
-
- DBG(3, fprintf(outfp, "Buf is at %p\n", (void *)buf_ptr));
- return (void *)buf_ptr;
-}
-
-void free_buf32(void * ptr)
-{
- free(ptr);
-}
-
-long alloc_buff64(unsigned int size, int align)
-{
- char * buf;
- long ret_value;
-
- /*
- if (memalign((void **)&buf, align, size))
- return 0;
- */
- size += align;
- buf = malloc(size);
- align--;
- ret_value = (long)buf + ((long)buf & align);
- return ret_value;
-}
-
-void free_buf64(long ptr)
-{
- free((char *)ptr);
-}
-
-
-/*
- * Hash function for variables. Shamelessly stolen
- * from the ext3 code
- */
-unsigned int dx_hack_hash (const char *name, int len)
-{
- unsigned int hash0 = 0x12a3fe2d, hash1 = 0x37abe8f9;
- while (len--)
- {
- unsigned int hash = hash1 + (hash0 ^ (*name++ * 7152373));
- if (hash & 0x80000000) hash -= 0x7fffffff;
- hash1 = hash0;
- hash0 = hash;
- }
- return hash0;
-}
-
-struct var_mapping *get_map(char *var_name)
-{
- int index;
- struct var_mapping_list *curr;
-
-
- if (var_name[0] == '$') {
- /* It is a name--chop off the initial and get the mapping $ */
- var_name++;
- }
-
- index = dx_hack_hash(var_name, strlen(var_name));
- index %= MAX_VARS -1;
-
- DBG(5, fprintf(outfp, "Got index of %d for %s\n", index, var_name));
- curr = &map[index];
-
- while ((curr) && (curr->map.obj != -1) ) {
- if ( (curr->map.name == NULL) || (strcmp(curr->map.name, var_name)) )
- curr = curr->next;
- else
- return &curr->map;
- }
-
- return NULL;
-}
-
-char *get_str(char *var_name)
-{
- /* See if it is a quoted string */
- if (var_name[0] == '"') {
- /* Chop off the beginning and end quotes and return the string */
- int len = strlen(var_name);
- var_name[len-1] = '\0';
- var_name++;
- }
-
- return var_name;
-}
-
-static char*
-get_or_part(char **str, int* did_alloc)
-{
- char *tmp_str = *str;
- int i, norm_str=0;
-
- if (tmp_str == NULL)
- return NULL;
-
- if (tmp_str[0] == '|') {
- tmp_str++;
- norm_str=1;
- }
-
- for (i=0; (unsigned int)i < strlen(tmp_str); i++) {
- if (tmp_str[i] == '|') {
- char *new_str = (char *)malloc(i+1);
- memcpy(new_str, tmp_str, i);
- new_str[i] = '\0';
- *did_alloc = 1;
- *str = &tmp_str[i];
- return new_str;
- }
- }
-
- if (norm_str) {
- *did_alloc = 0;
- *str = NULL;
- return tmp_str;
- }
-
- return NULL;
-}
-
-int get_obj(char *var_name)
-{
- char** str = &var_name;
- char *str1;
- struct var_mapping *var_map;
- int did_alloc=0;
- int obj=0, got_obj=0;
-
- DBG(5, fprintf(outfp, "Getting object for %s\n", var_name));
-
- /* If var_name is a digit, we assume it is a literal */
- if (isdigit(var_name[0]))
- return atoi(var_name);
-
- /*
- * Check for '|', indicates that one or more values are or'd
- * together
- */
- while ((str1 = get_or_part(str, &did_alloc)) != NULL) {
-
- if (isdigit(str1[0])) {
- if (str1[0] == '0') {
- /* Assume octal format */
- obj |= strtol(str1, NULL, 8);
- } else
- obj |= atoi(str1);
- } else {
- var_map = get_map(str1);
- if (!var_map) {
- if (did_alloc)
- free(str1);
- return -1;
- }
- obj |= var_map->obj;
- }
-
- if (did_alloc) {
- did_alloc = 0;
- free(str1);
- }
- got_obj++;
- }
-
- if (got_obj)
- return obj;
-
- var_map = get_map(var_name);
- if (!var_map)
- return -1;
- else
- return var_map->obj;
-}
-
-
-void store_result(char *var_name, int result)
-{
- int index = dx_hack_hash(var_name, strlen(var_name));
- struct var_mapping_list *map_obj;
- struct var_mapping_list *new_map;
- index %= MAX_VARS -1 ;
-
- if (map[index].map.obj >= 0) {
-
- /* Got a collision --just chain it*/
- new_map = malloc(sizeof(struct var_mapping_list));
-
- map_obj = &map[index];
- while (map_obj->next != NULL)
- map_obj = map_obj->next;
-
- map_obj->next = new_map;
- } else
- new_map = &map[index];
-
- new_map->map.name = malloc(strlen(var_name) + 1);
- strcpy(new_map->map.name, var_name);
- new_map->map.obj = result;
- new_map->map.type = last_type;
- new_map->next = NULL;
- DBG(3, fprintf(outfp, "Stored %d in index %d hashed with %s\n",
- result, index, var_name));
-}
-
-void free_obj(char *obj_name)
-{
- int index;
- struct var_mapping_list *prev, *curr;
-
-
- /* See if it is a variable name */
- if (obj_name[0] == '$') {
- /* It is a name--chop off the initial $ */
- obj_name++;
- }
- index = dx_hack_hash(obj_name, strlen(obj_name));
- index %= MAX_VARS -1;
-
- DBG(5, fprintf(outfp, "Got index of %d\n", index));
- curr = &map[index];
-
- prev = NULL;
-
- while ((curr) && (curr->map.obj != -1) ) {
- if (strcmp(curr->map.name, obj_name)) {
- prev = curr;
- curr = curr->next;
- } else
- break;
- }
-
- /* Remove the object from the chain */
- if (prev)
- prev->next = curr->next;
-
- curr->map.obj = -1;
- free(curr->map.name);
- if (prev)
- free(curr);
-}
-
-
-/*
- * Given a long string, returns the string divided into
- * whitespace seperated words in list. Returns the number
- * of words
- */
-int parser(char *str, char** list)
-{
- int len, i=0, j=0, counter=-1;
- int in_quotes = 0;
- char *new_str;
-
-
- len = strlen(str);
- DBG(5, fprintf(outfp, "str is %s len is %d\n", str, len));
- while (i < len) {
-
- if ((i==0) || ((str[i] == ' ') && (in_quotes == 0)) ) {
- if (i != 0) {
- new_str[j] = '\0';
- DBG(5, fprintf(outfp, "Got word %s\n", list[counter]));
- i++;
- }
- while ((str[i] == ' ') && (in_quotes == 0))
- i++;
- counter++;
- new_str = list[counter] = malloc(MAX_WORD);
- j = 0;
-
- }
-
- new_str[j] = str[i];
- if (str[i] == '"') {
- if (in_quotes)
- in_quotes = 0;
- else
- in_quotes = 1;
- }
- if ((str[i] == ' ') && (in_quotes==0)){
- while (str[i+1] == ' ')
- i++;
- new_str[j] = '\0';
- }
- i++;
- j++;
-
- }
- new_str[j] = '\0';
- DBG(5, fprintf(outfp, "Got word %s\n", list[counter]));
- return counter +1;
-}
-
-
-int execute_cmd(char *cmd, char **args, int arg_count)
-{
- int i = 0;
-
- if (!strcmp(cmd, "help")) {
- if (arg_count > 0) {
- while(cmd_list[i].cmd != NULL) {
- if (!strcmp(cmd_list[i].cmd, args[0])) {
- (cmd_list[i].usage)();
- return 0;
- }
- i++;
- }
- } else {
- do_help();
- return 0;
- }
- return -1;
- }
- while(cmd_list[i].cmd != NULL) {
- if (!strcmp(cmd_list[i].cmd, cmd)) {
- return (cmd_list[i].func)(arg_count, args);
- }
- i++;
- }
- DBG(2, fprintf(outfp, "Command %s was invalid\n", cmd));
- return INVALID_CMD;
-}
-
-int get_args(struct queue_t *child, char** list, int num_args, int argnum)
-{
- char *argval;
-
- if (child->val != NULL) {
- argval = child->val;
- } else if (child->cmd != NULL) {
- run_cmd(child->cmd);
- if (child->cmd->res_name != NULL)
- argval = child->cmd->res_name;
- else {
- char tmpstr[50];
- int val = last_ret_val;
- sprintf(tmpstr, "%x", val);
- argval = tmpstr;
- }
- } else {
- DBG(2, fprintf(outfp, "I am confused\n"));
- return INVALID_ARGS;
- }
-
- list[argnum] = malloc(strlen(argval) + 1);
- strcpy(list[argnum], argval);
- argnum++;
-
- if (argnum == num_args)
- return SUCCESS;
- else if (child->next == NULL) {
- DBG(2, fprintf(outfp, "Only on arg number %d out of %d, but ran out of children\n",
- argnum, num_args));
- return INVALID_ARGS;
- } else
- return get_args(child->next, list, num_args, argnum);
-
- return SUCCESS;
-}
-
-int run_cmd(cmd_tree *cmd_arg)
-{
- char cmdstr[MAX_COMMAND];
- char *cmdptr;
- char **args;
- int res, i;
- struct buf_t *buf;
- char *cmd;
- struct queue_t *child;
-
- if (cmd_arg == NULL)
- return INVALID_CMD;
-
- cmd = cmd_arg->val;
- cmdptr = cmdstr;
- child = cmd_arg->children;
- if ( (!strcmp("exit", cmd)) || (!strcmp("quit", cmd)) ||
- (!strcmp("EXIT", cmd)) || (!strcmp("QUIT", cmd)) )
- strcpy(cmdstr, "exit");
- else if (!strcmp("ALLOC", cmd))
- strcpy(cmdstr, "alloc");
- else if (!strcmp("FREE", cmd))
- strcpy(cmdstr, "free");
- else if (!strcmp("HELP", cmd))
- strcpy(cmdstr, "help");
- else if (!strcmp("CALL", cmd)) {
- if (cmd_arg->arg_count < 1) {
- DBG(2, fprintf(outfp, "Need at least one command\n"));
- return INVALID_CMD;
- }
-
- cmd_arg->arg_count--;
- if (child->val != NULL)
- cmdptr = child->val;
- else {
- DBG(2, fprintf(outfp, "Need to specify command\n"));
- return INVALID_CMD;
- }
-
- DBG(3, fprintf(outfp, "Got cmd %s\n", child->val));
- if (cmd_arg->arg_count != 0)
- child = child->next;
-
-
- } else if (!strcmp("DEPOSIT", cmd))
- strcpy(cmdstr, "fill");
- else if (!strcmp("PRINT", cmd))
- strcpy(cmdstr, "printbuf");
- else {
- if (cmd_arg->res_name != NULL) {
- /*
- * If the cmd is not a valid command, just store it
- */
- res = get_obj(cmd_arg->children->val);
- last_type = UINT;
- if (res < 0) {
- /* Just store it as a string */
- buf = (struct buf_t *)malloc(sizeof(struct buf_t));
- buf->len = strlen(cmd);
- buf->buf = (char *)malloc(buf->len+1);
- strcpy(buf->buf, cmd_arg->children->val);
- buflist[next] = buf;
- res = next;
- DBG(3, fprintf(outfp, "Stored %s in index %d\n", (char *)buf->buf, next));
- next++;
- last_type = STR;
- }
- store_result(cmd_arg->res_name, res);
- return SUCCESS;
- } else
- return INVALID_CMD;
- }
-
-
- if (cmd_arg->arg_count == 0)
- args = NULL;
- else {
- args = (char **)malloc(sizeof(char *)*cmd_arg->arg_count);
- get_args(child, args, cmd_arg->arg_count, 0);
- }
-
- DBG(3, fprintf(outfp, "CMD: %s\n ARGS: ",cmdptr));
- for (i=0; i < cmd_arg->arg_count; i++)
- DBG(3, fprintf(outfp, "%s ", args[i]));
- DBG(3, fprintf(outfp, "\n"));
- res = execute_cmd(cmdptr, args, cmd_arg->arg_count);
- if (cmd_arg->res_name != NULL)
- store_result(cmd_arg->res_name, last_ret_val);
-
- return res;
-}
-
-
-int is_command(char *name)
-{
- if ( (strcmp(name, "CALL")) && (strcmp(name, "FILL")) &&
- (strcmp(name, "ALLOC")) && (strcmp(name, "PRINT")) &&
- (strcmp(name, "FREE")) && (strcmp(name, "exit")) &&
- (strcmp(name, "HELP")) && (strcmp(name, "help")) &&
- (strcmp(name, "quit")) && (strcmp(name, "EXIT")) &&
- (strcmp(name, "QUIT")) && (strcmp(name, "DEPOSIT")) )
- return 0;
-
- return 1;
-}
-
-#define ARGS 1
-int get_type(char *arg0)
-{
- if ((arg0[0] == '(') || (is_command(arg0)) ){
- return 2;
- }
-
- return ARGS;
-}
-
-
-int add_args(char **cmd, int length, int total, cmd_tree *tree)
-{
- int new_len, type;
- struct queue_t *old, *new;
-
- old = tree->children;
- while ((old) && (old->next))
- old = old->next;
- new = (struct queue_t *)malloc(sizeof(struct queue_t));
- if (old)
- old->next = new;
- else
- tree->children = new;
- new->next = NULL;
-
- type = get_type(cmd[0]);
- if (type < 0) {
- DBG(2, fprintf(outfp, "Don't understand %s\n", cmd[0]));
- return INVALID_CMD;
- }
- if (type == ARGS) {
- new->val = (char *)malloc(strlen(cmd[0])+1);
- strcpy(new->val, cmd[0]);
- new->cmd = NULL;
- total = 1;
- } else {
- new_len = length;
- if (cmd[0][0] == '(') {
- new_len--;
- }
-
- new->val = NULL;
- new->cmd = build_tree(&cmd[1], &new_len, total);
- if (new->cmd == NULL) { /* Invalid command */
- return length; /* Pretend we used everything up */
- }
- total = (length - new_len);
- DBG(4, fprintf(outfp, "Used %d bytes\n", total));
- }
-
- return total;
-}
-
-void free_tree(cmd_tree* tree)
-{
- if (!tree)
- return;
-
- if (tree->children) {
- struct queue_t *child = tree->children;
- struct queue_t *next;
- do {
- next = child->next;
- if (child->cmd)
- free_tree(child->cmd);
- free(child->val);
- free(child);
- child = next;
- } while (child);
- }
-
- if (tree->res_name)
- free(tree->res_name);
-
- if (tree->val)
- free(tree->val);
-
- free(tree);
-}
-
-cmd_tree* build_tree(char **cmd, int *length, int total)
-{
- int index = 0, used_args = 0;
- cmd_tree *tree;
- if ((*length < 0) || (!cmd) || (*cmd == NULL))
- return NULL;
-
-
- DBG(4, fprintf(outfp, "length is %d\n", *length));
- tree = (cmd_tree *)malloc(sizeof(cmd_tree));
- tree->res_name = NULL;
- tree->children = NULL;
- if (cmd[index][0] == '$') {
- tree->res_name = (char *)malloc(strlen(cmd[index])+1);
- strcpy(tree->res_name, (char*)(cmd[index]+1));
- index++;
- if (cmd[index][0] == '=')
- index++;
- } else
- tree->res_name = NULL;
-
- if (is_command(cmd[index]) == 0) {
- if (tree->res_name == NULL) {
- DBG(2, fprintf(outfp, "command %s is invalid \n", cmd[index]));
- return NULL;
- }
- }
-
- tree->val = (char *)malloc(strlen(cmd[index])+1);
- strcpy(tree->val, cmd[index]);
- index++;
- *length -= index;
- tree->arg_count = 0;
-
- if (*length == 0) {
- /* All done! */
- return tree;
- }
-
- /* Got to get the arguments */
- while (*length > 0) {
-
- if (cmd[index][0] == ')') {
- *length = *length-1;
- DBG(4, fprintf(outfp, "and now len is %d\n", *length));
- return tree;
- }
-
- used_args = add_args(&cmd[index], *length, total, tree);
- tree->arg_count++;
- *length -= used_args;
- index += used_args;
- }
-
- return tree;
-}
-
-char *line;
-char *getline(char *prompt)
-{
- int i=-1;
- int count=0;
-
- line = malloc(MAX_LINE);
- if ((do_prompt) && (infp == stdin))
- printf(prompt);
-
- do {
- /* If we get an end of file, just wait */
- if (feof(infp)) {
- while (feof(infp) && (line[i] != '\n')) {
- clearerr(infp);
- count++;
- fseek(infp, 0, SEEK_CUR);
- }
- } else {
- i++;
- }
- fread(&line[i], 1, 1, infp);
- } while(line[i] != '\n');
-
- line[i] = '\0';
-
- /* fprintf(stderr, "Got word %s\n", line); */
- DBG(5, fprintf(outfp, "Got word %s\n", line));
- return line;
-}
-
-void my_perror(char *msg)
-{
- char *errmsg = strerror(errno);
-
- DBG(2, fprintf(outfp, "%s: %s\n", msg, errmsg));
-}
-
-/* Static list of flag names */
-struct var_mapping flags_map[] = {
- {"O_RDONLY", O_RDONLY, UINT },
- {"O_WRONLY", O_WRONLY, UINT },
- {"O_RDWR", O_RDWR, UINT },
- {"O_CREAT", O_CREAT, UINT },
- {"O_EXCL", O_EXCL, UINT },
- {"O_NOCTTY", O_NOCTTY, UINT },
- {"O_TRUNC", O_TRUNC, UINT },
- {"O_APPEND", O_APPEND, UINT },
- {"O_SYNC", O_NONBLOCK, UINT },
- {"O_NDELAY", O_NDELAY, UINT },
- {"O_SYNC", O_SYNC, UINT },
- {"O_FSYNC", O_FSYNC, UINT },
- {"O_ASYNC", O_ASYNC, UINT },
- {"SEEK_SET", SEEK_SET, UINT },
- {"SEEK_CUR", SEEK_CUR, UINT },
- {"SEEK_END", SEEK_END, UINT },
- {"S_ISUID", S_ISUID, UINT },
- {"S_ISGID", S_ISGID, UINT },
- {"S_ISVTX", S_ISVTX, UINT },
- {"S_IRWXU", S_IRWXU, UINT },
- {"S_IRUSR", S_IRUSR, UINT },
- {"S_IREAD", S_IREAD, UINT },
- {"S_IWUSR", S_IWUSR, UINT },
- {"S_IWRITE", S_IWRITE, UINT },
- {"S_IXUSR", S_IXUSR, UINT },
- {"S_IEXEC", S_IEXEC, UINT },
- {"S_IRWXG", S_IRWXG, UINT },
- {"S_IRGRP", S_IRGRP, UINT },
- {"S_IWGRP", S_IWGRP, UINT },
- {"S_IXGRP", S_IXGRP, UINT },
- {"S_IRWXO", S_IRWXO, UINT },
- {"S_IROTH", S_IROTH, UINT },
- {"S_IWOTH", S_IWOTH, UINT },
- {"S_IXOTH", S_IXOTH, UINT },
- {"S_IFCHR", S_IFCHR, UINT },
- {"S_IFMT", S_IFMT, UINT },
- {"S_IFBLK", S_IFBLK, UINT },
- {"S_IFREG", S_IFREG, UINT },
- {"S_IFIFO", S_IFIFO, UINT },
- {"S_IFLNK", S_IFLNK, UINT },
- { NULL, -1, SINT }
-};
-
-void init_map()
-{
- int index = 0;
-
- while (flags_map[index].obj != -1) {
- store_result(flags_map[index].name, flags_map[index].obj);
- index++;
- }
-}
-
-int getquotedlen(char *str)
-{
- int i;
-
- if (str[0] != '"' && str[0] != '\'')
- return -1;
-
- for (i=1; str[i] != '\0' && str[i] != '"' && str[i] != '\''; i++);
-
- return i;
-}
-
-int perform_op(int num1, int num2, char op)
-{
- switch(op) {
-
- case '+':
- return num1 + num2;
- break;
-
- case '*':
- return num1 * num2;
- break;
-
- case '/':
- return num1 / num2;
- break;
-
- case '-':
- return num1 - num2;
- break;
-
- case '%':
- return num1%num2;
- break;
-
- default:
- return num1;
- }
- return 0;
-}
-
-int get_constant_val(char **str_ptr, int type)
-{
- struct buf_t *buf;
- char *buf_ptr;
- char *str = *str_ptr;
- char ch;
- int i, j, num1, num2, size;
-
- printf("Getting constant val from %s\n", str);
- switch(type) {
- case 1:
- size = getquotedlen(str);
- buf = (struct buf_t *)malloc(sizeof(struct buf_t));
- buf->buf = alloc_buff32(size, 8);
- buf->len = size;
- buf_ptr = buf->buf;
- buflist[next] = buf;
- j=0;
- for (i=1; i < size; i++) {
- buf_ptr[j] = str[i];
- j++;
- }
- buf_ptr[j] = '\0';
-
- DBG(3, fprintf(outfp, "Your buffer (%p) (%p) is at index %d\n",
- (void *)buf, buf->buf, next));
- next++;
-
- last_type = PTR;
- last_ret_val = next-1;
- return last_ret_val;
- break;
-
- case 2:
- if (str[0] == '$') {
- num1 = get_obj(str);
- } else {
- num1 = atoi(str);
- }
- str = str_ptr[1];
- ch = str_ptr[1][0];
- if ((ch == '+') || (ch == '/') || (ch == '*') ||
- (ch == '-') || (ch == '%')) {
- if (str_ptr[2][0] == '$')
- num2 = get_obj(str_ptr[2]);
- else
- num2 = atoi(str_ptr[2]);
- num1 = perform_op(num1, num2, ch);
- }
-
- last_type = UINT;
- last_ret_val = num1;
-
- break;
-
- default:
- DBG(2, fprintf(outfp, "Can't understand type of %d\n", type));
- return INVALID_ARGS;
- }
-
- return last_ret_val;
-}
-
-int is_constant(char *str)
-{
- if ((str[0] == '"') || (str[0] == '\''))
- return 1;
-
-
- if ( (str[0] == '$') ||
- ( ((int)str[0] > 47) && ((int)str[0] < 57) ) )
- return 2;
-
- return 0;
-}
-
-int main(int argc, char *argv[])
-{
- int count, err, i, orig_count;
- char *input, *name;
- char **cmd;
- cmd_tree *tree;
- extern int _test_sysio_startup(void);
-
- /*
- * Init sysio lib.
- */
- err = _test_sysio_startup();
-
- infp = stdin;
- outfp = stdout;
-
- do_prompt = 1;
-
- errno = 0;
- /* Get the input/output streams */
- for (i = 1; i < argc; i++) {
- if (!strcmp(argv[i], "--input")) {
- i++;
- infp = fopen(argv[i], "r");
- if (!infp) {
- fprintf(outfp, "Unable to open file %s for reading\n", argv[i]);
- return -1;
- }
- } else if (!strcmp(argv[i], "--output")) {
- i++;
- outfp = fopen(argv[i], "w");
- if (!outfp) {
- fprintf(stderr, "Unable to open file %s for writing\n", argv[i]);
- return -1;
- }
- } else if (!strcmp(argv[i], "--np")) {
- do_prompt = 0;
- } else {
- fprintf(stderr, "%s: Invalid arg\n", argv[i]);
- return -1;
- }
- }
- /* Initilize the mapping */
- for (i=0; i < MAX_VARS; i++)
- map[i].map.obj = -1;
-
- /* Debug defaults */
- debug_level = 1;
- print_line = 0;
-
-
-#if 0
- /* sysio defaults */
- strcpy(root_driver, DEFAULT_DRIVER);
- strcpy(mntpath, "/");
- mntflgs = 0;
-#endif
-
- my_errno = 0;
-
- /* Set up line buffering */
- setlinebuf(outfp);
- setlinebuf(infp);
-
- /*
- * This sets up some common flags so that the string
- * names can be used (for instance 0_RDWR, SEEK_SET, etc
- */
- init_map();
- i=0;
- next = 0;
- while (1) {
- bzero(output, 4096);
-
- input = getline("> ");
- cmd = malloc(MAX_COMMAND * sizeof(char *));
- count = orig_count = parser(input, cmd);
- name = NULL;
- if ((!count) || (count > MAX_COMMAND)){
- fprintf(outfp, "%s: invalid command\n", input);
- } else {
- i = 0;
- if (cmd[0][0] == '$') {
- /* Need to store output of command in var name */
- name = cmd[0]+1;
- DBG(4, fprintf(outfp, "name is %s\n", name));
- count--;
- /* The '=' is not necessary, but available */
- if (!strcmp(cmd[1], "=")){
- i++;
- count--;
- }
- i++;
- if ((err=is_constant(cmd[i])) != 0) {
- store_result((char *)(&cmd[0][1]), get_constant_val(&cmd[i], err));
- tree = NULL;
- err = 0;
- } else {
-
- tree = build_tree(&cmd[i], &count, 0);
- if (tree != NULL) {
- err = run_cmd(tree);
- store_result((char *)(&cmd[0][1]), last_ret_val);
- }
- }
- } else {
-
- tree = build_tree(cmd, &count, 0);
- if (tree != NULL)
- err = run_cmd(tree);
- }
- /* Print out return code and any string from command */
- fprintf(outfp, "%#04x %s\n", err, output);
- if (tree)
- free_tree(tree);
- /* fprintf(stderr, "%#04x %s\n", err, output); */
- for (i=0; i < count; i++)
- free(cmd[i]);
- }
- free(cmd);
- free(line);
- }
-}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff