Comparar login e senha a partir de arquivo txt

[Xaws]

 Como eu faço pra comparar duas strings a partir de um arquivo txt?

 

char login[100];
   char senha[100];
   char str[100];
	main ()
{
	volta:
	FILE *fp;
	fp = fopen("login.txt","r");
	printf("LOGIN: ");
	scanf("%s",login);
	printf("SENHA:");
	scanf("%s",senha);
	if((strcmp(str,login) == 0) && (strcmp(str,senha) == 0))
	{
	printf("LOGADO");
}
else
{
	printf("ERRO\n");
	goto volta;
}
}

 Tentei assim mais da erro 

[devair1010]

@Xaws     creio que está dando erro por que o str está sem valor nenhum e para verificar do arquivo você precisa pegar o dado no arquivo e depois comparar,

[Xaws]

@devair1010  Já tentei de tudo quanto foi forma que eu pensei... Com valor,sem valor e nada

[devair1010]

@Xaws    aqui esse código  aqui funciona , coloquei o login como str e a senha como str2  e está funcionando    mas para usar o arquivo precisa modificar o código. e para isso precisa saber como você criou o arquivo txt . se for com fprintf fica mais fácil .

 teste esse código aqui :

#include <stdio.h>
#include <string.h>
#include <conio.h>
char login[100];
char senha[100];
char str1[100]="str";
char str2[100]="str2";

int main (){
    FILE *fp;
    fp = fopen("login.txt","r");

	volta:

	printf("LOGIN: se digitar < str > da certo ");
	scanf("%s",login);/*aqui você digita o login*/
	printf("SENHA: aqui digite < str2 > que da certo ");
	scanf("%s",senha);/*aqui você digita a senha*/
	if((strcmp(str1,login) == 0) && (strcmp(str2,senha) == 0)){
	    printf("\n\nLOGADO");
    }
    else{
	    printf("ERRO\n\n");
	    goto volta;
    }
    getch();
    return 0;
}

 

[Xaws]

@devair1010  Assim eu sei man,mais eu queria tipo... O login e senha ta em um arquivo txt,ai queria que ele comparasse as informações que estão no arquivo com as que o usuário digitou,esse que ta ***** 

[devair1010]

@Xaws     então diz aí como você colocou os dados nesse arquivo , você pode usar o comando fprintf e depois para pegar esses mesmos dados que estão no arquivo você pode usar o comando fscanf, aí depois que você pegar esse dado você compara com o login ou senha.  já se for um arquivo txt criado com o notpad aí fica mais difícil pois precisa ver com os dados foram gravados nele

adicionado 58 minutos depois

@Xaws      veja se esse código funciona como você quer, abra o notpad e coloque nele esse texto aqui "  qualquer coisa e mais alguma coisa esse é o login e essa é a senha mais alguma coisa gravada nesse arquivo    "    a palavra login é o login e você pode altera-la para outra palavra a senha é também a senha que você pode modifica-la também para outra palavra  aí salve o arquivo na mesma pasta em que está o código do programa, então se no arquivo tiver a palavra que você digitou para login e tiver a palavra que você digitou para senha ele imprimirá a mensagem "   LOGADO  ", então para testar  rode esse programa .:

#include <stdio.h>
#include <string.h>
#include <conio.h>
char login[100];
char senha[100];
char str1[100]="str";
char str2[100]="str2";
int i,k,g;
char a[50];
int main (){
    FILE *fp;

	volta:
    k=0;g=0;
    fp = fopen("teste de arquivo.txt","r");

	printf("LOGIN: se digitar < login > da certo ");
	scanf("%s",login);/*aqui você digita o login*/
	printf("SENHA: aqui digite < senha > que da certo ");
	scanf("%s",senha);/*aqui você digita a senha*/

	while(fscanf(fp,"%s",a)!=EOF){
        if(strcmp(a,login) == 0){
	        k=1;
	        break;
        }
    }
    fclose(fp);
    fp = fopen("teste de arquivo.txt","r");
    while(fscanf(fp,"%s",a)!=EOF){
        if(strcmp(a,senha) == 0){
	        g=1;
	        break;
        }
    }
    fclose(fp);
	if(k==1&&g==1){
	    printf("\n\nLOGADO");
    }
    else{
	    printf("ERRO\n\n");
	    goto volta;
    }
    printf("\n\n\n");
    getch();
    return 0;
}

 

