Sistemas Operativos:

Relatrio do Primeiro Trabalho Prtico

Shell> sosh
Elementos do Grupo: Amlcar Fernandes: [ ei99079@fe.up.pt]

Faculdade de Engenharia da Universidade do Porto Departamento de Engenharia Electrotcnica e de Computadores Rua Roberto Frias, s/n, 4200-465 Porto, Portugal

Outubro 2009
Shell SOSH Pgina 1

Resumo
Shell SOSH um interpretador de comandos do Sistema Operativo Linux. Trabalho proposto foi desenvolvido no mbito de disciplina de Sistemas Operativos, do 3 ano de Mestrado Integrado em Engenharia Informtica e Computao, da Faculdade de Engenharia da Universidade do Porto. Programa cumpre todos os objectivos propostos para desenvolvimento deste trabalho. Sem contar com a parte de valorizao que no foi implementada. Neste relatrio, encontram-se descritas as funcionalidades do programa que foram implementadas, as fases de desenvolvimento, bem como a compilao e execuo.

Shell SOSH

Pgina 2

ndice
1. Resumo 2. Introduo 1. Objectivo 2. Motivao 3. Shell SOSH 1. Introduo 2. Funcionalidades e Usabilidade 3. Descrio 4. Execuo do Programa 5. Resultados Obtidos 4. Desenvolvimento 1. Descrio de Ferramenta de Desenvolvimento 2. Mdulo SOSH 3. Implementao 4. Arquitectura 5. Estrutura do Programa 5. Concluso e Perspectivas de Desenvolvimentos Futuros 6. Bibliografia

Shell SOSH

Pgina 3

Glossrio

Shell SOSH programa de interpretao de comandos de Sistema Operativo Linux. quem comando SOSH para executar comando Unix num processo independente. psu comando SOSH lista processos em execuo do utilizador actual. ver comando SOSH imprime no stdout a verso do programa. ajuda comando SOSH lista os comandos suportados. localiza comando SOSH localiza todos os caminhos absolutos onde aparece um comando passado como parmetro. exit comando SOSH termina e sai do programa. execv famlias da funo exec(), permitem lanamento de execuo de programas externos ao processo. Nesta funo, o nmero de argumentos do programa lanado desconhecido. execvp idem a descrio de cima, feito no execv, sendo que, esta funo, fornece um vector de apontadores para strings no nulas que representam a lista de argumentos do programa que se pretende executar. execlp idem a descrio de cima, feito no execv, mas nesta funo, o argumento uma lista passada como parmetro na linha de comando, que descrevem uma lista ou mais de apontadores para strings no nulas e que representam a lista de argumentos do programa que se pretende executar.

Shell SOSH

Pgina 4

Lista de figuras
[Figura 1: Shell SOSH Execuo do comando: quem] -------------------------------------Pg. 8 [Figura 2: Shell SOSH Execuo do comando: psu] ----------------------------------------Pg. 8 [Figura 3: Shell SOSH Execuo do comando: ver] ----------------------------------------Pg. 9 [Figura 4: Shell SOSH Execuo do comando: ajuda] -------------------------------------Pg. 9 [Figura 5: Shell SOSH Execuo do comando: localiza] ------------------------------------Pg. 10 [Figura 6: Shell SOSH Execuo do comando: exit] ----------------------------------------Pg. 10 [Figura 6: Shell SOSH Execuo do comando: /usr/bin/ cmd] ---------------------------Pg. 11 [Figura 8: Arquitectura de Aplicao Shell SOSH] --------------------------------------------Pg. 13 [Figura 9: Estrutura do Programa SOSH] ------------------------------------------------------Pg. 13

Shell SOSH

Pgina 5

Introduo
Ao longo deste relatrio, salientam-se duas abordagens principais inerentes funcionalidades do programa e ao desenvolvimento do mesmo: Shell SOSH descreve funcionalidades do programa que foram implementadas, compilao e execuo. Desenvolvimento descreve fases de implementao, arquitectura e estrutura do programa.

