Cliente / Servidor em UDP

[Marina_DC]

Espero estar postando no local certo, como o sistema é desenvolvido em C e acho que o problema é de lógica, achei que deveria ser aqui em programação e não na área de Linux, enfim, qualquer coisa me avisem que eu apago e coloco no local certo.

Olá pessoal estou aqui recorrendo a ajuda de vocês para me auxiliarem em um trabalho da faculdade. Tenho que desenvolver um sistema cliente/escalonador/servidor em C usando protocolo UDP e TCP, entre cliente / escalonador vai ser em UDP e entre o escalonador e o servidor em TCP, na verdade essa parte toda já está pronta, os meus problemas são:

1 - Eu preciso carregar o endereço e porta do escalonador de um arquivo em txt, onde contem 10 endereços e portas, isso também já faz, só que ele não pode enviar a todos os endereços e sim apenas para o primeiro que encontra disponível e depois encerra a leitura do arquivo, só que não consigo fazer isso, já tentei no while colocar além do feof(fp) também testar se controle (que recebe o valor do envio) for igual a 0 executar, senão parar, mas aí só funciona se for na primeira porta que o escalonador estiver rodando, se for em qualquer outra ele não envia a mensagem.

2 - Do servidor para o escalonador ele envia a resposta, mas essa resposta não chega até o cliente. Ou seja, se o servidor responder (OK), no escalonador a mensagem é recebida e deveria ser repassada para o cliente, mas isso não ocorre.

Espero que alguém possa me ajudar.

Códido co cliente:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>


pthread_attr_t * attr;
pthread_t tid;
void *arg;

struct scheduller{

char ip[16];
unsigned int port;

};

typedef struct scheduller SCHEDULLER;

SCHEDULLER sch_server[10];

struct sockaddr_in scheduller;
int s, i, controle, ret, opc, opc1;
socklen_t sched_tam;
char buf[255], ip[16], port[6], opcc[1], nome[250], cod[2];
FILE * fp;

void * resposta(void *arg){

sched_tam = sizeof(scheduller);
if(recvfrom(s,buf,(strlen(buf)+1),0,(struct sockaddr *)&scheduller,&sched_tam)<0)
{
perror("Erro ao receber a resposta");
exit(4);
}
}

void carrega()
{

if ((fp=fopen("./config.dat","r+")) != NULL)
{
i = 0;
fscanf(fp, "%s %s", &ip, &port);
controle = 0;
while((!feof(fp)) && (controle != 1))
{
strcpy(sch_server[i].ip,ip);
sch_server[i].port = htons((unsigned int) atoi(port));

scheduller.sin_family = AF_INET;
scheduller.sin_addr.s_addr = inet_addr(sch_server[i].ip);
scheduller.sin_port = sch_server[i].port;

controle = sendto(s,buf,(strlen(buf)+1),0,(struct sockaddr *)&scheduller,sizeof(scheduller));

if(controle == 1)
{
ret = pthread_create(&tid, attr, resposta, arg);
sleep(2);
kill(ret);
printf("\t\t\n\nResposta: %s\n\n", buf);
break;
}
else
{
controle = 0;
i++;
fscanf(fp, "%s %s", &ip, &port);
}
}

}
else
printf("não foi possivel se conectar ao servidor, tente mais tarde\n");
fclose(fp);
}

void menu_entrada()
{
opc1 = 0;
do
{
system("clear");
printf("\n\t\t===============================================\n");
printf("\n\t\t\tCodigo: ");
scanf("%s", &cod);
printf("\n\t\t\tNome: ");
scanf("%s", &nome);
printf("\n\n\t\t[1] - Confirmar [2] - Limpar [3] - Menu\n\t\tOpcao: ");
scanf("%i", &opc1);
printf("\n\t\t===============================================\n");

if(opc1 == 1)
{
memcpy(buf, "{TEXTO}", sizeof(buf));
sprintf(buf, "%s %s %s", opcc, cod, nome);
carrega();

}
if (opc1 == 2)
system("clear");

}while( opc1 != 3);
}

main(int argc, char ** argv)
{
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
perror("socket()");
exit(1);
}
opc = 0;
do
{
system("clear");
printf("\n\t\t==================== Menu ====================\n");
printf("\n\t\t\t\t[1] Incluir");
printf("\n\t\t\t\t[2] Alterar");
printf("\n\t\t\t\t[3] Excluir");
printf("\n\t\t\t\t[4] Consultar");
printf("\n\t\t\t\t[5] Sair");
printf("\n\n\t\t===============================================\n");
printf("\t\tDigite a Opcao: ");
scanf("%i", &opc);

switch(opc)
{
case 1:
{
strcpy(opcc, "1");
menu_entrada();
break;
}
case 2:
{
strcpy(opcc, "2");
menu_entrada();
break;
}
case 3:
{
strcpy(opcc, "3");
menu_entrada();
break;
}
case 4:
{
strcpy(opcc, "4");
menu_entrada();
break;
}
default:
{
break;
}
}
}while (opc != 5);
close(s);
printf("Cliente encerrado com sucesso\n");
exit(0);
}

E o código do escalonador:

struct servidor{

char ip[16];
unsigned int port;

};
typedef struct servidor SERVIDOR;

SERVIDOR sch_sched[10];
FILE *fs;
int s, size, sock, i;
struct sockaddr_in client, scheduller, server;
char buf[32], ip[16], port[6];
socklen_t socklen = sizeof(struct sockaddr_in);

void servidor()
{
/* ************************ SERVIDOR CONEXÃO ***************************** */

if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("Socket()");

}

if ((fs=fopen("./server.dat","r+")) != NULL)
{
i = 0;

fscanf(fs, "%s %s", &ip, &port);

while(!feof(fs))
{
strcpy(sch_sched[i].ip,ip);
sch_sched[i].port = htons((unsigned int)atoi(port));

server.sin_family = AF_INET;
server.sin_addr.s_addr = inet_addr(sch_sched[i].ip);
server.sin_port = sch_sched[i].port;
if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0)
{
i++;
fscanf(fs, "%s %s", &ip, &port);
}
}
if (send(sock, buf, sizeof(buf), 0) < 0)
{
perror("A mensagem não pode ser enviada");

}
if (recv(sock, buf, sizeof(buf), 0) < 0)
{
perror("Erro ao receber a resposta");

}
printf("Mensagem do servidor: %s\n", buf);
}
else
printf("não foi possivel se conectar ao servidor, tente mais tarde");

/* *********************** FIM CONEXÃO SERVIDOR ************************** */

}

main(int argc, char ** argv)
{

while(1)
{
if (argc < 2) {
perror("Quantidade de parametros incorreta!");
printf("\n%s [port]\n",argv[0]);

}

if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
perror("socket()");

}

scheduller.sin_family = AF_INET;
scheduller.sin_port = htons(atoi(argv[1]));
scheduller.sin_addr.s_addr = INADDR_ANY;

if (bind(s, (struct sockaddr *)&scheduller, sizeof(scheduller)) < 0)
{
perror("bind()");

}

if (getsockname(s, (struct sockaddr *) &scheduller, &socklen) < 0)
{
perror("getsockname()");

}

if(recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr *) &client, &socklen) <0)
{
perror("recvfrom()");

}

printf("Protocolo: %s\n", buf);

servidor();


if(sendto(s, buf, (strlen(buf)+1), 0, (struct sockaddr *) &client,sizeof(client)) <0)
{
perror("Erro ao enviar a resposta");

}
fclose(fs);
close(sock);
close(s);
}
}