elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


Tema destacado: AIO elhacker.NET 2021 Compilación herramientas análisis y desinfección malware


  Mostrar Mensajes
Páginas: 1 ... 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 [47] 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 ... 235
461  Programación / Programación C/C++ / Primero en Entrar, primero en salir FIFO, Cola o Fila en: 30 Noviembre 2018, 18:38 pm
No es lo mas eficiente, hay muchas cosas se podrian mejorar, en especifico la forma en la que se organizan  el arreglo de elementos actuales en la Fila,  sin embargo funciono para el proposito.

Yo se que la mayoría de estas estructuras ya están implementadas. Pero no se puede decir que eres programador si no sabes implementarlas por tu cuenta.



Código
  1. /*
  2.  El tipo de dato se puede cambiar dependiendo de la implementación que se le quiera dar, también se tendrían que cambiar los tipos de datos devueltos por las funciones
  3.  En este caso yo quería un arreglo de apuntadores char* por lo cual el contenedor es char**
  4.  */
  5.  
  6.  
  7. typedef struct str_queue	{
  8. 	char **queue;
  9. 	int len;
  10. 	int max;
  11. }Queue;	
  12.  
  13. Queue *create_queue()	{
  14. 	Queue *r = malloc(sizeof(struct str_queue));
  15. 	r->len = 0;
  16. 	r->max = 2;
  17. 	r->queue = malloc(sizeof(char*)*r->max);
  18. 	return r;
  19. }
  20.  
  21. void free_queue(Queue *q)	{
  22. 	if(q)	{
  23. 		if(q->queue)
  24. 			free(q->queue);
  25. 		free(q);
  26. 	}
  27. }
  28.  
  29. void en_queue(Queue *q, char *ptr)	{
  30. 	if((q->len+1) == q->max)	{
  31. 		q->max *= 2;
  32. 		q->queue = realloc(q->queue,q->max*sizeof(char*));	
  33. 	}
  34. 	if(q->queue != NULL)	{
  35. 		q->queue[q->len] = ptr;
  36. 		q->len++;
  37. 	}
  38. }
  39.  
  40. char * de_queue(Queue *q)	{
  41. 	char *r = NULL;
  42. 	int i = 0;
  43. 	if(q->len >= 1)	{
  44. 		r = q->queue[0];
  45. 		q->len--;
  46. 		while(i < q->len)	{
  47. 			q->queue[i] = q->queue[i+1];
  48. 			i++;
  49. 		}
  50. 		q->queue[i] = NULL;
  51. 	}
  52. 	return r;
  53. }

Yo en su momento lo utilize para un post, donde realizaba una versión iterativa y necesitaba almacenar en una Cola el listado de los directorios que aun faltaba por recorrer:

problema de memoria con readdir (Solucionado)

Ejemplo de uso:

Código
  1. int main()	{
  2. 	char *cadenas[10] = { "Cadena_0","Cadena_1","Cadena_2","Cadena_3","Cadena_4","Cadena_5","Cadena_6","Cadena_7","Cadena_8","Cadena_9"};
  3. 	char *actual;
  4. 	int index1,index2,i =0;
  5. 	srand(time(NULL));
  6. 	Queue *q = create_queue();
  7. 	while(i < 10)	{
  8. 		index1 = rand() % 10;
  9. 		index2 = rand() % 10;
  10. 		printf("Agregando a la fila: %s\n",cadenas[index1]);
  11. 		en_queue(q,cadenas[index1]);
  12. 		printf("Agregando a la fila: %s\n",cadenas[index2]);
  13. 		en_queue(q,cadenas[index2]);
  14. 		printf("Saliendo de la fila %s\n",de_queue(q));
  15. 		i++;
  16. 	}
  17. 	free_queue(q);
  18. }
  19.  

Como es randon la salida es variada, pero podemos observar el funcionamiento:



