Blog bloc

Object Literal y los nombres de espacio en javascript

dactivo — 2006-04-08T12:03:00+01:00

Cómo todo el mundo sabe, javscript puede ser un lenguaje muy feo y sólo algunos habían conseguido exprimir la quintaesencia de este lenguaje, como se hacía en dhtmlcentral.com, cuyas librerías han sido toda una ayuda para los que programamos en javascript desde hace años.
No obstante, eso fue una etapa y los tiempos cambian, y se han buscado nuevas formas que nos acerquen al tipo de lenguaje orientado a objeto propiamente dicho como es java o más actual, .net.
Siempre se ha pensado que era imposible crear clases en javascript, y es así,jaja, pero han buscado formas de imitarlo mediante la creación de objetos, lo que se ha venido a llamar en el mundo anglófono, namespaced javascript o object Literal.
Antes de entrar en materia, os haré un resumen de lo que estoy diciendo para que nos entendamos.

ANTES:
Antes todo eran funciones y entonces siempre podía pasar que si incluíamos 2 archivos de javascript distintos pudieran compartir nombres de funciones similares, y al más frecuentes, variables globales similares, y por lo tanto, ambos scripts dejaban de funcionar.
Como mencionaba, en dhtmlcentral.com y en otros sitios, propulsaron una forma propia de javascript de crear pseudo-classes, se hacía así:
function bola()
{
this.moverx=moverx;
this.movery=movery;
}
function moverx()
{
}
function movery()
{
}
nuevaBola=new bola();

O sea creábamos un objeto, que tenía asociado unos pseudo-métodos, pero el problema de que otro script tuviera una función con el mismo nombre seguía ahí.Había que fastidiarse.
AHORA:
Hoy día, con el surgimiento de Ajax se le está dando mucho bombo a otra forma de imitar las clases, y no es algo nuevo, pero lo cierto es que es cada vez más frecuente.
La "nueva forma", el javascript con nombre de espacio, no crea clases, crea objetos a los que se les añade propiedades, que van a hacer las veces de variables locales por su puesto públicas (aquí no hay distinciones del tipo privada o protegida) y métodos, métodos que no van a poder pisarse por otros scripts, aunque por supuesto nada de métodos con la propiedad override ni sealed ni nada que se le parezca. Es un truco, no una solución final.
Si has llegado hasta aquí, y no sabes de que estoy hablando, este ejemplo te haré comprender:
myscript=new Object();
myscript.current=1;
myscript.init=function(){
// some code
}
myscript.validate=function(){
// some code
}

Otro ejemplo con el código más resumido, no voy a decir más elegante, pero mejor para tener todo en un sólo bloque:
myscript={
current:1,
init:function(){
// code
},
validate:function(){
// code
}
}
Por lo tanto, os animo aquello que hayáis tenido la suerte o la desgracia de llegar hasta aquí que para cuando tengáis tiempo en el trabajo de programar bien javascript y sea un proyecto algo complejo o reutilizable, cojáis las riendas de los nombres de espacio en javascript y empecéis a crear objetos.

Dolor de cabeza: redondeando en ASP

dactivo — 2006-04-05T14:25:00+01:00

Aquellos que hayáis programado en cualquier lenguaje medianamente aceptable,
habrá podido apreciar que las funciones matemáticas math.floor y math.ceil o
math.ceiling nos proporcionan métodos para redondear hacia abajo o hacia
arriba, cosa que para algunos casos es vital.
Pues bien, ASP ni lo huele.
No obstante, siempre podemos crearnos unos métodos ingeniosos para conseguir casi los mismos
resultados.

He creado 2 funciones que podemos llamar según queramos redondear hacia arriba
o hacia abajo, llamadas roundDown y roundUp, y después una función con piloto
automático y que decidirá si usar uno u otro método dependiendo de su decimal:
autoRound.

