// Paginas web de referencia:
// tomado del: https://sites.google.com/site/fpoprogramadorsistemas/analisis-de-argumentos-2
// https://sites.google.com/site/fpoprogramadorsistemas/soluciones-profe-del-cat
#include <stdio.h>
#include <limits.h>
#include <string.h>
// https://sites.google.com/site/fpoprogramadorsistemas/c-trabajar-con-directorios
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>
// para datos del usuario: man getpwuid
#include <pwd.h>
//http://www.fismat.umich.mx/mn1/manual/node19.html
#include <unistd.h> // leer la ruta actual donde este el programa
#include <grp.h> // datos del grupo
void VerResultadoA(char *, struct stat *); //lsl -a: ocultos y visibles mas datos.
void escribedatos(char *, struct stat *);
void VerResultadoAC(char *, struct stat *); //lsl -aca: ocultos y visibles sin datos
void VerResultadoC(char *, struct stat *); //lsl -c: solo nombre de visibles
void VerResultadoLSL(char *, struct stat *); //lsl: de visibles mas datos
int comprobar_Directorio_o_Fichero(char *); // lsl comprobar directorio o fichero
int procesarArgumentos(int, char **);
DIR *pdir;
char *nomfich;
char nomcomp[255];
struct stat st;
struct dirent *dp;
FILE *pf;
char cadena[125]; // aqui guarda el directorio actual si solo ejecuto LSL
// procesa todos los argumentos que reciba, y devuelve un numero
// positivo= la suma de los valores de los argumentos
// negativo =hay argumentos pero no son validos
// cero= no hay ningun argumento
int argumento(char *); // procesa cada argumento de forma
int esArgumento(char *); // comprueba que es un argumento
int main(int argc, char **argv)
{
int resul;
int numero_de_argumentos=0; // contador de argumentos
int uno=0;
int dos=0;
int archivo=0;
int valor=0;
// caso de lsl solo
// comprobacion si: es un archivo o directorio, y si existen....
if (argc==1) {
printf("Se trata del comando lsl solo.\n");
// se trata de solo la orden lsl
pdir = opendir(".");
dp = readdir(pdir);
while (dp != NULL) {
sprintf(nomcomp, "%s/%s", ".", dp->d_name);
nomfich = dp->d_name;
if (stat(nomcomp, &st) < 0) {
perror(nomcomp);
} else {
VerResultadoLSL(nomfich, &st);
}
dp = readdir(pdir);
}
closedir(pdir);
return 0; // termino el programa aqui
}
// hay mas de 1 arguento......
// PROCESAR ARGUMENTOS......
resul = procesarArgumentos(argc, argv);
printf("Trabajo realizar: \n");
if (resul > 0) { //
if (resul & 1) { // Enmascaramiento Binario: pregunto por los numero &(=y logico a nivel de bits). (no es lo mismo que &&) posicion 1, vease final
printf("Usado argumento \"a\"\n");
numero_de_argumentos++;
uno=1;
}
if (resul & 2) {
printf("Usado argumento \"c\"\n");
dos=1;
if (uno!=1) {
// para que no sume cuando la a esta tambien...
numero_de_argumentos++;
}
}
}
//***********************************************************************************
// dos= 1 ,numero de agumento =1
// uno=1, numero de agumento =1
// uno=1 y dos=1, numero de argumentos=2
//***********************************************************************************
// caso de lsl y directorio/fichero
if (uno==0 && dos==0 && argc==2) {
// ver si es un archivo o un directorio y listar como si fuera lsl solo
valor=comprobar_Directorio_o_Fichero(argv[1]);
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
if (valor==1) {
pdir = opendir(argv[1]);
dp = readdir(pdir);
while (dp != NULL) {
sprintf(nomcomp, "%s/%s", argv[1], dp->d_name);
nomfich = dp->d_name;
if (stat(nomcomp, &st) < 0) {
perror(nomcomp);
} else {
VerResultadoLSL(nomfich, &st);
}
dp = readdir(pdir);
}
closedir(pdir);
return 0; // termino el programa aqui
}
if (valor==2) {
if((pf = fopen(argv[1], "r")) != NULL) {
// es un archivo... lo que nos han pasado
archivo=1;
//Importante: cargo con la funcio stat los datos del fichero a st
if (stat(argv[1], &st) < 0) {
perror(argv[1]);
} else {
VerResultadoLSL(argv[1], &st);
}
fclose(pf);
} else {
printf("Error: no encuentro el fichero");
}
return 0;
}
}
// caso de lsl un argumento y sin nada: caso a al directorio actual
if (uno==1 && dos==0 && argc==2) {
// ver si es un archivo o un directorio y listar como si fuera lsl solo
pdir = opendir(".");
dp = readdir(pdir);
while (dp != NULL) {
sprintf(nomcomp, "%s/%s", ".", dp->d_name);
nomfich = dp->d_name;
if (stat(nomcomp, &st) < 0) {
perror(nomcomp);
} else {
VerResultadoA(nomfich, &st);
}
dp = readdir(pdir);
}
closedir(pdir);
return 0; // termino el programa aqui
}
// caso de lsl un argumento y sin nada: caso c
if (uno==0 && dos==1 && argc==2) {
// ver si es un archivo o un directorio y listar como si fuera lsl solo
pdir = opendir(".");
dp = readdir(pdir);
while (dp != NULL) {
sprintf(nomcomp, "%s/%s", ".", dp->d_name);
nomfich = dp->d_name;
if (stat(nomcomp, &st) < 0) {
perror(nomcomp);
} else {
VerResultadoC(nomfich, &st);
}
dp = readdir(pdir);
}
closedir(pdir);
return 0; // termino el programa aqui
}
// caso de lsl un argmento y con directorio/fichero: caso a
if (uno==1 && dos==0 && argc==3) {
valor=comprobar_Directorio_o_Fichero(argv[3-1]);
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
if (valor==1) {
pdir = opendir(argv[3-1]);
dp = readdir(pdir);
while (dp != NULL) {
sprintf(nomcomp, "%s/%s",argv[3-1] , dp->d_name);
nomfich = dp->d_name;
if (stat(nomcomp, &st) < 0) {
perror(nomcomp);
} else {
VerResultadoA(nomfich, &st);
}
dp = readdir(pdir);
}
closedir(pdir);
return 0; // termino el programa aqui
}
if (valor==2) {
if((pf = fopen(argv[3-1], "r")) != NULL) {
// es un archivo... lo que nos han pasado
archivo=1;
if (stat(argv[3-1], &st) < 0) {
perror(argv[3-1]);
} else {
VerResultadoA(argv[3-1], &st);
}
fclose(pf);
}
return 0;
}
}
// caso de lsl un argmento y con directorio/fichero: caso c
if (uno==0 && dos==1 && argc==3) {
valor=comprobar_Directorio_o_Fichero(argv[3-1]);
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
if (valor==1) {
pdir = opendir(argv[3-1]);
dp = readdir(pdir);
while (dp != NULL) {
sprintf(nomcomp, "%s/%s",argv[3-1] , dp->d_name);
nomfich = dp->d_name;
if (stat(nomcomp, &st) < 0) {
perror(nomcomp);
} else {
VerResultadoC(nomfich, &st);
}
dp = readdir(pdir);
}
closedir(pdir);
return 0; // termino el programa aqui
}
if (valor==2) {
if((pf = fopen(argv[3-1], "r")) != NULL) {
// es un archivo... lo que nos han pasado
archivo=1;
if (stat(argv[3-1], &st) < 0) {
perror(argv[3-1]);
} else {
VerResultadoC(argv[3-1], &st);
fclose(pf);
}
return 0;
}
}
}
// caso de lsl dos argumentos y sin nada: lsl -a -c ó es -a-c
if (uno==1 && dos==1 && argc==2) {
pdir = opendir(".");
dp = readdir(pdir);
while (dp != NULL) {
sprintf(nomcomp, "%s/%s","." , dp->d_name);
nomfich = dp->d_name;
if (stat(nomcomp, &st) < 0) {
perror(nomcomp);
} else {
VerResultadoAC(nomfich, &st);
}
dp = readdir(pdir);
}
closedir(pdir);
return 0; // termino el programa aqui
}
// caso de lsl dos argumentos con fichero: lsl -a -c ó es -ac ó es -ca + fichero
if (uno==1 && dos==1 && argc==3) {
valor=comprobar_Directorio_o_Fichero(argv[3-1]);
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
if (valor==1) {
pdir = opendir(argv[3-1]);
dp = readdir(pdir);
while (dp != NULL) {
sprintf(nomcomp, "%s/%s",argv[3-1], dp->d_name);
nomfich = dp->d_name;
if (stat(nomcomp, &st) < 0) {
perror(nomcomp);
} else {
VerResultadoAC(nomfich, &st);
}
dp = readdir(pdir);
}
closedir(pdir);
return 0; // termino el programa aqui
}
if (valor==2) {
if((pf = fopen(argv[3-1], "r")) != NULL) {
// es un archivo... lo que nos han pasado
archivo=1;
if (stat(argv[3-1], &st) < 0) {
perror(argv[3-1]);
} else {
VerResultadoC(argv[3-1], &st);
fclose(pf);
}
return 0;
}
}
}
// caso de lsl dos argumentos y con directorio o fichero
if (uno==1 && dos==1 && argc==4) {
valor=comprobar_Directorio_o_Fichero(argv[4-1]);
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
if (valor==1) {
pdir = opendir(argv[4-1]);
dp = readdir(pdir);
while (dp != NULL) {
sprintf(nomcomp, "%s/%s",argv[4-1] , dp->d_name);
nomfich = dp->d_name;
if (stat(nomcomp, &st) < 0) {
perror(nomcomp);
} else {
VerResultadoAC(nomfich, &st);
}
dp = readdir(pdir);
}
closedir(pdir);
return 0; // termino el programa aqui
}
if (valor==2) {
if((pf = fopen(argv[4-1], "r")) != NULL) {
// es un archivo... lo que nos han pasado
archivo=1;
if (stat(argv[4-1], &st) < 0) {
perror(argv[4-1]);
} else {
VerResultadoAC(argv[4-1], &st);
fclose(pf);
}
return 0;
}
}
}
return 0;
}
//-------------------------------------------------------------------------------
// FIN DEL MAIN
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
// OTRAS FUNCIONES
//-------------------------------------------------------------------------------
// Procesa la lista de argumentos.
// Devuelve un nº positivo indicando la suma de los argumentos empleados
// Negativo si alguna letra no es válida
int procesarArgumentos(int argc, char **argv)
{
char usados[100] = "";
int c = 0;
int suma = 0;
char *argu; // para procesar la lista de argumentos
int valor;
char *posUsados;
// para buscar en la tabla de usados
// el argumento 0 no lo proceso ya que es el nombre del programa, y empieza por el c=1
for (c = 1; c < argc; c++) {
argu = argv[c];
if(esArgumento(argu)) {
//sumo al puntero 1 posicion, me desplazo a la derecha una posicion
//(salto al signo menos que no me interesa analizar ahora dentro de la cadena)
argu++;
//*argu=conenido a lo que apuntaba argu: la letra "a" en asci no vale cero,
// por lo tanto cumple la condicion de que sea distinto de cero
// cuando encuentre \0, el valor numerico es 0, con lo cual parará el while.
while (*argu) {
valor = argumento(argu);
// 0 es cuando no tenga signo menos, y negativo cuendo no lo encuentra en la tabla
if (valor > 0) {
posUsados = strchr(usados, *argu);
// si el usuario pone varias veces el mismo argumento, solo lo cuenta una vez
//si no lo he encontrado lo meto en la tabla
if (posUsados == NULL) {
usados[strlen(usados)] = *argu;
} else {
// si la he encontrado, es porque ha repetido el valor
valor = 0;
}
}
// calculo la suma de todos los arguemntos
suma += valor;
//me desplazo al siguiente argumento
argu++;
}
}
}
return suma;
}
// Procesa un argumento de forma individual
// Devuelve INT_MIN si no es válido y positivo si lo es (2 ^ posicion)
int argumento(char *argu)
{
// los argumentos validos van a ser: a,c
// el comando -l ya lo doy visto
char valen[] = { "ac" };
// tabla sin tamaño definido([]), el compilador cuenta los elementos "abcdef",
// y lo dimensiona automaticamente, tambien valdria: char valen[6]={ "abcdef" }
char *pos;
int dif; // es la diferencia....
if ((pos = strchr(valen, argu[0]))) {
// la asignación pos=strchr. La función strchr te busca un caracter en una cadena:
// si lo encuentra lo que hace es que pos apunte al caracter,
// y la expresion (pos=strchr(valen, *argu[0])) la evalua el if.
// si strchr() devuelve una posicion, pos = esa posicion, con lo cual es correcto(verdadero)
// si strchr() no devuelve nada (NULL), no lo ha encontrado, pos=NULL, con lo cual el falso
dif = (pos - valen); // se pueden hacer operaciones aritmeticas con los puntero,
// se estan restando las posiciones.
// por ejemplo si pos marcaria 12034, y si valen marcaria 12035, dif=1
return (1 << dif); // << operador binario que trabaja con bits, y hace desplazamiento a la izquierda
} else {
return INT_MIN; //
}
}
int esArgumento(char *argu)
{
// en el puntero *argu, (guarda la posicion donde esta apuntando)
//...y nos puede mostrar el contenido a donde apunta:
if (*argu == '-') {
// si el primer carater es '-' es un argumento.
return 1; // verdadero
}
return 0; // falso
}
//------------------------------------------------------------------------------------------
void VerResultadoA(char *nomfich, struct stat *st)
{
escribedatos(nomfich,st); // todos, incluidos los ocultos
}
void VerResultadoAC(char *nomfich, struct stat *st)
{
// voy a colorear segun sea fichero,directorio,o enlace
struct tm *t;
struct passwd *p;
struct group *p2;
struct stat atributos;
char permiso[13];
t = gmtime(&st->st_mtime);
int ejecutable=0;
int directorio=0;
int enlace=0;
int fichero=0;
lstat(nomfich,&atributos); // leo todos los atributos de nomfich
if((atributos.st_mode & S_IXUSR)!=0) {
ejecutable=1;
} else {
}
if( S_ISDIR(st->st_mode )) {
directorio=1;
} else {
if(( S_ISREG(st->st_mode ))) {
//ES UN FICHERO
fichero=1;
} else {
if((S_ISLNK(st->st_mode ))) {
// es un enlace Simbolico
enlace=1;
}
}
}
if (ejecutable==1 && fichero==1 ) {
// lo pongo en verde
printf("\033[0;32m %-20s \033[m\n", nomfich);
}
if (directorio==1) {
// lo pongo en azul
printf("\033[0;34m %-20s \033[m\n", nomfich);
} else {
if (fichero==1 && ejecutable==0) {
// lo pongo en gris claro
printf("\033[1;30m %-20s \033[m\n", nomfich);
}
}
}
void VerResultadoC(char *nomfich, struct stat *st)
{
if (nomfich[0]!='.') {
// se trata visible
VerResultadoAC(nomfich,st);
}
}
void VerResultadoLSL(char *nomfich, struct stat *st)
{
// muestro todos los archivos (incluido los ocultos)
escribedatos(nomfich,st);
}
//-----------------------------------------------------------------------------------------------
// Funcion para saber si lo me pasan es un directorio o un fichero
//----------------------------------------------------------------------------------------------
// intento abrirlo con opendir(),
// si me da error no es un directorio en caso contrario es un directorio y devuelve 1
// si ha dado error en opendir(), intento abrirlo como un fichero fopen(), si no da error es un fichero y
// devuelve 2, en caso contrario devuelve 0
// devuelve 1 si es directorio.
// devuelve 2 si es fichero.
int comprobar_Directorio_o_Fichero(char *argumento)
{
pdir = opendir(argumento);
if (pdir != NULL) {
// es un directorio.... lo que nos han dado
//directorio=1;
printf("directorio: %s\n",argumento);
closedir(pdir);
return 1;
} else {
if((pf = fopen(argumento, "r")) != NULL) {
// es un archivo... lo que nos han pasado
// archivo=1;
printf("Fichero: %s\n",argumento);
fclose(pf);
return 2;
}
}
return 0;
}
void escribedatos(char *nomfich, struct stat *st)
{
struct tm *t;
struct passwd *p;
struct group *p2;
struct stat atributos;
char permiso[13];
t = gmtime(&st->st_mtime);
p=getpwuid(st->st_uid);
p2=getgrgid(st->st_gid);
int ejecutable=0;
int directorio=0;
int fichero=0;
int enlace=0;
// http://www.juntadeandalucia.es/averroes/iesbajoguadalquivir/inf/dfsi/lstat.c
lstat(nomfich,&atributos);
// printf("\nPermisos:\n");
// p=passwd(&);
printf("%8ld bytes %02d/%02d/%4d %02d:%02d:%02d %-10s %-10s ",
st->st_size,
t->tm_mday,
t->tm_mon + 1,
t->tm_year + 1900,
t->tm_hour,
t->tm_min,
t->tm_sec,
// ------------------
// t->tm_nlink ,
p->pw_name,
p2->gr_name);
//-------------------
// es un directorio
if( S_ISDIR(st->st_mode )) {
printf(" D ");
directorio=1;
} else {
if(( S_ISREG(st->st_mode ))) {
//ES UN FICHERO
printf(" F ");
fichero=1;
} else {
if((S_ISLNK(st->st_mode ))) {
// es un enlace Simbolico
printf(" E ");
enlace=1;
}
}
}
if((atributos.st_mode & S_IRUSR)!=0) {
printf("r");
} else {
printf("-");
}
if((atributos.st_mode & S_IWUSR)!=0) {
printf("w");
} else {
printf("-");
}
if((atributos.st_mode & S_IXUSR)!=0) {
printf("x");
ejecutable=1;
} else {
printf("-");
}
if((atributos.st_mode & S_IRGRP)!=0) {
printf("r");
} else {
printf("-");
}
if((atributos.st_mode & S_IWGRP)!=0) {
printf("w");
} else {
printf("-");
}
if((atributos.st_mode & S_IXGRP)!=0) {
printf("x");
} else {
printf("-");
}
if((atributos.st_mode & S_IROTH)!=0) {
printf("r");
} else {
printf("-");
}
if((atributos.st_mode & S_IWOTH)!=0) {
printf("w");
} else {
printf("-");
}
if((atributos.st_mode & S_IXOTH)!=0) {
printf("x");
} else {
printf("-");
}
if((atributos.st_mode & S_ISUID)!=0) {
printf("1");
} else {
printf("-");
}
if((atributos.st_mode & S_ISGID)!=0) {
printf("2");
} else {
printf("-");
}
if((atributos.st_mode & S_ISVTX)!=0) {
printf("t");
} else {
printf("-");
}
if (ejecutable==1 && fichero==1 ) {
// lo pongo en verde
printf("\033[0;32m %-20s \033[m\n", nomfich);
}
if (directorio==1) {
// lo pongo en azul
printf("\033[0;34m %-20s \033[m\n", nomfich);
} else {
if (fichero==1 && ejecutable==0) {
// lo pongo en gris claro
printf("\033[1;30m %-20s \033[m\n", nomfich);
}
}
}
No hay comentarios:
Publicar un comentario