Código:
Agregando a la fila: Cadena_5
Agregando a la fila: Cadena_5
Saliendo de la fila Cadena_5
Agregando a la fila: Cadena_8
Agregando a la fila: Cadena_2
Saliendo de la fila Cadena_5
Agregando a la fila: Cadena_5
Agregando a la fila: Cadena_7
Saliendo de la fila Cadena_8
Agregando a la fila: Cadena_8
Agregando a la fila: Cadena_7
Saliendo de la fila Cadena_2
Agregando a la fila: Cadena_9
Agregando a la fila: Cadena_2
Saliendo de la fila Cadena_5
Agregando a la fila: Cadena_1
Agregando a la fila: Cadena_3
Saliendo de la fila Cadena_7
Agregando a la fila: Cadena_8
Agregando a la fila: Cadena_5
Saliendo de la fila Cadena_8
Agregando a la fila: Cadena_0
Agregando a la fila: Cadena_3
Saliendo de la fila Cadena_7
Agregando a la fila: Cadena_4
Agregando a la fila: Cadena_0
Saliendo de la fila Cadena_9
Agregando a la fila: Cadena_7
Agregando a la fila: Cadena_1
Saliendo de la fila Cadena_2


Funcion actualizada de de_queue

Código
  1. char * de_queue(Queue *q)	{
  2. 	char *r = NULL;
  3. 	int i = 0;
  4. 	if(q->len >= 1)	{
  5. 		r = q->queue[0];
  6. 		q->len--;
  7. 		while(i < q->len)	{
  8. 			q->queue[i] = q->queue[i+1];
  9. 			i++;
  10. 		}
  11. 		q->queue[i] = NULL;
  12. 	}
  13. 	return r;
  14. }
  15.  
462  Programación / Programación C/C++ / Re: problema de memoria con readdir (Solucionado) en: 30 Noviembre 2018, 04:57 am
Cita de: CalgaryCorpus en 29 Noviembre 2018, 21:35 pm
Segun la documentacion, readdir usa memoria estatica, de modo que no corresponde usar free() sobre lo que se retorna.

Excelente, segun veo usa parte de la misma estrucutra original del directorio pasado como parametro. o algo asi alcance a ver.

Cita de: CalgaryCorpus en 29 Noviembre 2018, 22:10 pm
Sugiero reemplazar esto de pedir y liberar memoria en cada vuelta del while por solo pedir memoria cuando es necesario pedirla, y no liberarla en cada vuelta, solo liberarla al final del while.

Voy aplicarlo gracias!, ya que si termina siendo mas eficiente, por que evitaria tantas llamadas a malloc como sea posible.

Creo que ya encontre la solucion, según veo no es problema de memoria por liberar, es problema de la implementación recursiva de la función.

La solución recursiva es la que menos memoria utiliza.

Saludos!
463  Programación / Programación C/C++ / Re: Avanzar en programación de c++ de manera escalonada en: 29 Noviembre 2018, 19:00 pm
Pues segun mi recomendación personal podria ser lo siguiente:

Decisiones Basicias:

if, else, switch

Ciclos repetitivos

while, do-while, for ¿Saber cuando es mejor uno u otro?

Casos Itetivos, casos recursivos ¿Saber cuando es mejor uno u otro?

Memoria dinámica en caso de C++ new/delete, aunque un poco de background seria conveniente malloc/realloc/free

Archivos lectura, escritura, actualización, diferencia entre archivos binarios y de texto, Aunque esto ultimo confunde a mucha gente, es lo mismo, solo tienes que estar conciente de como vasa manejar los datos.

Ordenamiento de datos
Liststas Ligagamas, Doblemente Ligadas, Circulares

Estrucuturas de datos
Aparte de las anteriores, Pilas Arboles Binarios, Arboles, Grafos (El santo grial de la programación)

Ya terminado lo anterior, tal vez funciones de red

Trabajando con Sockets, para adentrarte en  el mundo de los protocolos de Red, como "hablar" http, ftp etc...
(Aqui seria muy didactivo programar un WEB spider)

