Projeto PRG- Engenharia

Exemplo do programa desenvolvido durante a disciplina de programação. Este programa esta dividido em 4 partes (main.c, main.h, admin.c, admin.h)

main.c

/***********************************************************************
  Programa de controle de acesso
  Disciplina de programação - Engenharia de telecomunicações
  IFSC 2013 
  Professor:
	  Prof. Eraldo Silveira e Silva, Dr.
  Autoras:
	  Ana Luiza Scharf
	  Karoline da Rocha
  Incrementos:
	  André Felippe Weber
*************************************************************************/

#include <stdio.h>
#include <string.h>
//#include "bibprg.h"
#include <stdlib.h>
#include <time.h>
#include "main.h" 
#include "admin.h"


struct TUsuario *head, *tail; /* ponteiros inicial e final*/
char userID[TAM_VET];


//------------------------------------------------------------

void mostrar_menu_entrada_usuario()
{
    
    printf("\nEntre com o seu USERID para ter acesso\n"); 
  
}

//------------------------------------------------------------

/* Função para encontrar usuários na lista ligada*/
struct TUsuario *encontrar_usuario_lista( char *userID)
{

struct TUsuario *p;
       p = head;

    while(p){    /* loop para encontrar usuário*/
         if(strcmp(userID,p->userID)==0)
            return p; 
            p = p->next;                   
    }
    return NULL;
}

//-----------------------------------------------

/* Função para armazenar os dados de entrada do usuários*/

int login(struct TUsuario *p)

{
    time_t ltime;
    FILE *fp;
 
    time(&ltime); 
 
    if ((fp=fopen("DATA.txt", "a")) == NULL){/*Abre um arquivo com dados de login*/ 
         printf("Problemas na abertura do arquivo\n");
         return;
    }

    if (fprintf(fp,"%s %s\n",ctime(&ltime),p->userID)){/*escreve a cadeia de caracteres e o usuário no arquivo DATA*/
        printf("%s",ctime(&ltime));
        fclose(fp);
       
    }else{
        printf("Erro na escrita do arquivo!\n");
    }
}

//-----------------------------------------------
int permissao(struct TUsuario *p)
{
 
   time_t rawtime; 

struct tm *tminfo; 

    time ( &rawtime ); 
    tminfo = localtime ( &rawtime ); 
    printf ( "hora: %d minuto: %d segundo: %d \n", tminfo->tm_hour, tminfo->tm_min, tminfo->tm_sec); 

   
    if(p->entrada.hora < tminfo->tm_hour){/*testa se a hora real é maior que o tempo definido na entrada*/
      
    }else{
          
      if(p->entrada.hora == tminfo->tm_hour){/* Caso a hora real for igual ao tempo de entrada, assim testa minutos e segundos*/

        if(p->entrada.minuto < tminfo->tm_min){

          if(p->entrada.segundo < tminfo->tm_sec){

          }else{
            return 2;/* Caso alguma dessas comprações sejam falsas returna 2*/ 
           }
        }else{
          return 2;
         }
      }else{
           return 2;
       }
     }
        
    if(p->saida.hora > tminfo->tm_hour){/* Quando a hora real esta no limite de entrada e saída já sai dos if's e retorna 1*/
       printf ("deixa passar\n");
       return 1;          
    }else{
      if(p->saida.hora == tminfo->tm_hour){/*Caso a hora real for igual ao tempo de saída, assim testa minutos e segundos*/

         if(p->saida.minuto > tminfo->tm_min){

            if(p->saida.segundo < tminfo->tm_sec){
      
            }else{
              return 2;
             }
         }else{
           return 2;
          }
      }else{
        return 2;
       }
    }

    printf ("deixa passar\n");/* Se todas as comparações forem verdadeiras retorna 1*/
    return 1;

}
//-----------------------------------------------

/* Função para  sorteia uma pergunta para confirmar o usuário*/

int perguntas(struct TUsuario *p)
{
  
    int iSecret, iGuess;
    char  resp [TAM_VET];
 
    srand ( time(NULL) );/* inicia o randômico*/
 
    iSecret = rand() % 3 + 1; /*sorteia o número*/
   
    if(iSecret==1){
       printf("\nDigite o primeiro nome do seu pai\n");
       scanf("%s",resp);

       if(strcmp(resp, p->nome_pai)==0){
         return 1;
       }else{
         return 0;
        }
    }

    if(iSecret==2){
       printf("\nDigite o nome da sua cidade natal\n");
       scanf("%s",resp);
     
       if(strcmp(resp, p->cid_natal)==0){
          return 1;
       }else{
         return 0;
        }
    }

    if(iSecret==3){
       printf("\nDigite o primeiro nome do seu mãe\n");
       scanf("%s",resp);

       if(strcmp(resp, p->nome_mae)==0){
          return 1;
       }else{
         return 0;
        }
    }
}

//-----------------------------------------------

void tratar_usuario()
{
    char senha[TAM_VET];
    struct TUsuario *p;
    int ret;
    int r;
  
    p = encontrar_usuario_lista(userID); /* Procura o usuário na lista */

    if (!p){ /* Se o usuário existir*/
        printf ("\nUsuário inválido\n"); /* quando o usuário não está na lista*/
    }else{
      r=permissao(p);
      if(r==1){
         if(p -> contador < 3){ /* analisa o número de tentativas*/
            printf("\n%s %s!Entre com a senha\n",p-> mensagem, p-> userID);
  	        scanf("%s",senha);
 
	        if(strcmp(senha, p-> senha)==0){    
               ret=perguntas(p);/*Caso o usuário acerte a senha é chamada a função para sortea uma pergunta para confirmar se é ele*/           
             
                if(ret==1){
	               printf("\nAbrir porta!!!\n");
			     //enviar_analogica('1', "130");
     			     //sleep(2);
     			     //enviar_analogica('1', "000");
                   p->contador = 0; /* zera o contador*/
                   login(p);
                }else{
                  p->contador++ ; /* Caso erre a pergunta acrescenta o contador*/
		          printf("\nDados Inválida\n");
                }            

	         }else{
               p->contador++ ; /* Caso erre a senha acrescenta um contador*/
		       printf("\nSenha Inválida\n");
           }
       }else{
          printf("\nUsuario Bloqueado\n");/* Caso o número de tentativas seja maior que 3, usuário bloqueado*/
        }
     }else{ 
       printf("\nFora do Horário\n");
      }   
    }
}
 
//------------------------------------------------------------

void ler_lista()
{
    struct TUsuario *p;
    FILE *p_arq;
    int res;

    if((p_arq=fopen("DADOS.txt","r"))==NULL){/*Abre um arquivo para ler os dados dos usuários*/
       head=tail= NULL;
       return;
    }

    head=p=(struct TUsuario *)malloc(sizeof(struct TUsuario));/*Aloca a memória*/  
    p->next=NULL; 

    for(;;){
        if ((res=fscanf(p_arq,"%s %s %s %s %s %s %d %d %d %d %d %d \n",p->userID,p->senha,p->nome_pai,p->nome_mae,p->cid_natal,p->mensagem, &p->entrada.hora,
&p->entrada.minuto,&p->entrada.segundo,&p->saida.hora,&p->saida.minuto,&p->saida.segundo))==EOF){
            if (p==head){/*Lista de usuários vazia*/
                head=NULL;
                tail=NULL;
            } else 
                tail->next=NULL;/*Finaliza a lista*/
            free(p);/*Libera a memória*/   
            break;
        }
       tail=p;
       p=p->next=(struct TUsuario *)malloc(sizeof(struct TUsuario));/*Aloca a memória para novos usuários*/
   }
   fclose(p_arq);
}

//-----------------------------------------------------------