1. Objectivos
Familiarizar com a interface de desenvolvimento de sistemas baseados em Unix. Consolidao de tcnicas de programao de aplicaes, do domnio Shell, recorrendo a utilizao de interfaces disponibilizadas pelo Sistema Operativo.

2. Motivao
Consolidao de competncias tcnicas, no domnio de desenvolvimento de aplicaes que interpretam os comandos do sistema Unix. E desenvolver, por outro, capacidades de utilizar e explorar melhor, os recursos que o Sistema Operativo disponibiliza.

Shell SOSH

Pgina 6

Shell SOSH
1. Introduo
Shell SOSH explora as potencialidades dos recursos disponibilizados pelo Sistema Operativo UNIX para implementar funcionalidades, baseadas na utilizao de interface de desenvolvimento do sistema.

2. Descrio
Shell SOSH, l os comandos introduzidos pelo utilizador, interpreta-os de acordo com a semntica definida no programa e apresenta os resultados na consola. O interpretador reconhece sete comandos descritos por ordem nos pontos a seguir.

3. Funcionalidades e Usabilidade
Shell SOSH disponibiliza sete funcionalidades implementadas. Essas funcionalidades esto descritas com mais detalhe no ponto a seguir. A partir do ambiente Shell SOSH, o utilizador pode consultar os processos em execuo, ver a verso actual do programa, aceder ao menu ajuda, localizar os caminhos dos comandos ou executar aplicaes localizadas no /usr/bin.

4. Execuo do Programa
Para executar o programa, foi criado um Makefile para fazer a ligao do programa e gerar automaticamente o ficheiro executvel sosh. Executar make na linha de comando: shell> make Arrancar o programa: shell> sosh <nome de comando> e ou <argumentos> Nome de comandos e argumentos (ver a descrio no Glossrio): shell> sosh quem shell> sosh psu shell> sosh ver shell> sosh ajuda shell> sosh localiza <path> <comando> shell> sosh exit shell> sosh /usr/bin/ <comando> <argumento>

Shell SOSH

Pgina 7

5. Resultados Obtidos
A seguir so apresentados os resultados obtidos com a execuo dos comandos descritos acima.

Execuo do comando quem:

[Figura 1: Shell SOSH Execuo do comando: quem]

Execuo do comando psu:

[Figura 2: Shell SOSH Execuo do comando: psu] Shell SOSH Pgina 8

Execuo do comando ver:

[Figura 3: Shell SOSH Execuo do comando: ver]

Execuo do comando ajuda:

[Figura 4: Shell SOSH Execuo do comando: ajuda]

Shell SOSH

Pgina 9

Execuo do comando localiza:

[Figura 5: Shell SOSH Execuo do comando: localiza]

Execuo do comando exit:

[Figura 6: Shell SOSH Execuo do comando: exit]

Shell SOSH

Pgina 10

Execuo do comando /usr/bin/ cmd:

[Figura 6: Shell SOSH Execuo do comando: /usr/bin/ cmd]

Desenvolvimento
1. Descrio de Ferramenta de Desenvolvimento
Todo o programa foi desenvolvido no ambiente UNIX, utilizando a linguagem de programao C. A linguagem de programao C, disponibiliza bibliotecas com funes bastante teis, que permitem criar aplicaes capazes de utilizar interface de desenvolvimento do sistema UNIX.

2. Mdulo SOSH
SOSH o mdulo principal do programa. Todos os programas implementados so chamados neste mdulo.

Shell SOSH

Pgina 11

Implementa os mecanismos para a manipulao dos dados passados no ambiente Shell SOSH. Possui estruturas definidas, para suportar os dados de entrada, de formas a armazena-los correctamente, afim de serem utilizados para gerar resultados de sada desejveis.

