• Sábado 9 de Noviembre de 2024, 03:35

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - faio

Páginas: [1]
1
JavaScript / Re: cookie con javascript
« en: Domingo 13 de Junio de 2010, 15:54 »
He investigado por hay este script saca las cookies que tengamos.
pero me quedo mas tranquilo al leer en una pagina esto

Ningún navegador otorgará cookies de un dominio diferente al script de otro dominio...

osea que este script solo podría sacar la cookie de su mismo dominio ejemplo

mipagina.com en esta pagina esta el script solo sacaría los script de mipagina.com

2
JavaScript / cookie con javascript
« en: Sábado 12 de Junio de 2010, 23:41 »
Código: Text
  1. var caution = false
  2.  
  3. function setCookie(name, value, expires, path, domain, secure) {
  4. var curCookie = name + "=" + escape(value) +
  5. ((expires) ? "; expires=" + expires.toGMTString() : "") +
  6. ((path) ? "; path=" + path : "") +
  7. ((domain) ? "; domain=" + domain : "") +
  8. ((secure) ? "; secure" : "")
  9. if (!caution || (name + "=" + escape(value)).length <= 4000)
  10. document.cookie = curCookie
  11. else
  12. if (confirm("Cookie exceeds 4KB and will be cut!"))
  13. document.cookie = curCookie
  14. }
  15.  
  16. function getCookie(name) {
  17. var prefix = name + "="
  18. var cookieStartIndex = document.cookie.indexOf(prefix)
  19. if (cookieStartIndex == -1)
  20. return null
  21. var cookieEndIndex = document.cookie.indexOf(";", cookieStartIndex + prefix.length)
  22. if (cookieEndIndex == -1)
  23. cookieEndIndex = document.cookie.length
  24. return unescape(document.cookie.substring(cookieStartIndex + prefix.length, cookieEndIndex))
  25. }
  26.  
  27. function deleteCookie(name, path, domain) {
  28. if (getCookie(name)) {
  29. document.cookie = name + "=" +
  30. ((path) ? "; path=" + path : "") +
  31. ((domain) ? "; domain=" + domain : "") +
  32. "; expires=Thu, 01-Jan-70 00:00:01 GMT"
  33. }
  34. }
  35.  
  36. function fixDate(date) {
  37. var base = new Date(0)
  38. var skew = base.getTime()
  39. if (skew > 0)
  40. date.setTime(date.getTime() - skew)
  41. }
  42.  
  43. var now = new Date()
  44. fixDate(now)
  45. now.setTime(now.getTime() + 31 * 24 * 60 * 60 * 1000)
  46. var name = getCookie("name")
  47. if (!name)
  48. name = prompt("Por Favor Teclea tu Nombre", "Solo se te pedira una vez.")
  49. setCookie("name", name, now)
  50. document.write("Bienvenido  " + name + ", Gracias por visitar mi pagina espero te guste, comentarios y sugerencias a mi MetroFlog")
  51.  
  52.  
  53.  
que hace este codigo lee las cookies
cuales?
creo k lo utilizan para crakear metroflog. menos mal k no tengo.
Gracias de antemano