Un poco de criptografia tal vez.

Y pues en general el cielo es el limite.

Tengo 15 años programando en C y C++ y aun estoy aprendiendo cosas nuevas.

Saludos
464  Programación / Programación C/C++ / problema de memoria con readdir (Solucionado) en: 29 Noviembre 2018, 18:47 pm
Muy buen dia.

Problema: La memoria utilizada por el programa aumenta y no disminuye

Solución: No es un problema, es la memoria que se genera por el paradigma de la recursividad, esto es: que al llamar a la misma función de forma recursiva, el Stack Frame de la memoria que utiliza cada una de las llamadas a la función se acumule.

Intente aplicar una solucion de forma Iterativa, guardando el Path de los directorios que faltan por leer en una Queue, pero utiliza mas memoria  que la solucion recursiva.

readdir devuelve un apuntador de la estructura (struct dirent)
Mas info: https://linux.die.net/man/3/readdir

El cual creo que es el causante de este POST.

Versión Corta

¿Quien controla el Apuntador entregado por readdir?

Es memoria estatica y no se debe de liberar

Código
  1. directorio_archivo_temporal = readdir(directorio)

Al momento de tratar de liberar dicho apuntador, el programa se cuelga...

Código
  1. while(directorio_archivo_temporal = readdir(directorio) )	{
  2. 	//etc..
  3. 	free(directorio_archivo_temporal);
  4. }
  5.  

El problema radica en que la memoria del programa solo aumenta y no disminuye.

Codigo de la version corta funcionando
Código
  1. #include<sys/stat.h>
  2. #include<sys/types.h>
  3. #include<dirent.h>
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. #include<string.h>
  7.  
  8. int is_regular_file(const char *path);
  9.  
  10. int procesar_directorio(char *path);
  11.  
  12. int main(int argc,char **argv)	{
  13. 	switch(argc){
  14. 		case 2:	//Se espera directorio
  15. 			procesar_directorio(argv[1]);
  16. 		break;
  17. 		default:
  18. 			printf("Numero de argumentos no esperado\n");
  19. 		break;
  20. 	}
  22.  
  23. }
  24.  
  25. int is_regular_file(const char *path)	{
  26. 	struct stat path_stat;
  27. 	stat(path, &path_stat);
  28. 	return S_ISREG(path_stat.st_mode);
  29. }
  30.  
  31. int procesar_directorio(char *path)	{
  32. 	DIR *directorio;
  33. 	struct dirent *directorio_archivo_temporal;
  34. 	char *path_copy;
  35. 	int len_path;
  36. 	char *path_temporal;
  37. 	int len_path_temporal;
  38. 	directorio = opendir(path);
  39. 	if(directorio != NULL)	{	
  40. 		len_path = strlen(path);
  41. 		path_copy = malloc(len_path+2);
  42. 		memcpy(path_copy,path,len_path);
  43. 		if(path_copy[len_path - 1] == '\\' ){
  44. 			path_copy[len_path] = '\0';
  45. 		}
  46. 		else	{
  47. 			path_copy[len_path] = '\\';
  48. 			path_copy[len_path+1] = '\0';
  49. 			len_path++;
  50. 		}
  51. 		while(directorio_archivo_temporal = readdir(directorio) )	{		
  52. 			len_path_temporal = strlen(directorio_archivo_temporal->d_name);
  53. 			path_temporal = malloc(len_path+len_path_temporal+1);
  54. 			path_temporal[len_path+len_path_temporal] = '\0';
  55. 			sprintf(path_temporal,"%s%s",path_copy,directorio_archivo_temporal->d_name);
  56. 			if(is_regular_file(path_temporal))	{
  57. 				printf("%s\n",path_temporal);
  58. 			}
  59. 			else	{	//Directorio?
  60. 				if( len_path_temporal > 2 ) { //not .. or .
  61. 					procesar_directorio(path_temporal);	//recursivamente
  62. 				}			
  63. 			}
  64. 			free(path_temporal);
  65. 		}
  66. 		free(path_copy);
  67. 		closedir(directorio);
  68. 	}
  69. }
  70.  