3. Implementao
O programa foi implementado por etapas. Na primeira etapa, foi desenvolvida a primeira verso do sosh0.1. Para esta fase, foi implementada uma funcionalidade, que reconhece o comando quem que por sua vez executa o comando UNIX who. Na segunda etapa, foi desenvolvida a segunda verso de aplicao sosh0.2 onde foi implementada outras cinco funcionalidades, j descritos anteriormente; psu, ver, ajuda, localiza e exit. Na terceira etapa, a verso sosh0.3 foi implementado um programa que permite a execuo de aplicaes localizadas no /usr/bin. Produto resultante est compactado num mdulo com trs ficheiros: cmds.h contm o prottipo dos programas implementados. cmds.s contm todos os programas desenvolvidos para suportar os comandos segundo a semntica Shell SOSH. sosh.c o ficheiro que contm o programa principal.

Shell SOSH

Pgina 12

4. Arquitectura
Shell SOSH alm de chamadas programas internos do mdulo, utiliza recursos da interface de desenvolvimento do sistema disponveis. Recursos que aparecem especificados como segunda camada de Aplicao.

[Figura 8: Arquitectura de Aplicao Shell SOSH]

5. Estrutura do Programa
A aplicao resultante um mdulo com trs ficheiros, que contm implementao de todo o programa Shell SOSH. Como mostra a figura em baixo, alm dos trs ficheiros referido, tambm tem um Makefile para compilar o programa e gerar um executvel sosh automaticamente.

[Figura 9: Estrutura do Programa SOSH]

Shell SOSH

Pgina 13

Concluso e Perspectivas de Desenvolvimentos Futuros

Todos os objectivos foram cumpridos neste trabalho. Isto , sem contar com a parte de valorizao que no foi implementada, do resto, como j foi referido na parte introdutria deste relatrio. Interface de desenvolvimento de sistemas baseado em UNIX, oferece uma potencialidade enorme que podem ser explorados, na concesso de aplicaes que fazem uso desses recursos. Num futuro projecto desta natureza, se poderia adaptar esta aplicao, Shell SOSH, como interface de gerao automtica de executveis para aplicaes. Precisar-se- fazer, obviamente, muitas adaptaes e outras implementaes adicionais.

Shell SOSH

Pgina 14

Bibliografia
[1]Tanenbaum, Andrew S.;Modern operating systems [2] - http://www.linux.com [2] - http://www.linuxsecurity.com.br/

Shell SOSH

Pgina 15

ANEXOS

Shell SOSH

Pgina 16

[Cdigos do programa]

shsh.c
#include <unistd.h> #include <sys/types.h> #include <signal.h> #include <sys/wait.h> #include <sys/stat.h> #include <sys/fcntl.h> #include <sys/dir.h> #include <sys/param.h> #include <dirent.h> #include <stddef.h> #include <stdlib.h> #include <stdio.h> #include <getopt.h> #include <string.h>

#include "cmds.h" #define MAX_LEN 1024 pid_t pid; void handler(int sig){ if (sig==SIGINT){ printf("Programa cancelado por sua ordem"); cmd_exit(pid); } } int main(int argc, char **argv){

int estado; signal(SIGINT, handler); /* INSTALA O HANDLER*/

Shell SOSH

Pgina 17

if ((pid = fork()) == 0){

printf("Processo filho em execucao..."); printitle(); printf("\nPARA SAIR PRIMA CTRL - C\n"); } else { wait(&estado); printf("\nProcesso Pai aguarda Filho com PID: [%d]\n", pid); printf("\nValor de retorno: [%d]\n", WEXITSTATUS(estado)); /* DEFINIDAS AQUI ESTRUTURAS PARA FAZER PARSE DOS ARGUMENTOS PASSADOS NA LINHA DE COMANDO */ int i = 0, j; char *p; char buf[1024]; char *stringrec[1024];

printf("Escreve nome comando: \n");

if (argc < 2){ printf("USAGE: ./sosh <comand_name> <args>\n"); exit(0); } memset(buf,0,sizeof(buf)); for(j=0; j < argc; j++){ strcat(buf,argv[j]); if(j<argc) strcat(buf," "); } p = strtok(buf, " ");

Shell SOSH

Pgina 18

while (p != NULL){

stringrec[i] = p; printf("%d - %s\n", i, stringrec[i]); p = strtok(NULL, " "); i++; } do { int n; char cmd[MAX_LEN]; memset(cmd, 0, sizeof(cmd)); for (n=1; n < argc; n++){

if ((strcmp(stringrec[n], "quem"))==0){ strcpy(cmd, stringrec[n]); cmd_quem(cmd); cmd[n] = '\0'; } else if((strcmp(stringrec[n], "psu"))==0){ strcpy(cmd, stringrec[n]); cmd_psu(cmd); cmd[n] = '\0'; } else if((strcmp(stringrec[n], "ver"))==0){ cmd[n] = '0'; cmd_ver(); } else if((strcmp(stringrec[n], "ajuda"))==0){

cmd_ajuda();

Shell SOSH

Pgina 19

} else if(((strcmp(stringrec[n], "localiza"))==0) || ((strcmp(stringrec[n], "localiza"))==0 && ((strcmp(stringrec[n+1], "cmd"))==0))){

cmd_localiza(argv, argc); } else if((strcmp(stringrec[n], "exit"))==0){ cmd_exit(pid); } else if ((strcmp(stringrec[n], "/usr/bin/"))==0){ cmd_usrbin(argv, argc); } else { printf("\nComando Invalido!"); } } } while(argv != NULL); } return 0; }

Shell SOSH

Pgina 20

cmds.c
#include <unistd.h> #include <sys/types.h> #include <signal.h> #include <sys/wait.h> #include <sys/stat.h> #include <sys/fcntl.h> #include <sys/dir.h> #include <sys/param.h> #include <dirent.h> #include <stddef.h> #include <stdlib.h> #include <stdio.h> #include <getopt.h> #include <string.h>

#include "cmds.h"

#define FALSE 0 #define TRUE 1 #define MAX_LEN 1024

typedef struct{ char nome[MAX_LEN]; float valor; int quantidade; } Informacao;

int file_select(struct dirent *entry); char pathname[MAXPATHLEN];

Shell SOSH

Pgina 21

/* @printh()

< FUNCAO PRINTH IMPLEMENTADA APENAS PARA IMPRIMIR O CABECALHO QUE IDENTIFICA O PROGRAMA. */ void printh(){ puts("\n\t*********************"); puts("\tPROGRAMA SHELL - SOSH"); puts("\t>> puts("\tA J VERSAO .02 <<"); U D A");

puts("\t*********************\n"); }

/* @printitle()

< FUNCAO PRINTH IMPLEMENTADA APENAS PARA IMPRIMIR O CABECALHO QUE IDENTIFICA O PROGRAMA. */

void printitle(){ puts("\n\t***********************"); puts("\tPROGRAMA SHELL - SOSH");

Shell SOSH

Pgina 22

puts("\t>>

VERSAO .03 <<");

puts("\t***********************\n"); }

/* @cmd_psu(char *cmd)

< FUNCAO PSU IMPLEMENTADA. LISTA PROCESSOS EM EXECUCAO. < RECEBE COMO ARGUMENTO O COMANDO RECONHECIDO PELO SISTEMA - PSU < ATRAVES DO EXECVP EXECUTA O COMANDO PS */ int cmd_quem(char *cmd){

if (strcmp(cmd, "quem") == 0){ execvp("who", NULL); exit(0); } return 0; }

/* @cmd_psu(char *cmd)

< FUNCAO PSU IMPLEMENTADA. LISTA PROCESSOS EM EXECUCAO. < RECEBE COMO ARGUMENTO O COMANDO RECONHECIDO PELO SISTEMA - PSU

Shell SOSH

Pgina 23

< ATRAVES DO EXECVP EXECUTA O COMANDO PS */ int cmd_psu(char *cmd){

if (strcmp(cmd, "psu")==0){ execvp("ps", NULL); exit(0); } return 0; }

/* @cmd_exit(int pid)

< FUNCAO EXIT IMPLEMENTADA. TERMINA O PROGRAMA PEMITINDO AO UTILIZADOR < ESCOLHER UMA DAS DUAS OPCOES (S / N): < (S) - TERMINA O PROGRAMA E FAZ KILL AO PROCESSO EM EXECUCAO CUJO O PID E' PASSADO COMO PARAMETRO DO EXIT. < (N) - PROGRAMA CONTINUA. */ void cmd_exit(int pid){

char msg; printf("Pretende Terminar Programa (S / N)?: \n"); fflush(stdin); printf("> "); msg = getchar();

Shell SOSH

Pgina 24

if (msg == 'S' || msg == 's'){ printf("\nPrograma vai terminar...\n"); sleep(1); printf("OK\n"); if (pid==0){ kill(pid, SIGKILL); } if (pid==1){ kill(pid, SIGKILL); }

exit(0); } else if (msg == 'N' || msg == 'n'){ while(1){ printf("\nPrograma continua\n"); cmd_exit(pid); } } else{ printf("\nComando Invalido!\n"); cmd_exit(pid); } fflush(stdout); }

Shell SOSH

Pgina 25

/* @cmd_localiza()

< FUNCAO LOCALIZA IMPLEMENTADA. RECEBE O PATH E COMANDOS COM ARGUMENTOS OU NAO < LISTA TODOS OS CAMINHOS ABSOLUTOS ONDE APARECE O COMANDO DADO COMO ARGUMENTO. < LISTA DIRECTORIOS E TODOS OS FICHEIROS QUE CONTEM. */ int cmd_localiza(char **argv, int argc){

int i=0, j; char *p; char buf[1024]; char *strings[1024];

char pathcat[MAX_LEN] ;

DIR *dir; struct dirent *entry;

//- INICIALIZA BUF A ZERO ANTES DO PARSE PARA ELIMINAR CARACTERES INDESEJAVEIS. memset(buf, 0, sizeof(buf)); for (j=0; j < argc; j++){ strcat(buf, argv[j]); if (j < argc) strcat(buf, " "); }

Shell SOSH

Pgina 26

//- FAZ PARSER DOS DADOS DE ENTRADA PASSADOS PELA LINHA DE COMANDO p = strtok(buf, " "); while(p != NULL){

strings[i] = p; printf("%i - %s\n", i, strings[i]); p = strtok(NULL, " "); i++; } strings[i] = NULL;

//- COLOCA APENAS O PATH E O COMANDO A EXECUTAR NA VARIAVEL - pathcat. int k; memset(pathcat, 0, sizeof(pathcat)); for (k=2; k < 3; k++){ strcat(pathcat, strings[k]); }

if ((dir = opendir("/")) == NULL){ perror("opendir() error"); }

printf("\nAbriu o directorio\n");

while ((entry = readdir(dir)) != NULL){ //if ((strcmp(entry->d_name, strings[2]))==0){ printf("%s \n", entry->d_name); //execv(pathcat, strings); execlp("find", "find", pathcat, pathcat, NULL); puts(" ");

Shell SOSH

Pgina 27

//} } closedir(dir); return 0; }

int file_select(struct dirent *entry){

if ((strcmp(entry->d_name, ".") == 0) || (strcmp(entry->d_name, "..") == 0) ) return (FALSE); return (TRUE); }

/* @cmd_ajuda(void)

< FUNCAO AJUDA IMPLEMENTADA. LISTA TODOS OS COMANDOS SUPORTADOS PELO SISTEMA. < LISTA NUMERO DE OPCOES CORRESPONDENTES A CADA COMANDO, PARA ACEDER MAIS < INFORMACOES SOBRE OS COMANDOS. */ int cmd_ajuda(void){ printh();

int opc;

Shell SOSH

Pgina 28

do { printf("\nLISTA DE OPCOES DOS COMANDOS SUPORTADAS PELO SISTEMA.\n\n"); puts("\nSeleccione uma opcao para mais informacao\n");

printf("\n[1] - QUEM\n"); printf("\n[2] - PSU\n"); printf("\n[3] - VER\n"); printf("\n[4] - AJUDA\n"); printf("\n[5] - EXIT\n"); printf("\n[6] - LOCALIZA\n"); printf("\n[7] - SAIR\n");

printf("> "); scanf("%d", &opc);

switch (opc){

case 1: printf("\n<quem> : Executa o comando <who>.\n"); printf("\nPara listar processos do utilizador.\n"); break;

case 2: printf("\n<psu> break; : Lista processo em execucao do actual user.\n");

case 3: printf("\n<ver> break; : Imprime a versao do programa sosh no stdout.\n");

Shell SOSH

Pgina 29

case 4: printf("\n<ajuda> : Lista os comandos suportados pelo programa.\n"); break;

case 5: printf("\n<exit> break; : Para sair do programa.\n");

case 6: printf("\n<localiza> <file_name>: Localiza caminhos absolutos.\n"); break;

case 7: printf("\nFim do Programa.\n"); exit(0); break;

default: printf("\nOpcao Invalida!\n"); } } while(opc); return 0; }

/* @cmd_ver(char *nome)

Shell SOSH

Pgina 30

< FUNCAO VER IMPLEMENTADA. MOSTRA A VERSAO DO SISTEMA < VERSAO SO SISTEMA IMPRIMIDO ATRAVEZ DO SDTOUT */ void cmd_ver(){

int fd; size_t n;

//nome = "root@amilcar-laptop: ./home/amilcar/rea de Trabalho/so/*.c>";

Informacao info;

fd = open("readme.txt", O_RDONLY); if (fd < 0){ perror("USAGE open"); exit(0); }

lseek(fd, 0, SEEK_SET); while (fd != 0){ n = read(fd, &info, sizeof(info)); if (n==0){ //- fim do ficheiro break; } //printf("\nNome: %s\n", info.nome); //printf("\nValor: %f\n", info.valor); //printf("\nQuantidade: %d\n\n", (int)info.quantidade); }

Shell SOSH

Pgina 31

printf("\nNome: %s\n", info.nome); }

/* @cmd_usrbin(char **argv, int argc)

< FUNCAO USR_BIN IMPLEMENTADA. EXECUTA COMANDOS LOCALIZADOS NO /usr/bin/ < RECEBE O PATH E O NOME DO COMANDO A SER EXECUTADO. < USA - execv - PARA EXECUTAR COMANDOS */ int cmd_usrbin(char **argv, int argc){

int i=0, j, n; char *p; char buf[1024]; char *strings[1024];

char *path = "/usr/bin"; char pathcat[MAX_LEN] ;

DIR *dir; struct dirent *files;

memset(buf, 0, sizeof(buf)); for (j=0; j < argc; j++){ strcat(buf, argv[j]); if (j < argc)

Shell SOSH

Pgina 32

strcat(buf, " "); }

p = strtok(buf, " "); while(p != NULL){

strings[i] = p; printf("%i - %s\n", i, strings[i]); p = strtok(NULL, " "); i++; } strings[i] = NULL;

int k; memset(pathcat, 0, sizeof(pathcat)); for (k=1; k < 3; k++){ strcat(pathcat, strings[k]); }

for (n=1; n < argc; n++){

if ((dir = opendir(path)) == NULL){ perror("Opendir ERROR"); }

while ((files = readdir(dir)) != NULL){

printf("\nA executar comando: %s - %s\n", pathcat, files->d_name); execv(pathcat, strings); //- EXECUTA RESTO DE COMANDOS PASSOS COMO ARGUMENTOS puts(" ");

Shell SOSH

Pgina 33

} closedir(dir); } return 0; }

cmds.h
/* * cmds.h - sosh command module */

#ifndef _CMDS_H_ #define _CMDS_H_

int cmd_quem(char *cmd); //- Implementado

int cmd_psu(char *cmd); //- Implementado

int cmd_usrbin(char **argv, int argc); //- Implementado

void cmd_exit(int pid); //- Implementado

int cmd_localiza(char **argv, int argc); //- a fazer

int cmd_ajuda(); //- Implementado

void printitle();

Shell SOSH

Pgina 34

void printh();

void cmd_ver(); //- Implementado

#endif

Shell SOSH

Pgina 35