[Anonymous Programmer]

a melhor forma de fazer seria utilizando uma struct Ex:

struct infos_contas{

     char login[256];

     char senha[50];

}

 

para gravar os dados no arquivo basta preencher as variaveis e gravalas no arquivo com fwrite;

para ler depois os dados utilize a fread, que vai buscar todos dados da struct de uma vez so,

para saber a quantidade de contas dentro do arquivo você vai dividir o tamanho da struct pela quantidade de bytes do arquivo, com a quantidade ja em mãos desenvolva uma while() que percorra todas as contas comparando ate achar a correta, se encontrar alguma correspondente  LONGA, se não mostra erro de login!

 

Da forma que você esta fazendo acaba dificultando porque cada dado dentro do arquivo tem um ponteiro diferente(endereço), utilizando a struct voce so vai carrega-los 1 conta por vez e comparar,

[Xaws]

@devair1010  Deu certo man,obrigado 

@Anonymous Programmer  Não cheguei a testar da sua forma pois a do Devair deu certo,mais obrigado pela resposta,depois vou testar 

[Anonymous Programmer]

no momento de comparar a struct do arquivo com a struct de login, utilize memcmp(ponteiro de dados1,ponteiro de dados2,tamanho dos dados); ela retorna 0 se for igual, facilita muito mais,

[Xaws]

@devair1010  Era só por causa do while que não dava certo antes  arrumei o código e ficou bem pequeno 
 

#include <stdio.h>
#include <string.h>
#include <conio.h>
char login[100];
char senha[100];
char str[100];
char str2[100];
FILE *logs;
int main()
{
	volta:
	logs = fopen("login.txt","r");
	printf("USUARIO: ");
	scanf("%s",login);
	printf("SENHA: ");
	scanf("%s",senha);
	while((fscanf(logs,"%s",str) !=EOF) && (fscanf(logs,"%s",str2) !=EOF))
	{
	if((strcmp(login,str) == 0) && (strcmp(senha,str2) == 0))
	{
	printf("LOGADO");
	}
	else
	{
		printf("REJEITADO\n");
		goto volta;
	}
}
fclose(logs);
}

 

adicionado 13 minutos depois

@Anonymous Programmer  Seria assim?

 

#include <stdio.h>
#include <string.h>
#include <conio.h>
struct teste{
char login[100];
char senha[100];
char str[100];
char str2[100];
};
struct teste teste;
FILE *logs;
int main()
{
	volta:
	logs = fopen("login.txt","r");
	printf("USUARIO: ");
	scanf("%s",teste.login);
	printf("SENHA: ");
	scanf("%s",teste.senha);
	
	while((fscanf(logs,"%s",teste.str) !=EOF) && (fscanf(logs,"%s",teste.str2) !=EOF))
	{
	//if((strcmp(teste.login,teste.str) == 0) && (strcmp(teste.senha,teste.str2) == 0))
	if(memcmp(teste.login,teste.senha,100))
	{
	printf("LOGADO");
	return 0;
	}
	else 
	{
		printf("REJEITADO\n");
		goto volta;
	}
}
fclose(logs);
}

 Tentei dessa forma mais quando coloco qualquer coisa ele da como logado,tenho certeza que fiz tudo errado 

[devair1010]

@Xaws    seu código ficou muito bom e com poucas linhas, interessante o modo como você pegou as duas palavras no arquivo, as duas de uma vez,  depois que fiz o código percebi que havia repetido um loop sem necessidade eu poderia ter usado apenas um loop e por isso o código ficou bem extenso .