Versión extensa

Aquí esta toda la Letanía

Estoy realizando un programa que lea de forma Recursiva un directorio dado y liste los archivos en pantalla. Nada del otro mundo. Asi mismo estoy haciendo que el formato de salida sea el formato tipo UNIX /bla/bla/bla en lugar del formato de windows C:\lalala\lalalala.txt

Esto con el objetivo de virtualizar el path de subdirectorios específicos para otro programa pero eso ya es harina de otro costal.

El problema es que cuando listo Cualquier carpeta con muchos subdirectorios como la unidad C:\  el programa en empieza usando lo clasico unos 400 KB y termina utilizando 800 KB o mas dependiendo de la carpeta que este listada.

El dia Ayer publique un post parecido:
Problema de memoria en miniservidor usando Winsock (Solucionado)

En el cual se estaba cerrando el socket de forma incorrecta.

En este caso creo que es problema del apuntador devuelto por readdir.

Código del programa funcionando:

Código
  1. #include<sys/stat.h>
  2. #include<sys/types.h>
  3. #include<dirent.h>
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. #include<string.h>
  7.  
  8. int fsize(const char *filename);
  9. int is_regular_file(const char *path);
  10.  
  11. int procesar_directorio(char *path,char *virtual_path);
  12.  
  13. int main(int argc,char **argv)	{
  14. 	switch(argc){
  15. 		case 2:	//Se espera directorio
  16. 			procesar_directorio(argv[1],"/");
  17. 		break;
  18. 		case 3:	//Se espera archivo + nombre de directorio de destino.
  19. 		break;
  20. 		default:
  21. 			printf("Numero de argumentos no esperado\n");
  22. 		break;
  23. 	}
  25.  
  26. }
  27.  
  28. int is_regular_file(const char *path)	{
  29. 	struct stat path_stat;
  30. 	stat(path, &path_stat);
  31. 	return S_ISREG(path_stat.st_mode);
  32. }
  33.  
  34. int fsize(const char *filename) {
  35.     struct stat st;
  36.     if (stat(filename, &st) == 0)
  37.         return st.st_size;
  38.     return -1; 
  39. }
  40.  
  41. int procesar_directorio(char *path,char *virtual_path)	{
  42. 	DIR *directorio;
  43. 	struct dirent *directorio_archivo_temporal,*result;
  44.  
  45. 	char *path_copy;
  46. 	char *virtual_path_copy;
  47. 	int len_path,len_virtual_path;
  48.  
  49. 	char *path_temporal;
  50. 	char *virtual_path_temporal;
  51. 	int len_path_temporal;
  52. 	int len_virtual_path_temporal;
  53.  
  54.  
  55. 	directorio = opendir(path);
  56. 	if(directorio != NULL)	{	
  57.  
  58. 		len_path = strlen(path);
  59. 		len_virtual_path = strlen(virtual_path);
  60.  
  61. 		virtual_path_copy = malloc(len_virtual_path+2);
  62. 		path_copy = malloc(len_path+2);
  63. 		memcpy(path_copy,path,len_path);
  64. 		memcpy(virtual_path_copy,virtual_path,len_virtual_path);
  65.  
  66. 		if(path_copy[len_path - 1] == '\\' ){
  67. 			path_copy[len_path] = '\0';
  68. 		}
  69. 		else	{
  70. 			path_copy[len_path] = '\\';
  71. 			path_copy[len_path+1] = '\0';
  72. 			len_path++;
  73. 		}
  74. 		if(virtual_path_copy[len_virtual_path - 1] == '/' ){
  75. 			virtual_path_copy[len_virtual_path] = '\0';
  76. 		}
  77. 		else	{
  78. 			virtual_path_copy[len_virtual_path] = '/';
  79. 			virtual_path_copy[len_virtual_path+1] = '\0';
  80. 			len_virtual_path++;
  81. 		}
  82. 		/*
  83. 		directorio_archivo_temporal = calloc(1,sizeof(struct dirent));
  84. 		result == NULL;
  85. 		*/
  86. 		//while(readdir_r(directorio,directorio_archivo_temporal,&result) == 0 && result != NULL){
  87. 		while(directorio_archivo_temporal = readdir(directorio) )	{
  88.  
  89. 			len_path_temporal = strlen(directorio_archivo_temporal->d_name);
  90. 			//printf("readdir point to %p\n",directorio_archivo_temporal);
  91. 			//printf("Len %i : %s\n",len_path_temporal,directorio_archivo_temporal->d_name);
  92.  
  93. 			path_temporal = malloc(len_path+len_path_temporal+1);
  94. 			virtual_path_temporal = malloc(len_virtual_path + len_path_temporal+1);
  95.  
  96. 			path_temporal[len_path+len_path_temporal] = '\0';
  97. 			virtual_path_temporal[len_virtual_path+len_path_temporal] = '\0';
  98.  
  99. 			sprintf(path_temporal,"%s%s",path_copy,directorio_archivo_temporal->d_name);
  100. 			sprintf(virtual_path_temporal,"%s%s",virtual_path_copy,directorio_archivo_temporal->d_name);
  101.  
  102. 			if(is_regular_file(path_temporal))	{
  103. 				//printf("Archivo :\"%s\"\n",path_temporal);
  104. 				printf("%s\n",virtual_path_temporal);
  105. 			}
  106. 			else	{	//Directorio?
  107. 				if( len_path_temporal > 2 ) { //not .. or .
  108. 					procesar_directorio(path_temporal,virtual_path_temporal);	//recursivamente
  109. 				}			
  110. 			}
  111. 			free(path_temporal);
  112. 			free(virtual_path_temporal);
  113. 		}
  114. 		//free(directorio_archivo_temporal);
  115.  
  116.  
  117.  
  118. 		free(path_copy);
  119. 		free(virtual_path_copy);
  120. 		closedir(directorio);
  121. 	}
  122. 	else	{
  123. 		printf("El directorio \"%s\" no es un directorio valido\n",path);
  124. 	}
  125. }
  126.  

Funciona bien, recibe parametros de entrada, ejemplo

Ejemplo

Código:
C:\>generar_contenido.exe contenido
/index.html

Le agregue un getchar al final del archivo para poder ver con cuanta memoria termina el programa. Para carpetas sin tanto subdirecorio no hay problema, el detalle es cuando se trata de todo un disco...

Imagen:


Ya he validado que todos los apuntadores que yo genero de forma dinámica son liberados en su totalidad, esto mediante re implementaciones de malloc,calloc,realloc y free como describo en el siguiente post: ¿He liberado todos los apuntadores?

Imagen:


Con lo cual considero que el problema es el apuntador devuelto por readdir.

Intente cambiar el siguiente pedazo de codigo

Código
  1. while(directorio_archivo_temporal = readdir(directorio) )	{
  2. 	//etc...
  3. }
  4.  

por

Código
  1. while(directorio_archivo_temporal = readdir(directorio) )	{
  2. 	//etc..
  3. 	free(directorio_archivo_temporal);
  4. }
  5.  

Pero el programa se queda colgado por un rato y finaliza, seguramente por tratar de escribir en memoria que no esta asignada...

Intente implementarlo con readdir_r utilizando mi propio apuntador previamente asignado..

Código
  1. while(readdir_r(directorio,directorio_archivo_temporal,&result) == 0 && result != NULL){
  2.  

Pero por alguna razon MinGW no lo tiene implementado, y segun he visto ya esta deprecated, entonces ¿Cual puede ser la solución?

Saludos!


Pordon por el Post tan largo, aqui esta su patata
465  Seguridad Informática / Hacking Wireless / Re: Necesito saber si mi tarjeta de red soporta modo monitor no sé como en: 29 Noviembre 2018, 05:52 am
Si ya tienes linux instalado con la suite de aircrack puedes checar este tutorial

https://www.aircrack-ng.org/doku.php?id=compatibility_drivers

Código:
You can use the iw command to get a full list of all capabilities of a physical wireless card:

Linux command

Código:
 iw list
466  Programación / Programación C/C++ / Re: duda con otro función en c en: 29 Noviembre 2018, 04:34 am
Por si tienes dudas

te explico para que no exista confusión.


Código:
void imprimir_ite(char *pcad)

Se declara que la variable que recibe imprimir_ite es Apuntador char *pcad
Código:
    if(*pcad!='\0')
 

*pcad nos indica o devuelve el VALOR apuntado por pcad en ese momento para realizar la comparacion
Código:
        printf("%c",*pcad);
Lo mismo que lo anterior, nos devuelve el valor apuntado por pcad, esto podria ser equivalente a

Código:
 printf("%c",pcad[0]);

Código:
    if(pcad[0]!='\0');


Código:
        pcad++;
Incrementamos el valor de apuntador en 1


Código:
        imprimir_ite(pcad);

Pasamos como argumento el apuntador pcad, sin * por que con * es el valor apuntado en ese momento. y sin * es el apuntador como tal,

Saludos
467  Programación / Programación C/C++ / Re: duda con otro función en c en: 29 Noviembre 2018, 03:24 am
Hola antes que nada en el panel cuando redactas un mensaje hay un box que dice Código GeSHi, si lo despliegas aparece una lista de lenguajes buscas C y pegas tu código adentro.

El problema es siguiente:

TU CODIGO

Código
  1. void imprimir_ite(char *pcad)
  2. {
  3.     if(*pcad!='\0')
  4.     {
  5.         printf("%c",*pcad);
  6.         pcad++;
  7.         imprimir_ite(*pcad);
  8.  
  9.     }
  10.     return;
  11. }
  12.  

En TEORIA Corregido:

Código
  1. void imprimir_ite(char *pcad)
  2. {
  3.     if(*pcad!='\0')
  4.     {
  5.         printf("%c",*pcad);
  6.         pcad++;
  7.         imprimir_ite(pcad);
  8.  
  9.     }
  10.     return;
  11. }
  12.  

No se, ni verifique tu codigo "ITERATIVO", pero como pcad ya es un apuntador, no necesitas colocarle el * antes de cada uso, eso se puede prestar para otras operaciones pero en este caso no.

Saludos
468  Programación / Programación C/C++ / Re: Resolver C++ en: 29 Noviembre 2018, 01:05 am
Cita de: Beginner Web en 29 Noviembre 2018, 00:57 am
La verdad que es medio raro eso, se la respuesta pero no se como es que el signo ?

Es el Operador Ternario, es basicamente un mini if

Código
  1. char C = 'A';
  2. printf("%s\n",(C == 'A')? "Verdadero": "Falso");
  3.  

Se utiliza para realizar ciertas evaluaciones rapidamente.

De manera que te devuelve el primer valor el que esta antes del ":" si la evaluacion fue verdadera, encaso contrareo te devuelve lo que esta despues del ":"

Otro ejemplo seria:

Código
  1. char C = 'A',otro;
  2. otro = (C == 'A') ? 'q' : 'r' ;
  3.  


Saludos
469  Programación / Programación C/C++ / Re: Problema de memoria en miniservidor usando Winsock en: 29 Noviembre 2018, 00:42 am
Excelente con eso ya funciona muy bien  ;-)

