~drizzle-trunk/drizzle/development

/*

  Original copyright header listed below. This comes via rsync.

  Any additional changes are provided via the same license as the original.

  Copyright (C) 2011 Muhammad Umair

*/

/*

 * Copyright (C) 1996-2001  Internet Software Consortium.

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM

 * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL

 * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,

 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING

 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#pragma once

#include <cstdio>

#include <cstring>

#include <iostream>

namespace drizzled

{

namespace type

{

class IPv6 {

    struct ipv6_ds

    {

    	unsigned short ip6[8];

    } str;

    //Function to store the IPv4 address in IPv6 Data Structure

    int ipv4_inet_pton(const char *src)

    {

	char *ptr_src ;

	char ipv4_map_ipv6[20], ipv4[16], octet_1[5], octet_2[5], concat_octets[20];

	int octet[4], octet_index = 0 , dot_count = 0;

	static const char hex[] = "0123456789";

	const char * char_ptr_src;

	memset(ipv4_map_ipv6, 0, sizeof(ipv4_map_ipv6));

	strcpy(ipv4_map_ipv6, src);

	memset(octet, 0, sizeof(octet));

	memset(ipv4, 0, sizeof(ipv4));

	memset(octet_1, 0, sizeof(octet_1));

	memset(octet_2, 0, sizeof(octet_2));

	memset(concat_octets, 0, sizeof(concat_octets));

        ptr_src = ipv4_map_ipv6;

        if (*ptr_src == ':' && *++ptr_src != ':')

            return 0; // Invalid IP Address

        if (*ptr_src == ':' && *++ptr_src == ':')

            ++ptr_src;

	strcpy(ipv4,ptr_src);

	ptr_src = ipv4;

        while(*ptr_src != '\0')

        {

            dot_count++;

            if (*ptr_src == '.' && *++ptr_src != '.')

            {

                if (dot_count == 1)

                    return 0; // Invalid IP Address

            }

            char_ptr_src = strchr (hex, *ptr_src);

            if(char_ptr_src == NULL)

            {

                return 0; // Invalid IP Address

            }

            ++ptr_src;

        }

        ptr_src = ipv4;

	while(*ptr_src != '\0')

        {

            if ( *ptr_src == ':' && *++ptr_src == '\0')

            {

                    return 0; // Invalid IP Address

            }

            if ( *ptr_src == '.' && *++ptr_src == '\0')

            {

                    return 0; // Invalid IP Address

            }

          ++ptr_src;

        }

	ptr_src = strtok(ipv4,".");

	while (ptr_src != '\0')

	{

		sscanf(ptr_src, "%d", &octet[octet_index]);

		if(octet[octet_index++] > 255)

		{

			return 0; // Invalid IP Address

		}

		ptr_src = strtok (NULL, ".");

	}// end of main while loop

        if(octet[3] == 0)

        {

            octet[3] = octet[2];

            octet[2] = octet[1];

            octet[1] = octet[0];

            octet[0] = 0;

        }

	if(octet_index < 3 || octet_index > 4)

	{

		return 0; // Invalid IP Address

	}

	octet_index = 0;

        str.ip6[0] = str.ip6[1] = str.ip6[2] = str.ip6[3] = str.ip6[4] = str.ip6[5] = 0;

	for (int i=6 ; i <= 7; i++)

	{

		if (i == 7)

		{

			++octet_index;

		}

		sprintf(octet_1, "%02x", octet[octet_index]);

		sprintf(octet_2, "%02x", octet[++octet_index]);

		strcpy(concat_octets,octet_1);

		strcat(concat_octets,octet_2);

		sscanf(concat_octets,"%x",(unsigned int *)&str.ip6[i]);

		memset(octet_1, 0, sizeof(octet_1));

		memset(octet_2, 0, sizeof(octet_2));

		memset(concat_octets, 0, sizeof(concat_octets));

    	}

	return 1;

    }//end of ipv4_inet_pton() function

    //Function to retain the IPv4 address from IPv6 Data Structure

    char * ipv4_inet_ntop(char *destination)

    {

	memset(destination, 0, sizeof(destination));

	snprintf(destination, IPV6_BUFFER_LENGTH, "%03x:%03x:%03x:%03x:%03x:%03x:%03d.%03d.%03d.%03d" ,

	str.ip6[0],str.ip6[1],str.ip6[2],str.ip6[3],str.ip6[4],str.ip6[5],

	(((unsigned int )str.ip6[6]>>8) & 0xFF),

	((unsigned int )str.ip6[6] & 0xFF),

	(((unsigned int )str.ip6[7]>>8) & 0xFF),

	((unsigned int )str.ip6[7] & 0xFF));

	return destination;

    }// end of ipv4_inet_ntop function

    //Function to store the IPv6 address in IPv6 Data Structure

    int ipv6_inet_pton(const char *src)

    {

        if (strlen(src)> IPV6_DISPLAY_LENGTH)

        {

          return 0;   //Invalid IPaddress

        }

        //Local variables

        char ipv6[IPV6_BUFFER_LENGTH];

        memset(ipv6, 0, IPV6_BUFFER_LENGTH);

        strcpy(ipv6,src);

        char ipv6_temp[IPV6_BUFFER_LENGTH], ipv6_temp1[IPV6_BUFFER_LENGTH], ipv6_temp2[IPV6_BUFFER_LENGTH];

        memset(ipv6_temp, 0, IPV6_BUFFER_LENGTH);

        strcpy(ipv6_temp, ipv6);

        memset(ipv6_temp1, 0, IPV6_BUFFER_LENGTH);

        strcpy(ipv6_temp1, ipv6);

        memset(ipv6_temp2, 0, IPV6_BUFFER_LENGTH);

        strcpy(ipv6_temp2,ipv6);

        static const char hex[] = "0123456789abcdef";

        char temp[IPV6_BUFFER_LENGTH];

        char *ptr_src ,*ptr_char, *ptr_src1;

        const char *char_ptr_src;  // get the src char

        int char_int = 0, index_ip6 = 0, octet_count = 0, not_colon = 0, colon = 0, count_colon = 0;

        char temp_first[IPV6_BUFFER_LENGTH],temp_end[IPV6_BUFFER_LENGTH];

        memset(temp_first, 0, IPV6_BUFFER_LENGTH);

        memset(temp_end, 0, IPV6_BUFFER_LENGTH);

        ptr_src = ipv6;

        //while loop check three consective colons

         while (*ptr_src != '\0')

         {

            if (*ptr_src == ':' && *++ptr_src == ':' && *++ptr_src == ':')

            {

                return 0; // Invalid IP Address

            }

          ++ptr_src;

          }

        ptr_src = ipv6;

        //Check first colon position

        while (*ptr_src != '\0')

        {

            count_colon++;

            if (*ptr_src == ':' && *++ptr_src != ':')

            {

                if (count_colon == 1)

                    return 0; // Invalid IP Address

            }

          ++ptr_src;

        }

        ptr_src = ipv6;

        //Check last colon position

        while (*ptr_src != '\0')

        {

            if ( *ptr_src == ':' && *++ptr_src == '\0')

            {

                    return 0; // Invalid IP Address

            }

            ++ptr_src;

        }

        count_colon = 0;

        //while loop count the total number of octets

        ptr_src = strtok (ipv6_temp2,":");

        while (ptr_src != NULL)

        {

            octet_count++;

            ptr_src = strtok (NULL, ":");

        }

        //Retrun zero if total number of octets are greater than 8

        if(octet_count > 8)

        {

            return 0 ; // Invalid IP Address

        }

       bool colon_flag = true;

       ptr_src = ipv6;

	//Check the existance of consective two colons

        while (*ptr_src != '\0')

        {

            if (*ptr_src == ':' && *++ptr_src == ':')

            {

                colon_flag = false;

            }

            ++ptr_src;

        }

        if (colon_flag ==  true && octet_count < 8)

        {

            return 0;

        }

        int num_miss_octet =0;

	num_miss_octet = 8 - octet_count;

#if 0

        size = 2*num_miss_octet +1;

#endif

        std::string zero_append;

        ptr_src = ipv6_temp;

        //while loop locate the "::" position (start,middle or end)

        while(*ptr_src != '\0')

        {

            if(*ptr_src == ':' && *++ptr_src == ':')

            {

                if (*++ptr_src=='\0')

                {

                    colon =2;

                }

                else if (not_colon == 0)

                {

                    colon=1;

                }

                else

                {

                    colon=3;

                }

                count_colon++;

                if(count_colon == 2)

                {

                    return 0; // Invalid IP Address. Ther must be single time double  colon '::'

                }

            }

            ptr_src++;

            not_colon++;

        }// end of while loop

        // if colon = 0 means the IPv6 Address string is in presffered form otherwise first it covert it into prefeered form

        if(colon>0)

        {

            //zero padding format according to the '::' position

            zero_append+= "";

            for (int i= 0; i < num_miss_octet; i++)

            {

                if(colon==1) // start

                {

                    zero_append+= "0:";

                }

                if(colon==2 || colon==3)  //middle or end colon =2 shows at end

                {

                    zero_append+= ":0";

                }

            }

            if(colon==3)

            {

                zero_append+= ":";

            }

            ptr_src = temp_end;

            if(colon==1 || colon==3)

            {  //only for start and middle

              ptr_src1 = strstr (ipv6_temp,"::");

              ptr_src1 = ptr_src1+2;

              while(*ptr_src1 != '\0')

              {

                *ptr_src++ = *ptr_src1++;

                if(*ptr_src1 == '\0')

                {

                    *ptr_src ='\0';

                }

              }

            }

            //copy the input IPv6 string before and after '::'

            ptr_src1 = strstr (ipv6_temp1,"::");

            *ptr_src1 ='\0';

            strcpy(temp_first,ipv6_temp1);

            if(colon==2) // end

            {

                strcat(temp_first, zero_append.c_str());

            }

            else

            {

                strcat(temp_first, zero_append.c_str());

                strcat(temp_first,temp_end);

            }

            memset(ipv6, 0, IPV6_BUFFER_LENGTH);

            strcpy(ipv6,temp_first);

        }// end of main if statement

        //while loop store each octet on ipv6 struture in decimal value of hexadecimal digits

        ptr_char = temp;

        ptr_src = strtok (ipv6,":");

        while (ptr_src != NULL)

        {

                strcpy(temp, ptr_src);

                ptr_char = temp;

                int octet_length = strlen(ptr_char);

                *(ptr_char + octet_length) = '\0';

                while(*ptr_char != '\0')

                {

                    char_int = tolower(*ptr_char);

                    char_ptr_src = strchr (hex, char_int);

                    if(char_ptr_src == NULL)

                    {

                        return 0; // Invalid IP Address

                    }

                        *ptr_char = *char_ptr_src;

                        ptr_char++;

                }//end of inner while loop

                ptr_char -= octet_length;

                unsigned int ptr_char_val = 0;

                sscanf(ptr_char, "%x", (unsigned int *)&ptr_char_val);

                //check if "xxxx" value greater than "ffff=65535"

                if (ptr_char_val > 65535)

                {

                    str.ip6[0] = str.ip6[1] = str.ip6[2] = str.ip6[3] = str.ip6[4] = str.ip6[5] = str.ip6[6] = str.ip6[7] = 0;

                    return 0;

                }

                unsigned int *ptr = (unsigned int *)&(str.ip6[index_ip6++]);

                sscanf(ptr_char, "%x", ptr);

                memset(temp, 0, IPV6_BUFFER_LENGTH);

                ptr_src = strtok (NULL, ":");

        }// end of main while loop

        return 1;

    }// end of Ipv6_Inet_pton function

    //Function to retain the IPv6 address from IPv6 Data Structure

    char* ipv6_inet_ntop(char *destination)

    {

        char temp[10];

        memset(temp, 0, sizeof(temp));

        memset(destination, 0, IPV6_BUFFER_LENGTH);

        for (int i= 0; i <= 7; i++)

        {

            if(i==7)

            {

                sprintf(temp,"%04x",str.ip6[i]);

                strcat(destination,temp);

            }

            else

            {

                sprintf(temp,"%04x:",str.ip6[i]);

                strcat(destination,temp);

            }

            memset(temp, 0, sizeof(temp));

        }

        return destination;

    }// end of Ipv6_Inet_ntop function

    public:

    IPv6()

    {

        str.ip6[0] = str.ip6[1] = str.ip6[2] = str.ip6[3] = str.ip6[4] = str.ip6[5] = str.ip6[6] = str.ip6[7] = 0;

    }

    void store_object(unsigned char *out)

    {

        memcpy(out, (unsigned char *)&str, sizeof(str));

    }

    void restore_object(const unsigned char * in)

    {

    	memcpy(&str, (struct ipv6_ds *)in,  sizeof(str));

    }

    int inet_pton(const char *ip)

    {

         char * pch;

         pch=strchr((char *)ip,'.');

         if(pch == NULL)

         {

            return ipv6_inet_pton(ip);

         }

         else

         {

            return ipv4_inet_pton(ip);

         }

    }

    char * inet_ntop(char *dest)

    {

        if (str.ip6[0]==0 && str.ip6[1]==0 && str.ip6[2]==0 && str.ip6[3]==0 && str.ip6[4]==0 && str.ip6[5]==0 && str.ip6[6]!=0)

        {

            return ipv4_inet_ntop(dest);

        }

       else

        {

            return ipv6_inet_ntop(dest);

        }

    }

    static const size_t LENGTH= 16;

    static const size_t IPV6_DISPLAY_LENGTH= 39;

    static const size_t IPV6_BUFFER_LENGTH= IPV6_DISPLAY_LENGTH+1;

};  // endof class

} /* namespace type */

} /* namespace drizzled */