3
C/C++ / Re: archivos
« en: Jueves 10 de Junio de 2010, 15:14 »
Gestoragenda.c
Código: C
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <iostream.h>
  5. #include <conio.h>
  6. #include "agenda.h"
  7.  
  8. char Menu(void);
  9.  
  10. int main(void)
  11. {
  12.     nodoagenda *lista;
  13.     int num;
  14.     char op;
  15.    
  16.     CrearAgenda(lista);
  17.    
  18.     do{
  19.        op = Menu();
  20.    
  21.        switch(op)
  22.        {
  23.           //***********************************
  24.           case 'A':
  25.           {
  26.              if (!AgendaLlena(lista))
  27.                 InsertarAgenda(lista);
  28.              else
  29.                  printf("nNo se puede insertar debido a que la lista esta llena.");
  30.                  
  31.              break;
  32.           }
  33.           //***********************************
  34.           case 'B':
  35.           {
  36.              do{
  37.                  printf("Introduce el dni de la persona a eliminar: ");
  38.                  scanf("%d",&num);
  39.              }while (num<1);
  40.              
  41.              if (EstaElementoAgenda(lista,num))
  42.                 EliminarElementoAgenda(lista,num);
  43.              else
  44.                 printf("nEsa persona no se encuentra en la lista.");
  45.                
  46.              break;
  47.           }
  48.           //***********************************
  49.           case 'C':
  50.           {
  51.             printf("n");
  52.             MostrarInversoAgenda(lista);
  53.             getch();
  54.            
  55.             break;
  56.           }
  57.           //***********************************
  58.           case 'D'://guardar en fichero
  59.           {
  60.                            printf("n");
  61.             GuardarAgenda(lista);
  62.             getch();
  63.              
  64.              break;
  65.           }
  66.           //***********************************
  67.           case 'E'://leer de fichero
  68.           {
  69.           printf("n");
  70.              LeerAgenda();
  71.              getch();
  72.              
  73.              break;
  74.           }
  75.           //***********************************
  76.           case 'F'://borrar y salir
  77.           {
  78.              BorrarAgenda(lista);
  79.              
  80.              break;
  81.           }
  82.        }
  83.     }while (op!='F');
  84.  
  85.     printf("nn");
  86.     system("pause");
  87. }
  88.  
  89. char Menu(void)
  90. {
  91.      char opcion;
  92.      
  93.      do{
  94.           fflush(stdin);
  95.           system("cls");
  96.           printf("n***************************************************************** ");
  97.           printf("n                 A - Insertar en Agenda");
  98.           printf("n                 B - Eliminar de Agenda");
  99.           printf("n                 C - Mostrar Agenda Orden Creciente");
  100.           printf("n                 D - Guardar Agenda");
  101.           printf("n                 E - Leer de Fichero");
  102.           printf("n                 F - Borrar agenda y Salir");
  103.           printf("n***************************************************************** ");
  104.           printf("nIntroduce una opcion: ");
  105.           scanf("%c",&opcion);
  106.           system("cls");
  107.           opcion = toupper(opcion);    //tolower
  108.      }while ((opcion<'A')||(opcion>'F'));
  109.      
  110.      return opcion;
  111. }
  112.  
  113.  

agenda.h
Código: C
  1.  
  2. typedef struct nodoagenda{
  3.         int dni;
  4.         char nombre[15];
  5.         char apellidos[25];
  6.         char direccion[30];
  7.         struct nodoagenda *ant;
  8.         struct nodoagenda *sig;
  9.         }nodoagenda;
  10.  
  11.        
  12. void CrearAgenda(nodoagenda *(&));
  13.  
  14. int AgendaVacia(nodoagenda *);
  15.  
  16. int AgendaLlena(nodoagenda *);
  17.  
  18. int EstaElementoAgenda(nodoagenda *,int);
  19.  
  20. void InsertarAgenda(nodoagenda *(&));
  21.  
  22. void EliminarElementoAgenda(nodoagenda *(&));
  23.  
  24. void MostrarInversoAgenda(nodoagenda *);
  25.  
  26. void BorrarAgenda(nodoagenda *(&));
  27.  
  28. void GuardarAgenda(nodoagenda *);
  29.  
  30. void LeerAgenda();
  31.  
  32.  
  33.  
  34. //
  35. void CrearAgenda(nodoagenda *(&listad))
  36. {
  37.      listad = NULL;
  38. }
  39. /*****************************************************************************************/
  40. int AgendaVacia(nodoagenda *listad)
  41. {
  42.     int dev = 0;
  43.    
  44.     if (listad==NULL)
  45.        dev = -1;
  46.    
  47.     return dev;
  48. }
  49. /*****************************************************************************************/
  50. // Controlaremos la memoria en la insercion de elementos en la lista
  51. int AgendaLlena(nodoagenda *)
  52. {
  53.     return 0;
  54. }
  55. /*****************************************************************************************/
  56. // Devuelve -1 si el elemento esta en la lista. 0 en caso contrario
  57. int EstaElementoAgenda(nodoagenda *listad,int dni)
  58. {
  59.       nodoagenda *Paux;
  60.       int res;
  61.      
  62.       Paux = listad;
  63.       while ((Paux != NULL)&&(Paux->dni != dni))
  64.             Paux = Paux->sig;
  65.      
  66.       if (Paux == NULL)
  67.          res = 0;
  68.       else
  69.           res = -1;
  70.      
  71.       return res;
  72. }
  73. /*****************************************************************************************/
  74. void InsertarAgenda(nodoagenda *(&listad))
  75. {
  76.      nodoagenda *Nuevonodo, *Paux;
  77.      int dni;
  78.      char nombre[15],apellidos[25];
  79.      
  80.      Nuevonodo = (nodoagenda *)malloc(sizeof(nodoagenda));
  81.      if (Nuevonodo == NULL)
  82.         printf("nSe produjo un error en la creación del elemento.");
  83.      else
  84.      {
  85.          do{
  86.             printf("Introduce el dni sin letra: ");
  87.             scanf("%d",&dni);
  88.          }while((dni < 1)||(EstaElementoAgenda(listad,dni)));
  89.          Nuevonodo->dni = dni;
  90.          fflush(stdin);    //Borra el buffer de teclado
  91.          printf("Introduce el nombre: ");
  92.          gets(Nuevonodo->nombre);
  93.          printf("Introduce los apellidos: ");
  94.          gets(Nuevonodo->apellidos);
  95.          printf("Introduce la direccion: ");
  96.          gets(Nuevonodo->direccion);
  97.          Nuevonodo->sig = NULL;
  98.          Nuevonodo->ant = NULL;
  99.          
  100.          if (AgendaVacia(listad))
  101.             listad = Nuevonodo;
  102.          else
  103.          {
  104.              if (dni > listad->dni)
  105.              {
  106.                 Nuevonodo->sig = listad;
  107.                 listad->ant=Nuevonodo;
  108.                 listad = Nuevonodo;
  109.              }
  110.              else
  111.              {
  112.                  Paux = listad;
  113.                  while (((Paux->sig)!=NULL)&&((dni < Paux->sig->dni)))
  114.                        Paux = Paux->sig;
  115.                  
  116.                  if (Paux->sig != NULL)  //Si no es el ultimo nodo
  117.                     Paux->sig->ant=Nuevonodo;
  118.                    
  119.                  Nuevonodo->sig = Paux->sig;
  120.                  Nuevonodo->ant = Paux;
  121.                  Paux->sig = Nuevonodo;
  122.                      
  123.              }
  124.          }
  125.      }        
  126. }
  127.  
  128. /*****************************************************************************************/
  129. void EliminarElementoAgenda(nodoagenda *(&listad),int dni)
  130. {
  131.    nodoagenda *actual = listad;
  132.    
  133.    while (actual->dni != dni)
  134.          actual = actual->sig;
  135.    
  136.    if (actual->ant == NULL)    // Es el primer nodo de la lista
  137.    {
  138.       if (actual->sig!=NULL)           // Hay mas de un nodo en la lista
  139.           actual->sig->ant=NULL;
  140.          
  141.       listad=actual->sig;
  142.    }
  143.    else
  144.    {
  145.        if (actual->sig!=NULL)           // Es el ultimo nodo de la lista
  146.           actual->sig->ant=actual->ant;
  147.    
  148.        actual->ant->sig=actual->sig;
  149.    }    
  150.    
  151.    free(actual);
  152. }
  153. /*****************************************************************************************/
  154. void MostrarInversoAgenda(nodoagenda *listad)
  155. {
  156.      nodoagenda *paux=listad;
  157.      
  158.      if (paux != NULL)
  159.      {
  160.         // Recorremos toda la lista hasta el final      
  161.         while (paux->sig != NULL)
  162.            paux=paux->sig;
  163.        
  164.         // Recorremos toda la lista en orden inverso hasta el primer nodo
  165.         while (paux != NULL)
  166.         {
  167.               printf("nnDNI: %d",paux->dni);
  168.               printf("nNombre: %s",paux->nombre);
  169.               printf("nApellidos: %s",paux->apellidos);
  170.               printf("nDireccion: %s",paux->direccion);
  171.               paux=paux->ant;
  172.         }
  173.      }
  174. }
  175. /*****************************************************************************************/
  176. void BorrarAgenda(nodoagenda *(&listad))
  177. {
  178.      nodoagenda *paux;
  179.      
  180.      while (listad != NULL)
  181.      {
  182.         paux=listad;
  183.         listad=listad->sig;
  184.         free(paux);
  185.      }
  186. }
  187. /*****************************************************************************************/
  188. void GuardarAgenda(nodoagenda *listad)
  189. {
  190.      nodoagenda *paux=listad;
  191.      FILE*pFile;
  192.      int i=0;
  193.      
  194.      if (paux != NULL)
  195.      {
  196.         // Recorremos toda la lista hasta el final      
  197.         while (paux->sig != NULL)
  198.            paux=paux->sig;
  199.        
  200.    
  201.  
  202.         pFile = fopen ( "amigos.dat" , "wb" );//abrir fichero
  203.          
  204.          if(pFile== NULL)
  205.              puts ("nError guardando el fichero.");
  206.           else
  207.          {
  208.        
  209.        
  210.         // Recorremos toda la lista en orden inverso hasta el primer nodo
  211.                       while (paux != NULL)
  212.                       {
  213.                       fwrite(paux, sizeof(nodoagenda), 1, pFile);
  214.                        paux=paux->ant;
  215.                        }
  216.                        
  217.                                   if( !fclose(pFile) )
  218.                                       printf( "Fichero Guardadon" );
  219.                                   else
  220.                                       printf( "Error: Fichero NO Guardadon" );
  221.          }
  222.      }
  223. }
  224. /*****************************************************************************************/
  225. void LeerAgenda()
  226. {
  227.    nodoagenda nodo;
  228.  
  229.    FILE*pFile = fopen("amigos.dat", "rb");
  230.  
  231.    while(fread(&nodo,sizeof(nodoagenda),1,pFile)) /* fread() devuelve la cantidad de registros leidos, cuando se llega al final del archivo este valor es 0 y el bucle termina. */
  232.    {
  233.      printf("DNI: %dn",nodo.dni);
  234.      printf("Nombre: %sn",nodo.nombre);
  235.      printf("Apellidos: %sn",nodo.apellidos);
  236.      printf("Direccion: %sn",nodo.direccion);
  237.    }
  238.  
  239.    fclose(pFile);
  240.  
  241. }
  242.  
  243.  