Esos de Microsoft ni siquiera dejan utilizar el Descriptor proporcionado por accept como un File Descriptor normal para usarlo con fdopen y/o read y write. En fin es windows  :rolleyes:

Salduos!
470  Programación / Programación C/C++ / Problema de memoria en miniservidor usando Winsock (Solucionado) en: 28 Noviembre 2018, 23:13 pm
Estoy haciendo pruebas con un miniservidor, que actualmente solo lee la entrada y la muestra en pantalla.



El detalle esta en que La memoria utilizada no deja de incrementar, empieza el programa usando sobre 400 KB y mientras mas preciono F5 en el navegardor WEB, (El miniservidor es WEB), enviando Multiples GET al servidor la memoria del programa incrementa y nunca decrementa, siendo que en cada ocasion he liberado el apuntador utilizado para leer la linea, y he cerrado el socket del cliente:

Codigo:

Código
  1. #include<winsock2.h>
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include <unistd.h>
  5.  
  6. #define BACKLOG 256
  7.  
  8. WSADATA *wsaData;
  9. struct sockaddr_in *server_sa;
  10.  
  11. char *readLine(SOCKET descriptor,int *len);
  12.  
  13. int main()	{
  14. 	SOCKET s,c;
  15. 	int b = 0,iResult;
  16. 	int read_len;
  17. 	char *linea;
  18. 	char caracter;
  19. 	wsaData = calloc(1,sizeof(WSADATA));
  20. 	iResult = WSAStartup(MAKEWORD(2,2), wsaData);
  21. 	if (iResult != 0) {
  22. 		printf("WSAStartup failed: %d\n", iResult);
  23. 		return 1;
  24. 	}
  25. 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
  26. 		perror("socket");
  27. 		return 2;
  28. 	}
  29. 	server_sa = calloc(1,sizeof(struct sockaddr_in));
  30. 	server_sa->sin_family = AF_INET;
  31. 	server_sa->sin_port   = htons(80);
  32. 	server_sa->sin_addr.s_addr = htonl(INADDR_ANY);	
  33.  
  34. 	if (bind(s,(struct sockaddr *) server_sa, sizeof(struct sockaddr)) < 0) {
  35. 		perror("bind");
  36. 		return 3;
  37. 	}
  38. 	b = sizeof(struct sockaddr);
  39. 	listen(s, BACKLOG);
  40. 	while(1)	{
  41. 		if((c = accept(s,(struct sockaddr *)server_sa, &b)) < 0) {
  42. 			printf("WS error code: %i\n",WSAGetLastError());
  43. 			perror("accept");
  44. 			return 4;
  45. 		}
  46. 		do{
  47. 			linea = readLine(c,&read_len);
  48. 			printf("%s\n",linea);
  49. 			free(linea);
  50. 		}while(read_len != 0);
  51. 		close(c);
  52. 	}
  53. }
  54.  
  55. char *readLine(SOCKET descriptor,int *len)	{
  56. 	char *buffer = NULL;
  57. 	int i = 0,entrar = 1,len_read;
  58. 	do	{
  59. 		buffer = realloc(buffer,(i+1));
  60. 		len_read = recv(descriptor,buffer + i,1,0);
  61. 		if(len_read == 1){
  62. 			switch(buffer[i])	{
  63. 				case 0xD:
  64. 					buffer[i] = '\0';
  65. 				break;
  66. 				case 0xA:
  67. 					buffer[i] = '\0';
  68. 					entrar = 0;
  69. 				break;
  70. 				default:
  71. 					i++;
  72. 				break;
  73. 			}
  74. 		}
  75. 		else	{
  76. 			buffer[i] = '\0';
  77. 			entrar = 0;
  78. 		}
  79. 	}while(entrar);
  80. 	if(len  != NULL){
  81. 		len[0] = i;
  82. 	}
  83. 	return buffer;
  84. }
  85.  

El problema es que se espera que el servidor se lo mas liguero ligero posible y atienda millones de peticiones por segundo. Y no creo que el F5 del navegador supere mas de 100 peticiones por segundo.

Saludos
Páginas: 1 ... 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 [47] 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 ... 235
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines