#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
//libs padrão para uso da socket
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
// lib para usar para converter host para ip
#include <netdb.h>


# define   MAXBUFF 1024
# define   FIM    "fim da transmissao"
client(int socketfd);
int main ()
{
int       socketfd;
char         Porta_servidor[4],ip_address[]="192.168.0.104";
struct sockaddr_in   serv_addr;    //Estrutura de endereco do servidor

printf("digite a porta do servidor:");
scanf("%s",Porta_servidor);

//Preenche a estrutura "serv_addr" com o endereco do servidor
bzero( (char*) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family        = AF_INET;
serv_addr.sin_addr.s_addr  = inet_addr(ip_address);
serv_addr.sin_port        = htons(atoi(Porta_servidor));

//Cria o socket TCP
if ( (socketfd = socket(AF_INET, SOCK_STREAM, 0) ) < 0){
printf("cliente: erro na criacao do socket");
exit(0);
}

//Se conecta ao servidor
if (connect(socketfd,(struct sockaddr *)&serv_addr, sizeof(serv_addr))<0){
printf("cliente: erro na conexao com o servidor");
close(socketfd);
exit(0);
}

//Chama a funcao cliente para enviar o pedido e receber a resposta
client(socketfd);

//Fecha o socket apos uso
close (socketfd);
exit(0);

}//Fim main()

/*------------------------------------------------------------
Funcao client:  - Envia o numeros ao servidor
/////////////   - Recebe os dados vindos do servidor e
- mostra-os na tela
-------------------------------------------------------------*/
client(int socketfd)

{
char      op='';
int    n=0,num1=0,num2=0,resposta=0,flag ;

//Envia o nome do arquivo ao servidor
printf("digite o primeiro numero");
scanf("%d",&num1);
printf("digite o operador");
scanf("%s",&op);
printf("digite o segundo numero");
scanf("%d",&num2);


if (send(socketfd, &num1, sizeof(num1), 0) == -1 ) {
printf("Funcao client: erro no envio do 1 numero ao servidor");
printf("Read error [%d]: %s n", errno, strerror(errno));
close(socketfd);
exit(0);
}
if (send(socketfd, &op, sizeof(&op),0) == -1) {
printf("Funcao client: erro no envio do operando ao servidor");
printf("Read error [%d]: %s n", errno, strerror(errno));
close(socketfd);
exit(0);
}
if (send(socketfd, &num2, sizeof(num2),0) == -1) {
printf("Funcao client: erro no envio do 2 numero ao servidor");
printf("Read error [%d]: %s n", errno, strerror(errno));
close(socketfd);
exit(0);
}
//Le os dados vindos do servidor e escreve-os
//para a saida padrao (video)
n=recv(socketfd,resposta,sizeof(int),0);
if (n == -1) {
printf("Read error [%d]: %s n", errno, strerror(errno));
printf("Funcao client: erro no recebimento do resultado");
close(socketfd);
exit(0);
}else{
printf("resposta = %d", resposta);
close(socketfd);
exit(0);
}
}//fim funcao client

/*
Exemplo de Servidor Multi-thread - SERVIDOR
Laboratorio de Sistemas Operacionais
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#define MAXBUFF 1024
#define FIM     "fim da transmissao"
#define TRUE 1
#define FALSE 0

void * NewSocketThread (void *fdnewsock);
int server(int);

int main()
{
    int    socketfd, serv_len;
    struct sockaddr_in   serv_addr;

    //Cria o socket TCP
    if ( (socketfd = socket(AF_INET, SOCK_STREAM, 0) ) < 0)
    {
        printf("servidor: erro na criacao do socket");
        exit(0);
    }

    //Preenche a estrutura do servidor e faz o Bind Local
    bzero( (char*) &serv_addr, sizeof(serv_addr));
    serv_addr.sin_family        = AF_INET;
    serv_addr.sin_addr.s_addr  = htonl(INADDR_ANY);
    serv_addr.sin_port        = htons(1443);

    serv_len = sizeof(serv_addr);
    if (bind(socketfd, (struct sockaddr *) &serv_addr, serv_len)<0)
    {
        printf("servidor: erro no bind local");
        close(socketfd);
        exit(0);
    }

    //Mostra a porta alocada dinamicamente
    if (getsockname(socketfd, (struct sockaddr *)&serv_addr, &serv_len) < 0)
    {
        printf("servidor: erro na chamada da funcao getsockname");
        close(socketfd);
        exit(0);
    }

    printf("nPorta alocada para o Servidor: %dn", ntohs(serv_addr.sin_port));

    //Chama a funcao servidor para esperar uma requisicao de servico

    server(socketfd);

    //fecha o socket apos uso

    close (socketfd);
    exit(0);
}

/*--------------------------------------------------------------------
 FUNCAO server:  -Conexoes para vários clientes - Servidor Multithread
 //////////////
---------------------------------------------------------------------*/
int server(int socketfd)
{
    char buff[MAXBUFF];
    int *newsocketfd, cli_len;
    struct sockaddr_in   cli_addr;
    pthread_t *sockthread;

    //Prepara para receber conexoes dos clientes
    listen(socketfd,5);

    //Estrutura de repetição para continuar recebendo conexões de clientes
    for(;;)
    {
        //Aloca espaço na memória para o novo descritor - newsocketfd
        newsocketfd = (int *)malloc(sizeof(newsocketfd));
        //Aguarda a conexao de algum cliente e quando o cliente conecta, o valor de accept
        //é recebido pelo conteúdo do endereço de newsocketfd (que está alocado na memória)
        cli_len=sizeof(newsocketfd);
        if ((*newsocketfd=accept(socketfd,(struct sockaddr *)&cli_addr,&cli_len))<0)
        {
            printf("Funcao server: erro no accept");
            close(socketfd); //Fecha o socket do servidor
            exit(0);
        }

        //Aloca espaço na memória para uma nova thread - sockthread
        sockthread = (pthread_t *)malloc(sizeof(pthread_t));
        //Cria e chama a nova thread(NewSocketThread) para tratar da comunicação do novo
        //cliente, passando como argumento o descritor(newsocketfd) do novo cliente
        pthread_create(sockthread,NULL,NewSocketThread,newsocketfd);

    }


} //Fim Funcao server


/*--------------------------------------------------------------------------------
 FUNCAO NewSocketThread: -Recebe o descritor do novo cliente.
 //////////////////////  -Le a mensagem enviada pelo cliente e escreve a mesma mensagem
                          para este cliente. Assim cada thread trata da comunicação
                          de leitura e escrita para cada cliente, individualmente.
                          ( 1 thread para 1 cliente )
                         -Enquanto o cliente estiver conectado, a thread correspondente
                          ao descritor deste cliente estará efetuando a comunicação.
----------------------------------------------------------------------------------*/

void * NewSocketThread (void *fdnewsock)
{

    int *newsockfd = (int *)fdnewsock;  //cast do tipo void para tipo int *
    char      op;
    int n,num1,num2,resposta;
    //Estrutura de repetição para continuar efetuando leitura e escrita na comunicação

    {
        //O servidor le mensagem do cliente "dono" deste descritor
        if(recv(*newsockfd, &num1, sizeof(int), 0) == -1)
            printf("nao recebeu o numero 1");

        if(recv(*newsockfd, &op, sizeof(char), 0) == -1)
            printf("nao recebeu o op");

        if(recv(*newsockfd, &num2, sizeof(int), 0) == -1)
            printf("nao recebeu o numero 2");

        write(1,op,1);

        if(op == '+')
        {
            resposta=num1+num2;
            printf ("n O resposta na soma e: %d",resposta);
        }
        else if(op == '-')
        {
            resposta=num1-num2;
            printf ("n O resposta subtração e: %d",resposta);
        }
        else if(op == '/')
        {
            resposta=num1/num2;
            printf ("n O resposta divisao e: %d",resposta);
        }
        else if (op == '*')
        {
            resposta=num1*num2;
            printf ("n O resposta multiplicaçao e: %d",resposta);
        }

        //O servidor escreve mensagem no cliente "dono" deste descritor
        send(*newsockfd,&resposta,sizeof(resposta),0);
    }
    }