+ Responder ao Tópico



  1. #1
    crisduarte
    Amigos,

    Estou fazendo um PTP para uma repetidora e gostaria de testar o PTP com ping( estou usando windows), ou se vocês podessem me apontar alguma outra forma.

    Queria fazer teste se ta passando 2Mb, o tempo de resposta destes 2MB etc.....


    Obrigado

  2. #2
    Amigo ping é ping não mede velocidade para medir a velocidade faz um FTP de um ponto para o outro e com relação ao ping oq vc pode fazer é aumentar o tamanho do pacote..
    Experimenta fazer um ping ? no prompt e vc vai ver como faz pq agora eu não lembro
    Abraço



  3. Citação Postado originalmente por Anonymous
    Amigo ping é ping não mede velocidade para medir a velocidade faz um FTP de um ponto para o outro e com relação ao ping oq vc pode fazer é aumentar o tamanho do pacote..
    Experimenta fazer um ping ? no prompt e vc vai ver como faz pq agora eu não lembro
    Abraço
    :toim: :toim: :toim: :toim: :toim: :toim: A resposta acima é minha esqueci de logar..rsrrss :toim: :toim: :toim: :toim: :toim: :toim: :toim: :toim:

  4. Citação Postado originalmente por crisduarte
    Amigos,

    Estou fazendo um PTP para uma repetidora e gostaria de testar o PTP com ping( estou usando windows), ou se vocês podessem me apontar alguma outra forma.

    Queria fazer teste se ta passando 2Mb, o tempo de resposta destes 2MB etc.....


    Obrigado

    Win
    Use ping -l <pacote>

    Linux -s <pacote>

    O pacote pode variar de 64 ou 4096 que se responder seu link esta otimo!!



    para testar velocidade so fazendo uns downloads de uma ponta para outra ou copiando um arquivo grande.



  5. no linux: ping -s 1500 -f

    se quiser ver o negocio melhor ainda; abre uns 10 terminaise roda o comando... pode aumentar o tamanho dos pacotes tb ...:twisted:

    vai mostar o q seu link aguenta... 8) ou nao... 8)

  6. não tenho certeza, mas parece que realmente existe um cálculo de velocidade baseado nos resultados do ping . Vou dar uma pesquisa pois uma vez um técnico da T..... me mostrou que meu link estava dando 768k atravé desse cálculo !

    [].s



  7. Citação Postado originalmente por fabmotcam
    não tenho certeza, mas parece que realmente existe um cálculo de velocidade baseado nos resultados do ping . Vou dar uma pesquisa pois uma vez um técnico da T..... me mostrou que meu link estava dando 768k atravé desse cálculo !

    [].s

    ve la como se calcula pois é interessante isso....

  8. ha muito tempo atras achei na web o codigo abaixo (speed.c)... eh um progaminha em C que faz um despejo de pacotes para se medir links...nem sei quem escreveu... (se o autor ver o codigo abaixo, posta ae):

    speed.c
    Código :
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>  
    #include <sys/signal.h>
    #include <stdio.h>
    #include <netdb.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <string.h>
     
    #include "sockbib.h"
     
    #define ROUND           5
    #define SERVICE         "chargen"
    #define MAXTMPLEN       10240   /* max length of tmp array declared below */
     
    #define VERSION "\nSpeed - TCP/UDP Version 1.0.6 - by Ethy Brito 1999/09/14\n"
     
    //char *wheel="/-\\|";
    char *wheel=" .o0O0o.";
    long charread, arr[ROUND];
    int cti;
     
    void catcher()
    {        
            int j;
     
            arr[cti++%ROUND]=charread;
    //      for(charread=0,j=ROUND; j--;)
    //              charread+= arr[j];
    //      charread/=ROUND;
            printf("%c %ld.%ld %cbyte(s)/s (%ld Kbits/s)       \n\e[A",
                    wheel[cti%strlen(wheel)],
                    (charread<1024?charread:charread/1024),
                    (charread<1024?0:(10*charread)/1024-10*(charread/1024)),
                    charread<1024?' ':'K',
                    8*charread/1024);
            charread=0;
            (void)signal(SIGALRM, catcher);
            (void)alarm((u_int)1);
    }
                                                                                                                                                                                                         $
     
    void main(argc, argv)
    char *argv[];
    {
            CNCSOCK * skt;
            char *cmdname,
                    tmp[MAXTMPLEN],
                    proto[8];
            long i;   
            int udp=0;
     
            printf("%s\n", VERSION);
            /* save the command name (usually called "speed") */
            cmdname = argv[0];
            /* punt if syntax is wrong */
            if (argc == 1) {
                    fprintf(stderr, "usage: %s [-u] hostname|hostaddress\n", cmdname);
                    exit(1);
            }
     
            if (!strcmp(argv[1], "-u"))
            {
               strcpy(proto, "udp");
               argv++;
               udp=1;
            }
            else
               strcpy(proto, "tcp");
            printf("%s measuring...\n", proto);
            if((skt=InicSocket(argv[1], SERVICE, proto))==NULL)
            {
               fprintf(stderr, "Error opening socket!\n");
               exit(1);
            }
            putc('\n',stdout);
            memset(arr, 0, sizeof(arr));
            catcher();
            if(udp)
            {
    //           fcntl(skt->sock, F_SETFL, O_NONBLOCK);
               send ( skt->sock, "", 0, 0 ); //wake up server!  
            }
            for(; ; )
            {
               if((i=recv(skt->sock, tmp, MAXTMPLEN, 0))>0)
                  charread+=i+(udp*33);
               if(udp)
                  send ( skt->sock, "", 0, 0 );
    //           printf("\n<<<< %ld - %ld>>>>%.40s", charread, i,tmp);
            }
            return;
    }
     
     
    =============Aqui a sockbib.c==================
    sockbib.c
     
    static char rcs_id[]="$Id: sockbib.c,v 1.4 1997/09/09 13:45:24 penna Exp $";
     
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <signal.h>
    #include <sys/types.h>
     
    #include "sockbib.h"
     
     
     
    /************
     
    As funcoes de interface com o mundo externo sao:
     
    InicSocket()  - usada pelos clientes para abrir comunicacao com o server
    FimSocket()  - usada pelos clientes para fechar comunicacao com o server
    MsgToServer()  - usada pelos clientes para mandar mensagem para o server
    MsgFromServer()  - usada pelos clientes para receber mensagem do server
     
    MsgFromClient()  -  usada pelos servidores, apos seu start pelo inetd
    MsgToClient()  -  usada pelos servidores para responder para o cliente
     
    ************/
     
    /******
     
    nomehost=nome do host servidor
    nomeserv=nome do servico no /etc/services (ftp, tacacs, finger, ...)
    tipo=tcp, udp, icmp, ...
     
    ******/
     
    CNCSOCK *InicSocket(nomehost, nomeserv, tipo)
     
    char *nomehost, *nomeserv, *tipo;
     
    {
     
    struct servent *servicep;       /* ponteiro de informacoes do servico */
    struct hostent *hostp;          /* ponteiro de informacoes do hospedeiro */
    CNCSOCK *aux;
     
    	aux = (CNCSOCK *)malloc(sizeof(CNCSOCK));
    	if ( aux == (CNCSOCK *)NULL )
    		return (CNCSOCK *)NULL;
    	memset(aux, 0x00, sizeof(CNCSOCK));
     
    	/* Obtem o IP do servidor */
    	hostp = gethostbyname(nomehost);
    	if ( hostp == (struct hostent *)NULL ) {
    		free(aux);
    		return (CNCSOCK *)NULL;
    	}
     
    	/* Atribui o tipo de endereco do hospedeiro */
    	aux->serveraddr_in.sin_family = AF_INET;
    	if ( strcmp(tipo, "udp") == 0 )
    		aux->sock_type = SOCK_DGRAM;
    	else
    		aux->sock_type = SOCK_STREAM;
     
    	/* Atribui o endereco do hospedeiro */
    	aux->serveraddr_in.sin_addr.s_addr = ((struct in_addr *) (hostp->h_addr))->s_addr;
     
    	/* Obtem os dados relativos ao servico prestado pelo servidor */
    	servicep = getservbyname(nomeserv, tipo);
    	if ( servicep == (struct servent *)NULL ) {
    		free(aux);
    		return (CNCSOCK *)NULL;
    	}
     
    	/* Atribui a porta onde o servico esta sendo prestado */
    	aux->serveraddr_in.sin_port = (ushort) servicep->s_port;
    	if ( AbreSocket(aux) < 0 ) {
    		free(aux);
    		return (CNCSOCK *)NULL;
    	}
    	return aux;
     
    }  /* end InicSocket() */
     
    /*************************************************************************/
     
    int AbreSocket(cs)
     
    CNCSOCK *cs;
     
    {
     
    int addrlen;
    struct sockaddr_in myaddr_in;
     
    	/* Cria um socket para TCP */
    	cs->sock = socket ( AF_INET, cs->sock_type, 0 );
    	if ( cs->sock < 0 )
    		return -1;
     
     	/* Estabelece conexao com o servidor para enviar transacoes */
     	if ( connect ( cs->sock, &cs->serveraddr_in, sizeof( struct sockaddr_in ) ) == -1 ) {
    		close(cs->sock);
    		return -1;
     	}
    	addrlen = sizeof( struct sockaddr_in );
    	getsockname( cs->sock, &myaddr_in, &addrlen );
     
    	return cs->sock;
     
    }  /* end AbreSocket() */
     
    /*************************************************************************/
     
    int MsgToServer (cs, buffer, tam)
     
    CNCSOCK *cs;
    char *buffer;
    int tam;
     
    {
     
    int tot_env;
     
    	if ( cs == (CNCSOCK *)NULL || buffer == (char *)NULL || tam <= 0 )
    		return -1;
     
    	tot_env = send ( cs->sock, buffer, tam, 0 );
    	if ( tot_env < 0 )
    		return -1;
     
    	return tot_env;
     
    }  /* end MsgToServer() */
     
    /**************************************************************************/
     
    int MsgFromServer (cs, buffer, tam, timeout)
     
    CNCSOCK *cs;
    char *buffer;
    int tam;
    int timeout;
     
    {
     
    int lidos, tam_max=tam;
     
    	lidos = LeDoServer ( cs, buffer, tam_max, timeout );
    	if ( lidos < 0 )
    		return -1;
    	return lidos;
     
    }  /* end MsgFromServer() */
     
    /**************************************************************************/
     
    int LeDoServer( cs, buffer, tam, timeout )
     
    CNCSOCK *cs;
    char *buffer;
    int tam, timeout;
     
    {
     
    int recebidos = 0;
    int restantes = tam;
    void ( * func_old ) ();
     
    	func_old = signal (SIGALRM, AlarmSock);
     
    	alarm(timeout);
    	recebidos = recv( cs->sock, buffer, restantes, 0 );
    	alarm(0);
     
    	signal(SIGALRM, func_old);
    	return recebidos;
     
    }  /* end LeDoServer() */
     
    /***************************************************************************/
     
    int FimSocket(cs)
     
    CNCSOCK *cs;
     
    {
     
    	if ( cs == (CNCSOCK *)NULL )
    		return 0;
    	close(cs->sock);
    	free(cs);
    	cs = (CNCSOCK *)NULL;
    	return 0;
     
    }  /* end FimSocket() */
     
    /****************************************************************************/
     
    void AlarmSock()
     
    {
     
    	return;
     
    }  /* end AlarmSock() */
     
    /***************************************************************************/
     
    int MsgFromClient (buffer, tam, timeout)
     
    char *buffer;
    int tam;
    int timeout;
     
    {
     
    int lidos, tam_max=tam;
     
    	lidos = LeDoCliente ( buffer, tam_max, timeout );
    	return lidos;
     
    } /* fim MsgFromClient */
     
    /***************************************************************************/
     
    int LeDoCliente( buffer, tam, timeout )
     
    char *buffer;
    int tam, timeout;
     
    {
     
    int recebidos = 0;
    int restantes = tam;
    int total = 0;
    void ( * func_old ) ();
     
    	func_old = signal (SIGALRM, AlarmSock);
    	while ( restantes > 0 ) {
    		alarm(timeout);
    		recebidos = read( E_PADRAO, buffer, restantes );
    		alarm(0);
    		if ( recebidos < 0 )
    			break;  /* sair do while() */
    		if ( recebidos == 0 )
    			break;   /* sair do while() */
    		total += recebidos;
    		restantes -= recebidos;
    		buffer += recebidos;
    	}
    	signal(SIGALRM, func_old);
    	return total;
     
    }  /* end LeDoCliente() */
     
    /**************************************************************************/
     
    int MsgToClient (buffer, tam)
     
    char *buffer;
    int tam;
     
    {
     
    int tot_env;
     
    	tot_env = write ( S_PADRAO, buffer, tam );
    	if ( tot_env < 0 )
    		return -1;
     
    	return tot_env;
     
    } /* fim MsgToClient() */






Tópicos Similares

  1. Respostas: 10
    Último Post: 14-11-2014, 10:40
  2. Como fazer um ptp com ap gts e ap2000
    Por river2 no fórum Redes
    Respostas: 2
    Último Post: 30-08-2008, 21:07
  3. Ptp Com Bridge Dos 2 Lados Como
    Por eniak no fórum Redes
    Respostas: 1
    Último Post: 05-10-2007, 21:55
  4. Como fazer PTP com dois mikrotik em 5.8
    Por wireless&cia no fórum Redes
    Respostas: 1
    Último Post: 06-09-2007, 18:13
  5. PTP com AP 4000 Proxim em 802.11A Ping Alto
    Por patrickcanton no fórum Redes
    Respostas: 4
    Último Post: 09-03-2005, 00:38

Visite: BR-Linux ·  VivaOLinux ·  Dicas-L