Como testar comunicação PTP com ping?

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

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

Como testar comunicação PTP com ping?

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:

Re: Como testar comunicação PTP com ping?

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.

Como testar comunicação PTP com ping?

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)

Teste de velocidade

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

Re: Teste de velocidade

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....

Como testar comunicação PTP com ping?

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() */