Creating Apache Virtual Hosts with Enable/Disable Vhosts Options in RHEL/CentOS 7.0

by Matei Cezar Last Updated: January 7, 2015

Download Your Free eBooks NOW - 10 Free Linux eBooks for Administrators | 4 Free Shell Scripting eBooks

Virtual Hosting allows Apache Weberver to serve different content based on IP Address, hostname or used port number. This guide will use a Debian like approach on enabling and managing Virtual Hosts on Red Hat Enterprise Linux/CentOS 7.0 by creating two directories on /etc/httpd/ path, which will keep all enabled and disabled website file configurations – sites-available and sites-enabled, and two types of scripts to act as commands, one that enables and other that disables specified virtual hosts – a2ensite and a2dissite. This approach has some advantages because you done have to mess with httpd configuration file and every virtual host has its own configuration file that can be found on a single location – enabled hosts are just symlinks – which make the process of enabling, disabling, creating or deleting them very manageable.

Apache Virtual Hosting with Enable/Disable Options

Requirements

1. LAMP Basic Installation on RHEL/CentOS 7.0

Create and Manage Apache Virtual Hosts in RHEL/CentOS 7

1. To begin, start by entering on /etc/httpd/ path, create sites-available and sites-enabled directories and edit Apache httpd.conf file to apply the new enabled websites location.

# cd /etc/httpd/
# mkdir sites-available sites-enabled
# nano conf/httpd.conf

Create Apache Vhost Directories

2. On httpd.conf file add the following directive line at the bottom of the file, which will make Apache read and parse all files located on /etc/httpd/sites-enabled/ ended in .conf extension.

IncludeOptional sites-enabled/*.conf

Enable Apache Directories

3. On next step create a new Virtual Host on sites-available location using a descriptive name – in this case I’ve used rheltest.lan.conf – and use the following file as a template.

# nano /etc/httpd/sites-available/rheltest.lan.conf

Use this configuration as a guide.

<VirtualHost *:80>
        ServerName rheltest.lan
        DocumentRoot "/var/www/rheltest.lan"
                <Directory "/var/www/rheltest.lan">
                Options Indexes FollowSymLinks MultiViews
         # AllowOverride controls what directives may be placed in .htaccess files.      
                        AllowOverride All
        # Controls who can get stuff from this server file
                        Order allow,deny
                        Allow from all
           </Directory>
        <IfModule mpm_peruser_module>
                ServerEnvironment apache apache
        </IfModule>
        ErrorLog  /var/log/httpd/rheltest.lan-error.log
        CustomLog /var/log/httpd/rheltest.lan-access.log combined
</VirtualHost>

Create Apache Vhosts

4. If you changed DocumentRoot location on your virtual host from default /var/www/html to other path make sure you also create this path.

# mkdir -p /var/www/rheltest.lan

NOTE: Also assure that ServerName host is a valid DNS record or is added to your local machines hosts file, from where you are planning to visit the website.
5. Now it’s time to create a2ensite and a2dissite bash scripts on a executable system path – in this case is /usr/local/bin/ – but
you can use any executable path that $PATH system variable outputs.

Create a2ensite Script

Create a following file with your choice of editor.

# nano /usr/local/bin/a2ensite

Add the following script to it.

#!/bin/bash
if test -d /etc/httpd/sites-available && test -d /etc/httpd/sites-enabled  ; then
echo "-----------------------------------------------"
else
mkdir /etc/httpd/sites-available
mkdir /etc/httpd/sites-enabled
fi

avail=/etc/httpd/sites-available/$1.conf
enabled=/etc/httpd/sites-enabled/
site=`ls /etc/httpd/sites-available/`

if [ "$#" != "1" ]; then
                echo "Use script: a2ensite virtual_site"
                echo -e "\nAvailable virtual hosts:\n$site"
                exit 0
else

if test -e $avail; then
sudo ln -s $avail $enabled
else

echo -e "$avail virtual host does not exist! Please create one!\n$site"
exit 0
fi
if test -e $enabled/$1.conf; then

echo "Success!! Now restart Apache server: sudo systemctl restart httpd"
else
echo  -e "Virtual host $avail does not exist!\nPlease see available virtual hosts:\n$site"
exit 0
fi
fi

Create a2ensite Script

Create a2dissite Script

Create a following file with your choice of editor.

# nano /usr/local/bin/a2dissite

Add the whole following script to the file.

#!/bin/bash
avail=/etc/httpd/sites-enabled/$1.conf
enabled=/etc/httpd/sites-enabled
site=`ls /etc/httpd/sites-enabled/`

if [ "$#" != "1" ]; then
                echo "Use script: a2dissite virtual_site"
                echo -e "\nAvailable virtual hosts: \n$site"
                exit 0
else

if test -e $avail; then
sudo rm  $avail
else
echo -e "$avail virtual host does not exist! Exiting!"
exit 0
fi

if test -e $enabled/$1.conf; then
echo "Error!! Could not remove $avail virtual host!"
else
echo  -e "Success! $avail has been removed!\nPlease restart Apache: sudo systemctl restart httpd"
exit 0
fi
fi

Create a2dissite Script

6. After both script files had been created, make sure they are executable and start using them to enable or disable virtual hosts by appending vhost name as command parameter.

# chmod +x /usr/local/bin/a2*
# a2ensite vhost_name
# a2disite vhost_name

7. To test it, enable the virtual host created earlier, restart Apache service and direct browser to the new virtual host – in this case http://rheltest.lan.

# a2ensite rheltest.lan
# systemctl restart httpd

Enable Apache Virtualhost

Verify Apache Virtualhost

That’s it! Now you can use a2eniste and a2disite bash scripts as system commands to manage Apache Vhosts file on RHEL/CentOS 7.0.

Netstat: Analizando la red y detectando problemas

netstat es una herramienta que proporciona un conjunto de comandos que permitirá saber qué está pasando en nuestra red. A lo largo de este artículo se explicarán algunas opciones básicas que permitirán entender mejor nuestra red y conocer qué programa puede estar causando problemas. 

Netstat es un paquete de herramienas de red

El comando netstat sirve para varias cosas, como mostrar estadísticas de la red, imprimir la tabla de rutas, mostrar conexiones activas y mucho más. Para cada una de las opciones de uso menciondas existe un comando específico que realiza la misma tarea. Pero netstat los abarca todos bajo un mismo comando, y además es multiplataforma. Lo cual quiere decir que podremos usarlo tanto en Windows, Linux o Mac.
Tras esta pequeña introducción, veamos algunas salidas de este comando:

Mostrar las conexiones de red

Es posible mostrar las conexiones que existen actualmente entre tu máquina y otras máquinas, así como sockets escuchando en un puerto para que otra máquina se conecte. También muestra qué programas están activos en la red:

$ sudo netstat -apA inet
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 *:sunrpc                *:*                     LISTEN      1775/rpcbind    
tcp        0      0 *:38768                 *:*                     LISTEN      1808/rpc.statd  
tcp        0      0 localhost:smtp          *:*                     LISTEN      2861/exim4      
tcp        0      0 *:17500                 *:*                     LISTEN      2477/dropbox    
tcp        0      0 hkr-pc.local:48985      wordpress.com:https     ESTABLISHED 3451/firefox.real
tcp        0      0 hkr-pc.local:60706      93.184.220.111:http     TIME_WAIT   -               
tcp        0      0 hkr-pc.local:60684      93.184.220.111:http     TIME_WAIT   -               
tcp        0      0 hkr-pc.local:44415      216.151.210.122:http    TIME_WAIT   -               
tcp        0      0 hkr-pc.local:43597      72.21.91.121:http       TIME_WAIT   -               
tcp        0      0 hkr-pc.local:35340      178-33-113-45.ovh.:http TIME_WAIT   -               
tcp        0      0 hkr-pc.local:36162      76.74.254.120:https     ESTABLISHED 3451/firefox.real
tcp        0      0 hkr-pc.local:44472      76.74.254.123:http      TIME_WAIT   -               
tcp        0      0 hkr-pc.local:35336      178-33-113-45.ovh.:http TIME_WAIT   -               
tcp        0      0 hkr-pc.local:43599      72.21.91.121:http       TIME_WAIT   -               
tcp        0      0 hkr-pc.local:37806      amung.us:http           ESTABLISHED 3451/firefox.real
tcp        0  13352 hkr-pc.local:34422      ec2-23-21-220-38.:https ESTABLISHED 2477/dropbox    
tcp        0      0 hkr-pc.local:43260      fa-in-f154.1e100.n:http ESTABLISHED 3451/firefox.real
tcp        0      0 hkr-pc.local:52897      wg-in-f95.1e100.ne:http TIME_WAIT   -               
tcp        0      0 hkr-pc.local:60689      93.184.220.111:http     TIME_WAIT   -               
tcp        0      0 hkr-pc.local:60687      93.184.220.111:http     TIME_WAIT   -               
tcp        0      0 hkr-pc.local:60685      93.184.220.111:http     TIME_WAIT   -               
tcp        0      0 hkr-pc.local:43335      wordpress.com:https     ESTABLISHED 3451/firefox.real
tcp        0      0 hkr-pc.local:52902      wg-in-f95.1e100.ne:http TIME_WAIT   -               
tcp        0      0 hkr-pc.local:44416      216.151.210.122:http    TIME_WAIT   -               
tcp       38      0 hkr-pc.local:58802      v-client-1a.sjc.d:https CLOSE_WAIT  2477/dropbox    
tcp        0      0 hkr-pc.local:57347      ec2-23-21-114-122.:http ESTABLISHED 3451/firefox.real
tcp        0      0 hkr-pc.local:43601      72.21.91.121:http       TIME_WAIT   -               
tcp        0      0 hkr-pc.local:60704      93.184.220.111:http     TIME_WAIT   -               
tcp        0      0 hkr-pc.local:41758      199.119.233.72.sta:http ESTABLISHED 3451/firefox.real
tcp        0      0 hkr-pc.local:60710      93.184.220.111:http     TIME_WAIT   -               
tcp        0      0 hkr-pc.local:52920      wordpress.com:http      ESTABLISHED 3451/firefox.real
tcp        0      0 hkr-pc.local:36232      76.74.254.123:https     ESTABLISHED 3451/firefox.real
tcp        0      0 hkr-pc.local:60688      93.184.220.111:http     TIME_WAIT   -               
tcp        0      0 hkr-pc.local:40181      sjc-not20.sjc.drop:http ESTABLISHED 2477/dropbox    
tcp        0      0 hkr-pc.local:60686      93.184.220.111:http     TIME_WAIT   -               
tcp        0      0 hkr-pc.local:43600      72.21.91.121:http       TIME_WAIT   -               
udp        0      0 *:bootpc                *:*                                 2405/dhclient   
udp        0      0 *:sunrpc                *:*                                 1775/rpcbind    
udp        0      0 *:678                   *:*                                 1775/rpcbind    
udp        0      0 localhost:712           *:*                                 1808/rpc.statd  
udp        0      0 *:17500                 *:*                                 2477/dropbox    
udp        0      0 *:mdns                  *:*                                 2298/avahi-daemon: 
udp        0      0 *:44290                 *:*                                 1808/rpc.statd  
udp        0      0 *:53066                 *:*                                 2405/dhclient   
udp        0      0 *:1900                  *:*                                 2905/minissdpd  
udp        0      0 *:45008                 *:*                                 2298/avahi-daemon:

Las parámetros pasados a netstat son; -a para mostrar todos los sockets, -p muestra la columna PID/Program, -A inet muestra solo sockets TCP/UDP. En Windows la opción -A inet puede omitirse y -p debe reemplazarse por -o. En Mac, no hay equivalente a -p y -A inet debe reemplzarse por -f inet. Para conocer los nombres de los programas en Mac usa lsof -i
El singnificado de cada columna es el siguiente:
Proto: Indica el protocolo usado por el socket, puede ser TCP o UDP (Son protocolos de red). TCP se usa para obtener conexiones en las que se asegura que todos los paquetes llegan a su destino, en el orden correcto. El problema es que se vuelve muy lento si la conexión es mala. UDP es mucho más rápido, pero puede perder paquetes o entregarlos en un orden incorrecto. En resumen, TCP se usa para navegar por internet y descargar ficheros y UDP se usa en videos streaming y juegos.
Recv-Q y Send-Q: Indican la cantidad de bytes que hay en cola para dicho socket. En Recv-Q datos esperando a ser leidos y en Send-Q a ser enviados. Normalmente ambas columnas han de estar a 0. De lo contrario puede que exista algún problema. En el ejemplo hay dos sockets con valores distintos a cero, los miraremos más adelante.
Local Address y Foreign Address: A qué host y puerto está conectado cada socket. La dirección local siempre será el ordenador en el que se está ejecutando netstat, en este caso se llama * hkr-pc*. Foreign Address puede ser cualquier otro pc en internet, o la misma máquina local. Aunque parezca algo extraño, en ocasiones es útil que en ambas columnas aparezca la máquina local, lo cual indica que dicha máquina se está comunicando con ella misma a través de la red.
State: Muestra el estado del socket. TCP dispone de una serie de estados, algunos de ellos son LISTEN (Esperando a que otra máquina establezca conexión),ESTABLISHED (Listo para comunicarse). En la lista aparecen varios más, como CLOSE WAIT, este estado indica que la máquina remota cerró la conexión, pero el programa local no ha seguido la petición y permanece abierto. Normalmente, un estado como este y cantidades distintas a cero en las columnas Recv-Q y Send-Q suelen ir de la mano. Otro estado que aparece en el ejemplo es TIME WAIT, puedes consultar una lista completa de los estados TCP en la referencias.
PID/Program name: El indicador de proceso del socket en ejecución y el nombre del programa ejecutando dicho proceso.
Procedamos a interpretar los resultados de netstat. En el ejemplo de arriba las direcciones de la columna Foreign adress aparecen cortadas. Para verlas completas es necesario ejecutar netstat con el parámetro -W:

$ sudo netstat -apWA inet | grep https
tcp        0      0 hkr-pc.local:50974      ec2-176-34-135-167.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:48162      ec2-50-18-192-251.us-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:50145      ec2-46-51-197-88.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:50149      ec2-46-51-197-88.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:49490      fa-in-f113.1e100.net:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:48158      ec2-50-18-192-251.us-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:59060      mad01s08-in-f31.1e100.net:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:50147      ec2-46-51-197-88.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:50976      ec2-176-34-135-167.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:50972      ec2-176-34-135-167.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:50973      ec2-176-34-135-167.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:50977      ec2-176-34-135-167.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:50144      ec2-46-51-197-88.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:50148      ec2-46-51-197-88.eu-west-1.compute.amazonaws.com:https TIME_WAIT   -               
tcp        0      0 hkr-pc.local:50975      ec2-176-34-135-167.eu-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real
tcp        0      0 hkr-pc.local:48163      ec2-50-18-192-251.us-west-1.compute.amazonaws.com:https ESTABLISHED 3619/firefox.real

Con el comando de arriba estoy mostrando únicamente las conexiones https establecidas con mi máquina. Ahora, sí que se ven las direcciones completas. Si te diriges a la dirección
ec2-176-34-135-167.eu-west-1.compute.amazonaws.com podrás comprobar que dicha dirección pertenece al buscador duckduckgo. Y ha sido listada por netstat porque al momento de ejecutarlo tenía una pestaña del navegador abierta con el buscador del pato.
Veamos ahora la razón de que existan dos conexiones con datos pendientes en la cola de entrada y salida.
Ambas conexiones son de dropbox, una de ellas tiene el estado TCP en ESTABLISHED, así que de esa no hay que preocuparse, ya que está transmitiendo datos. La otra sin embargo tiene datos pendientes en la cola de entrada y estado TCP CLOSE WAIT, es decir, la máquina conectada a la nuestra ha cerrado la conexión, pero nuestro proceso local de dropbox no lo ha hecho. Lo cual quiere decir que aunque haya finalizado la tarea que se estaba llevando a cabo, no se han liberando los recursos que el socket había reservado. Estos escenários no deberían producirse, pero mientras no haya demasiados casos como este no debes preocuparte.
He comentado que en ocasiones es posible que tanto en la columna Local Address como en Foreign Address aparezca la dirección local de nuestra máquina. Este comportamiento lo usan algunos programas para conseguir que la aplicación sea multiplataforma, ya que la comunicación a través de la red no varía de plataforma a plataforma (Linux, Windows, mac ect.)
Otro de los posibles valores que puede aparecer en la columna Foreign Address es *:*, y si el tipo de conexión es TCP tendrá el estado LISTEN. Esto quiere decir que la máquina local está esperando a que otra máquina remota envíe datos. Ejemplos típicos pueden ser sshd (esperando a que alguien abra una conexión ssh), apache o nginx (Esperando a que alguien solicite una página web) etc.
Cuando se realiza una conexión externa, el programa local no suele preocuparse por el puerto local usado para la conexión. Esa es la razón por la que el puerto en el lado local no suele reconocerse y se traduce al nombre del protocolo como https, www etc.
Netstat también sirve para mostrar la tabla de rutas (Routing Table)

Imprimiendo la tabla de rutas (Routing Table)

La tabla de rutas significa dedidir dónde mandar un paquete en base a su destino. Un ejemplo de estas tablas es el siguiente:

$ netstat -r
Kernel IP routing table
Destination     Gateway         Genmask         Flags   MSS Window  irtt Iface
default         10.61.29.89     0.0.0.0         UG        0 0          0 eth1
10.61.29.89     *               255.255.255.255 UH        0 0          0 eth1
192.168.1.32    *               255.255.255.248 U         0 0          0 eth1

Una breve explicación del significado de las columnas:

Destination: Patrón con el que se compara la dirección de destino del paquete. Cuando se envia un paquete a internet, se comprueba esta tabla de arriba a abajo hasta que se cumpla el patrón, luego se envía. El valor 0 se usa como comodín, si usamos este patrón 192.168.1.0, las direcciones desde 192.168.1.1 hasta 192.168.1.255 serán valores válidos para dicho patrón.

Gateway: Indica dónde mandar el paquete que coincide con el patrón de la columna anterior. El * en esta columna significa “enviar localmente” (El destino estará en la misma red.)

Genmask: La máscara de subred. Se usa para determinar cuantos bits desde el principio de la ip se usan para identificar una subred.

Flags: Muestra qué flags se aplican a cada línea de la tabla. U viene de Up, indicando que dicha línea está activa. G significa que la línea usa un Gateway. H, indica que el enrutamiento se hace a una dirección de host completa.

MSS: Maximum Segment Size, parámetro TCP usado para dividir paquetes en partes más pequeñas cuando el destinatario indica que es capaz de trabajar con tamaños muy grandes. A dia de hoy, la mayoría de ordenadores no tienen problemas con esto, por lo que está fijado a 0.

Window: Igual que MSS, permite alterar un parámetro TCP. En este caso el default Window size, que indica cuantos paquetes TCP pueden mandarse antes de que uno de ellos sea de ACKnowledged. Suele estar a 0.

irtt: Initial Round Trip Time, puede ser usado por el Kernel para intentar adivinar la mejor configuración de parámetros para TCP. No suele usarse.

iface: Establece la interfaz de red a usar para enviar los paquetes.

Mostrar estadísticas e interfaces

También es posible, con netstat, mostrar las interfaces disponibles y listar algunas estadísticas de cómo se están comportando:

$ netstat -i
Kernel Interface table
Iface       MTU Met   RX-OK RX-ERR RX-DRP RX-OVR    TX-OK TX-ERR TX-DRP TX-OVR Flg
eth0       1500 0         0      0      0 0             0      0      0      0 BMU
eth1       1500 0    253744      0      0 0        153622      0      0      0 BMRU
lo        16436 0         4      0      0 0             4      0      0      0 LRU

El significado de cada columna es el siguiente:
Iface: Interfaces disponibles para las que se muestran las estadísticas. lo es la interfaz de loopback, una interfaz privada usada por la máquina para comunicarse consigo misma, como se vió arriba, este comportamiento es frecuente y proporciona mayor rendimiento.

MTU: Maximum Transmission Unit (Unidad Máxima de Transmisión) que la interfaz puede enviar de una sola vez.

RX-OK/ERR/DRP/OVR: Estadísticas sobre los paquetes que se han recibido. OK significa “Correctemente recibido”, “ERR” recibido pero con CheckSum incorrecto (ocurre cuando la conexión es mala), “DRP” eliminado porque el buffer está lleno (Ocurre cuando se reciben muchos paquetes en un periodo muy corto de tiempo), “OVR”, eliminado porque el kernel no pudo manejarlo a tiempo (Si esto ocurre, la máquina estaba muy ocupada).

TX-OK/ERR/DRP/OVR: Significan lo mismo que sus homólogos en la columna RX, pero para paquetes enviados por la interfaz.

FLG: Flags activas para la interfaz. “B” de “Capacidad de broadcast”, es decir, la interfaz es capaz de transmitir un paquete a todos los equipos de su misma subred. “M” de “capacidad de Multicast”, la interfaz puede enviar paquetes con múltiples destinos. “L” de “interfaz loopback”, la interfaz con dicho flag activa coloca todo que envía inmediatamente en su cola de recibido. “U” y “R” significan “Up”(Activa) y “running”(ejecutandose) respectivamente.
El motivo por el que el valor del “MTU” es mayor en la interfaz de loopback se debe a motivos de rendimiento, ya que no tendrá que partir los paquetes en trozos más pequeños.
Como se aprecia en el ejemplo, todo parece estar correcto, ya que las columnas de errores están a 0. Una opción interesante de este comando es añadirle la opción -c, es decir “netstat -ci”, para ver la tabla cada segundo, y comprobar así si hay algún error.
Como nota final, y aunque este no es un artículo patrocinado, considero que debo proporcionar un enlace a la Linux Academy, perteneciente al autor cuyo artículo he traducido.

NetStat: Tips para detectar ataques DDoS

 

Me he encontrado un artículo muy interesante en Linuxaria sobre como detectar si nuestro Servidor se encuentra bajo ataque DDoS (Distributed Denial of Service), o lo que es lo mismo, Ataque de Denegación de Servicios.

Este tipo de ataques es bastante habitual y puede ser el motivo por el cual nuestros servidores estén algo lentos (aunque también puede ser un problema de Capa 8) y nunca está de mas estar prevenidos. Para ello, se puede usar la herramienta netstat, la cual nos permite ver las conexiones de red, tablas de rutas, estadísticas de las interfaces y otras series de cosas.

Ejemplos de NetStat

netstat -na

Esta pantalla se incluyen todas las conexiones de Internet activas en el servidor y sólo las conexiones establecidas.

netstat -an | grep :80 | sort

Mostrar sólo las conexiones activas de Internet al servidor en el puerto 80 , que es el puerto http y ordenar los resultados. Útil en la detección de una sola inundación (flood) por lo que permite reconocer muchas conexiones provenientes de una dirección IP.

netstat -n -p|grep SYN_REC | wc -l

Este comando es útil para saber cuántos SYNC_REC activa se están produciendo en el servidor. El número debe ser bastante bajo , preferiblemente menos de 5 . En los incidentes de ataques de denegación de servicio o bombas por correo, el número puede ser bastante alto. Sin embargo, el valor siempre depende del sistema, por lo que un valor alto puede ser normal en otro servidor.

netstat -n -p | grep SYN_REC | sort -u

Haz una lista de todas las direcciones IP de los implicados.

netstat -n -p | grep SYN_REC | awk '{print $5}' | awk -F: '{print $1}'

Enumere todas las direcciones IP únicas del nodo que están enviando el estado de la conexión SYN_REC .

netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -n

Utilice el comando netstat para calcular y contar el número de conexiones de cada dirección IP que hace al servidor.

netstat -anp |grep 'tcp|udp' | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -n

Cantidad de direcciones IP que se conectan al servidor mediante el protocolo TCP o UDP.

netstat -ntu | grep ESTAB | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -nr

Verifique las conexiones marcadas como ESTABLECIDOS en lugar de todas las conexiones, y muestra las conexiones para cada IP.

netstat -plan|grep :80|awk {'print $5'}|cut -d: -f 1|sort|uniq -c|sort -nk 1

Muestra y lista de direcciones IP y su número de conexiones que se conectan al puerto 80 en el servidor. El puerto 80 es utilizado principalmente por HTTP para peticiones Web.

Cómo mitigar un ataque DOS

Una vez que haya encontrado la IP que están atacando el servidor puede utilizar los siguientes comandos para bloquear su conexión a su servidor :

iptables -A INPUT 1 -s $IPADRESS -j DROP/REJECT

Tenga en cuenta que usted tiene que reemplazar $IPADRESS con las direcciones IP que se han encontrado con netstat.
Después de la cocción el comando anterior, MATAR todas las conexiones httpd para limpiar su sistema y reiniciarlo posteriormente usando los siguientes comandos:

killall -KILL httpd

service httpd start # Para los sistemas de Red Hat
/etc/init/d/apache2 restart # Para sistemas Debian

 

Aviso

Si alguien encuentra publicado su informacion en este sitio quiero que sepa que lo uso para tener guardados todos los temas que me interesan en un solo lugar y como estan en su mayoria muy bien explicados los atesoro !!


Por eso si los ven aca es porque me olvide de ponerlos como borrador para que no se vean !!  Y pido mil disculpas al respecto !!

Comandos avanzados de SSH – SSH Tips & Tricks

1) Acceso SSH sin contraseña:

ssh-copy-id user@host

Generamos las llaves mediante ssh-keygen y luego las copiamos al equipo para permitir el acceso sin clave.

2) Crear un tunel desde un puerto local a un equipo remoto en puerto 80:

ssh -N -L2002:localhost:80 equiporemoto

Nos permite acceder a un sitio web a través de http://localhost:2002/

3) Conectar micrófono a un equipo remoto:

dd if=/dev/dsp | ssh -c arcfour -C username@host dd of=/dev/dsp

Nos permite comunicar nuestro microfono con la salida de audio del equipo remoto.

4) Comparar un archivo remoto con uno local:

ssh user@host cat /path/to/remotefile | diff /path/to/localfile -

Útil para saber si un archivo local es idéntico a uno remoto.

5) Montar unidad a través de SSH

sshfs name@server:/path/to/folder /path/to/mount/point

Permite montar un directorio en forma remota, requiere SSHFS: http://fuse.sourceforge.net/sshfs.html

6) Conexión SSH con un host intermedio:

ssh -t reachable_host ssh unreachable_host

Podemos acceder a un equipo inaccesible desde nuestra red, pero que es accesible desde une red remota. Hacemos una conexión con un intermediario que nos permite acceder.

7) Copiar de host1 a host2 mediante el equipo local:

ssh root@host1 “cd /somedir/tocopy/ && tar -cf – .” | ssh root@host2 “cd /samedir/tocopyto/ && tar -xf -”

Útil cuando dos equipos no pueden conectarse en forma directa, utilizamos nuestro equipo como intermediario.

8) Ejecutar programas de entorno gráfico en forma remota:

ssh -fX <user>@<host> <program>

El servidor SSH requiere de la siguiente configuración:

X11Forwarding yes # default en Debian

Recomendable también:

Compression delayed

9) Crear una conexión persistente:

ssh -MNf <user>@<host>

10) Conectar salida de video por SSH:

ssh -t remote_host screen -r

11) Port Knocking!

knock <host> 3000 4000 5000 && ssh -p <port> user@host && knock <host> 5000 4000 3000

Knock para activar servicio SSH y para cerrar.
Ejemplo:
[options]
logfile = /var/log/knockd.log
[openSSH]
sequence = 3000,4000,5000
seq_timeout = 5
command = /sbin/iptables -A INPUT -i eth0 -s %IP% -p tcp –dport 22 -j ACCEPT
tcpflags = syn
[closeSSH]
sequence = 5000,4000,3000
seq_timeout = 5
command = /sbin/iptables -D INPUT -i eth0 -s %IP% -p tcp –dport 22 -j ACCEPT
tcpflags = syn

12) Remover una línea de texto:

ssh-keygen -R <the_offending_host>

13) Ejecutar comandos complejos sobre SSH sin comillas de escape:

ssh host -l user $(<cmd.txt)

14) Copiar una base de datos MySQL a un servidor nuevo:

mysqldump –add-drop-table –extended-insert –force –log-error=error.log -uUSER -pPASS OLD_DB_NAME | ssh -C user@newhost “mysql -uUSER -pPASS NEW_DB_NAME”

15) Quitar una línea de un archivo de texto, útil para eliminar las alertas: “ssh host key change”

sed -i 8d ~/.ssh/known_hosts

16) Copiar la clave pública de SSH s un servidor que no tiene ssh-copy-id

cat ~/.ssh/id_rsa.pub | ssh user@machine “mkdir ~/.ssh; cat >> ~/.ssh/authorized_keys”

Nos permite acceder a un equipo remoto sin necesidad de la contraseña.

17) Test de velocidad SSH

yes | pv | ssh $host “cat > /dev/null”

Nos muestra en vivo la transferencia, envia la salida a /dev/null
Es necesario contar con pv instalado:
Debian: ‘apt-get install pv’
Fedora: ‘yum install pv’ (‘extras’ repository)

18) Establecer una ventana GNU a la cual es posible reconectarse:

ssh -t user@some.domain.com /usr/bin/screen -xRR

19) Continuar scp para un archivo grande:

rsync –partial –progress –rsh=ssh $file_source $user@$host:$destination_file

Permite resumir una copia scp mediante rsync.
Requiere rsync en ambos hosts.

rsync –partial –progress –rsh=ssh $file_source $user@$host:$destination_file local -> remote
o
rsync –partial –progress –rsh=ssh $user@$host:$remote_file $destination_file remote -> local

20) Analizar tráfico ssh remoto mediante wireshark

ssh root@server.com ‘tshark -f “port !22″ -w -’ | wireshark -k -i -

Utilizando tcpdump:
ssh root@example.com tcpdump -w – ‘port !22′ | wireshark -k -i -

21) Abrir una sesión SSH en por tiempo indefinido:

autossh -M50000 -t server.example.com ‘screen -raAd mysession’

Ideal para conexiones inestables o cuando se requiere cambiar de servicio WiFi.

22) Mayor seguridad en la conexión:

ssh -4 -C -c blowfish-cbc

23) Balanceo de ancho de banda:

tar -cj /backup | cstream -t 77k | ssh host ‘tar -xj -C /backup’

Comprime y limita el ancho de banda a 77k bit/s.

24) Transferir la clave pública a través de SSH:

ssh-keygen; ssh-copy-id user@host; ssh user@host

25) Copiar stdin al buffer de tu X11:

ssh user@host cat /path/to/some/file | xclip

---

Ejemplos codigo pdo sqlite pragma sqlite_master

Coleccion de ejemplos comprobados de código pdo_sqlite, pragma , fetch, extension, transaction,sqlite_master

Programando con PDO SQLite3 – estilo orientado a objetos

Este blog es una colección de programas que muestran como usar SQLite.

Algunos programas necesitan que esten creadas previamente las tablas fieras.s3db, films3.s3db, zoomadrid.s3db, udf.s3db. Todas ellas se pueden crear con alguno de los programas adjuntos, solo hay que buscar los apropiados.

PDO significa PHP Data Objects y es una interfaz unificada para acceder a bases de datos en PHP.
Requiere un driver PDO para cada base de datos particular.

Existe una implementación de PDO y driver SQLite v.3, y además es la única que funciona con PHP5.

El código para declarar un objeto SQLite es:
$db = new PDO('sqlite:cds.db3');
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
cds.db3 se refiere a una base de datos instalada en el mismo directorio que el programa.
Si éste no es el caso hay que usar un path relativo.

1.- El nombre de la base de datos puede ser cualquiera.
2.-La declaración es diferente de la que se usaba en las versiones 1 y 2 de SQLite, que era
$db = new SQLiteDatabase('cds.db3');. Además es incompatible, si se intenta abrir una SQLite v.3 de este modo dá error.
3.- El usuario debe tener acceso de lectura y escritura al directorio en que está situada cds.db3.
4.-Si el fichero no existe, se crea, si existe el directorio al que apunta.

Muchas de las declaraciones son similares a las usadas en versiones anteriores de SQLite. Por ejemplo:Suponiendo que haya una tabla “discos” podemos hacer;
$resultado = $db->query('SELECT * FROM discos');
Sin embargo los FETCH son algo diferentes, siempre llevan como parámetro una constante predefinida, en la línea siguiente PDO::FETCH_ASSOC que determina lsa características del fetch, más adelante veremos otras opciones:
$fila = $resultado->fetch(PDO::FETCH_ASSOC);
$array_de_filas = $resultado->fetchall(PDO::FETCH_ASSOC);
Atención a los ::

La primera sentencia fetch suministra un array de una fila de la base de datos indexado por el nombre del campo,es particularmente útil porque permite llamar por los nombres de los campos.
La segunda fetchall es un array de arrays y suministra todas las filas.
Para poner en marcha una base de datos SQLite v.3, es muy útil SQLite Administrator
Opino que usar este programa o uno similar es la mejor opción para crear una base de datos SQLite,definir sus campos, índices, vistas, triggers y demás.
Para trabajar en el código use HTML-Kit, que permite una previsualización del código PHP
y por tanto corregir errores más fácilmente.Pulse aquí para las instrucciones de configuración
Finalmente tenga cuidado al cortar y pegar desde este documento.

SQLITE_MASTER
Todas las bases de datos SQLite disponen de una tabla de sistema sqlite_master
en la que se almacena la información estructural de la base de datos.
Al consultar la tabla de estructura tenemos las columnas siguientes:
1.- type puede ser table, view o index.
2.-name, el nombre del objeto.
3.-tbl_name el nombre de la tabla.
4.-root_page primera página del archivo con datos de este elemento.
5.-sql, sentencias SQL que generan el elemento.
<?php
$db = new PDO("sqlite:fieras.s3db");
// una función para determinar si ya existe la tabla animals
function existe_la_tabla($dataBase, $tablaDB)
{
$result = $dataBase->query("SELECT name FROM sqlite_master WHERE type='table' AND tbl_name=$tablaDB";
return $result;
}
// La llamada a la función
$tabla="animalessssss";
$resultado= existe_la_tabla($db, $tabla);
// el resultado de la llamada
($resultado) ? print("ya existe la tabla ".$tabla) : print("no existe la tabla ".$tabla);
?>
En este caso el resultado es: no existe la tabla animalesssss.


MEMORIA
Podemos situar la base de datos en la memoria. Por ejemplo:
$db = new PDO(‘sqlite::memory:’);
Al trabajar en memoria una vez terminado el programa, la base de datos desaparece.
Mientras existe, $db se comporta como la referencia a un objeto.
Desde luego podemos abrir diferentes bases de datos instanciadas en diferentes objetos,
cada uno independiente de los otros, y pasar datos de unos a otros,
y hacer todo lo que se hace con un objeto.
Las bases de datos en memoria son muy útiles para la programación por permitir usar SQL
Se usan también para poener ejemplos de código.

<?php
try {
/* cada vez se crea una nueva base de datos en memoria */
$db = new PDO('sqlite::memory:');
echo 'database conectada
';
/* creamos una tabla, con tres campos */
$db->exec("CREATE TABLE tableName(tableNameID INTEGER PRIMARY KEY,columna1 TEXT UNIQUE,columna2 TEXT)");
$count = $db->exec("INSERT INTO tableName(columna1,columna2) VALUES ('pepe', 'juan')");
/*** numero de filas afectado ***/
print($count.'
');
$sql = "SELECT * FROM tableName";
$set= $db->query($sql) ;
foreach ($set as $row)
{
print('tipo ='.$row['columna1'] .' animal='. $row['columna2'] . '&ltbr/>');
}
}
catch(PDOException $e)
{
echo $e->getMessage();
}
//----le cambiamos a $db el select------
$sql1 = "SELECT columna1 FROM tableName";
// atención al $db seguimos usando la misma base de datos con otro select
$set1= $db->query($sql1) ;
foreach ($set1 as $rowa)
{
print('tipo ='.$rowa['columna1'].'&ltbr/>');
}
?>

CREAR UNA TABLA
El método es el mismo que usamos en la creación de una tabla en memoria.Sin embargo es
mucho más cómodo y directo usar SqliteAdministrator, para crear bases de datos, tablas, campos, etc.
(No es posible usar SqliteAdministrator con las bases de datos en memoria).

Vamos a usar una base de datos fieras.s3db y añadirle una tabla, con tres campos.
Para ello usaremos el método $db->exec(“SQL command”);

Se toman precauciones, la base de datos no se abre, si no existe, o sea no se crea nueva,
lo mismo se hace con la tabla.
Total que el ejemplo sólo funciona si la base de datos existe y no tiene la tabla que se quiere crear.

<?php
try
{
/*** connect to SQLite database ***/
$baseDeDatos = "fieras.s3db";
// la comprobación se limita a constatar si existe el fichero
if(file_exists($baseDeDatos))
{
$db = new PDO("sqlite:$baseDeDatos");
echo 'database abierta';
//comprobar si la tabla necesita ser creada, aqúí usamos sqlite_master
$st = $db->query("SELECT name FROM sqlite_master WHERE type = 'table' AND tbl_name='animals' ");
// el QUERY devuelve false si no se cumple el SELECT
if( !$st )
{
$sqlCreateTable = 'CREATE TABLE animals(id_animal INTEGER PRIMARY KEY AUTOINCREMENT,
id_tipo VARCHAR(40) NOT NULL,id_name VARCHAR(40) NOT NULL)';
$db->exec($sqlCreateTable);
}
else
echo 'La tabla ya existe';
}
else
echo 'La base de datos'. $baseDeDatos.' no existe y no se ha creado';
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>

