Mudanças entre as edições de "Projeto PRG- Engenharia"

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
Linha 5: Linha 5:
  
 
/***********************************************************************
 
/***********************************************************************
−
  Programa de controle de acesso
+
Programa de controle de acesso
−
  Disciplina de programação - Engenharia de telecomunicações
+
Disciplina de programação - Engenharia de telecomunicações
−
  IFSC 2013  
+
IFSC 2013  
−
  Professor:
+
Professor:
−
  Prof. Eraldo Silveira e Silva, Dr.
+
Prof. Eraldo Silveira e Silva, Dr.
−
  Autoras:
+
Autoras:
−
  Ana Luiza Scharf
+
Ana Luiza Scharf
−
  Karoline da Rocha
+
Karoline da Rocha
−
  Incrementos:
+
Incrementos:
−
  André Felippe Weber
+
André Felippe Weber
−
*************************************************************************/
+
*************************************************************************/
  
 
#include <stdio.h>
 
#include <stdio.h>
 
#include <string.h>
 
#include <string.h>
−
//#include "bibprg.h"
+
#include "bibprg.h"
 
#include <stdlib.h>
 
#include <stdlib.h>
 
#include <time.h>
 
#include <time.h>
 
#include "main.h"  
 
#include "main.h"  
 
#include "admin.h"
 
#include "admin.h"
−
 
+
#include <stdio.h>
 +
#include <unistd.h>
 +
#include <stdlib.h>
 +
#include <string.h>
 +
#include <sys/socket.h>
 +
#include <bluetooth/bluetooth.h>
 +
#include <bluetooth/rfcomm.h>
 +
#include <errno.h>
 +
#include <sys/types.h>
 +
#include <netinet/in.h>
 +
#include <fcntl.h>
 +
#include <dirent.h>
 +
#include <sys/stat.h>
 +
#include <sys/select.h>
  
 
struct TUsuario *head, *tail; /* ponteiros inicial e final*/
 
struct TUsuario *head, *tail; /* ponteiros inicial e final*/
 
char userID[TAM_VET];
 
char userID[TAM_VET];
 +
char *buf_bluetooth = "senha";
 +
struct sockaddr_rc loc_addr = { 0 }, rem_addr = { 0 };
 +
char buf[1024] = { 0 };
 +
int s, client, bytesRead, passo;
 +
socklen_t opt = sizeof(rem_addr);
 +
 +
//-----------------------------------------------------------
 +
char Blue(char *retorno) {
 +
 +
if ((client = accept(s, (struct sockaddr *) &rem_addr, &opt)) < 0) {
 +
perror("accept: ");
 +
exit(1);
 +
}
 +
 +
memset(buf, 0, sizeof(buf));
 +
 +
// read data from the client
 +
if ((bytesRead = read(client, buf, sizeof(buf))) == -1) {
 +
perror("Erro read");
 +
exit(1);
 +
}
 +
passo = client;
 +
close(client);
 +
strcpy(retorno, buf);
 +
return;
 +
 +
}
 +
//-----------------------------------------------------------
 +
 +
char Pblue(char *mensagem) {
 +
 +
if ((client = accept(s, (struct sockaddr *) &rem_addr, &opt)) < 0) {
 +
perror("accept: ");
 +
exit(1);
 +
}
 +
 +
memset(buf, 0, sizeof(buf));
 +
 +
//envia uma resposta
 +
strcpy(buf, mensagem);
 +
write(client, buf, sizeof(buf));
 +
sleep(1);
 +
 +
// close connection
 +
close(client);
 +
return;
 +
}
 +
 +
//-----------------------------------------------------------
  
 +
void mostrar_menu_entrada_usuario() {
  
−
//------------------------------------------------------------
+
printf("\nEntre com o seu USERID para ter acesso\n");
  
−
void mostrar_menu_entrada_usuario()
 
−
{
 
−
   
 
−
    printf("\nEntre com o seu USERID para ter acesso\n");
 
−
 
 
 
}
 
}
  
 
//------------------------------------------------------------
 
//------------------------------------------------------------
  
−
/* Função para encontrar usuários na lista ligada*/
+
/* Função para encontrar usuários na lista ligada*/
−
struct TUsuario *encontrar_usuario_lista( char *userID)
+
struct TUsuario *encontrar_usuario_lista(char *userID) {
−
{
 
  
−
struct TUsuario *p;
+
struct TUsuario *p;
−
      p = head;
+
p = head;
  
−
    while(p){   /* loop para encontrar usuário*/
+
while (p) { /* loop para encontrar usuário*/
−
        if(strcmp(userID,p->userID)==0)
+
if (strcmp(userID, p->userID) == 0)
−
            return p;  
+
return p;
−
            p = p->next;                  
+
p = p->next;
−
    }
+
}
−
    return NULL;
+
return NULL;
 
}
 
}
  
 
//-----------------------------------------------
 
//-----------------------------------------------
  
−
/* Função para armazenar os dados de entrada do usuários*/
+
/* Função para armazenar os dados de entrada do usuários*/
  
 
int login(struct TUsuario *p)
 
int login(struct TUsuario *p)
  
 
{
 
{
−
    time_t ltime;
+
time_t ltime;
−
    FILE *fp;
+
FILE *fp;
−
+
 
−
    time(&ltime);  
+
time(&ltime);
−
+
 
−
    if ((fp=fopen("DATA.txt", "a")) == NULL){/*Abre um arquivo com dados de login*/  
+
if ((fp = fopen("DATA.txt", "a")) == NULL) {/*Abre um arquivo com dados de login*/
−
        printf("Problemas na abertura do arquivo\n");
+
printf("Problemas na abertura do arquivo\n");
−
        return;
+
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);
  
−
    if (fprintf(fp,"%s %s\n",ctime(&ltime),p->userID)){/*escreve a cadeia de caracteres e o usuário no arquivo DATA*/
+
} else {
−
        printf("%s",ctime(&ltime));
+
printf("Erro na escrita do arquivo!\n");
−
        fclose(fp);
+
}
−
     
 
−
    }else{
 
−
        printf("Erro na escrita do arquivo!\n");
 
−
    }
 
 
}
 
}
  
 
//-----------------------------------------------
 
//-----------------------------------------------
−
int permissao(struct TUsuario *p)
+
int permissao(struct TUsuario *p) {
−
{
+
 
−
+
time_t rawtime;
−
  time_t rawtime;  
+
 
 +
struct tm *tminfo;
 +
 
 +
time(&rawtime);
 +
tminfo = localtime(&rawtime);
 +
if (blue == 0)
 +
printf("porta aberta: 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 {
  
−
struct tm *tminfo;
+
if (p->entrada.hora == tminfo->tm_hour) {/* Caso a hora real for igual ao tempo de entrada, assim testa minutos e segundos*/
  
−
    time ( &rawtime );
+
if (p->entrada.minuto < tminfo->tm_min) {
−
    tminfo = localtime ( &rawtime );
 
−
    printf ( "hora: %d minuto: %d segundo: %d \n", tminfo->tm_hour, tminfo->tm_min, tminfo->tm_sec);
 
  
−
 
+
if (p->entrada.segundo < 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){
+
} else {
 +
return 2;/* Caso alguma dessas comprações sejam falsas returna 2*/
 +
}
 +
} else {
 +
return 2;
 +
}
 +
} else {
 +
return 2;
 +
}
 +
}
  
−
          if(p->entrada.segundo < tminfo->tm_sec){
+
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*/
 +
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*/
  
−
          }else{
+
if (p->saida.minuto > tminfo->tm_min) {
−
            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) {
  
−
            if(p->saida.segundo < tminfo->tm_sec){
+
} else {
−
     
+
return 2;
−
            }else{
+
}
−
              return 2;
+
} else {
−
            }
+
return 2;
−
        }else{
+
}
−
          return 2;
+
} else {
−
          }
+
return 2;
−
      }else{
+
}
−
        return 2;
+
}
−
      }
 
−
    }
 
  
−
    printf ("deixa passar\n");/* Se todas as comparações forem verdadeiras retorna 1*/
+
printf("deixa passar\n");/* Se todas as comparações forem verdadeiras retorna 1*/
−
    return 1;
+
return 1;
  
 
}
 
}
 
//-----------------------------------------------
 
//-----------------------------------------------
  
−
/* Função para  sorteia uma pergunta para confirmar o usuário*/
+
/* Função para  sorteia uma pergunta para confirmar o usuário*/
 +
char *pergunta;
 +
int perguntas(struct TUsuario *p) {
  
−
int perguntas(struct TUsuario *p)
+
int iSecret, iGuess;
−
{
+
char resp[TAM_VET], retorno[256];
−
 
+
 
−
    int iSecret, iGuess;
+
srand (time(NULL) );/* inicia o randômico*/
−
    char resp [TAM_VET];
+
 
−
+
iSecret = rand() % 3 + 1; /*sorteia o número*/
−
    srand ( time(NULL) );/* inicia o randômico*/
+
 
−
+
if (iSecret == 1) {
−
    iSecret = rand() % 3 + 1; /*sorteia o número*/
+
if (blue == 0) {
−
 
+
printf("Digite o primeiro nome do seu pai\n");
−
    if(iSecret==1){
+
scanf("%s", resp);
−
      printf("\nDigite o primeiro nome do seu pai\n");
+
} else {
−
      scanf("%s",resp);
+
Pblue("Digite o primeiro nome do seu pai");
 +
Blue(retorno);
 +
strcpy(resp, retorno);
 +
}
 +
 
 +
if (strcmp(resp, p->nome_pai) == 0) {
 +
return 1;
 +
} else {
 +
return 0;
 +
}
 +
}
  
−
      if(strcmp(resp, p->nome_pai)==0){
+
if (iSecret == 2) {
−
        return 1;
+
if (blue == 0) {
−
      }else{
+
printf("Digite o nome da sua cidade natal\n");
−
        return 0;
+
scanf("%s", resp);
−
        }
+
} else {
−
    }
+
Pblue("Digite o nome da sua cidade natal");
 +
Blue(retorno);
 +
strcpy(resp, retorno);
 +
}
  
−
    if(iSecret==2){
+
if (strcmp(resp, p->cid_natal) == 0) {
−
      printf("\nDigite o nome da sua cidade natal\n");
+
return 1;
−
      scanf("%s",resp);
+
} else {
−
   
+
return 0;
−
      if(strcmp(resp, p->cid_natal)==0){
+
}
−
          return 1;
+
}
−
      }else{
 
−
        return 0;
 
−
        }
 
−
    }
 
  
−
    if(iSecret==3){
+
if (iSecret == 3) {
−
      printf("\nDigite o primeiro nome do seu mãe\n");
+
if (blue == 0) {
−
      scanf("%s",resp);
+
printf("Digite o primeiro nome da sua mãe\n");
 +
scanf("%s", resp);
 +
} else {
 +
Pblue("Digite o primeiro nome da sua mãe");
 +
Blue(retorno);
 +
strcpy(resp, retorno);
 +
}
  
−
      if(strcmp(resp, p->nome_mae)==0){
+
if (strcmp(resp, p->nome_mae) == 0) {
−
          return 1;
+
return 1;
−
      }else{
+
} else {
−
        return 0;
+
return 0;
−
        }
+
}
−
    }
+
}
 
}
 
}
  
 
//-----------------------------------------------
 
//-----------------------------------------------
  
−
void tratar_usuario()
+
void tratar_usuario() {
−
{
+
char senha[TAM_VET], retorno[256];
−
    char senha[TAM_VET];
+
struct TUsuario *p;
−
    struct TUsuario *p;
+
int ret;
−
    int ret;
+
int r;
−
    int r;
+
 
−
 
+
p = encontrar_usuario_lista(userID); /* Procura o usuário na lista */
−
    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 = 1; //permissao(p);
 +
if (r == 1) {
 +
// if(p -> contador < 3){ /* analisa o número de tentativas*/
 +
if (blue == 0) {
 +
printf("\n%s %s!Entre com a senha\n", p->mensagem, p->userID);
 +
scanf("%s", senha);
 +
} else {
 +
Pblue("senha");
 +
Blue(retorno);
 +
strcpy(senha, retorno);
 +
}
 +
//printf("%s", pergunta);
 +
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) {
 +
if (blue == 0)
 +
printf("\nPorta aberta\n");
 +
else
 +
Pblue("Porta aberta");
 +
enviar_analogica('1', "150");
 +
sleep(2);
 +
enviar_analogica('1', "000");
 +
p->contador = 0; /* zera o contador*/
 +
login(p);
 +
} else {
 +
p->contador++; /* Caso erre a pergunta acrescenta o contador*/
 +
if (blue == 0)
 +
printf("\nDados Inválidos\n");
 +
else
 +
Pblue("Dados Inválidos");
 +
}
  
−
    if (!p){ /* Se o usuário existir*/
+
} else {
−
        printf ("\nUsuário inválido\n"); /* quando o usuário não está na lista*/
+
p->contador++; /* Caso erre a senha acrescenta um contador*/
−
    }else{
+
if (blue == 0)
−
      r=permissao(p);
+
printf("\nSenha Inválida\n");
−
      if(r==1){
+
else
−
        if(p -> contador < 3){ /* analisa o número de tentativas*/
+
Pblue("Senha inválida");
−
            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{
+
} else {
−
              p->contador++ ; /* Caso erre a senha acrescenta um contador*/
+
if (blue == 0)
−
      printf("\nSenha Inválida\n");
+
printf("\nFora do Horário\n");
−
          }
+
else
−
      }else{
+
Pblue("Fora do Horário");
−
          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()
+
void ler_lista() {
−
{
+
struct TUsuario *p;
−
    struct TUsuario *p;
+
FILE *p_arq;
−
    FILE *p_arq;
+
int res;
−
    int res;
 
  
−
    if((p_arq=fopen("DADOS.txt","r"))==NULL){/*Abre um arquivo para ler os dados dos usuários*/
+
if ((p_arq = fopen("DADOS.txt", "r")) == NULL) {/*Abre um arquivo para ler os dados dos usuários*/
−
      head=tail= NULL;
+
head = tail = NULL;
−
      return;
+
return;
−
    }
+
}
  
−
    head=p=(struct TUsuario *)malloc(sizeof(struct TUsuario));/*Aloca a memória*/
+
head = p = (struct TUsuario *) malloc(sizeof(struct TUsuario));/*Aloca a memória*/
−
    p->next=NULL;  
+
p->next = NULL;
  
−
    for(;;){
+
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,
+
if ((res = fscanf(p_arq, "%s %s %s %s %s %s %d %d %d %d %d %d \n",
−
&p->entrada.minuto,&p->entrada.segundo,&p->saida.hora,&p->saida.minuto,&p->saida.segundo))==EOF){
+
p->userID, p->senha, p->nome_pai, p->nome_mae, p->cid_natal,
−
            if (p==head){/*Lista de usuários vazia*/
+
p->mensagem, &p->entrada.hora, &p->entrada.minuto,
−
                head=NULL;
+
&p->entrada.segundo, &p->saida.hora, &p->saida.minuto,
−
                tail=NULL;
+
&p->saida.segundo)) == EOF) {
−
            } else  
+
if (p == head) {/*Lista de usuários vazia*/
−
                tail->next=NULL;/*Finaliza a lista*/
+
head = NULL;
−
            free(p);/*Libera a memória*/  
+
tail = NULL;
−
            break;
+
} else
−
        }
+
tail->next = NULL;/*Finaliza a lista*/
−
      tail=p;
+
free(p);/*Libera a memória*/
−
      p=p->next=(struct TUsuario *)malloc(sizeof(struct TUsuario));/*Aloca a memória para novos usuários*/
+
break;
−
  }
+
}
−
  fclose(p_arq);
+
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 botao() {
 +
float n;
 +
int i = 0;
 +
 
 +
n = receber_analogica('1');
 +
 
 +
while (i == 0) {
 +
n = receber_analogica('1');
 +
 
 +
if (n > 0.20 && n != 0) {
 +
if (n <= 0.26) {
 +
return 9;
 +
}
 +
if (n > 0.26 && n < 0.30) {
 +
return 8;
 +
}
 +
if (n >= 0.30 && n <= 0.35) {
 +
return 7;
 +
}
 +
if (n >= 0.36 && n <= 0.40) {
 +
return 6;
 +
}
 +
if (n >= 0.43 && n < 0.50) {
 +
return 5;
 +
}
 +
if (n > 0.53 && n <= 0.58) {
 +
return 4;
 +
}
 +
if (n > 0.70 && n <= 0.80) {
 +
return 3;
 +
}
 +
if (n > 1.0 && n <= 1.1) {
 +
return 2;
 +
}
 +
if (n > 1.8 && n <= 2.0) {
 +
return 1;
 +
}
 +
if (n > 3.0 && n <= 3.3) {
 +
return 0;
 +
}
 +
if (n > 4.0 && n <= 5.0) {
 +
return 10; //enter
 +
}
 +
i = 1;
 +
n = 0;
 +
usleep(5000);
 +
 
 +
}
 +
return 20;
 +
}
 +
return 20;
 +
}
 +
 
 +
int main(int argc, char **argv) {
 +
 
 +
int fd;
 +
int fdmax;
 +
int i, j, lag = 0;
 +
size_t bytes_read;
 +
fd_set master_set, myset;
 +
char buffer[256];
 +
 
 +
char buf[50]; //variavel do teclado
 +
int bot, x = 0, y = 0, z = 0; //variaveis do teclado
 +
int W = 6;
 +
int segundos;
 +
 
 +
FD_ZERO(&master_set);
 +
 
 +
for (i = 1; i < argc; i++) {
 +
if ((fd = open(argv[i], O_RDWR)) == -1) {
 +
perror("open");
 +
exit(1);
 +
}
 +
FD_SET(fd, &master_set);
 +
}
  
−
int fd, W=6;
+
// allocate socket http://www.br-c.org/doku.php?id=socket
−
int i, segundos;
+
if ((s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) == -1) {
−
size_t bytes_read;
+
printf("Problemas na criação do socket\n");
−
fd_set readfds;
+
exit(-1);
−
char buffer[256], uderID[256];  
+
}
−
   
+
FD_SET(s, &master_set);
−
    struct timeval timeout;
+
fd++;
  
−
    segundos = 2;
+
/* registra o maior descritor */
 +
fdmax = fd;
  
−
    timeout.tv_sec=segundos;
+
// bind socket to port 1 of the first available
−
    timeout.tv_usec=300000;
+
// local bluetooth adapter
−
   
+
//http://www.br-c.org/doku.php?id=bind
−
    //conectar ();
 
−
    ler_lista();
 
−
    listar_lista();
 
  
−
    for (;;) { 
+
loc_addr.rc_family = AF_BLUETOOTH;
−
       
+
loc_addr.rc_bdaddr = *BDADDR_ANY;
−
        if (i==1){
+
//str2ba( endereco, &loc_addr.rc_bdaddr );
−
mostrar_menu_entrada_usuario();
+
loc_addr.rc_channel = (uint8_t) 3;
−
i=0;
+
if (bind(s, (struct sockaddr *) &loc_addr, sizeof(loc_addr)) == -1) {
 +
printf("Problemas no bind\n");
 +
exit(-1);
 
}
 
}
  
−
FD_ZERO(&readfds);
+
//listen http://www.br-c.org/doku.php?id=listen
−
FD_SET(0, &readfds);  
+
printf("Preparando para listen..\n");
 +
// put socket into listening mode
 +
if (listen(s, 1) < 0)
 +
printf("Problemas de listen...\n");
  
−
        if ((W=select(1,&readfds,NULL,NULL, &timeout))==-1) {
+
conectar();
−
            perror("select");
+
ler_lista();
−
            exit(1);  
+
listar_lista();
−
        }
 
  
−
    if (W){
+
struct timeval timeout;
−
          if ((bytes_read=read(0,buffer,sizeof(buffer)))==-1) {
+
 
−
                  perror("Erro read");
+
segundos = 0;
−
                  exit(1);
+
 
−
          }
+
timeout.tv_sec = segundos;
−
if (bytes_read>0) {
+
timeout.tv_usec = 500000;
−
sscanf(buffer,"%s",userID);
+
 
−
if(strcmp( userID, "admin")==0){
+
for (;;) {
 +
if (x == 0) {
 +
mostrar_menu_entrada_usuario();
 +
x = 1;
 +
}
 +
 
 +
myset = master_set; /* deve ser copiado sempre pois o conjunto é alterado */
 +
 
 +
if ((W = select(fdmax + 1, &myset, NULL, NULL, &timeout)) == -1) {
 +
perror("select");
 +
exit(1);
 +
}
 +
if (W == 0) {
 +
 
 +
enviar_digital('1', '1');
 +
 
 +
bot = botao();
 +
if (bot == 10) {
 +
printf("enter");
 +
while (z < y) {
 +
printf("\n %d \n", buf[z]);
 +
z++;
 +
x = 0;
 +
}
 +
z = 0;
 +
}
 +
 
 +
if (bot >= 0 && bot <= 9) {
 +
 
 +
buf[y] = bot;
 +
y++;
 +
}
 +
 
 +
}
 +
 
 +
if (FD_ISSET(3, &myset)) {
 +
blue = 0;
 +
if ((bytesRead = read(0, buffer, sizeof(buffer))) == -1) {
 +
perror("Erro read");
 +
exit(1);
 +
}
 +
if (bytesRead > 0) {
 +
sscanf(buffer, "%s", userID);
 +
if (strcmp(userID, "admin") == 0) {
 
administrar();
 
administrar();
−
        }
+
} else
−
      else
+
tratar_usuario();
−
          tratar_usuario();
+
 
−
+
}
−
                }  
+
x = 0;
−
          timeout.tv_sec=segundos;
+
}
−
i=1;
+
if (FD_ISSET(4, &myset)) {
−
    }
+
blue = 1;
−
    else{
+
if ((client = accept(s, (struct sockaddr *) &rem_addr, &opt)) < 0) {
−
        printf("Lendo temperatura\n");
+
perror("accept: ");
−
        timeout.tv_sec=segundos;
+
exit(1);
−
    }
+
}
−
    }  
+
 
 +
memset(buf, 0, sizeof(buf));
 +
 
 +
// read data from the client
 +
if ((bytesRead = read(client, buf, sizeof(buf))) == -1) {
 +
 
 +
perror("Erro read");
 +
exit(1);
 +
}
 +
close(client);
 +
 
 +
if (bytesRead > 0) {
 +
sscanf(buf, "%s", userID);
 +
if (strcmp(userID, "admin") == 0) {
 +
administrar();
 +
} else
 +
tratar_usuario();
 +
 
 +
}
 +
x = 0;
 +
 
 +
}
 +
 
 +
}
 
}
 
}
 +
 +
 +
 
</syntaxhighlight>
 
</syntaxhighlight>
  

Edição das 19h20min de 2 de novembro de 2013

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"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/rfcomm.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/select.h>

struct TUsuario *head, *tail; /* ponteiros inicial e final*/
char userID[TAM_VET];
char *buf_bluetooth = "senha";
struct sockaddr_rc loc_addr = { 0 }, rem_addr = { 0 };
char buf[1024] = { 0 };
int s, client, bytesRead, passo;
socklen_t opt = sizeof(rem_addr);

//-----------------------------------------------------------
char Blue(char *retorno) {

	if ((client = accept(s, (struct sockaddr *) &rem_addr, &opt)) < 0) {
		perror("accept: ");
		exit(1);
	}

	memset(buf, 0, sizeof(buf));

	// read data from the client
	if ((bytesRead = read(client, buf, sizeof(buf))) == -1) {
		perror("Erro read");
		exit(1);
	}
	passo = client;
	close(client);
	strcpy(retorno, buf);
	return;

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

char Pblue(char *mensagem) {

	if ((client = accept(s, (struct sockaddr *) &rem_addr, &opt)) < 0) {
		perror("accept: ");
		exit(1);
	}

	memset(buf, 0, sizeof(buf));

	//envia uma resposta
	strcpy(buf, mensagem);
	write(client, buf, sizeof(buf));
	sleep(1);

	// close connection
	close(client);
	return;
}

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

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);
	if (blue == 0)
		printf("porta aberta: 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*/
		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*/
char *pergunta;
int perguntas(struct TUsuario *p) {

	int iSecret, iGuess;
	char resp[TAM_VET], retorno[256];

	srand (time(NULL) );/* inicia o randômico*/

iSecret	= rand() % 3 + 1; /*sorteia o número*/

	if (iSecret == 1) {
		if (blue == 0) {
			printf("Digite o primeiro nome do seu pai\n");
			scanf("%s", resp);
		} else {
			Pblue("Digite o primeiro nome do seu pai");
			Blue(retorno);
			strcpy(resp, retorno);
		}

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

	if (iSecret == 2) {
		if (blue == 0) {
			printf("Digite o nome da sua cidade natal\n");
			scanf("%s", resp);
		} else {
			Pblue("Digite o nome da sua cidade natal");
			Blue(retorno);
			strcpy(resp, retorno);
		}

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

	if (iSecret == 3) {
		if (blue == 0) {
			printf("Digite o primeiro nome da sua mãe\n");
			scanf("%s", resp);
		} else {
			Pblue("Digite o primeiro nome da sua mãe");
			Blue(retorno);
			strcpy(resp, retorno);
		}

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

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

void tratar_usuario() {
	char senha[TAM_VET], retorno[256];
	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 = 1; //permissao(p);
		if (r == 1) {
			// if(p -> contador < 3){ /* analisa o número de tentativas*/
			if (blue == 0) {
				printf("\n%s %s!Entre com a senha\n", p->mensagem, p->userID);
				scanf("%s", senha);
			} else {
				Pblue("senha");
				Blue(retorno);
				strcpy(senha, retorno);
			}
			//printf("%s", pergunta);
			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) {
					if (blue == 0)
						printf("\nPorta aberta\n");
					else
						Pblue("Porta aberta");
					enviar_analogica('1', "150");
					sleep(2);
					enviar_analogica('1', "000");
					p->contador = 0; /* zera o contador*/
					login(p);
				} else {
					p->contador++; /* Caso erre a pergunta acrescenta o contador*/
					if (blue == 0)
						printf("\nDados Inválidos\n");
					else
						Pblue("Dados Inválidos");
				}

			} else {
				p->contador++; /* Caso erre a senha acrescenta um contador*/
				if (blue == 0)
					printf("\nSenha Inválida\n");
				else
					Pblue("Senha inválida");
			}

		} else {
			if (blue == 0)
				printf("\nFora do Horário\n");
			else
				Pblue("Fora do Horário");
		}
	}
}

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

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);
}

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

int botao() {
	float n;
	int i = 0;

	n = receber_analogica('1');

	while (i == 0) {
		n = receber_analogica('1');

		if (n > 0.20 && n != 0) {
			if (n <= 0.26) {
				return 9;
			}
			if (n > 0.26 && n < 0.30) {
				return 8;
			}
			if (n >= 0.30 && n <= 0.35) {
				return 7;
			}
			if (n >= 0.36 && n <= 0.40) {
				return 6;
			}
			if (n >= 0.43 && n < 0.50) {
				return 5;
			}
			if (n > 0.53 && n <= 0.58) {
				return 4;
			}
			if (n > 0.70 && n <= 0.80) {
				return 3;
			}
			if (n > 1.0 && n <= 1.1) {
				return 2;
			}
			if (n > 1.8 && n <= 2.0) {
				return 1;
			}
			if (n > 3.0 && n <= 3.3) {
				return 0;
			}
			if (n > 4.0 && n <= 5.0) {
				return 10; //enter
			}
			i = 1;
			n = 0;
			usleep(5000);

		}
		return 20;
	}
	return 20;
}

int main(int argc, char **argv) {

	int fd;
	int fdmax;
	int i, j, lag = 0;
	size_t bytes_read;
	fd_set master_set, myset;
	char buffer[256];

	char buf[50]; //variavel do teclado
	int bot, x = 0, y = 0, z = 0; //variaveis do teclado
	int W = 6;
	int segundos;

	FD_ZERO(&master_set);

	for (i = 1; i < argc; i++) {
		if ((fd = open(argv[i], O_RDWR)) == -1) {
			perror("open");
			exit(1);
		}
		FD_SET(fd, &master_set);
	}

	// allocate socket http://www.br-c.org/doku.php?id=socket
	if ((s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) == -1) {
		printf("Problemas na criação do socket\n");
		exit(-1);
	}
	FD_SET(s, &master_set);
	fd++;

	/* registra o maior descritor */
	fdmax = fd;

	// bind socket to port 1 of the first available 
	// local bluetooth adapter
	//http://www.br-c.org/doku.php?id=bind

	loc_addr.rc_family = AF_BLUETOOTH;
	loc_addr.rc_bdaddr = *BDADDR_ANY;
	//str2ba( endereco, &loc_addr.rc_bdaddr );
	loc_addr.rc_channel = (uint8_t) 3;
	if (bind(s, (struct sockaddr *) &loc_addr, sizeof(loc_addr)) == -1) {
		printf("Problemas no bind\n");
		exit(-1);
	}

	//listen http://www.br-c.org/doku.php?id=listen
	printf("Preparando para listen..\n");
	// put socket into listening mode
	if (listen(s, 1) < 0)
		printf("Problemas de listen...\n");

	conectar();
	ler_lista();
	listar_lista();

	struct timeval timeout;

	segundos = 0;

	timeout.tv_sec = segundos;
	timeout.tv_usec = 500000;

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

		myset = master_set; /* deve ser copiado sempre pois o conjunto é alterado */

		if ((W = select(fdmax + 1, &myset, NULL, NULL, &timeout)) == -1) {
			perror("select");
			exit(1);
		}
		if (W == 0) {

			enviar_digital('1', '1');

			bot = botao();
			if (bot == 10) {
				printf("enter");
				while (z < y) {
					printf("\n %d \n", buf[z]);
					z++;
					x = 0;
				}
				z = 0;
			}

			if (bot >= 0 && bot <= 9) {

				buf[y] = bot;
				y++;
			}

		}

		if (FD_ISSET(3, &myset)) {
			blue = 0;
			if ((bytesRead = read(0, buffer, sizeof(buffer))) == -1) {
				perror("Erro read");
				exit(1);
			}
			if (bytesRead > 0) {
				sscanf(buffer, "%s", userID);
				if (strcmp(userID, "admin") == 0) {
					administrar();
				} else
					tratar_usuario();

			}
			x = 0;
		}
		if (FD_ISSET(4, &myset)) {
			blue = 1;
			if ((client = accept(s, (struct sockaddr *) &rem_addr, &opt)) < 0) {
				perror("accept: ");
				exit(1);
			}

			memset(buf, 0, sizeof(buf));

			// read data from the client
			if ((bytesRead = read(client, buf, sizeof(buf))) == -1) {

				perror("Erro read");
				exit(1);
			}
			close(client);

			if (bytesRead > 0) {
				sscanf(buf, "%s", userID);
				if (strcmp(userID, "admin") == 0) {
					administrar();
				} else
					tratar_usuario();

			}
			x = 0;

		}

	}
}

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
Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=Projeto_PRG-_Engenharia&oldid=61641”