[Anonymous Programmer]

21 horas atrás, Xaws disse:

 Tentei dessa forma mais quando coloco qualquer coisa ele da como logado,tenho certeza que fiz tudo errado 

@Xaws

Quase, seria mais ou menos assim, postarei em partes!

// Declarando a struct

struct usuarios_infos{

char usuario[200];

char senha[50];

}

 

// Carregando o arquivo,

struct usuarios_infos usuarios_carregados;

 

wFile = fopen("usuarios.db","wb");

if(wFile == NULL){

printf("ERRO no arquivo e tal. \n");

}

 

int bytes = fread(&lista_de_contas,1,sizeof(lista_de_contas),wFile); // retorna 0 se der errado

 

apos ter carregado todos os usuarios dentro do arquivo iremos verificar quantas contas existem a partir do retorno de fread, que retorna exatamente a quantidade de bytes dentro do arquivo, ou seja dividindo esse valor pelo tamanho da struct teremos o total de contas,

 

int total_de_contas = bytes / sizeof(usuarios_infos);

 

dessa forma a primeira conta cadastrada fica no total_de_contas 0 a segunda é 0 + sizeof(usuarios_infos) que é o tamanho de uma conta,

 

a partir dai é só comparar através da memcmp,

 

exemplo:
char usuario[200];

char senha[50];

scanf("%s",&usuario);

scanf("%s",&senha);

memcpy(&umastructtemporaria.usuario,&usuario,strlen(usuario)); // passa os dados para strucft

memcpy(&umastructtemporaria.senha,&senha,strlen(senha)); // passa os dados para struct

if(memcmp(&umastructtemporaria,&structdecontacarregada,sizeof(usuarios_infos)) == 0){

printf("Usuario longado. \n");

}else{

printf("Usuario ou senha incorreto. \n");

}

 

Ai meu amigo basta você fazer um while que percorre todo seu arquivo de contas lembrando que cada conta sem encontra na seguinte posição,

contas = 0;

0 - primeira conta

contas = contas + sizeof(usuarios_infos);

1 - segunda conta

contas = contas + sizeof(usuarios_infos);

2 - segunda conta

 

o while vai percorrer ate chegar no resultado do total de bytes carregados do arquivo dividido pelo sizeof(usuarios_infos);

 

Qualquer duvida mande ai! seus resultados bons ou ruins também!

 

[Xaws]

@Anonymous Programmer  Parece bem complicado kk,amanhã eu dou uma olhada com calma 

[Anonymous Programmer]

Realmente, porém te dar um controle muito maior e melhor, afinal você vai poder adicionar varias contas dentro do arquivo,

[Xaws]

@Anonymous Programmer  Não entendi a parte da structtemporaria.usuario ... .senha

 Eu fiz assim:
 

#include <stdio.h>
#include <string.h>
#include <conio.h>
struct usuarios_infos{
char login[100];
char senha[100];
};
struct usuarios_infos contas;

FILE *logs;
int main()
{
	volta:
	logs = fopen("login.db","r");
	int bytes = fread(&contas,1,sizeof(contas),logs);
	int total_de_contas = bytes / sizeof(contas);
	printf("USUARIO: ");
	scanf("%s",contas.login);
	printf("SENHA: ");
	scanf("%s",contas.senha);
	memcpy(&contas.login,&contas.login,strlen(contas.login)); // passa os dados para strucft
    memcpy(&contas.senha,&contas.senha,strlen(contas.senha)); // passa os dados para struct
    if(memcmp(&contas,&total_de_contas,sizeof(contas)) == 0)
	{
	printf("LOGADO");
	}
	else 
	{
	printf("REJEITADO\n");	
	goto volta;
	return 0;
}
fclose(logs);
}

 

[Anonymous Programmer]

Isso, essa é a ideia, só um detalhe na hora de utilizar o fread, voce carregou os bytes do arquivo dentro da struct contas, não deu erro porque você limitou a quantidade de bytes a ser lidos do tamanho da struct, o tamanho da struct suporta 1 usuário e 1 senha correto? ou seja você só vai conseguir carregar 1 conta, para verificar varias contas ao mesmo tempo crie uma variavel ex: ponteiro_de_contas=0; (ela deve começar com 0)

 

ela apontando pra 0 você vai ler a primeira conta do arquivo, esse valor 0 + sizeof(usuarios_infos) já vai ser  aproxima conta da forma que te disse antes, 

0 - primeira conta

contas = contas + sizeof(usuarios_infos);

1 - segunda conta

contas = contas + sizeof(usuarios_infos);

2 - segunda conta

 

você fez tudo certo, agora é só adicionar uma while que percorra todas as contas e compare ao mesmo tempo, tipo

while(true){

// codigo para carregar todas as contas

memcpy(&contas,ponteiro_de_contas,sizeof(contas)); // Aqui sim que você vai passar os dados para struct

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

// codigo para verificar todas as contas a partir do ponteiro_de_contas

memcmp(&contas,etc,sizeof(contas));

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

if(total_de_contas == sizeof(lista_de_contas)){

break;

}

}

 

Obs: para carregar todas contas de uma vez só você deve carrega-la dentro de um array pode ser declarada assim char lista[100000];

ou

 

char * lista;

lista = malloc(100000);

 

agora no lugar de carregar fread() em &contas você vai por sua lista, 

[Xaws]

@Anonymous Programmer  Na verdade daquele jeito ele só da rejeitado

[Anonymous Programmer]

@Xaws o codigo da forma que falei fica assim:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct usuarios_infos{
char usuario[100];
char senha[100];
};
void main(){
	struct usuarios_infos contas_tmp,conta_definida;
	char * lista_de_contas,usuario[20]="\0",senha[20]="\0";
	int ponteiro_contas=0,total_de_contas=0,total_de_bytes=0;
	printf("****** Systema de Login ****** \n");
	printf("Usuario: ");
	scanf("%s",usuario);
	printf("Senha: ");
	scanf("%s",senha);
	// coloca nossos dados dentro de conta_definida
	memset(&conta_definida,0,sizeof(struct usuarios_infos));
	memcpy(&conta_definida.usuario,&usuario,strlen(usuario));
	memcpy(&conta_definida.senha,&senha,strlen(senha));
	// --------------------------------------------
	FILE * file_contas;
	file_contas = fopen("usuarios.db","rb");
	if(file_contas == NULL){
		printf("[F] Falha ao criar o arquivo de dados. \n");
		return;
	}else{
		// codigo para pegar o tamanho do arquivo
		fseek(file_contas,0,SEEK_END);
		total_de_bytes = ftell(file_contas);
		rewind(file_contas);
			// cria um array no ponteiro lista_de_contas exatamente com tamanho do arquivo
			lista_de_contas = malloc(total_de_bytes);
			if(lista_de_contas == NULL){
				printf("[F] Não foi possivel liberar espaço. \n");
				return;
			}
			// ---------------------------------------------------------------------------
		// --------------------------------------
		printf("[Ok] Arquivo carregado bytes: %d \n",total_de_bytes);
	}
	// Carrega todas as contas dentro do arquivo
	if(fread(lista_de_contas,1,total_de_bytes,file_contas) == 0){
		printf("[F] Falha na leitura das contas. \n");
		return;
	}else{
		total_de_contas = total_de_bytes / sizeof(struct usuarios_infos);
		printf("[Ok] Todas as %d contas foram carregadas. \n",total_de_contas);
	}
	// -----------------------------------------
	// Compara a conta inserida no programa com todas presentes dentro do arquivo usuarios.db
	while(1){
		memset(&contas_tmp,0,sizeof(struct usuarios_infos));
		memcpy(&contas_tmp,&lista_de_contas[ponteiro_contas],sizeof(struct usuarios_infos));
		if(memcmp(&conta_definida,&contas_tmp,sizeof(struct usuarios_infos))==0){
			// coloque uma função abaixo caso usuario longado
			printf("Bem - Vindo: %s \n",contas_tmp.usuario);
			// ---------------------------------------------
			break;
		}else{
			//printf("Conta %d \nUsuario:%s\nSenha:%s \n",ponteiro_contas/sizeof(struct usuarios_infos),contas_tmp.usuario,contas_tmp.senha);
		}
		if(ponteiro_contas/sizeof(struct usuarios_infos) == total_de_contas-1){
			printf("Usuario ou Senha Incorreto. \n");
			break;
		}
		ponteiro_contas = ponteiro_contas + sizeof(struct usuarios_infos);
	}
	// --------------------------------------------------------------------------------------
	fclose(file_contas);
	free(lista_de_contas);
}

Da uma olhada, uma estudadinha, não copia kkkk .não vai pelo fácil, tente ler e ver como funciona deixei com muitos comentarios e o nome das variaveis estão bem claras. tente ai! mande seus resultados

[Xaws]

@Anonymous Programmer  Amanhã dou uma estudada valeu,depois posto o resultado

[Xaws]

@Anonymous Programmer  Então bora lá...
 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
struct usuarios_infos{
char login[30];
char senha[30];
};
struct usuarios_infos usuario_comp,usuario_cadastrado;
int main()
{
	volta:
	char * lista_de_contas,usuario[30] = "\0",senha[30] = "\0";
    int ponteiro_contas = 0,total_contas = 0,arq_tamanho = 0;
	printf("USUARIO: ");
	scanf("%s",usuario_cadastrado.login);
	printf("SENHA: ");
	scanf("%s",usuario_cadastrado.senha);
	memset(&usuario_cadastrado,0,sizeof(struct usuarios_infos));
	memcpy(&usuario_comp,&usuario_cadastrado.login,strlen(usuario_cadastrado.login));
	memcpy(&usuario_comp,&usuario_cadastrado.senha,strlen(usuario_cadastrado.senha));
	
    FILE* logs;
	logs = fopen ("contas.db","rb");
	if(logs == NULL)
	{
		printf("Erro ao abrir arquivo de logs\n");
		goto volta;
	}
	else
	{
		fseek(logs,0,SEEK_END);
		arq_tamanho = ftell(logs);
		rewind(logs);
		logs = malloc (arq_tamanho);
		if(logs == NULL)
		{
			printf("Erro ao abrir arquivo de logs\n");
			goto volta;
		}
		else
		{
	if(fread(usuario_cadastrado,1,arq_tamanho,logs) == 0)
    {
    	printf("Falha ao tentar ler contas\n");
    	return;
	}
	else
	{
		total_contas = arq_tamanho / sizeof (struct usuarios_infos);
	}
    while(1)
    {
    	memset(&usuario_comp,0,sizeof(struct usuario_infos));
    	memcpy(&usuario_comp,&lista_de_contas[ponteiro_contas],sizeof(usuarios_infos);
    	if(memcmp(&usuario_cadastrado,&usuario_comp,sizeof(struct usuario_infos)) == 0)
    	{
    		printf("logado");
		}
		else
		{
			printf("negado");
			goto volta;
		}
		fclose(file_contas);
	free(lista_de_contas);
	}
}
}
}

 Ficou assim mais eu não entendi algumas coisas, tipo...
 Essa parte do malloc está dando erro (invalid conversion from VOID to FILE*) 
PS: empaquei nessa parte kk

logs = malloc (arq_tamanho);

 Nessa parte... o que ele faz é o seguinte? (total de contas é = arq_tamanho dividido (/) pelo tamanho da struct usuarios_infos), porque a divisão?  pra saber que metade é usuário e metade senha? (ou eu estou todo errado?) 

	total_contas = arq_tamanho / sizeof (struct usuarios_infos);

 

 E aqui... porque o [ponteiro_contas]?

memcpy(&usuario_comp,&lista_de_contas[ponteiro_contas],sizeof(usuarios_infos);

 Na parte do usuario[30] = "\0"; Quando fui usar ele deu erro, por isso eu mudei... Só não sei se fiz certo .-.

 

[Anonymous Programmer]

@Xaws

o malloc serve pra reservar espaço de memoria para posteriormente receber os dados de fread, deu falha porque você tentou reservar memoria para uma um ponteiro do tipo FILE *, lembre que quando você utiliza a função arquivo = fopen("usuarios.db","rb"); você não esta carregando o arquivo dentro do seu programa, a função so esta te retornando um ponteiro de arquivo para depois ser carregado os bytes se desejado
,

portanto você deve trocar em seu codigo esse logs = malloc(); e altrar para lista_de_contas = malloc(arq_tamanho);

 

a divisão é feita para saber qual  a quantidade de contas presentes dentro do arquivo, para o while ter um fim, Ex:

Usuario[100]; ocupa 100 espaços de memoria

Senha[100]; ocupa + 100 espaços de memoria,

 

ou seja cada conta vai utilizar 200 bytes do arquivo, 200 bytes vai ser igual o tamanho da struct das contas, portanto supondo que tenhamos 5 contas dentro do arquivo seria 5x200 = 1000 bytes, de cara quando você carrega o arquivo é esse valor que ele retorna como tamanho, você não tem o total de contas no mole, tem que fazer essa continha de Ex: 1000 bytes / 200 bytes que é a mesma coisa que arq_tam = arq_tam / sizeof(struct usuarios_infos);

 

o ponteiro_contas serve para indicar o memcmp qual pedaço do bloco de bytes você quer comparar, se é a primeira conta segunda conta .... isso limita o memcmp para não sair comparando tudo que ve pela frente, ele compara 200 bytes depois os proximos +200bytes que sera 400bytes, e assim vai ate chegar o total de contas

[Xaws]

@Anonymous Programmer  Complicado essa parte dos bytes .-.
 Ficou assim mais ainda me da o mesmo erro:
 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
struct usuarios_infos{
char login[30];
char senha[30];
};
struct usuarios_infos usuario_comp,usuario_cadastrado;
int main()
{
	volta:
	char * lista_de_contas,login[30] = "\0",senha[30] = "\0";
    int ponteiro_contas = 0,total_contas = 0,arq_tamanho = 0;
	printf("USUARIO: ");
	scanf("%s",login);
	printf("SENHA: ");
	scanf("%s",senha);
	memset(&usuario_cadastrado,0,sizeof(struct usuarios_infos));
	memcpy(&usuario_cadastrado.login,&login,strlen(login));
	memcpy(&usuario_cadastrado.senha,&senha,strlen(senha));
	
    FILE* logs;
	logs = fopen ("contas.db","rb");
	if(logs == NULL)
	{
		printf("Erro ao abrir arquivo de logs\n");
		goto volta;
	}
	else
	{
		fseek(logs,0,SEEK_END);
		arq_tamanho = ftell(logs);
		rewind(logs);
		lista_de_contas = malloc (arq_tamanho);
		if(logs == NULL)
		{
			printf("Erro ao abrir arquivo de logs\n");
			goto volta;
		}
		else
		{
	if(fread(usuario_cadastrado,1,arq_tamanho,logs) == 0)
    {
    	printf("Falha ao tentar ler contas\n");
    	return 1;
	}
	else
	{
		total_contas = arq_tamanho / sizeof (struct usuarios_infos);
	}
    while(1)
    {
    	memset(&usuario_comp,0,sizeof(struct usuarios_infos));
    	memcpy(&usuario_comp,&lista_de_contas[ponteiro_contas],sizeof(usuarios_infos));
    	if(memcmp(&usuario_cadastrado,&usuario_comp,sizeof(struct usuarios_infos)) == 0)
    	{
    		printf("logado");
		}
		else
		{
			printf("negado");
			goto volta;
		}
		fclose(logs);
	free(lista_de_contas);
	}
}
}
}

 

[isrnick]

Me parece que está complicando o código sem necessidade, uma ideia mais simples, usando usando a struct pra ler os dados do arquivo, e comparar com o login e senha digitados pelo usuário, poderia ficar assim:

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct usuarios_infos{
    char login[30];
    char senha[30];
};

struct usuarios_infos usuario_cadastrado;

int main()
{
    char login[30], senha[30];
    int logado = 0;

    FILE * logs;
    logs = fopen ("contas.db","rb");

    if(logs == NULL) {
        printf("Erro ao abrir arquivo de logs.\n");
        return 1;
    }
    else {
        do {

            printf("USUARIO: ");
            scanf("%s", login);

            printf("SENHA: ");
            scanf("%s", senha);

            while (fread(&usuario_cadastrado, sizeof usuario_cadastrado, 1, logs) == 1){
                if (strcmp(usuario_cadastrado.login, login) == 0 && strcmp(usuario_cadastrado.senha, senha) == 0) {
                    logado = -1;
                    break;
                }
            }
            
            rewind(logs);

            if (!logado)
                printf("O usuario %s nao foi encontrado ou a senha digitada nao e valida.\n", login);

        } while (!logado);
    }

    printf("\nLogado!\n\n");

    fclose(logs);

    return 0;
}

 

Não testei porque não tenho o arquivo contas.db, mas deveria funcionar sem problemas.

 

Edit: Corrigi colocando o rewind(logs) que havia esquecido.

[Xaws]

@isrnick  Não deu... Deixa pra lá, obrigado a todos, já sei que pra ler mais de 1 conta por arquivo devo usar struct então vou dar uma estudada e depois posto os resultados 

[isrnick]

@Xaws Eu fiz esse código pra gerar o arquivo contas.db contendo as contas e senhas:

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct usuarios_infos{
    char login[30];
    char senha[30];
};

struct usuarios_infos usuario_cadastro;

int main()
{
    
    FILE * logs;
    logs = fopen ("contas.db","ab");
    
    do {
        printf("USUARIO: ");
        scanf("%s", usuario_cadastro.login);
        if(strcmp(usuario_cadastro.login, "0") != 0) {
            printf("SENHA: ");
            scanf("%s", usuario_cadastro.senha);
            printf("\n");
            
            fwrite(&usuario_cadastro, sizeof usuario_cadastro, 1, logs);
        }
    } while (strcmp(usuario_cadastro.login, "0") != 0);
    
    fclose(logs);
    return 0;
}

 

E depois usei o arquivo gerado pra testar o código de login que coloquei no meu post anterior, e funcionou como esperado, sem erros.

 

Então o motivo que não deu certo aí provavelmente seja o modo como você armazenou os dados no seu arquivo contas.db, afinal os dados no arquivo precisam ser compatíveis com o modo em que a leitura com o fread é feita para obter os dados da struct usuarios_info.

 

 

 

Mas note que os logins e senhas estão sendo armazenados sem qualquer encriptação, a struct é composta por strings logo estamos basicamente salvando as senhas diretamente como texto no arquivo, então qualquer pessoa poderia simplesmente abrir o arquivo num editor de texto e ler os logins e senhas diretamente.

 

Logo, esse não é o modo que seria usado em uma aplicação real para salvar e/ou verificar logins e senhas, ou ao menos não deveria ser, mas incrivelmente existem exemplos de mal programadores salvando senhas como texto sem qualquer encriptação, que acabam sendo hackeados e dando acesso a todas os logins e senhas dos usuários aos hackers.