Muchisimas gracias, Ahora va perfecto.

4
C/C++ / Re: archivos
« en: Martes 8 de Junio de 2010, 09:30 »
Muchas gracias
 y la condición para leer la sabrías

5
C/C++ / archivos
« en: Miércoles 2 de Junio de 2010, 19:29 »
me falta la parte de archivos que no funciona, hace tiempo que no programo en c y olvide algunas cosas

Código: C
  1.  
  2.  
  3. typedef struct nodoagenda{
  4.         int dni;
  5.         char nombre[15];
  6.         char apellidos[25];
  7.         char direccion[30];
  8.         struct nodoagenda *ant;
  9.         struct nodoagenda *sig;
  10.         }nodoagenda;
  11.  
  12.        
  13. void CrearAgenda(nodoagenda *(&));
  14.  
  15. int AgendaVacia(nodoagenda *);
  16.  
  17. int AgendaLlena(nodoagenda *);
  18.  
  19. int EstaElementoAgenda(nodoagenda *,int);
  20.  
  21. void InsertarAgenda(nodoagenda *(&));
  22.  
  23. void EliminarElementoAgenda(nodoagenda *(&));
  24.  
  25. void MostrarInversoAgenda(nodoagenda *);
  26.  
  27. void BorrarAgenda(nodoagenda *(&));
  28.  
  29. void GuardarAgenda(nodoagenda *);
  30.  
  31. void LeerAgenda(nodoagenda *listad);
  32.  
  33.  
  34.  
  35. //
  36. void CrearAgenda(nodoagenda *(&listad))
  37. {
  38.      listad = NULL;
  39. }
  40. /*****************************************************************************************/
  41. int AgendaVacia(nodoagenda *listad)
  42. {
  43.     int dev = 0;
  44.    
  45.     if (listad==NULL)
  46.        dev = -1;
  47.    
  48.     return dev;
  49. }
  50. /*****************************************************************************************/
  51. // Controlaremos la memoria en la insercion de elementos en la lista
  52. int AgendaLlena(nodoagenda *)
  53. {
  54.     return 0;
  55. }
  56. /*****************************************************************************************/
  57. // Devuelve -1 si el elemento esta en la lista. 0 en caso contrario
  58. int EstaElementoAgenda(nodoagenda *listad,int dni)
  59. {
  60.       nodoagenda *Paux;
  61.       int res;
  62.      
  63.       Paux = listad;
  64.       while ((Paux != NULL)&&(Paux->dni != dni))
  65.             Paux = Paux->sig;
  66.      
  67.       if (Paux == NULL)
  68.          res = 0;
  69.       else
  70.           res = -1;
  71.      
  72.       return res;
  73. }
  74. /*****************************************************************************************/
  75. void InsertarAgenda(nodoagenda *(&listad))
  76. {
  77.      nodoagenda *Nuevonodo, *Paux;
  78.      int dni;
  79.      char nombre[15],apellidos[25];
  80.      
  81.      Nuevonodo = (nodoagenda *)malloc(sizeof(nodoagenda));
  82.      if (Nuevonodo == NULL)
  83.         printf("nSe produjo un error en la creación del elemento.");
  84.      else
  85.      {
  86.          do{
  87.             printf("Introduce el dni: ");
  88.             scanf("%d",&dni);
  89.          }while((dni < 1)||(EstaElementoAgenda(listad,dni)));
  90.          Nuevonodo->dni = dni;
  91.          fflush(stdin);    //Borra el buffer de teclado
  92.          printf("Introduce el nombre: ");
  93.          gets(Nuevonodo->nombre);
  94.          printf("Introduce los apellidos: ");
  95.          gets(Nuevonodo->apellidos);
  96.          printf("Introduce la direccion: ");
  97.          gets(Nuevonodo->direccion);
  98.          Nuevonodo->sig = NULL;
  99.          Nuevonodo->ant = NULL;
  100.          
  101.          if (AgendaVacia(listad))
  102.             listad = Nuevonodo;
  103.          else
  104.          {
  105.              if (dni > listad->dni)
  106.              {
  107.                 Nuevonodo->sig = listad;
  108.                 listad->ant=Nuevonodo;
  109.                 listad = Nuevonodo;
  110.              }
  111.              else
  112.              {
  113.                  Paux = listad;
  114.                  while (((Paux->sig)!=NULL)&&((dni < Paux->sig->dni)))
  115.                        Paux = Paux->sig;
  116.                  
  117.                  if (Paux->sig != NULL)  //Si no es el ultimo nodo
  118.                     Paux->sig->ant=Nuevonodo;
  119.                    
  120.                  Nuevonodo->sig = Paux->sig;
  121.                  Nuevonodo->ant = Paux;
  122.                  Paux->sig = Nuevonodo;
  123.                      
  124.              }
  125.          }
  126.      }        
  127. }
  128.  
  129. /*****************************************************************************************/
  130. void EliminarElementoAgenda(nodoagenda *(&listad),int dni)
  131. {
  132.    nodoagenda *actual = listad;
  133.    
  134.    while (actual->dni != dni)
  135.          actual = actual->sig;
  136.    
  137.    if (actual->ant == NULL)    // Es el primer nodo de la lista
  138.    {
  139.       if (actual->sig!=NULL)           // Hay mas de un nodo en la lista
  140.           actual->sig->ant=NULL;
  141.          
  142.       listad=actual->sig;
  143.    }
  144.    else
  145.    {
  146.        if (actual->sig!=NULL)           // Es el ultimo nodo de la lista
  147.           actual->sig->ant=actual->ant;
  148.    
  149.        actual->ant->sig=actual->sig;
  150.    }    
  151.    
  152.    free(actual);
  153. }
  154. /*****************************************************************************************/
  155. void MostrarInversoAgenda(nodoagenda *listad)
  156. {
  157.      nodoagenda *paux=listad;
  158.      
  159.      if (paux != NULL)
  160.      {
  161.         // Recorremos toda la lista hasta el final      
  162.         while (paux->sig != NULL)
  163.            paux=paux->sig;
  164.        
  165.         // Recorremos toda la lista en orden inverso hasta el primer nodo
  166.         while (paux != NULL)
  167.         {
  168.               printf("nnDNI: %d",paux->dni);
  169.               printf("nNombre: %s",paux->nombre);
  170.               printf("nApellidos: %s",paux->apellidos);
  171.               printf("nDireccion: %s",paux->direccion);
  172.               paux=paux->ant;
  173.         }
  174.      }
  175. }
  176. /*****************************************************************************************/
  177. void BorrarAgenda(nodoagenda *(&listad))
  178. {
  179.      nodoagenda *paux;
  180.      
  181.      while (listad != NULL)
  182.      {
  183.         paux=listad;
  184.         listad=listad->sig;
  185.         free(paux);
  186.      }
  187. }
  188. /*****************************************************************************************/
  189. void GuardarAgenda(nodoagenda *listad)
  190. {
  191.      nodoagenda *paux=listad;
  192.      FILE*pFile;
  193.      
  194.      if (paux != NULL)
  195.      {
  196.         // Recorremos toda la lista hasta el final      
  197.         while (paux->sig != NULL)
  198.            paux=paux->sig;
  199.        
  200.    
  201.  
  202.         pFile = fopen ( "amigos.txt" , "wb" );//abrir fichero
  203.          
  204.          if(pFile== NULL)
  205.              puts ("nError guardando el fichero.");
  206.           else
  207.          {
  208.        
  209.        
  210.         // Recorremos toda la lista en orden inverso hasta el primer nodo
  211.                       while (paux != NULL)
  212.                       {
  213.              
  214.                        
  215.                       fwrite(&paux, sizeof paux, 1, pFile);
  216.                        printf("nnDNI: %d",paux->dni);
  217.                        printf("nNombre: %s",paux->nombre);
  218.                        printf("nApellidos: %s",paux->apellidos);
  219.                        printf("nDireccion: %s",paux->direccion);
  220.                        paux=paux->ant;
  221.                        }
  222.                        
  223.                                   if( !fclose(pFile) )
  224.                                       printf( "Fichero Guardadon" );
  225.                                   else
  226.                                       printf( "Error: Fichero NO Guardadon" );
  227.          }
  228.      }
  229. }
  230. /*****************************************************************************************/
  231. void LeerAgenda(nodoagenda *listad)
  232. {
  233.      nodoagenda *Nuevonodo;
  234.      
  235.    FILE *file = fopen("amigo.txt", "rb");
  236.  
  237.    if ( file != NULL )
  238.    {
  239.  
  240.  
  241.       fclose(file);
  242.    }
  243.  
  244. }
  245.  
  246.  
  247.  

Gracias de antemano.

Páginas: [1]