/*
 * IGMP/ICMP/IPIP/IDP/RSVP/IPIP/IPPROTO_RAW KERNEL CHECKER
 *
 * These protocols have the same pr_usrreqs... This is a kld to monitor
 * their packets via FreeBSD kernel.
 *
 * idea & code by pIGpEN [pigpen@s0ftpj.org, deadhead@sikurezza.org ]
 *
 * Tested on FreeBSD CURRENT 4.0
 *
 * s0ftpr0ject - digital security for y2k
 * www.s0ftpj.org
 *
 * sikurezza.org - italian security mailing list
 * www.sikurezza.org
 *
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/proc.h>
#include <sys/protosw.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/sysctl.h>

#include <vm/vm_zone.h>

#include <net/if.h>
#include <net/route.h>

#define _IP_VHL
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/in_pcb.h>
#include <netinet/in_var.h>
#include <netinet/ip_var.h>
#include <netinet/ip_mroute.h>


#define    print_ip(a)  printf("%d.%d.%d.%d\n",      \
          (int)(ntohl(a) >>24) & 0xFF,  \
          (int)(ntohl(a) >>16) & 0xFF,  \
          (int)(ntohl(a) >> 8) & 0xFF,  \
          (int)(ntohl(a))  & 0xFF);


static int    rip_new_send    __P((struct socket *, int, struct mbuf *,
             struct sockaddr *, struct mbuf *,
             struct proc *));

static int    (*old_rip_send) __P((struct socket *, int, struct mbuf *,
             struct sockaddr *, struct mbuf *,
             struct proc *));

static int    rip_my_output    __P((register struct mbuf *, 
             struct socket *, u_long));

static int    s_load    __P((struct module *, int, void *));



/* il controllo si poteva fare direttamente su questa funzione.... non l'ho
   fatto perche' avevo gia' messo la mia rip_my_output nel sorgente :) */


static int
rip_new_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
   struct mbuf *control, struct proc *p)
{
  struct inpcb *inp = sotoinpcb(so);
  register u_long dst;

  if (so->so_state & SS_ISCONNECTED) {
    if (nam) {
      m_freem(m);
      return EISCONN;
    }
    dst = inp->inp_faddr.s_addr;
  } else {
    if (nam == NULL) {
      m_freem(m);
      return ENOTCONN;
    }
    dst = ((struct sockaddr_in *)nam)->sin_addr.s_addr;
  }
  return rip_my_output(m, so, dst);
}

static int
rip_my_output(m, so, dst)
  register struct mbuf *m;
  struct socket *so;
  u_long dst;
{
  register struct ip *ip;
  register struct inpcb *inp = sotoinpcb(so);
  int flags = (so->so_options & SO_DONTROUTE) | IP_ALLOWBROADCAST;



  switch(inp->inp_ip_p) {
    case IPPROTO_RAW:  printf("RAW");
           break;
    case IPPROTO_ICMP: printf("ICMP");
           break;
    case IPPROTO_IGMP: printf("IGMP");
           break;
    case IPPROTO_RSVP: printf("RSVP");
           break;
    case IPPROTO_IPIP: printf("IPIP");
           break;
    case IPPROTO_IDP:  printf("IDP");
           break;           
    default:     printf("#%d", inp->inp_ip_p);
           break;
  }
  
  printf(" -> ");       print_ip(dst);
  
  /*
   * If the user handed us a complete IP packet, use it.
   * Otherwise, allocate an mbuf for a header and fill it in.
   */
  if ((inp->inp_flags & INP_HDRINCL) == 0) {
    if (m->m_pkthdr.len + sizeof(struct ip) > IP_MAXPACKET) {
      m_freem(m);
      return(EMSGSIZE);
    }
    M_PREPEND(m, sizeof(struct ip), M_WAIT);
    ip = mtod(m, struct ip *);
    ip->ip_tos = 0;
    ip->ip_off = 0;
    ip->ip_p = inp->inp_ip_p;
    ip->ip_len = m->m_pkthdr.len;
    ip->ip_src = inp->inp_laddr;
    ip->ip_dst.s_addr = dst;
    ip->ip_ttl = MAXTTL;
  } else {
    if (m->m_pkthdr.len > IP_MAXPACKET) {
      m_freem(m);
      return(EMSGSIZE);
    }
    ip = mtod(m, struct ip *);
    /* don't allow both user specified and setsockopt options,
       and don't allow packet length sizes that will crash */
    if (((IP_VHL_HL(ip->ip_vhl) != (sizeof (*ip) >> 2)) 
         && inp->inp_options)
        || (ip->ip_len > m->m_pkthdr.len)
        || (ip->ip_len < (IP_VHL_HL(ip->ip_vhl) << 2))) {
      m_freem(m);
      return EINVAL;
    }
    if (ip->ip_id == 0)
      ip->ip_id = htons(ip_id++);
    /* XXX prevent ip_output from overwriting header fields */
    flags |= IP_RAWOUTPUT;
    ipstat.ips_rawout++;
  }


  
  return (ip_output(m, inp->inp_options, &inp->inp_route, flags,
        inp->inp_moptions));
}



extern struct   protosw   inetsw[];

static int
s_load (struct module *module, int cmd, void *arg)
{
 int s;

 switch(cmd) {
  case MOD_LOAD:  
    s=splnet();
    old_rip_send = inetsw[ip_protox[IPPROTO_ICMP]].pr_usrreqs->pru_send;
    inetsw[ip_protox[IPPROTO_ICMP]].pr_usrreqs->pru_send = rip_new_send;
      splx(s);
    break;
      
  case MOD_UNLOAD:
    s=splnet();
    inetsw[ip_protox[IPPROTO_ICMP]].pr_usrreqs->pru_send = old_rip_send;
     splx(s);
    break;
 }

 return 0;
}

static moduledata_t s_mod_1 = {
          "raww_mod",
          s_load,
          0
};

DECLARE_MODULE(raww_mod, s_mod_1, SI_SUB_PSEUDO, SI_ORDER_ANY);