Erro em manipular ponteiros Sockets [RESOLVIDO]

leandrojapa
(usa Debian)

Enviado em 12/04/2010 - 12:01h

Bom dia a todos, estava com um problema em recuperar o conteudo de uma lista porem nosso colega de forum Daemonio me ajudou, agora estou com problemas novamente na manipulação dos ponteiros.Nao consigo adicionar endereco do cliente na lista..alguem poderia me ajduar..estarei anexando todo o codigo..
servidor.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <pthread.h>
#include "lib/uteis.h"
#include "lib/lista.h"

/***********Trabalho de Gerencia de Redes***********/

/*estrutura com informações sobre a conexao
struct sockaddr_in
{
short int sin_family;
unsigned short int sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[8];
};

struct in_addr
{
unsigned long s_addr;
}
*/

/*estrutura contendo informações sobre meu socket*/
struct sockaddr_in * getMeuSock(int porta)
{
struct sockaddr_in * sock;
memset(sock, '{TEXTO}', sinSize);
sock = meuMalloc(sizeof(struct sockaddr_in));
sock->sin_family = AF_INET;
sock->sin_addr.s_addr = INADDR_ANY;
sock->sin_port = htons(porta);

return sock;
}

void aceitaConexao(int sockfd)
{
struct in_addr *novo;
char *ip;
int novoSock;
char *bemVindo = "Bem vindo cliente";
while(1)
{
//novo = (struct in_addr*) malloc(sizeof(struct in_addr));
// novo = (struct sockaddr_in*) malloc(sizeof(struct sockaddr_in));
novo = meuMalloc(sizeof(struct in_addr));
// memset(&novo, '{TEXTO}', sizeof(struct in_addr));
novoSock = accept(sockfd,(struct sockaddr *) &novo, &sinSize); ->ERRO
adicionar(listaClientes, novo, novoSock); ->ERRO
send(novoSock, bemVindo, sizeof(char)*strlen(bemVindo)+1, 0);
// ip = inet_ntoa(novo->sin_addr);
// printf("\n %s conectou-se.\n", ip); //Esse printf não aparece na primeira vez
imprimeCliente(listaClientes);
}
}


int main(int argc, char ** argv)
{
int sockfd,n;
pthread_t threadAccept;
struct sockaddr_in * meu_end = getMeuSock(20000);

listaClientes = cria();

// struct in_addr temp;

// memset(&temp, 127, sizeof(struct in_addr));

// adicionar(listaClientes, temp, 2);

// memset(&temp, 255, sizeof(struct in_addr));

// adicionar(listaClientes, temp, 4);

// imprimeCliente(listaClientes);


sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd == -1)
{
printf("\nErro na chamada socket()");
return 1;
}
n=setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,(const char *) &meu_end, sizeof(meu_end));
if(bind(sockfd, (struct sockaddr_in *) meu_end, sizeof(struct sockaddr_in)) == -1)
{
printf("\nErro na chamada de bind()");
return 1;
}

if(listen(sockfd, 10))
{
printf("\nErro na chamada de listen()");
return 1;
}

pthread_create(&threadAccept, NULL, (void*)&aceitaConexao, &sockfd);

// aceitaConexao(sockfd);

return 0;
}

lista.h

int sinSize = sizeof(struct sockaddr_in);

/* estrutura para armazenar informacoes sobre processos */
/*struct processo{
char *usoCpu;
char *usoMem;
struct processo *prox;
};

typedef struct processo ListaP;
*/

/*estrutura para tratar insercao na lista */
struct listaSock
{
struct in_addr endereco;
int sockfd;
struct listaSock * proximo;
};

typedef struct listaSock ListaS;
int listSize = sizeof(ListaS);

ListaS *listaClientes;


ListaS* cria()
{
ListaS* s;
s = meuMalloc(sizeof(struct listaSock));
s->proximo = NULL;
return s;
}


/*estrutura para adicionar a lista*/
void adicionar(ListaS *s, struct in_addr end, int sockd)
{
ListaS *novo;
novo = meuMalloc(listSize);
novo->endereco = end;
novo->sockfd = sockd;

novo->proximo = s->proximo;
s->proximo = novo;
}


// Esta função recebe um inteiro x e uma lista
// encadeada de inteiros. O endereço da lista é
// ini e ela tem uma celula-cabeça. A função
// devolve o endereço de uma celula que contém x.
// Se tal celula não existe, a função devolve NULL.

/*celula *buscaCliente (int x, ListaS *ini)
{
ListaS *p;
p = ini->prox;
while (p != NULL && p->ip != x)
p = p->prox;
return p;
}
*/


// Esta função recebe uma lista encadeada ini,
// com cabeça, e remove da lista a primeira
// celula que contiver y, se tal celula existir.

/*void buscaEremoveCliente (int y, ListaC *ini)
{
ListaC *p, *q;
p = ini;
q = ini->prox;
while (q != NULL && q->conteudo != y) {
p = q;
q = q->prox;
}
if (q != NULL) {
p->prox = q->prox;
free (q);
}
}

*/

// Imprime o conteúdo de uma lista encadeada
// com cabeça. O endereço da primeira célula é ini.

void imprimeCliente (ListaS *ini)
{
ListaS *p;
for (p = ini->proximo; p != NULL; p = p->proximo)
printf ("%s %d\n", inet_ntoa(p->endereco),p->sockfd);
}

void *meuMalloc(unsigned int nbytes)
{
void *ptr;
ptr = malloc(nbytes);
if (ptr == NULL)
{
printf ("\nErro no Malloc\n");
exit(EXIT_FAILURE);
}
return ptr;
}