La gran pregunta aquí es qué pasa si le paso 10,5, pues según ocurre por ejemplo en
.NET se redondea hacia abajo, pero si está por encima, p.e., 10,51 se redondea hacia
arriba.
En un principio me plantee que examinaría el 2 decimal y si éste era mayor de 0 redondearía
hacia arriba, pero que pasa si el número fuera 10,501. Con este método hubiera
redondeado hacia abajo, y shlaf!! gran error, gran horror.
Es por eso que en autoRound empleo un loop que me indicará si uno de los decimales
a partir del segundo decimal es mayor de 0 pues se redondeará hacia arriba.

Esta función también lo toma en cuenta:

Function roundDown(dblValue)
Dim myDec

myDec = InStr(1, CStr(dblValue), ",")
If myDec > 0 Then
    roundDown = CDbl(Left(CStr(dblValue), myDec))
Else
    roundDown = dblValue
End If

End Function

Function roundUp(dblValue)
Dim myDec

myDec = InStr(1, CStr(dblValue), ",")
If myDec > 0 Then
    roundUp = CDbl(Left(CStr(dblValue), myDec)) + 1
Else
    roundUp = dblValue
End If

End Function

function autoRound(dblValue)
Dim myDec,pos,ini,aux

ini=1
pos = InStr(1, CStr(dblValue), ",")
myDec=left(mid(cstr(dblValue),pos+ini),1)
aux=false

If myDec > 5 Then
        autoRound = roundUp(dblValue)

    Else

    if myDec = 5 then

            do while Len(myDec)>0 and aux=false and ini<100
                ini=ini+1
                myDec=left(mid(cstr(dblValue),pos+ini),1)
                if not isNumeric(myDec) then myDec=0
                if myDec>0 then
                    aux=true
                end if

            loop

            if aux=true then

                autoRound = roundUp(dblValue)

            else

                autoRound = roundDown(dblValue)

            end if

    else

            autoRound = roundDown(dblValue)

    end if

end if

end function

Response.Write "
"
Response.Write "10,66: " & autoRound("10,66") & "
"'El output será 11.
Response.Write "10,1: " &autoRound("10,1") & "
"'El output será 10.
Response.Write "10,55: " &autoRound("10,55") & "
"'El output será 11.
Response.Write "10,5555: " &autoRound("10,5555") & "
"'El output será 11.
Response.Write "10,5: " &autoRound("10,5") & "
"'El output será 10.
Response.Write "10,51: " &autoRound("10,51") & "
"'El output será 10.
Response.Write "10,501: " &autoRound("10,501") & " Este estaría mal si no hiciéramos el loop
"'El output será 10.
Response.Write "10,5001: " &autoRound("10,5001") & " Este estaría mal si no hiciéramos el loop
"'El output será 10.
Response.Write "10,5000: " &autoRound("10,5000") & " Este estaría mal si no hiciéramos el loop
"'El output será 10.
Response.Write "10: " &autoRound("10") & "
"'El output será 10.

Dejadme salir!!!

dactivo — 2006-04-05T13:06:00+01:00

Para los que procedáis de PHP como yo mismo, le habréis dado algunas vueltas antes de encontrar el equivalente a Exit en ASP.
Cómo que no funciona la famosa etiqueta? Cuál será la solución? Antes de que empecemos a sudar, la solución es simplemente:
Response.End

Utilizar chr en lugar de caracteres

dactivo — 2006-04-05T12:58:00+01:00

Como regla general, recomiendo utilizar chr para las sustituciones de tipo replace para
los caracteres especiales, por ejemplo, si quiero sustituir unas comillas,
pensemos en el siguiente código:

dim strPrueba

strPrueba="texto ""de prueba"""