void main(){

 int fd, W=6;
 int i, segundos;
 size_t bytes_read;
 fd_set readfds;
 char buffer[256], uderID[256]; 
    
    struct timeval timeout;

    segundos = 2;

    timeout.tv_sec=segundos;
    timeout.tv_usec=300000;
    
    //conectar ();
    ler_lista();
    listar_lista();

    for (;;) {   
        
        if (i==1){
	mostrar_menu_entrada_usuario();
	i=0;
	}

	FD_ZERO(&readfds);
	FD_SET(0, &readfds); 

        if ((W=select(1,&readfds,NULL,NULL, &timeout))==-1) {
            perror("select");
            exit(1);    
        }

    	if (W){
           	if ((bytes_read=read(0,buffer,sizeof(buffer)))==-1) {
       	            	perror("Erro read");
       	            	exit(1);
           	}
		 	if (bytes_read>0) {
				sscanf(buffer,"%s",userID);
				if(strcmp( userID, "admin")==0){
					administrar();
        			}
	      			else
           				tratar_usuario();
	
                	} 
           	timeout.tv_sec=segundos;
		i=1;
     	}
     	else{
        	printf("Lendo temperatura\n");
        	timeout.tv_sec=segundos;
     	}
     } 
}

main.h

#ifndef ADMIN_H
#define ADMIN_H
#define TAM_VET 20
#define TAM_MEN 100

struct TTempo{ 
int hora,minuto,segundo; 
}; 

struct TUsuario /* struct TUsuario é o local onde contém todas as informações do usuário */
{ 
    char userID[TAM_VET];
    char senha[TAM_VET];
    char cid_natal[TAM_VET];
    char nome_pai[TAM_VET];
    char nome_mae[TAM_VET];
    int contador;
    char mensagem[TAM_MEN];
    struct TTempo entrada; 
    struct TTempo saida; 
    struct TUsuario *next;
};

extern char userID [];

extern struct TUsuario *next, *head, *tail; /* ponteiros próximo, inicial e final*/

//------------------------------------------------------------

void mostrar_menu_entrada_usuario();

//------------------------------------------------------------

/* Função para encontrar usuários na lista ligada*/

struct TUsuario *encontrar_usuario_lista(char *userID);

//------------------------------------------------------------

/* Função para armazenar os dados de entrada do usuários*/

int login(struct TUsuario *p);

//------------------------------------------------------------

/* Função para  sorteia uma pergunta para confirmar o usuário*/

int perguntas(struct TUsuario *p);

//------------------------------------------------------------

void tratar_usuario();

//------------------------------------------------------------

void ler_lista( );

//-----------------------------------------------------------

#endif

admin.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include "main.h" 
#include "admin.h"

//------------------------------------------------------------

/* Função que permite subescrever a mensagem do usuário, quando o programa pedir sua senha*/

struct TUsuario *nova_mensagem ()
{  
    struct TUsuario *p;

    printf("\nESCOLHA O USUARIO\n");
    scanf("%s",  userID);
    
    p = encontrar_usuario_lista(userID); 
    
    if (!p){
        printf("Usuário não existente\n"); 
    }else{    
        printf("\nDigite a nova mensagem Inicial\n");
        scanf("%s",p ->mensagem); /* vai escrever uma mensagem lá na struct mensagem*/

     }         
}

//------------------------------------------------------------

/* Função para encontrar desbloquear usuário na lista ligada*/
 
struct TUsuario *desbloquear_usuario_lista( )
{
    struct TUsuario *p;
      
    printf("\nESCOLHA O USUARIO\n");
    scanf("%s",  userID);
    
    p = encontrar_usuario_lista(userID); 
       
    if(!p)
       printf("Usuário não existente\n");
    else{  
       p -> contador = 0;    /* zerar o contador do usuário escolhido*/
       printf("\nUSUARIO DESBLOQUEADO\n");
    } 
       
} 

//------------------------------------------------------------

/* Função para  salvar o usuário no arquivo DADOS*/    

void salvar_lista()
{

    FILE *p_arq;
    int res;
    struct TUsuario *p;

    if((p_arq=fopen("DADOS.txt","w"))==NULL){/* Cria um arquivo DADOS, se não houver nenhum*/
       printf("\nProblemas na abertura do arquivo\n");
    }

    p =head;    

    while(p!=NULL){/* Escreve os dados do usuário no arquivo*/
          if((res=fprintf(p_arq,"%s %s %s %s %s %d %d %d %d %d %d\n",p->userID,p->senha,p->nome_pai,p->nome_mae,p->cid_natal, p->entrada.hora,
p->entrada.minuto,p->entrada.segundo,p->saida.hora,p->saida.minuto,p->saida.segundo))==EOF){
             printf("\nErro\n");
          }
          p=p->next;                               
    }
    fclose(p_arq);
}

//------------------------------------------------------------

/* função para adicionar usuário no final da lista*/

void adicione_usuario_tail(struct TUsuario *p) 
{

    if(tail==NULL){/* Teste para saber se a lista está vazia*/
       tail = head = p; 


    }else{/* Quando a lista não está vazia, adiciona o usuário no final*/
       tail->next = p;
       tail = p;
       
     }

   salvar_lista();

}
//------------------------------------------------------------

/* Função para definir um horário fixo, quando cria um usuário*/
 
void definir_horario (struct TUsuario *p) 
{
      p->entrada.hora=8;
      p->entrada.minuto=30;
      p->entrada.segundo=0;
      p->saida.hora=18;
      p->saida.minuto=30;
      p->saida.segundo=0;

}
//------------------------------------------------------------

/* Função para adicionar usuários e seus dados*/

void adicionar_usuario()
{
 
    struct TUsuario *p;
 
    if ((p=(struct TUsuario *)malloc(sizeof(struct TUsuario)))==NULL){
        printf("Não é possível adicionar usuário ao sistema");
        return;
    }

    printf("Entre com userID\n");
    scanf("%s",p->userID);

    printf("Entre com senha\n");
    scanf("%s",p->senha);

    printf("Entre com o nome do pai\n");
    scanf("%s",p->nome_pai);

    printf("Entre com o nome do mãe\n");
    scanf("%s",p->nome_mae);

    printf("Entre com a sua cidade natal\n");
    scanf("%s",p->cid_natal);



    definir_horario(p);/* esta dando erro na  hora que pede para entrar com o userid*/
    p->next = NULL;

    adicione_usuario_tail(p); 
}

//------------------------------------------------------------

/* função que remove qualquer usuário */

void remover_usuario_lista(struct TUsuario *p)
{
    
    struct TUsuario *p_aux;

    if(p == head){

        if(head == tail){/*quando na lista ligada tem um único usuário*/
           free(p);
           head=tail=NULL;

        }else{          
           head = head-> next;/*Exclui o primeiro da lista*/
           free(p);/* libera a memória */
         }
        return;
    }else{
       p_aux=head;/*cria um auxiliar que é igual ao inicio*/

       while(p_aux->next!=p) /*Enqunto o p_aux aponta para o próximo for diferente de p, executa o loop*/
             p_aux=p_aux->next;

             if(p_aux==NULL){/*Lista éstá vazia*/
                 return;

             }else{
               
                if(tail==p_aux->next)/*reconstroi a lista para remover o usuário*/
                   tail=p_aux;/*Tanto exclui o do meio ou do fim*/
                   p_aux->next = p->next;
                   free(p);
              }            
     }
}

//------------------------------------------------------------ 

/* Função para escolher o usuário a ser removido */

void remover_usuario()
{

    char userID[TAM_VET];
    struct TUsuario *p;  
  
    printf("Entre com userID do usuario a ser removido\n");
    scanf("%s", userID);
 
    p = encontrar_usuario_lista(userID); 

    if (!p)
        printf("Usuário não existente\n");

    else{   
        remover_usuario_lista(p);
        printf("Usuário removido!\n");
        salvar_lista();
    }
}

//------------------------------------------------------------

/* Função para imprimir todos os usuários */

void listar_lista ()
{

    struct TUsuario *p;

    p=head;

   if(head==NULL){
      printf ("\nLista Vazia!\n");

   }else{
      while(p){ /*enquanto não chega o fim da lista*/
            printf ("Usuários: %s\n", p->userID);
            p = p->next;
      }
    }
} 

struct TUsuario *novo_horario()
{  
    struct TUsuario *p;

    printf("\nESCOLHA O USUARIO\n");
    scanf("%s",  userID);
    
    p = encontrar_usuario_lista(userID); 
    
    if (!p){
        printf("Usuário não existente\n"); 
    }else{     /* vai reescrever o horário na struct */
        printf("\nDigite a novo horario de entrada:\n");
        printf("\nHora:\n");
        scanf("%d",&p->entrada.hora); 

        printf("\nMinuto:\n");
        scanf("%d",&p->entrada.minuto);

        printf("\nSegundo:\n");
        scanf("%d",&p->entrada.segundo);

        printf("\nDigite a novo horario de saida:\n");
        printf("\nHora:\n");
        scanf("%d",&p->saida.hora);

        printf("\nMinuto:\n");
        scanf("%d",&p->saida.minuto);

        printf("\nSegundo:\n");
        scanf("%d",&p->saida.segundo);
        salvar_lista();

     }         
}

//------------------------------------------------------------

void  administrar()
{
    
    char senha_admin[TAM_VET];
    char userID[TAM_VET];
    int t;

    struct TUsuario *p;

    printf("\nBom dia Adiministrador! Entre com a senha\n");
    scanf("%s",senha_admin);
 
    if(strcmp(senha_admin,"123")==0){

       printf("\nOpção1:Desbloquear Usuario\n");
       printf("\nOpção2:Renomear a mensagem inicial do usuario\n");
       printf("\nOpção3:Adicionar usuário na lista\n");
       printf("\nOpção4:Remover usuário da lista\n");
       printf("\nOpção5:Listar usuários\n");
       printf("\nOpção6:Motificar horário de permissão de login\n");
       scanf("%d",&t);

       if(t==1){
          desbloquear_usuario_lista();
       }

       if(t==2){
          nova_mensagem();
       }

       if(t==3){
          adicionar_usuario();
       }

       if(t==4){
          remover_usuario();
       }

       if(t==5){
          listar_lista ();
       }

       if(t==6){
          novo_horario();
       }

    }else{
      printf("\nsenha Invalida\n");
     }
       
}

admin.h

#ifndef MAIN_H
#define MAIN_H
#define TAM_MEN 100
#include "main.h"

/* Função que permite subescrever a mensagem do usuário, quando o programa pedir sua senha*/

struct TUsuario *nova_mensagem ();

//------------------------------------------------------------

/* Função para encontrar desbloquear usuário na lista ligada*/

struct TUsuario *desbloquear_usuario_lista( );

//------------------------------------------------------------     

void salvar_lista();

//------------------------------------------------------------

/* Função para adicionar usuário no final da lista*/

void adicione_usuario_tail(struct TUsuario *p); 

//------------------------------------------------------------

/* Função para definir horário padrão*/

void definir_horario (struct TUsuario *p); 

//------------------------------------------------------------
/* Função para adicionar usuários e seus dados*/

void adicionar_usuario();

//------------------------------------------------------------

/* Função que remove qualquer usuário */

void remover_usuario_lista(struct TUsuario *p);

//------------------------------------------------------------ 

/* Função para escolher o usuário a ser removido */

void remover_usuario();

//------------------------------------------------------------

/* Função para imprimir todos os usuários */

void listar_lista ();

//------------------------------------------------------------

struct TUsuario *novo_horario();

//------------------------------------------------------------
void  administrar();

#endif

Para facilitar a compilação, existe um arquivo make pronto:

#arquivo Makefile
karol_ana: main.o admin.o
	gcc main.o admin.o -lprg -lusb-1.0 -o karol_ana
 
main.o:   main.c main.h admin.h
	gcc -c -lprg -lusb-1.0 main.c
 
admin.o: admin.c admin.h  main.h 
	gcc -c -lprg -lusb-1.0 admin.c 
 
clean: admin.o main.o
	rm main.o
	rm admin.o
	rm DADOS.txt
install:
	./karol_ana