Notas
1.- id_animal Integer Primary Key crea una columna Auto-increment.
No tenemos en adelante que preocuparnos por ella, al insertar irá añadiendo números al campo.

INSERT
Para introducir valores en una tabla usamos INSERT y el método exec.
<?php
try {
/*** conectar a la database ***/
$db = new PDO("sqlite::memory:");
echo 'database abierta';
$sqlCreateTable = 'CREATE TABLE animals(id_animal INTEGER PRIMARY KEY AUTOINCREMENT,
id_tipo VARCHAR(40) NOT NULL,id_name VARCHAR(40) NOT NULL)';
$db->exec($sqlCreateTable);
$count = $db->exec("INSERT INTO animals(id_tipo,id_name) VALUES ('kiwi', 'troy')");
/*** numero de filas afectado ***/
echo $count;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
La salida debe ser:
Database abierta
1
Esto muestra que hemos conectado bien y que hemos insertado una fila, sino $count
devolvería 0.
Se podría usar el mismo sistema para introducir más datos, pero es más eficiente usar un TRANSACTION.

CREAR UN PREPARED STATEMENT
Un prepared statement es una sentencia SQL precompilada que acepta cero o varios parámetros.
Hay dos tipos diferentes, con nombres, y con place holders.
Usamos $preSt = $dbh->prepare($insercion)

1.-Con nombres

<?php
try {
/*** connect to SQLite database ***/
$dbh = new PDO("sqlite:fieras.s3db");
/*** un mensaje que muestra que se abrió, o cuidado que se creó ***/
echo 'database abierta';
// hacer el prepared statement
$insercion="INSERT INTO animals(id_tipo,id_name) VALUES (:id_tipo,:id_name)";
$preSt = $dbh->prepare($insercion);

//ligar parámetros
//----------------------------------------------------
$preSt->bindParam(':id_tipo',$id_tipo_val);
$preSt->bindParam(':id_name',$id_name_val);
//----------------------------------------------------
$id_tipo_val = "pájaro";
$id_name_val = "cigueña";
$preSt->execute();

$id_tipo_val = "pájaro";
$id_name_val = "ruiseñor";
$preSt->execute();

$id_tipo_val = "pájaro";
$id_name_val = "jilguero";
$preSt->execute();

}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
NOTAS
1.-Atención a este $preparedStatement ->execute(); No tiene nada que ver con el $dbConn->exec de Crear Tabla.
2.-Los $preparedStatement->bindParam(':column1', $column1_val); ligan las columnas de la tabla y sus valores.
Estamos usando una base datos ya creada fieras.s3db en la que existe dos columnas id_tipo, id_name.
3.-Observar que se ejecutan tres $preSt->execute();
Cada uno con diferentes valores.


2.- Con PlaceHolders ? posicionales. (Reservadores de sitio posicionales).

Atención: No se pueden mezclar con los anteriores, (Con Nombre).
Este ejemplo realiza una query INSERT sustituyendo un name y un value por los placeholders ? posicionales.

<?php
/*** connect to SQLite database ***/
$db = new PDO("sqlite::memory:");
echo 'database abierta &ltbr />';
// crear una tabla
$sqlCreateTable = 'CREATE TABLE numeros(id INTEGER PRIMARY KEY AUTOINCREMENT,name VARCHAR(40) NOT NULL,value INTEGER NOT NULL)';
$db->exec($sqlCreateTable);
$stmt = $db->prepare("INSERT INTO numeros(name, value) VALUES (?, ?)");
$stmt->bindParam(1, $name);
$stmt->bindParam(2, $value);
// insertar una fila
$name = 'one';
$value = 1;
$stmt->execute();
// insertar otra fila con valores diferentes
$name = 'two';
$value = 2;
$stmt->execute();
//query devuelve un set, o si el SELECT no es correcto devuelve false.
$sql = "SELECT * FROM numeros";
$set= $db->query($sql) ;
foreach ($set as $row)
{
print('nombre: '. $row['name'] .'---- '. 'valor = '.$row['value'] . '&ltbr />');
}
?>

QUERY
A diferencia de exec, el método QUERY retorna un objeto, o si el SELECT no es correcto,lo que devuelve QUERY es false, en éste último caso el resultado es que el FOREACH dá error.
<?php
try {
/*** conectar a la base datos ***/
$dbh = new PDO("sqlite:fieras.s3db");
/*** confirmar la conexion ***/
echo 'database abierta';
$sql = "SELECT * FROM animals";
$obj= $dbh->query($sql) ;
/*
Los dos print indican que query($sql) es similar a $set= $dbh->query($sql,PDO::FETCH_BOTH),
(ver más adelante).*/
foreach ($obj as $row)
{
print('tipo ='.$row['id_tipo'].' animal='.$row['id_name']. '&ltbr/>');
print('tipo ='.$row[1] .' animal='. $row[2] . '&ltbr/>');
}
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
Notas
1.- Atención: Se puede iterar directamente sobre el $obj con foreach. Esto se debe a que internamente
el query implementa el SPL iterator, dando por tanto todos los beneficios de usar SPL.
El mayor beneficio es que los iteradores SPL sólo tratan un elemento a la vez y por tanto se puede trabajar
con sets grandes sin problemas de memoria.
2.-En el bucle try-catch, el try es normal pero catch(PDOException $e) no. Lo trataremos más adelante.

UPDATE
Para actualizar un campo en la base de datos usamos de nuevo el método $dbh->exec
pero con una sentencia SQL, UPDATE
<?php
try
{
/*** connect to SQLite database ***/
$dbh = new PDO("sqlite:fieras.s3db");
/*** a little message to say we did it ***/
echo 'database abierta';
$count = $dbh->exec( "UPDATE animals SET id_name='cernícalo' WHERE id_name='cigueña'");
/*** numero de filas afectado ***/
echo Se alteraron ".$count." filas";
/*** cerrar la conexión ***/
$dbh = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>

De nuevo vemos que la conexión fué correcta y las filas que se modificaron.
Si no se modificó ninguna es que el where no localizó ninguna con la condición especificada.

QUERY CON DOS PARÁMETROS
El query simple se comporta como un query($sel,PDO::FETCH_BOTH)
pero hay otras posiblidad cómo query($sel,PDO::FETCH_NUM) y query($sel,PDO:FETCH_ASSOC.).

En ocasiones es conveniente disponer sólo de un índice asociativo o numérico.

Esto es lo que se hace en el código siguiente con:
($dh->query(' SELECT * FROM animals', PDO::FETCH_ASSOC)
Naturalmente para el índice numérico se usaría: PDO::FETCH_NUM

PDO::FETCH_ASSOC
Para suministrar el equivalente a un array asociativo se usa la constante PDO::FETCH_ASSOC
los nombres de las columnas como índices o claves del array resultante.
<?php
try
{
/*** conectar a la base de datos ***/
$dbh = new PDO("sqlite:fieras.s3db");
echo 'database abierta';
$sel ='SELECT * FROM animals';
$que=$dbh->query($sel,PDO::FETCH_ASSOC);
foreach($que as $rowa)
print($rowa['id_animal']."----------". $rowa['id_name']."&ltbr />");
/*** cerrar la conexión ***/
$dbh = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
El $que=$dbh->query($sel,PDO::FETCH_ASSOC);
ha devuelto los resultados como un objeto PDOStatement que puede ser iterado directamente.
Los índices resultantes son los nombres de los campos en la base de datos tableName.
/** Se puede comprimir el código pero es menos legible
foreach ($dbh->query('SELECT * FROM animals',PDO::FETCH_ASSOC) as $row)
print($row['id_animal']."........". $row['id_name']."&ltbr />");**/

fetchall(PDO::FETCH_NUM)
El objeto resultado del query, es un objeto de una clase que incluye diferentes
funciones de tipo fetch
que podemos usar para obtener diferentes resultados. Estas funciones pueden recibir parámetros de tipo PDO::
En este caso vamos a usar $obj->fetchall(PDO::FETCH_NUM)
<?php
try
{
/*** connect to SQLite database ***/
$dbh = new PDO("sqlite:fieras.s3db");
echo 'database abierta ';
$sql = "SELECT id_animal,id_tipo,id_name FROM animals";
$obj = $dbh->query($sql);
$fet=$obj->fetchall(PDO::FETCH_NUM);
/*Atención: Aplicamos el PDO::FETCH_NUM sobre fetchall(), no sobre el query().
Esto produce el estallido de la matriz de línea ($row)
*/
foreach($fet as $row)
{
foreach($row as $key=>$val)
{
echo $key.': '.$val.' ';
}
echo '&ltbr />';
}
$dbh = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>

El resultado es:
database abierta
0: 17 1: pájaro 2: cernícalo
0: 18 1: pájaro 2: ruiseñor
0: 19 1: pájaro 2: jilguero
Los índices resultantes son ahora numéricos en cada row.


fetch(PDO::FETCH_BOTH)
Este es un ejemplo de $result = $stmt->fetch(PDO::FETCH_BOTH), al actuar sobre el fetch,
estallamos la matriz y podemos usarla directamente en el FOREACH,
bien con índices de campo o numéricos, según nos convenga.
En realidad el FOREACH del ejemplo lo hace con los dos.
En este caso particular mas bien se hace confusa la devolución de resultados.
En el ejemplo se devuelven ambos índices.
<?php
try
{
/*** connect to SQLite database ***/
$dbh = new PDO("sqlite:fieras.s3db");
echo 'database abierta ';

$sql = "SELECT * FROM animals";
$stmt = $dbh->query($sql);
$result = $stmt->fetch(PDO::FETCH_BOTH);
foreach($result as $key=>$val)
{
echo $key.' - '.$val.'&ltbr />';
}
$dbh = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>

fetchAll(PDO::FETCH_OBJ)
PDO::FETCH_OBJ devuelve un objeto de una clase anónima ,
que mapea los nombres de las columnas de la base de datos como propiedades de objeto
como si fuesen valores de variables de una clase.
No hace falta definir una clase, como en el siguiente FETCH_CLASS.

<?php
try
{
$dbh = new PDO("sqlite:fieras.s3db");
echo 'Connected to database&ltbr />';
$sql = "SELECT * FROM animals";
$stmt = $dbh->query($sql);
$arrBestia = $stmt->fetchAll(PDO::FETCH_OBJ);
/*** propiedades ***/
echo $arrBestia[1]->id_tipo.' ';
echo $arrBestia[1]->id_name.' ';
/*** cerrar conexion ***/
$dbConn = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
NOTA
Usar los nombres de las columnas como propiedades de clase hace más sencillo integrar
los resultados en un ambiente OOP.

fetch(PDO::FETCH_CLASS)
PDO::FETCH_CLASS instancia un array de objetos de la clase especificada.
Los nombres de los campos se mapean a las propiedades (variables) de igual nombre,dentro de la clase especificada.
Específicamente los nombres de de los campos de la base de datos se asignan a las variables de igual nombre en la clase especificada, si no existen se crean.
Esto permite ahorrar código y acelerarlo puesto que los mapeos se tratan internamente.
Suponemos que existe la base de datos fieras.s3db que se creó en CREATE, o bien que ha sido creada con SQLiteAdmin.

<?php
class animales
{
public $id_animal;
public $id_tipo;
public $id_name;
public $tip_name;
public $stapu;
//funcion para poner en mayúsculas la primera letra
retornando public function capitalizeType($pepe)
{
return ucwords($pepe);
}
public function pega()
{
return this->id_tipo."....".$this->id_name."....".$this->stapu."
";
}
}
try {
$dbh = new PDO("sqlite:fieras.s3db");
$sql = "SELECT * FROM animals";
$stmt = $dbh->query($sql);
//aquí estamos haciendo el enlace de $stmt con la clase animales
//el $arrObj que retornamos ya es un array de objetos de la clase animales $arrObj = $stmt->fetchall(PDO::FETCH_CLASS, 'animales');
/*** iteramos el objeto directamenie ***/ foreach($arrObj as $bestia)
{
$bestia->stapu="34";
/*** Llamamos a pega y a capitalizeType ***/ echo $bestia->capitalizeType($bestia->pega());
}
/*** close the database connection ***/ $dbConn = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
El código anterior produce una lista de animales con la primera letra en mayúsculas.
Usando la constante PDO::FETCH_CLASS se han suministrado los nombres directamente desde la base datos al $arrObj (que es un array de objetos de la clase animales).
En el objeto se modificaron los resultados, poniendolos con la primera letra en mayúsculas, y definiendo el valor de una de las variables del objeto,realmente podríamos haber definido una propiedad en vez de la variable.

fetchObject()
PDO suministra una alternativa a PDO::fetch y PDO::FETCH_CLASS que es:
PDOStatement::fetchObject().
El resultado es similar pero con una sóla línea.
Usamos un bucle while para ir recorriendo los registros de la base de datos
<?php
try
{
$dbh = new PDO("sqlite:fieras.s3db");
$sql = "SELECT * FROM animals";
$stmt = $dbh->query($sql);
//definimos una clase animales, diferente de la tabla animals de la base de datos
class animales
{
public $id_animal;
public $id_type;
public $id_name;
public $nombreAnimal;
//funcion para poner en mayúsculas la primera letra
public function capitalizeType($pepe)
{
return ucwords($pepe);
}
}
//-----------------------------------------------------------
/*** aquí estamos haciendo el enlace de $stmt con la clase animales, el $obj que retornamos
ya es un objeto de la clase animales.Con el while recorremos los registros hasta el final.***/
while($obj = $stmt->fetchObject('animales'))
{
// la siguiente sentencia implica que estamos en un objeto de la clase animales
$obj->nombreAnimal = $obj->id_name."-"."animal";
//llamada al método capitalizeType
echo $obj->capitalizeType($obj->id_tipo)." = ".$obj->capitalizeType($obj->id_name).'&ltbr />';
echo $obj->nombreAnimal.'&ltbr />'.'&ltbr />';
}
/*** cerrar la conexión ***/
$dbConn = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
NOTA
Puede escribirse PDO::fetchObject()en vez de PDO::FETCH_OBJ.

FETCH_INTO
La constante PDO::FETCH_INTO nos permite incrustar datos en un array de objetos de una clase.
Los valores iniciales del objeto se sustituyen por los incrustados.
Cómo en PDO::FETCH_CLASS los nombres de los campos se mapean a las propiedades(variables) de la clase.
En este caso, el modo fetch se establece usando el método PDO::setFetchMode(PDO::FETCH_INTO, $bestias)

<?php
try
{
$dbh = new PDO("sqlite:fieras.s3db");
$sql = "SELECT * FROM animals";
$stmt = $dbh->query($sql);
/*** definimos una clase animales, atencion a la diferencia con el campo animals de la base de datos
***/
class animales
{
public $id_animal;
public $id_tipo;
public $id_name;
public $nombreAnimal;
//funcion para poner en mayúsculas la primera letra

public function capitalizeType($pepe)
{
return ucwords($pepe);
}
}
//---------------------------------------------------------------------------
/*** instanciar un nuevo objeto de la clase animales ***/
$bestias = new animales;
$bestias->id_animal = 14;
$bestias->id_tipo = 'pez';
$bestias->id_name = 'merluza';
//----------------------------------------------------------------------
//valor devuelto por el objeto $bestias
echo $bestias->id_name.' ';
/*** set el modo fetch con PDO::setFetchMode() ***/
$stmt->setFetchMode(PDO::FETCH_INTO, $bestias);
/*** loop sobre el array de objetos ahora los valores ya están sustituidos ***/
foreach($stmt as $bestias)
{
echo $bestias->id_name.' ';
echo $bestias->capitalizeType($bestias->id_name).' ' }
/*** cerrar la conexión ***/
$dbh = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>

Transacciones(Transactions)
Hemos visto anteriormente como usar varias sentencias INSERT para construir la base de datos inicial.
Esto funciona bien pero tiene mucho código,y con SQLite surge un problema,
el bloqueo de fila para cada acceso.
Usando una TRANSACTION el proceso puede condensarse en un solo acceso.
Las transacciones son muy sencillas y tienen el beneficio de poderse echar atrás si tiene lugar un error,
por ejemplo una caída del sistema.
La transacción se inicia con el método beginTransaction().
Este método suprime el auto-commit, con lo cual cualquier sentencia o query no se ejecuta hasta que
se envía commit.
Cuando se llama a commit, todas las sentencias/querys se ejecutan y se devuelve
la base datos al estado auto-commit.
El ejemplo muestra como podríamos hacerlo en la base de datos zoomadrid.s3db.
<?php
try
{
$dbh = new PDO("sqlite::memory:");
echo 'Conectado a la base de datos';
/*** poner el modo PDO error a excepción ***/
$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
/*** Crear una tabla ***/
$table = "CREATE TABLE animals(animal_id INTEGER NOT NULL PRIMARY KEY,
animal_type VARCHAR(25) NOT NULL,
animal_name VARCHAR(25) NOT NULL
)";
$dbh->exec($table);
/*** comenzar la transacción ***/
$dbh->beginTransaction();
$dbh->exec("INSERT INTO animals (animal_type, animal_name) VALUES('emu', 'bruce')");
$dbh->exec("INSERT INTO animals (animal_type, animal_name) VALUES('funnel web', 'bruce')");
$dbh->exec("INSERT INTO animals (animal_type, animal_name) VALUES('lizard', 'bruce')");
$dbh->exec("INSERT INTO animals (animal_type, animal_name) VALUES('dingo', 'bruce')");
$dbh->exec("INSERT INTO animals (animal_type, animal_name) VALUES ('kangaroo', 'bruce')");
$dbh->exec("INSERT INTO animals (animal_type, animal_name) VALUES ('wallaby', 'bruce')");
$dbh->exec("INSERT INTO animals (animal_type, animal_name) VALUES ('wombat', 'bruce')");
$dbh->exec("INSERT INTO animals (animal_type, animal_name) VALUES ('koala', 'bruce')");
$dbh->exec("INSERT INTO animals (animal_type, animal_name) VALUES ('kiwi', 'bruce')");
/*** commit la transacción ***/
$dbh->commit();
echo 'Data entered successfully';
$sql = "SELECT * FROM animals";
$set= $dbh->query($sql,PDO::FETCH_ASSOC) ;
foreach ($set as $row)
{
print('tipo ='.$row['animal_type'] .' animal='. $row['animal_name'] . ' ');
}
}
catch(PDOException $e)
{
/*** roll back la transacción si hay fallo ***/
$dbh->rollback();
echo $sql . ' ' . $e->getMessage();
}
?>

ATTACH DATABASE
La sentencia ATTACH DATABASE permite añadir otras bases de datos a la conexión con la base datos principal.
El nombre de la base de datos a añadir debe ir entre comillas .
Las bases de datos añadidas pueden quitarse usando la sentencia DETACH DATABASE.

Se puede leer y escribir a una base datos añadida e incluso se puede modificar su esquema.
Pero no se puede crear, en la base de datos añadida, una tabla con el mismo nombre que otra existente ,
aunque sí se pueden añadir bases de datos que contengan tablas con el mismo nmbre que la base de datos principal,
incluso se pude añadir una base de datos varias veces.
La posibilidad de añadir varias bases de datos permite por ejemplo tener una base de datos
por cada caja de una tienda, sin problemas de bloqueo,
pudiendo tratarlas luego individualmente o agrupadas.
Hay un límite: No se pueden añadir más de 10 bases de datos.

Las tablas en una base de datos añadida se referencian, si son iguales en dos de las tablas,
usando la síntaxis nombreBaseDeDatos.nombreTabla.
Las Transacciones que envuelven bases de datos añadidas son atómicas,
siempre que la base principal no sea “:memory:.
Si la base principal es ":memory:" entonces las transacciones continúan siendo atómicas
dentro de cada fichero de base de datos individual. Pero si el ordenador casca en medio de un COMMIT
puede suceder que algunos ficheros se modifiquen y otros no.
El siguiente ejemplo es una demostración muy simple, en que el objeto db conecta a films3.s3d
y le añade fieras.s3db, permitiendo un SELECT mixto de ambas bases de datos.
El SELECT permite todo lo que permite la sentencia select como claúsulas WHERE.
<?php
try
{
/*** conectar a SQLite database ***/
$db = new PDO("sqlite:films3.s3db");
echo 'database creada
';
$db->exec("ATTACH DATABASE 'fieras.s3db' AS fieras");
$sql = "SELECT id_tipo, id_name, nombrePel FROM fieras.animals,peliculas";
$set= $db->query($sql) ;
foreach ($set as $row)
{
print $row['id_tipo'] .' - '. $row['id_name'] . $row['nombrePel'].' ';
}
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>

Una instancia Global
¿Ha necesitado alguna vez una instancia global de su conexión a la base de datos?.
Aquí lo conseguimos mediante el uso de una plantilla SINGLETON.
El objetivo de un Singleton es lograr que la clase tenga un solo objeto(instancia) y
suministrar un punto de acceso a ella.
Una nueva instancia se crea sólo la primera vez que se accede a ella.
En los siguientes accesos se devuelve simplemente la instancia existente.
<?php

class db
{
/*** Declarar la instancia ***/
private static $instance = NULL;
// el constructor se declara privado para que
//nadie pueda crear una nueva instancia usando new.
private function __construct()
{
/*** aquí no hace falta poner nada ***/
}
/***
Devolvemos la instancia de la base de datos o creamos la conexión inicial,
lo que devolvemos es un objeto PDO, el acceso a la función es público
***/
public static function getInstance()
{
if (!self::$instance)
{
self::$instance = new PDO("sqlite:zoomadrid.s3db");
self::$instance-> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
return self::$instance;
}
// También hacemos private la función _clone para evitar clonar la instancia.
private function __clone()
{ }
}
//---------------- fin de la clase------------------
try
{
/*** query la base de datos ***/
$sql="SELECT * FROM animals";
$result = db::getInstance($sql->query);
/*** loop ***/
foreach($result as $row)
{
print $row['animal_type'] .' - '. $row['animal_name'] . ' ';
}
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
El código anterior porduciría el siguiente resultado:
emu - bruce
funnel web - bruce
lizard - bruce
dingo - bruce
kangaroo - bruce
wallaby - bruce
wombat - bruce
koala - bruce

Este método de acceso ahorra el código creado cuando se llama una nueva instancia del objeto
cada vez que es referenciado. Además si desea pasar el estado del objeto de una referencia a otra no hay necesidad de crearla desde el estado inicial.
Nótese que los métodos constructor y clone se han declarado privados para que una instancia de la clase no pueda ser instanciada ni clonada.

Tratamiento de Error
El tratamiento de errores en PDO viene en varios aromas.
Previamente hemos usado el más sencillo de los bloque try{} ccatch{}
para devolver un error en la conexión de la base de datos.
Pero ¿que pasa con otros errores, por ejemplo si el nombre de un campo no existe?.
Veamos primero como tratamos un error sencillo en el código anterior.
<?php
try
{
$dbh = new PDO("PDO("sqlite:zoomadrid.s3db");
echo 'Connected to database
';
/*** El SELECT con un nombre de campo incorrecto ***/
$sql = "SELECT username FROM animals";
foreach ($dbh->query($sql) as $row)
{
print $row['animal_type'] .' - '. $row['animal_name'] . '&ltbr />';
}
/*** cerrar conexión ***/


El código anterior producirá el siguiente error:
Connected to database
Warning: Invalid argument supplied for foreach() in /www/pdo.php on line 18

Esto se debe a que no hay tratamiento del error.
El SELECT especifica un campo que no existe pero no podemos ver cual es el error.
Para remediar ésto necesitamos añadir un atributo al tipo de manejo de error que queremos utilizar.

Los tipos de manejo de error son:
Exception
Warning
Silent
Comencemos con exception con el código anterior

<?php
try
{
$dbh = new PDO("PDO("sqlite:zoomadrid.s3db");
/*** echo a message saying we have connected ***/
echo 'Connected to database';
/*** set the error reporting attribute ***/
$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
/*** The SQL SELECT statement ***/
$sql = "SELECT username FROM animals";
foreach ($dbh->query($sql) as $row)
{
print $row['animal_type'] .' - '. $row['animal_name'] . '
';
}
/*** close the database connection ***/
$dbh = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>
Ahora como el modo de error se puso a Exception, la advertencia aparecería así:
Connected to database
SQLSTATE[42S22]: Column not found: 1054 Unknown column 'username' in 'field list'

Para poner el modo de error a Warning sustituiríamos la línea
$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
por:
$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
Ahora se desplegaría una advertencia diferente

Connected to database
Warning: PDO::query() [function.PDO-query]: SQLSTATE[42S22]: Column not found: 1054
Unknown column 'username' in 'field list' in /www/pdo.php on line 21
Warning: Invalid argument supplied for foreach() in /www/pdo.php on line 21

Finalmente hay el modo Silent.
Este modo silencia el error de modo que no se emite advertencia.
Sin embargo no detiene el código en el punto de error y todos los errores siguientes se siguen emitiendo.
Para usarlo pondríamos:

$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
Ahora se desplegaría la siguiente advertencia:

Connected to database
Warning: Invalid argument supplied for foreach() in /www/pdo.php on line 21
El error se silenció pero aparecen los siguientes.

USER DEFINED FUNCTIONS (UDF)
Se puede extender SQLite para incluir funciones definidas por el usuario que se escriben en PHP,
se pueden usar las funciones predefinidas en ese lenguaje, y las que nosotros definamos..
Con una UDF usando sqliteCreateFunction se pasa la función PHP a una función en SQLite
y se pueden usar todas las facilidades de una base de datos, cómo ordenar o seleccionar.

Las UDF son buenas para trocear strings y ejecutar agrupaciones y listados no standard.
Por ejemplo si se quiere tratar una lista de URLs. quizá procedente de un log,
y crear una lista de nombres de host únicos, en minúsculas y ordenados alfabéticamente.

http://Example.com/directory/index.html y http://example.com/page.html
podrían convertirse en una sola sentencia: http://example.com/.

Para hacer ésto en PHP hay que recoger todos los URLs, procesarlos en un script,ordenarlos
y quitar los duplicados.
En SQL todo esto se haría usando DISTINCT y ORDER BY.

La misión de la UDF es pasar una función escrita en PHP a SQLite.
No se escribe nada en la base de datos propiamente dicha.
Si se abre en otro programa la misma base de datos hay que escribir de nuevo la función PHP
y la sqliteCreateFunction.

Con una UDF como la siguiente se pasa todo éste trabajo a SQLite, que es donde debe estar.
Aparte usamos el QUERY con dos parámetros, y el SELECT es más complicado que los anteriores.

<?php
try
{
// Abrir base de datos
$db = new PDO("sqlite:udf.s3db");
echo 'database abierta'." ".";
$urlses = array('http://Example.com/directory/index.html','http://example.com/page.html');
echo "Inserciones:"." ";
foreach ($urlses as $urla)
{
$sql = "INSERT INTO urls(nom_url) VALUES ('$urla')";
$count=$db->exec($sql);
echo $count." ";
echo $urla." ";
}
// UDF escrita en PHP, parse_url($url) está predefinida en PHP

function url2host($url)
{
$parts = parse_url($url);
return "{$parts['scheme']}: //{$parts['host']}/";
}

// Mapeo de la función PHP url2host() a la SQLite host(),
// e indicación de que host() vá a tener 1 argumento.
$db->sqliteCreateFunction('host', 'url2host', 1);

$sel='SELECT DISTINCT host(lower(nom_url)) AS clean_host FROM urls ORDER BY clean_host';
$r = $db->query($sel , PDO::FETCH_ASSOC);

echo " "."Resultado = ";
foreach ($r as $row) print($row['clean_host']);
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>

Devuelve:
http://example.com/

Para usar una UDF
1.- Se escribe una función normal en PHP.
Los argumentos de la función son los que se desea pasar en el SELECT
y la función debe retornar solo un valor.

La funcion url2host () toma un URL, llama a la fución PHP predefinida parse_url() para trocear el URL
en sus partes componentes, $parts contiene una matriz con estas partes.
Así, http://example.com/directory/index.html se fracciona en varios trozos,
http se almacena en $parts['scheme'], y example.com en $parts['host'].
Esto devuelve un valor http://example.com/.

Ver, para la definición de parse_url()

2.- Se registra url2host() con SQLite usando: $db->sqlite_create_function(). La función toma cuatro argumentos:
2.1.-El manejador de la base de datos,aquí $db.
2.2.-El nombre que se ha elegido para la función en SQLite, aquí 'host'.
2.3.-El nombre de la función en PHP, aquí 'url2host'.
2.4.-El número de argumentos que se espera. Este último argumento es opcional, pero si se conoce con certeza su número ayuda a SQLite a optimizar el código.

Los nombres de las funciones en SQLite y PHP pueden ser iguales,
pero aquí se ponen diferentes para clarificar la distinción entre ambos.
Se la ha denominado host() en SQLite y url2host() en PHP.
Ahora se pude usar host() en cualquier SQL query, que use la misam conexión a la base de datos.

El SQL de arriba 'SELECT DISTINCT host(lower(nom_url)) AS clean_host FROM urls ORDER BY clean_host',
coge la URL almacenada en lacolumna nom_url, la convierte a minúsculas y llama a la UDF host(),
que la transforma.
Al string devuelto se lo llama AS clean_host;
esto permite referirse a los resultados más tarde a clean_host en el query SQL
así como acceder al valor en PHP usando este nombre.

Como está en SQLite tiene la ventaja de poder ordenar la lista usando ORDER BY clean_host,
lo cual ordena los resutados por orden alfabético.

sqliteCreateAggregate
Registra dos funciones para su uso en sentencias SQL.
Descripción

bool PDO::sqliteCreateAggregate ( string function_name, callback step_func, callback finalize_func [, int num_args] )
Atención:La función es EXPERIMENTAL.

PDO::sqliteCreateAggregate() es similar a PDO::sqliteCreateFunction() excepto que registra dos funciones
que pueden usarse para calcular un resultado agregado a través de todas las filas de un query.


La diferencia clave () es que en PDO::sqliteCreateFunction son necesarias dos funciones para manejar el agregado

1.- step_func se llama para cada línea del set resultado.
Su función PHP debe acumular el resultado y almacenarlo en el contexto de agregación.para la definición de parse_url().
2.- Después de que todas las filas se hayan procesado,
se llamará a finalize_func y ella cogerá los datos del contexto de agregación y devolverá el resultado.
Las funciones Callback deben devolver un tipo comprendido por SQLite, (un escalar).

Parámetros
function_name. El nombre de la función que se usará en las sentencias SQL.
step_func. Callback función llamada para cada fila del set reultado.
finalize_func. Callback función para agregar los datos suministrados por los pasos de la función anterior.
num_args. Una orientación al parser SQLite de que la función callback acepta un número predeterminado de argumentos.

Ejemplo
1.-Creamos una step_func que calcule el mayor largo de un string en una de las columnas de la tabla.
Para cada fila se llama la función max_len_step y se le pasa un parámetro context .
Este context es como cualquier otra variable PHP y puede disponerse para contener un array o incluso un objeto.

Aquí lo usamos simplemente para almacenar el mayor largo que hemos encontrado hasta el momento;
si el string tiene un largo mayor que el máximo anterior modificamos el context a su nuevo largo máximo.

2.-Después de que han procesado todas las filas, SQLite llama la función max_len_finalize
para determinar el resultado agregado.
Aquí podríamos efectuar algun tipo de cálculo basado en los datos del context.
En nuestro ejemplo, hemos ido calculado el resultado a medida que progresaba el query,
así que simplemente devolvemos el valor del context multiplicado por 7.

La llamada a $fe=$que->fetch(PDO::FETCH_NUM) es básica,
sino por defecto el fetch llama a PDO::FETCH_ASSOC que devuelve un array asociativo con dos valores.

<?php

$data = array('one','two','three','four','five','six','seven','eight','nine','ten_diez');
$db = new PDO('sqlite::memory:');
$db->exec("CREATE TABLE strings(a)");
$insert = $db->prepare('INSERT INTO strings VALUES (?)');
foreach ($data as $str)
{
$insert->execute(array($str));
}
$insert = null;

function max_len_step($context, $rownumber, $string)
{
if (strlen($string) > $context)
{
$context = strlen($string);
}
echo " ".string: ".$string." valor máximo hasta ahora : ".$context;
return $context;
}

function max_len_finalize($context, $rownumber)
{
echo ' '."valor máximo último : ".$context.' ';
return $context*7;
}

$db->sqliteCreateAggregate('max_len', 'max_len_step', 'max_len_finalize');

$que=$db->query('SELECT max_len(a) from strings');
$fe=$que->fetch(PDO::FETCH_NUM);
foreach ($fe as $row)
{
print('numero de letras m. ='.$row);
}
//una forma alternativa de obtener el resultado $fe[0]
echo ' '.'num_echo = '.$fe[0];
?>

FORMULARIOS Y OTRAS COSAS
Ahora enviar formularios, es sencillo, ya que PDO protege contra ataques de SQL Inyection.
Aquí usamos lo que se le conoce como Prepared Statements o Comandos Preparados,
es igual de sencillo, cuando preparamos un query (ya sea Insert, Select, Update, Call, etc.).
Usamos dos documentos:

1.- Pdo19_Form.html
2._Pdo19_Form.php
El primero llama al segundo

Pdo19_Form.html

<html>
<head>
<title>Pdo-form</title>
<meta http-equiv="" content="text/html"; charset="iso-8859-1" />
</head>
<body>
<form action="Pdo19_Form.php" method="post">
Cliente:
<input type="submit" name="enviar" value="Envíar cliente">
</form
</body>
</html>

El segundo es:
Pdo19_Form.php

<?php
try
{
$db = new PDO("sqlite::memory:");

$sqlCreateTable = 'CREATE TABLE clientes(id_cliente INTEGER PRIMARY KEY AUTOINCREMENT, nom_cliente VARCHAR(40) NOT NULL)';
$db->exec($sqlCreateTable);

$inserto="INSERT INTO clientes(nom_cliente) VALUES (?)";
$preSt = $db->prepare($inserto);
$preSt->bindParam(1,$nomCliente);

$nomCliente= $_POST["cliente"];
$preSt->execute();

$sql = "SELECT * FROM clientes";
$set= $db->query($sql) ;
foreach ($set as $row)
{
print('nombre: '. $row['nom_cliente'] . ' ');
}
echo $_POST["cliente"];
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>

Podemos usar directamente el valor de nuestro $_POST, sin temor a que sea una cadena que pueda perjudicarnos,
ya que PDO automáticamente se encarga de analizar y enviar la cadena como un string.
Usamos un prepare con "placeholders"(marcadores), estos son los signos de interrogación en el WHERE "?", seguido por los bindParam
Estos marcadores se van a reemplazar por los valores que se asignen cuando use execute().
Para actualizar solo se cambiaría el $inserto:
UPDATE Clientes SET Nombre=? WHERE idCliente=?

Extensión de la clase PDO
Otra ventaja de usar PDO, es que podemos extenderla y crear nuestra propia clase. A continuación vemos un ejemplo en el que definimos una clase PDOEx, que extiende PDO, y una segunda clase DBStatement que extiende a PDOStatement.

Se ha ampliado con un atributo PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION y una función grid(), en ésta prestar atención al this que es por definición el propio objeto.

El conjunto permite definir una clase PDO ampliada, y una clase PDOStatement asimismo ampliada.

<?php
class PDOEx extends PDO {
function __construct($dsn) {
parent::__construct($dsn);
$this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('DBStatement', array($this)));
$this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}

function grid()
{
$numPara =func_num_args();
$a=true;
if( $numPara == 0)
{ }

if( $numPara == 1)
{
$selGrid =func_get_arg(0);
}

if( $numPara == 2)
{
$selGrid =func_get_arg(0);
$cabGrid =func_get_arg(1);

if(is_array($cabGrid)){$a=false;}

else
{
echo 'El segundo parámetro debe ser un array con los nombres de los campos.';
echo'Como no lo es se usan los nombres de las columnas de la BD'; }
}
$que=$this->query($selGrid,PDO::FETCH_ASSOC);
$fetall=$que->fetchall(PDO::FETCH_ASSOC);

echo '<table border="1">';
echo '<tr>';
if($a)
foreach($fetall as $row)
{
foreach($row as $key=>$val)
{

if($a)echo '<th>'.$key.'</th>';
}
$a=false;
}
}
else
{
foreach ($cabGrid as $cab)
{
echo '<th>'.$cab.'</th>';
}
}

echo '</tr>';

foreach($fetall as $row)
{
foreach($row as $key=>$val)
{
echo '<tr><td>'.$val.'</td>';
}
echo '</tr>';

}
echo '</table>';
}

}

class DBStatement extends PDOStatement {
public $dbh;
protected function __construct($dbh) {
$this->dbh = $dbh;
}
}

try
{
$db = new PDOEx('sqlite:fieras.s3db');
echo "abierta"."
";
$sel ='SELECT * FROM animals';
$cab =array('Num','Especie','Nombre');
$db->grid($sel,$cab);
/*** cerrar la conexión ***/
$db = null;
}
catch(PDOException $e)
{
echo $e->getMessage();
}
?>

INTEGRIDAD REFERENCIAL MEDIANTE TRIGGERS
SQLite no soporta la integridad referencial entre tablas de una base datos, pero sí los triggers.
Por medio de los triggers podemos realizar la integridad referencial.

Vamos a usar la base de datos films3.s3db, que tiene tres tablas;
Genero: Puede ser tragedia, comedia,western etc.
Soporte: Puede ser celuloide, MP3, etc.
Peliculas: Que lleva el titulo de la película.

La tabla PELICULAS tiene dependencia de GENERO y SOPORTE.
Los triggers antes de insert y antes de update en Peliculas tienen en cuenta estas dos dependencias.
El trigger film_pel_in before insert on peliculas impide insertar una película adjudicándole género o soporte no existente.

El trigger film_pel_up before update on peliculas impide modificar una película adjudicándole género o soporte no existente.

Para antes de delete hacen falta dos triggers uno en soporte y otro en genero.
El trigger film_sop_de before delete on soporte impide borrar un soporte que tenga películas.
El trigger film_gen_de before delete on genero impide borrar un genero que tenga películas.

Si la dependencia fuera de más tablas, sólo habría que añadir más OR en insert y update y los correspondientes triggers on delete.
Si solo dependiera una tabla, se quitaría un OR y el delete que sobre.

El código siguiente crearía la base de datos, sus tablas, campos y triggers.

<?php
$db = new PDO("sqlite:films.s3db");
CREATE TABLE [genero] (
[id_gen] INTEGER PRIMARY KEY NOT NULL,
[nombreGen] VARCHAR(40) UNIQUE NOT NULL
);

CREATE TABLE [soporte] (
[id_sop] INTEGER NOT NULL PRIMARY KEY,
[nombreSop] VARCHAR(20) UNIQUE NOT NULL
);

CREATE TABLE [peliculas] (
[id_pel] INTEGER NOT NULL PRIMARY KEY,
[id_genero] INTEGER NOT NULL,
[id_soporte] INTEGER NOT NULL,
[nombrePel] VARCHAR(40) NOT NULL
);

CREATE TRIGGER film_pel_in before insert on peliculas
for each row begin
select case
when
(
(new.id_soporte is not null)
and
(new.id_genero is not null)
and
(
((select id_sop from soporte where id_sop = new.id_soporte) is null)
or
((select id_gen from genero where id_gen = new.id_genero) is null)
)
)
then raise(abort,'No se inserta la película')
end;
end;

CREATE TRIGGER film_pel_up before update on peliculas
for each row begin
select case
when
(
((select id_sop from soporte where id_sop = new.id_soporte) is null)
or
((select id_gen from genero where id_gen = new.id_genero) is null)
)
then raise(abort,'No se modifica la película')
end;
end;

CREATE TRIGGER film_sop_de before delete on soporte
for each row begin
select case
when
((select id_soporte from peliculas where id_soporte = old.id_sop) is not null)
then raise(abort,'No se borra el soporte')
end;
end;

CREATE TRIGGER film_gen_de before delete on genero
for each row begin
select case
when
((select id_genero from peliculas where id_genero = old.id_gen) is not null)
then raise(abort,'No se borra el género')
end;
end;
?>