~ubuntu-branches/ubuntu/oneiric/openvpn/oneiric

/*

 *  OpenVPN -- An application to securely tunnel IP networks

 *             over a single TCP/UDP port, with support for SSL/TLS-based

 *             session authentication and key exchange,

 *             packet encryption, packet authentication, and

 *             packet compression.

 *

 *  Copyright (C) 2002-2010 OpenVPN Technologies, Inc. <sales@openvpn.net>

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License version 2

 *  as published by the Free Software Foundation.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program (see the file COPYING included with this

 *  distribution); if not, write to the Free Software Foundation, Inc.,

 *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include "syshead.h"

#include "dhcp.h"

#include "socket.h"

#include "error.h"

#include "memdbg.h"

static int

get_dhcp_message_type (const struct dhcp *dhcp, const int optlen)

{

  const uint8_t *p = (uint8_t *) (dhcp + 1);

  int i;

  for (i = 0; i < optlen; ++i)

    {

      const uint8_t type = p[i];

      const int room = optlen - i;

      if (type == DHCP_END)           /* didn't find what we were looking for */

	return -1;

      else if (type == DHCP_PAD)      /* no-operation */

	;

      else if (type == DHCP_MSG_TYPE) /* what we are looking for */

	{

	  if (room >= 3)

	    {

	      if (p[i+1] == 1)        /* option length should be 1 */

		return p[i+2];        /* return message type */

	    }

	  return -1;

	}

      else                            /* some other option */

	{

	  if (room >= 2)

	    {

	      const int len = p[i+1]; /* get option length */

	      i += (len + 1);         /* advance to next option */

	    }

	}

    }

  return -1;

}

static in_addr_t

do_extract (struct dhcp *dhcp, const int optlen)

{

  uint8_t *p = (uint8_t *) (dhcp + 1);

  int i;

  in_addr_t ret = 0;

  for (i = 0; i < optlen; ++i)

    {

      const uint8_t type = p[i];

      const int room = optlen - i;

      if (type == DHCP_END)

	break;

      else if (type == DHCP_PAD)

	;

      else if (type == DHCP_ROUTER)

	{

	  if (room >= 2)

	    {

	      const int len = p[i+1]; /* get option length */

	      if (len <= (room-2))

		{

		  if (!ret && len >= 4 && (len & 3) == 0)

		    {

		      memcpy (&ret, p+i+2, 4);      /* get router IP address */

		      ret = ntohl (ret);

		    }

		  memset (p+i, DHCP_PAD, len+2);    /* delete the router option by padding it out */

		}

	      i += (len + 1);         /* advance to next option */

	    }

	}

      else                            /* some other option */

	{

	  if (room >= 2)

	    {

	      const int len = p[i+1]; /* get option length */

	      i += (len + 1);         /* advance to next option */

	    }

	}

    }

  return ret;

}

static uint16_t

udp_checksum (const uint8_t *buf,

	      const int len_udp,

	      const uint8_t *src_addr,

	      const uint8_t *dest_addr)

{

  uint16_t word16;

  uint32_t sum = 0;

  int i;

  /* make 16 bit words out of every two adjacent 8 bit words and  */

  /* calculate the sum of all 16 bit words */

  for (i = 0; i < len_udp; i += 2){

    word16 = ((buf[i] << 8) & 0xFF00) + ((i + 1 < len_udp) ? (buf[i+1] & 0xFF) : 0);

    sum += word16;

  }

  /* add the UDP pseudo header which contains the IP source and destination addresses */

  for (i = 0; i < 4; i += 2){

    word16 =((src_addr[i] << 8) & 0xFF00) + (src_addr[i+1] & 0xFF);

    sum += word16;

  }

  for (i = 0; i < 4; i += 2){

    word16 =((dest_addr[i] << 8) & 0xFF00) + (dest_addr[i+1] & 0xFF);

    sum += word16; 	

  }

  /* the protocol number and the length of the UDP packet */

  sum += (uint16_t) OPENVPN_IPPROTO_UDP + (uint16_t) len_udp;

  /* keep only the last 16 bits of the 32 bit calculated sum and add the carries */

  while (sum >> 16)

    sum = (sum & 0xFFFF) + (sum >> 16);

  /* Take the one's complement of sum */

  return ((uint16_t) ~sum);

}

in_addr_t

dhcp_extract_router_msg (struct buffer *ipbuf)

{

  struct dhcp_full *df = (struct dhcp_full *) BPTR (ipbuf);

  const int optlen = BLEN (ipbuf) - (sizeof (struct openvpn_iphdr) + sizeof (struct openvpn_udphdr) + sizeof (struct dhcp));

  if (optlen >= 0

      && df->ip.protocol == OPENVPN_IPPROTO_UDP

      && df->udp.source == htons (BOOTPS_PORT)

      && df->udp.dest == htons (BOOTPC_PORT)

      && df->dhcp.op == BOOTREPLY

      && get_dhcp_message_type (&df->dhcp, optlen) == DHCPACK)

    {

      /* get the router IP address while padding out all DHCP router options */

      const in_addr_t ret = do_extract (&df->dhcp, optlen);

      /* recompute the UDP checksum */

      df->udp.check = htons (udp_checksum ((uint8_t *) &df->udp, 

					   sizeof (struct openvpn_udphdr) + sizeof (struct dhcp) + optlen,

					   (uint8_t *)&df->ip.saddr,

					   (uint8_t *)&df->ip.daddr));

      if (ret)

	{

	  struct gc_arena gc = gc_new ();

	  msg (D_ROUTE, "Extracted DHCP router address: %s", print_in_addr_t (ret, 0, &gc));

	  gc_free (&gc);

	}

      return ret;

    }

  else

    return 0;

}