strPrueba=replace(strPrueba,"""","")

No queda claro porque hay un barullo de dobles comillas propio de un lenguaje
como asp.

En su lugar yo utilizaría algo más elegante:
strPrueba=replace(strPrueba,chr(34),"")

Podemos buscarle utilidades interesantes al método chr, el más útil diría yo que es
el carácter que indica retorno de carro.
Esto es útil cuando el texto ha sido insertado desde un textarea. Se trata del carácter 13, el 13 es tu número como
dicen en las pelis americanas.
Con el siguiente source podrás convertir esos caracteres a saltos de html.

textArticle= replace(strPrueba, chr(13),"
")

Otra utilidad muy interesante es sustituir barras inclinadas hacia un lado por otras hacia el otro lado.

Otro truco al respecto, podéis saber a qué corresponde cada caracter así:

for i=0 to numMax step 1

Response.Write (i & ":" & chr(i) & "
")

next

Función/método para combatir el SQL INJECTION

dactivo — 2006-03-23T11:08:00+01:00

Como no podía faltar, os presento aquí una función que os será utilísima para aquellos que pasáis de procedimientos almacenados o que no os viene bien o no podéis o... bueno, paro ahí.

Se trata de una función o método para combartir el SQL INJECTION. Como todos sabéis, es un ataque a través de la barra de navegación o a través de cajas de texto en vuestra web etc... en el que se inyectan códigos malignos tipo DELETE etc... para dañar vuestra web o simplemente para acceder a sitios restringidos.

Bueno sin enrollarme más y agradeciendo la refinación de la función a mi compañero Andrés os dejo aquí esta función que deberíais incluir en vuestra librería de utilidades:

Function AntiSqlInjection(cadena)

dim charReplace, valuesBanned, x

'constantes de caracteres a eliminar

Const CHARS = "'%/\<>()"

For x = 1 To Len(CHARS)

charReplace = MID(CHARS, x, 1)

cadena = Replace(cadena, charReplace, " ")

'no queremos estos valores prohibidos

valuesBanned=Array("select","delete","update","insert", "truncate", "drop", "--")

for each valuesBanned in valuesBanned

cadena=Replace(lcase(cadena),valuesBanned,"")

AntiSqlInjection=cadena

End Function

Ajax y su ayudante Sarissa

dactivo — 2005-09-19T14:12:00+01:00

En mi artículo anterior os hablaba de las prendas y virtudes de Ajax, y me quedé con la sensación de haberme quedado muy corto en mis explicaciones y en las implicaciones que conlleva este método (no lo llamaré tecnología tal y como explica Jesse James Garrett en http://www.adaptivepath.com/publications/essays/archives/000385.php.

No obstante, ahora que ya tenemos más o menos claro qué es Ajax, cómo se hace con javascript etc... Llega el "momento API"!!!!!

El momento API es el momento de perfeccionamiento de una técnica o de cualquier tipo de programación. Es el momento en el que todo ese código diseminado, "scattered", forma un conjunto y se vuelve algo profesional.

Yo he optado por tomar prestado una API que hasta el momento ha atendido todas mis necesidades. Se trata de la API de Sarissa:

https://sourceforge.net/projects/sarissa/

Es un proyecto "open source" con el que unificamos el uso de Ajax para diferentes navegadores, no sé si Opera y otros, pero sí para Mozilla e Internet Explorer, y KHTML(Konqueror y Safari).

APIs javascript

Quien nunca haya utilizado una API de javascript, pensará una API de javascript? Ese lenguaje horrible que no puede depurarse como los verdaderos lenguajes de programación?
Eso no puede traer nada bueno!!

Pues bien, se equivocan, por supuesto, javascript no es perfecto, pero conocer javascript para un programador web es como el volante para un conductor, y sin javascript, no hay programador web. Suena obvio pero no es tanto así, porque el programador web tiende a aferrarse al lenguaje de servidor y aunque en una gran empresa todo el trabajo está dividido y seguramente no le toque escribir ni una línea de javascript, para optimizar la navegación del usuario, resulta necesario al 100%.

Al igual que antes los locos del javascript debieron adaptarse a los descubrimientos más óptimos de las CSS, ahora que xmlhttpRequest está dando fuerte, a los programadores ya no les queda otra que aprender javascript o se quedarán obsoletos. De hecho, todos los programadores tenemos que reintepretar la web y la forma de programar, y se debe invertir un período en reflexiónar al respecto.

Beneficios de una API:
-Una API de javascript hace como cualquier otra API, centraliza el código, ahorra código y se edita con facilidad

porque sólo hay que modificarlo una vez.

Negativos de una API:
-El código se vuelve más difícil, el programador tiene que aprender nuevos códigos y sin una buena documentación es de difícil modificación.

Tomando todo esto en cuenta, yo principalmente opto por las APIs de javascript pero no las totalizadoras, que hacen todo lo que quieras en tu web, sólo en casos concretos, donde las diferencias de códigos entre navegadores se vuelve más dispar.

El caso más claro de una buen API es la maravillosa y famosa API de dhtmlcentral.com. Es una API que me ha acompañado siempre y que he mejorado con el tiempo.

Qué conseguimos con una API si javascript hace unas tareas muy sencillas? Pues simplemente, unificamos el javascript que utilizan todos los navegadores. Por ejemplo, para ocultar una capa se hace diferente en IE4 que en IE6, Mozilla o Netscape 4.5. Con la API de dhtmlcentral escribimos una línea y lo hace compatible para todos.

Esto mismo conseguimos con Sarissa, más otras tareas relacionadas con el DOM.

Sarissa, la API para Ajax

En este tutorial, voy a tratar 2 métodos de cargar XML con Ajax.
Uno utilizando XmlhttpRequest y otro cargando XML con el objeto load, que en IE pertenece al ActiveX Msxml2.DOMDocument, y que en Mozilla se implementa de otra manera.
No obstante, como decía más arriba, no nos vamos a preocupar de las diferencias entre navegadores porque Sarissa hará los deberes por nosotros.

El resultado con ambos métodos es el mismo. No obstante, xmlhttpRequest, nos ofrece un mejor control sobre el estado de la carga del xml, porque podemos utilizar la propiedad ReadyState.

Como último apunte, Sarissa no se implementa creando una clase Sarissa, sino que se llama de manera estática.

Empecemos de lleno:
1.-Bajamos la API de su web.

2.-Incluimos los js:

3.-Creamos el formulario que describía en mi último tutorial sobre Ajax, pero incluyendo un nuevo enlace que llama a getDatosXML para cargar XML utilizando load:

4.-Ahora incluyamos las funciones getDatos y getDatosXML:
var xmlhttp=null;

function getDatos(){
if(xmlhttp && xmlhttp.readyState!=0 && xmlhttp.readyState!=4){
    alert("espere mientras la conexión anterior termina")
    return;
}
strUrl="xmlhttp_select.cs.asp?docid=4"

xmlhttp = new XMLHttpRequest();

xmlhttp.open("GET", strUrl, true);
xmlhttp.onreadystatechange=handlergetDatos
xmlhttp.send(null);

}

function getDatosXML(){
strUrl="xmlhttp_select.cs.asp?docid=4"

respuestaXML= Sarissa.getDomDocument();
respuestaXML.async = false;
respuestaXML.load(strUrl);

        mostrarDatos(1)

}

Como vemos más arriba, hemos reducido mucho el código, ya no tenemos ninguna función que se encarga de crear la compatibilidad del objeto xmlhttpRequest. De esto se encarga Sarissa, que ha redefinido el objeto, un poco como se hace con los métodos en .Net con la propiedad "override".

De momento, ya vemos un ahorro de código, y además el sistema está mejorado porque Sarissa para IE, va a hacer un loop a través de los diferentes Activex que utiliza IE para crear el xmlHttpRequest hasta que encuentre el apropiado. Es decir, los activeX:

"Msxml2.XMLHTTP.5.0", "Msxml2.XMLHTTP.4.0", "MSXML2.XMLHTTP.3.0", "MSXML2.XMLHTTP", "Microsoft.XMLHTTP.

Para la función getDatosXml. También ahorramos porque la forma de crear el objeto, lo hará de modo conveniente dependiendo del navegador, y además para IE mejorará el método haciendo un loop buscando la clase apropiada entre:

"Msxml2.DOMDocument.5.0", "Msxml2.DOMDocument.4.0", "Msxml2.DOMDocument.3.0", "MSXML2.DOMDocument", "MSXML.DOMDocument", "Microsoft.XMLDOM"

En mi código, he incluido una mejora:

if(xmlhttp && xmlhttp.readyState!=0 && xmlhttp.readyState!=4){
    alert("espere mientras la conexión anterior termina")
return;
}

Con lo cual nos aseguramos que las diferentes conexiones no se pisan.

5.-Incluyamos la función que controla la carga de datos del xmlhttprequest:

function handlergetDatos(){

    if(xmlhttp.readyState==2)
    {

    document.getElementById("lblError").innerHTML="Cargando datos";

    }

    if(xmlhttp.readyState==3)
    {

    document.getElementById("lblError").innerHTML="Datos cargados";

    }


    if(xmlhttp.readyState==4)
    {

    document.getElementById("lblError").innerHTML="Carga de datos completada";
            if(xmlhttp.status==200)
            {

respuestaXML=xmlhttp.responseXML

mostrarDatos();

            }else{

                alert("no se encuentra el documento xml")

            }

    }

}

Aquí hemos mejorado la forma de hacer un seguimiento del estado de la conexión.

Un detalle a tener en cuenta es que al final la función mostrarDatos, va a utilizar el objeto respuestaXML. En el caso de cargarlo como documento XML usando load. La respuesta xml ya estaá contenida en el objeto mismo,pero en el caso de xmlhttpRequest, respuestaXML equivale a xmlhttp.responseXML.

Desde ese momento ambos XML son iguales y se tratan igual.

6.-Incluimos la función mostrarDatos:

function mostrarDatos(){
numNode=0;
document.getElementById("lblError").innerHTML="";
try{
if(respuestaXML.parseError!=0){
throw "Posible formato erróneo:" + respuestaXML.parseError;
}
        xmlmetatags=Sarissa.getText(respuestaXML.selectNodes("root/message/metatags")[numNode])
        xmldescripcion=Sarissa.getText(respuestaXML.selectNodes("root/message/descripcion")[numNode])


xmldescripcionlarga=Sarissa.getText(respuestaXML.selectNodes("root/message/descripcionlarga")[numNode])

        Sarissa.clearChildNodes(document.getElementById("metatags"))
        Sarissa.clearChildNodes(document.getElementById("descripcion"))
        Sarissa.clearChildNodes(document.getElementById("descripcionlarga"))
        document.getElementById("metatags").appendChild(document.createTextNode(xmlmetatags))
        document.getElementById("descripcion").appendChild(document.createTextNode(xmldescripcion))
        document.getElementById("descripcionlarga").appendChild(document.createTextNode(xmldescripcionlarga))

}
catch(e)
{
    document.getElementById("lblError").innerHTML="error cargando xml."+e+"
Lea la descripcíon del error y

póngase en contacto con su departamento técnico:
"+Sarissa.getParseErrorText(respuestaXML);

}

}

Esta es la función que crea la magia.

Después de haber comprobado que se ha cargado sin problemas, seguimos haciendo comprobaciones:

    if(respuestaXML.parseError!=0){

Con esto vamos a saber si el xml está mal formado.
Sarissa en este sentido nos ofrece 1 propiedad:
respuestaXML.parseError
que debería ser 0 si no hay error.

Y un método para recuperar el error:
Sarissa.getParseErrorText(respuestaXML)

Ahora es cuando utilizamos el segundo .js que incluimos sarissa_ieemu_xpath.js:
xmlmetatags=Sarissa.getText(respuestaXML.selectNodes("root/message/metatags")[numNode])

Con el método getText vamos a recuperar el valor del nodo que le indiquemos. Para eso utilizamos el selectNodes si hay

más de una misma etiqueta (en este caso metatags) con un índice (numNode), o si fuera sólo uno, selectSingleNode.

Fin
Hasta aquí llega mi tutorial, un método muy bueno que utiliza google, ver:
http://serversideguy.blogspot.com/2004/12/google-suggest-dissected.html

Es utilizar en vez de una respuesta xml, una respuesta de texto, y ejecutarla como javascript, así:
eval(_xmlHttp.responseText)

Pero el lado de la fuerza incluye muchos otros métodos relacionados con hojas de estilo XML ( http://www-128.ibm.com/developerworks/xml/library/x-xslt/?article=xr ) que exploraremos otro día.Sólo mostraros un ejemplo de diccionario basado en Google Suggests:
http://www.objectgraph.com/dictionary/

Miguel Ángel.
Programador.

Instalar IIS bajo Windows XP Home Edition o el hijo descarriado de la edición Home

dactivo — 2005-09-19T09:10:00+01:00

Hay muchos programadores que después de comprarse un flamante portátil último modelo con más caballos que un porsche, se llevan la ingrata sorpresa de que su sistema operativo Windows XP Home no soporta IIS!!!!!!

Al principio, piensan que es un espejismo, se frotan bien los ojos, pero efectivamente no aparece en "Agregar componentes de Windows". Poco después, cogitan, y buscan por todos los lados y el IIS sigue escondido, el muy bribón!

Pero lo cierto es que esos dólares que diferencian la versión Professional de la Home crean un antes y un después a la hora de comprar el sistema operativo.

Tal vez a aquellos que usan piratería normalmente esto les importe un rábano, pero los legales y aquellos que no tienen ganas de ponerse a formatear su portátil y agenciarse el sistema profesional, puede ser realmente un inconveniente molesto.

Pero relajémonos, la comunidad web, en concreto Richard Sandoz, nos ofrece una alternativa con un fantástico hack que podéis encontrar por internet en inglés (www.15seconds.com/issue/020118.htm).

Las explicaciones de R. Sandoz son muy diversas y desordenadas, además de omitir algunos pasos, y por lo tanto, altamente frustantes!!
El hackeador se merece un premio pero el profe suspenso!!

Es mejor y más detallada la explicación de adamV.com:
http://adamv.com/dev/articles/iis-on-xp-home

Os hago un pequeño resumen, que yo mismo he probado (o sufrido), y os doy unas referencias para que investiguéis. Cuando terminéis este artículo, con suerte, tendréis vuestro IIS funcionando en el XP home!!

Antes de nada decir una evidencia, no por conseguir el IIS en el Home estamos pasando un Home a Professional. Estas 2 ediciones del famoso OS tienen muchas más diferencias, sobre todo en seguridad. Para ver un buen resumen:

www.winsupersite.com/showcase/windowsxp_home_pro.asp

Lo más impresionante del hack es que vamos a utilizar en realidad el IIS del Windows 2000 pro (necesitas el CD) para utilizarlo en el XP Home!!!
Antes de llegar a este punto, hagamos el trabajo sucio.

Empecemos:
1.-Localiza:
C:WINDOWSINFSYSOC.INF

Busca la entrada:
iis=iis.dll,OcEntry,iis.inf,hide,7

Sustitúyela por:
iis=iis2.dll,OcEntry,iis2.inf,,7

2.-Copia los archivos iis.dl_ and iis.in_ (el guión bajo existe y no es un fallo, esto signifca que es un dll comprimido) del disco de Windows 2000 pro. Se encuentran en la carpeta i386 del disco de instalación.

3.-Copia el iis.in_ en C:WINDOWSINF y el iis.dl_ en C:WINDOWSSYSTEM32SETUP.

4.-Abre una consola msdos y bajo cada uno de esos directorios de arriba, escribe bajo C:WINDOWSINF en msdos:
expand iis.dl_ iis2.dll

Escribe bajo C:WINDOWSSYSTEM32SETUP en msdos:
expand iis2.in_ iis2.inf

Con lo cual, hemos descomprimido los archivos que copiamos en las carpeta idóneas, y el archivo sysoc.inf indicará a windows que busque esos archivos.

5.-Ahora ya sólo nos queda ir a agregar/quitar programas>agregar componentes de windows, y buscar en esa lista el IIS.
Marcamos la opción y desmarcamos la casilla de SMTP, este servicio nos dará problemas si lo instalamos.

6.-Siguiente. Nos pedirá el CD. Utiliza el CD de Windows 2000 pro. Y busca la carpeta i386.

7.-Una vez se haya instalado todo. Hemos hecho el camino más duro, pero caminante no hay camino, y queda aún un trecho.

De esta parte se olvidan casi todos los tutoriales que hay en internet pero es fundamental y no todo el mundo está al tanto.

Al instalar un IIS del Windows 2000, este IIS va a utilizar la forma que tenía de gestionar la seguridad bajo aquel sistema operativo, pero en la edición XP home ha variado. Ahora para el usuario anónimo, se necesita especificar el nombre de la máquina. En W2k sólo hace falta el IIS_NAME como usuario anónimo, cuando en XP home es NAME/IIS_NAME ("NAME" es el nombre de tu máquina, que puedes ver en propiedades de mi PC).

Teletranspórtate a "Administrador de servicios Internet" o sea al Manager del IIS,y cliquea botón derecho sobre el icono de tu ordenador.

a.-Junto a Servicio WWW, cliquea Modificar.
b.-elige la pestaña Seguridad de directorio
c.-verifica las casillas de acceso anónimo y seguridad de windows integrada.
d.-cliquea Modificar de acceso anónimo.
e.-En el formulario de Cuenta de Usuario Anónimo desverifica "permitir que IIS controle contraseñas"
f.-Ahora Examinar, y tienes que buscar el usuario IUSR_NAME ("NAME" es el nombre de tu máquina), lo seleccionas, aceptas las pantallas precedentes y ahora aparecerá el usuario NAME/IUSR_NAME ("NAME" es el nombre de tu máquina).
g.-Acepta todas las pantallas y OK.

8.-Comprueba escribiendo un archivo asp bajo wwwroot, y http://localhost/NombreArchivo.asp.

Y voilà!!!!!

Con esto hemos efectuado un largo camino, para algunos tal vez demasiado pesado y antes de terminar el tutorial, han instalado el XP Pro.

Esto era la primera parte.

La segunda parte habla del Visual Studio 2003 y el IIS que hemos hackeado.

1.-Instalamos el Visual Studio 2003 (por supuesto y como es obligatorio, con todos sus "prerequisites" o requisitos previos).

2.-Depuramos y fallo, no se encuentra el filtro de ASP.NET.

3.-Esto no sólo nos pasa a nosotros los hackeadores de postín.

Tenemos que registrar la dll para que aparezca como filtro en los filtros Isapi del IIS, para navegamos a:
:WINDOWSMicrosoft.NETFramework

(normalmente:
C:WINNTMicrosoft.NETFramework1.1.4322)

Y picamos:

asp_regiis -i

También funcionaría:

regsvr32 aspnet_isapi.dll

Este debería ser el fin de nuestros problemas, pero a mí me acosó otro error. Seguí sin hacer funcionar el .NET, y el motivo era que no tenía permisos para escribir en el wwwroot.

Esto se soluciona cambiando la carpeta raíz de nuestro IIS en el "Administrador de Servicios de Internet" a una nueva carpeta que creemos, o simplemente, cambiándole los permisos a la carpeta wwwroot.

Bueno, espero haber servido de ayuda, este artículo se lo dedico a todos aquellos que perdieron su tiempo para ayudar a los enmarronados del XP Home.

M.A.
Programador.

Metatags:
Descripción:
Descripción larga: