---

conversion.c

Go to the documentation of this file.

/*! \file conversion.c
    This file contains various functions for converting data from one format to another.
 */

#include "conversion.h"


/* -------------------------------------------------------------------------- */
/* DEBUG MANAGEMENT                                                           */ 
/* -------------------------------------------------------------------------- */

/*! \brief Debug flag. */

static int debug = 0;

/*! \brief Default value for the log file (an empty string).
 */

static char default_log_file[] = "\0";

/*! \brief Pointer to a given zero terminated string of characters that represents the path to the log file.
 */

static char *log_file = default_log_file;

/*! \brief This is a handler to a fake loggin service.
 */

static int my_fake_syslog (const char *file, const char * fmt,...) { return 0; }

/*! \brief Logging service. by default it is assigned to the fake logging service that does nothing.
 */

static int (*my_syslog) (const char *file, const char * fmt,...) = my_fake_syslog;

/*! \brief Assign a logging service to the conversion module.
    \author Denis BEURIVE
    \param dbg Verbosity level.
    \param logfile Pointer to a zero terminated string of characters that represents the path to the log file.
    \param logger Pointer to a guven logging service.
    \remark <UL>
              <LI>If 'logger' is set to NULL, then the logging service is not activated.
              <LI>If 'logfile' is set to NULL, then the logging service is not activated.
              <LI>If 'logfile' points to an empty string, then the logging service is not activated.
            </UL>
 */

void conversion_logging_service (int dbg,
                                 char *logfile,
                                 int (*logger) (const char *file, const char * fmt,...))
{
  if ((logger != NULL) && (logfile != NULL))
  { if (logfile[0] != 0) { my_syslog = logger; log_file = logfile; } }

  debug = dbg;
}

/* -------------------------------------------------------------------------- */
/* END OF DEBUG MANAGEMENT                                                    */ 
/* -------------------------------------------------------------------------- */







/*! \brief Convert an integer (between 0 and 15 included) into the corresponding hexa character (from 0 to F).
    \author Denis BEURIVE
    \param c Integer value to convert (between 0 and 15 included).
    \return The function returns the corresponding hexa character.
 */

char int_to_char (unsigned char c)
{
  switch (c)
  {
    case 0:  return '0';
    case 1:  return '1';
    case 2:  return '2';
    case 3:  return '3';
    case 4:  return '4';
    case 5:  return '5';
    case 6:  return '6';
    case 7:  return '7';
    case 8:  return '8';
    case 9:  return '9';
    case 10: return 'A';
    case 11: return 'B';
    case 12: return 'C';
    case 13: return 'D';
    case 14: return 'E';
    case 15: return 'F';
  }

  return 0;
}

/*! \brief Convert a given hexa character (from '0' to 'F') into the corresponding integer value
           (from 0 to 15 included).
    \author Denis BEURIVE
    \param c Hexa character to convert (from '0' to 'F'). Note the c could be [0-9a-fA-F].
    \return The function returns the corresponding integer value.
 */

unsigned char char_to_int (char c)
{
  switch (c)
  {
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;

    case 'A': return 10;
    case 'B': return 11;
    case 'C': return 12;
    case 'D': return 13;
    case 'E': return 14;
    case 'F': return 15;

    case 'a': return 10;
    case 'b': return 11;
    case 'c': return 12;
    case 'd': return 13;
    case 'e': return 14;
    case 'f': return 15;
  }

  return 0xFF;
}

/*! \brief Convert a hardware address in standard ':' notation into its RAW representation.
    \author Denis BEURIVE
    \param haddr Pointer to a zero terminated string of characters that represents the hardware address in
           standard ':' notation.
    \param length Pointer to an integer that will be used to store the size (in bytes) of the RAW representation.
    \return Upon successful completion, the function returns a pointer to the RAW representation.
            The value pointed by 'lenght' is the number of bytes of the representation.
            Otherwize, the function returns the value NULL.
    \warning <UL>
               <LI>The buffer (which contains the RAW representation) is returned in a statically allocated
                   buffer,
                   which subsequent calls will overwrite. Do not try to free it!
               <LI>The maximum lenth for the RAW representation is 16 bytes.
             </UL>
 */

unsigned char* haddr_to_hexa (char *haddr, int *length)
{
  int                  len, hex, i;
  static unsigned char hexa[17];


  memset ((void*)hexa, 0, 17);
  len = strlen(haddr) + 1;

  if ((len % 3) != 0)
  {
    if (debug > 0)
    { my_syslog (log_file,
      "[DEBUG] [%s:%d] haddr_to_hexa: '%s' not multiple of 3!", __FILE__, __LINE__, haddr); }
    return NULL;
  }

  hex = len / 3;

  if (hex >= *length)
  {
    if (debug > 0)
    { my_syslog (log_file,
      "[DEBUG] [%s:%d] haddr_to_hexa: '%s' too long! (len = %d)", __FILE__, __LINE__, haddr, len); }
    return NULL;
  }

  *length = hex;

  for (i=0; i<hex; i++) { hexa[i] = (char_to_int(haddr[3*i]) << 4) | char_to_int(haddr[3*i+1]); }

  return hexa;
}

/*! \brief Convert IP address in standard numbers-and-dots notation into binary data
           (4 bytes in network byte order).
    \author Denis BEURIVE
    \param ip Pointer to a zero terminated string of characters that represents the IP address to convert.
    \return The function returns the binary representation of the IP address (in network byte order).
 */

unsigned long int get_network_ip (char *ip)
{
  struct in_addr inp;

  inet_aton (ip, &inp);
  return inp.s_addr;
}

/*! \brief Convert IP address in binary representation (4 bytes in network byte order)
           into standard numbers-and-dots notation.
    \author Denis BEURIVE
    \param ip Binary representation of the IP address to convert (4 bytes in network byte order).
    \return The function returns a zero terminated string that represents the IP address in standard
            numbers-and-dots notation.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite.
             Do not try to free it!
 */

char *get_doted_ip (unsigned long int ip)
{
  struct in_addr     add;
  static char        sip[16];

  add.s_addr = ip;
  memset ((void*)sip, 0, 16);
  strncpy (sip, inet_ntoa(add), 15);
  return sip;
}

/*! \brief Convert a list of RAW IP addresses (4 bytes in network IP order) into a string representation
           (standard numbers-and-dots notation separated by characters ':').
    \author Denis BEURIVE
    \param buffin Input buffer that contains the list of RAW IP addresses.
    \param buffout Output buffer that will receive the string representation.
    \param lenin Size (in bytes) in the input buffer.
    \param lenout Size (in bytes) in the output buffer.
    \return Upon successful completion, the function returns the value 0.
            Otherwize, the function returns the value 1.
 */

int raw_ips_to_string (unsigned char *buffin, char *buffout, int lenin, int lenout)
{
  unsigned long int *ip;
  int               nip, i;
  char              *sip;

  memset ((void*)buffout, 0, lenout);

  if (lenin % 4 != 0) { return 1; }
  nip = lenin / 4;

  if (lenout < 16 * nip) { return 1; }

  ip = (unsigned long int*)buffin;

  for (i=0; i<nip; i++)
  {
    sip = get_doted_ip (*ip);
    strcat (buffout, sip);
    if (i != nip-1) { strcat (buffout, ":"); }
    ip += 1;  
  } 

  return 0;
}

/*! \brief Convert a list of UINT32 into a succession of 4 bytes integers in network byte order.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents the list of UINT32
           (the separator is the ':').
    \param buffer_out pointer to a buffer that will receive the 4 bytes integers in network byte order.
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value. Otherwize,
            the function returns the value -1.
            If success, the returned value represents the number of UINT32.
    \remark If an error occured, look at the log file.
 */

int uint32_to_network_byte_order (char* buffer_in, char *buffer_out, int len_out)
{
  char                *pt_out;
  struct fields       fd;
  unsigned long int   v;
  int                 n, i, err;

  /* ---------------------------------------------------- */
  /* Split input string                                   */
  /* ---------------------------------------------------- */

  n = s_split(buffer_in, ":", &fd);
  if (n == -1)
  {
    my_syslog (log_file,
    "[ERROR] [%s:%d] uint32_to_network_byte_order: Could not allocate memory", __FILE__, __LINE__);
    return -1;
  }

  /* ---------------------------------------------------- */
  /* If no value to convert, then return                  */
  /* ---------------------------------------------------- */

  if (n == 0)
  {
    my_syslog (log_file,
    "[WARNING] [%s:%d] uint32_to_network_byte_order: No value to convert", __FILE__, __LINE__);
    return 0;
  }

  if (debug > 1)
  { my_syslog (log_file,
    "[DEBUG] [%s:%d] uint32_to_network_byte_order: Number of integer to convert is %d",
    __FILE__, __LINE__, n); }

  /* ---------------------------------------------------- */
  /* Make sure that len is a multiple of 4 bytes          */
  /* ---------------------------------------------------- */

  if (n*4 > len_out)
  {
    free_fields(&fd);
    my_syslog (log_file,
    "[ERROR] [%s:%d] uint32_to_network_byte_order: Size of ouput buffer is too short! %d > %d",
               __FILE__, __LINE__,
               n*4,
               len_out);
    return -1;
  } 

  memset ((void*)buffer_out, 0, len_out);

  /* ---------------------------------------------------- */
  /* Process buffer by groups of 4 bytes                  */
  /* ---------------------------------------------------- */
 
  pt_out = buffer_out;

  for (i=0; i<fd.number_of_fields; i++)
  {
    v = string2unsigned_int (fd.tabs[i], &err);
    if (err)
    {
      my_syslog (log_file,
      "[WARNING] [%s:%d] uint32_to_network_byte_order: Invalid integer (%s) - skip",
      __FILE__, __LINE__, fd.tabs[i]);
      n -= 1;
      continue;
    }

    v = htonl (v);

    if (debug > 1)
    { my_syslog (log_file,
      "[DEBUG] [%s:%d] uint32_to_network_byte_order: %s -> %X", __FILE__, __LINE__, fd.tabs[i], v); }

    memcpy ((void*)pt_out, (void*)&v, 4);
    pt_out += 4;
  }

  free_fields(&fd);
  return n;
}

/*! \brief Convert a list of IP addresses into a succession of 4 bytes integers in network byte order.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents the list of IP addresses
           (the separator is the ':').
    \param buffer_out pointer to a buffer that will receive the 4 bytes integers in network byte order.
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value. Otherwize,
            the function returns the value -1.
            If success, the returned value represents the number of IP addresses.
    \remark If an error occured, look at the log file.
 */

int ip_to_network_byte_order (char* buffer_in, char *buffer_out, int len_out)
{
  char                *pt_out;
  struct fields       fd;
  unsigned long int   v;
  int                 n, i;

  /* ---------------------------------------------------- */
  /* Split input string                                   */
  /* ---------------------------------------------------- */

  n = s_split(buffer_in, ":", &fd);
  if (n == -1)
  {
    my_syslog (log_file,
    "[ERROR] [%s:%d] ip_to_network_byte_order: Could not allocate memory", __FILE__, __LINE__);
    return -1;
  }

  /* ---------------------------------------------------- */
  /* If no value to convert, then return                  */
  /* ---------------------------------------------------- */

  if (n == 0)
  {
    my_syslog (log_file,
    "[WARNING] [%s:%d] ip_to_network_byte_order: No value to convert", __FILE__, __LINE__);
    return 0;
  }

  if (debug > 1)
  { my_syslog (log_file,
    "[DEBUG] [%s:%d] ip_to_network_byte_order: Number of IP addresses to convert is %d",
    __FILE__, __LINE__, n); }

  /* ---------------------------------------------------- */
  /* Make sure that len is a multiple of 4 bytes          */
  /* ---------------------------------------------------- */

  if (n*4 > len_out)
  {
    free_fields(&fd);
    my_syslog (log_file,
    "[ERROR] [%s:%d] ip_to_network_byte_order: Size of ouput buffer is too short! %d > %d",
               __FILE__, __LINE__,
               n*4,
               len_out);
    return -1;
  }

  memset ((void*)buffer_out, 0, len_out);

  /* ---------------------------------------------------- */
  /* Process buffer by groups of 4 bytes                  */
  /* ---------------------------------------------------- */

  pt_out = buffer_out;

  for (i=0; i<fd.number_of_fields; i++)
  {
    v = get_network_ip (fd.tabs[i]);
    memcpy ((void*)pt_out, (void*)&v, 4);

    if (debug > 1)
    { my_syslog (log_file,
      "[DEBUG] [%s:%d] ip_to_network_byte_order: %s -> %X", __FILE__, __LINE__, fd.tabs[i], v); }

    pt_out += 4;
  }

  free_fields(&fd);
  return n;
}

/*! \brief Convert hexa representation into bytes.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents a succession of bytes in hexa.
    \param buffer_out Pointer to a buffer that will receive the binary representation.
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value.
            Otherwize, the function returns the value -1.
            If success, the returned value represents the number of bytes.
    \remark If an error occured, look at the log file.
 */

int hexa_to_binary (char *buffer_in, char *buffer_out, int len_out)
{
  int    len_in, i;

  len_in = strlen(buffer_in);

  /* ---------------------------------------------------- */
  /* Sanity check                                         */
  /* Note: 2 hexa characters represent 1 byte.            */
  /* ---------------------------------------------------- */

  if (len_in == 0)
  {
    my_syslog (log_file,
    "[WARNING] [%s:%d] hexa_to_binary: No value to convert", __FILE__, __LINE__);
    return 0;
  }

  if (len_in % 2 != 0)
  {
    my_syslog (log_file,
    "[ERROR] [%s:%d] hexa_to_binary: Invalid size for input buffer (%d not multiple of 2)",
             __FILE__, __LINE__,
             len_in);
    return -1;
  }

  if (len_in/2 > len_out)
  {
    my_syslog (log_file,
    "[ERROR] [%s:%d] hexa_to_binary: Size of output buffer is too short! %d > %d",
             __FILE__, __LINE__,
             len_in/2,
             len_out);
    return -1;
  }

  /* ---------------------------------------------------- */
  /* Convert couples of hexa characters into binary       */ 
  /* ---------------------------------------------------- */

  memset ((void*)buffer_out, 0, len_out);

  for (i=0; i<len_in/2; i++) { buffer_out[i] = (char_to_int(buffer_in[2*i]) << 4) | char_to_int(buffer_in[2*i+1]); }

  return len_in/2;
}

/*! \brief Convert ASCII representation into bytes.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents a succession of bytes in ASCII.
    \param buffer_out Pointer to a buffer that will receive the binary representation.
    \param len_in Size, in bytes, of the buffer buffer_in.
           <UL>
               <LI>If you set the value of len_in to 0, then the function will consider the exact size
                   of the zero terminated string pointed by buffer_in. In other words, len_in will be set
                   to strlen(buffer_in).
               <LI>If you set the value of len_in to any positive value, then the function will consider
                   the exact number of characters specified by len_in. This feature can be used to add the
                   terminal zero.
           </UL> 
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value.
            Otherwize, the function returns the value -1.
            If success, the returned value represents the number of bytes.
    \remark If an error occured, look at the log file.
 */

int ascii_to_binary (char *buffer_in, char *buffer_out, int len_in, int len_out)
{
  if (len_in <= 0) { len_in = strlen(buffer_in); }

  /* ---------------------------------------------------- */
  /* Sanity check                                         */
  /* ---------------------------------------------------- */

  if (len_in == 0)
  {
    my_syslog (log_file,
    "[WARNING] [%s:%d] ascii_to_binary: No value to convert", __FILE__, __LINE__);
    return 0;
  }

  if (len_in >= len_out)
  {
    my_syslog (log_file,
    "[ERROR] [%s:%d] ascii_to_binary: Size of output buffer is too short! %d > %d",
             __FILE__, __LINE__,
             len_in,
             len_out);
    return -1;
  }

  if (debug > 1)
  { my_syslog (log_file,
    "[DEBUG] [%s:%d] ascii_to_binary: <%s> -> %d bytes", __FILE__, __LINE__, buffer_in, len_in); }

  /* ---------------------------------------------------- */
  /* Convert couples of hexa characters into binary       */
  /* ---------------------------------------------------- */

  memset ((void*)buffer_out, 0, len_out);
  memcpy ((void*)buffer_out, buffer_in, len_in);

  return len_in;
}


/*! \brief Convert a list of UINT16 into a succession of 2 bytes integers in network byte order.
    \author Denis BEURIVE
    \param buffer_in Zero terminated string of characters that represents the list of UINT16
           (the separator is the ':').
    \param buffer_out pointer to a buffer that will receive the 2 bytes integers in network byte order.
    \param len_out Size, in bytes, of the buffer buffer_out.
    \return Upon successful completion, the function returns a positive (>= 0) value.
            Otherwize, the function returns the value -1.
            If success, the returned value represents the number of UINT16.
    \remark If an error occured, look at the log file.
 */

int uint16_to_network_byte_order (char* buffer_in, char *buffer_out, int len_out)
{
  char                *pt_out;
  struct fields       fd;
  unsigned short int  v;
  int                 n, i, err;

  /* ---------------------------------------------------- */
  /* Split input string                                   */
  /* ---------------------------------------------------- */

  n = s_split(buffer_in, ":", &fd);
  if (n == -1)
  {
    my_syslog (log_file,
    "[ERROR] [%s:%d] uint16_to_network_byte_order: Could not allocate memory", __FILE__, __LINE__);
    return -1;
  }

  /* ---------------------------------------------------- */
  /* If no value to convert, then return                  */
  /* ---------------------------------------------------- */

  if (n == 0)
  {
    my_syslog (log_file,
    "[WARNING] [%s:%d] uint16_to_network_byte_order: No value to convert", __FILE__, __LINE__);
    return 0;
  }

  if (debug > 1)
  { my_syslog (log_file,
    "[DEBUG] [%s:%d] uint16_to_network_byte_order: Number of UINT16 to convert is %d",
             __FILE__, __LINE__,
             n);
  }

  /* ---------------------------------------------------- */
  /* Make sure that len is a multiple of 2 bytes          */
  /* ---------------------------------------------------- */

  if (n*2 > len_out)
  {
    free_fields(&fd);
    my_syslog (log_file,
    "[ERROR] [%s:%d] uint16_to_network_byte_order: Size of ouput buffer is too short! %d > %d",
             __FILE__, __LINE__,
             n*2,
             len_out);
    return -1;
  }

  memset ((void*)buffer_out, 0, len_out);

  /* ---------------------------------------------------- */
  /* Process buffer by groups of 2 bytes                  */
  /* ---------------------------------------------------- */

  pt_out = buffer_out;

  for (i=0; i<fd.number_of_fields; i++)
  {
    v = (unsigned short int) ((string2unsigned_int (fd.tabs[i], &err)) & 0x0000FFFF);
    v = htons(v);
    memcpy ((void*)pt_out, (void*)&v, 2);

    if (debug > 1)
    { my_syslog (log_file,
      "[DEBUG] [%s:%d] uint16_to_network_byte_order: %s -> %d", __FILE__, __LINE__, fd.tabs[i], v); }

    pt_out += 2;
  }

  free_fields(&fd);
  return n;
}

/*! \brief Convert a radius login into mydns ID. The conversion is :
           <ul>
             <li>s/-/--/g
             <li>s/@/-a/g
             <li>s/\./-p/g
             <li>s/_/-u/g
             <li>s/[^a-zA-Z0-9-]/-n/g
             <li>Keep only the 63 first characters.
           </ul>
    \author Denis BEURIVE
    \param radius Pointer to a zero terminated string of characters that represents the radius login to
                  convert into MyDns ID.
    \param mydns Pointer to a memory buffer used to store the converted radius login.
    \param mydns_size Number of bytes reserved for the buffer pointed by 'mydns'.
    \remark Make sure that the size of 'mydns' is long enough. You should have:
            mydns_size > 2*strlen(radius)
    
 */

#ifdef MYDNS_CONVERSION_BIN2HEX

  void radius2mydns (char *radius, char *mydns, int mydns_size)
  { bin2hex (radius, mydns, mydns_size); }

#endif

#ifdef MYDNS_CONVERSION_SPECIFIC

  void radius2mydns (char *radius, char *mydns, int mydns_size)
  {
    char c;
    int  i;

    memset ((void*)mydns, 0, mydns_size);

    /* -------------------------------------------------- */
    /* The following code is a "BRUTE force" conversion.  */ 
    /* It could have been MUCH shorter. But who cares?    */
    /* -------------------------------------------------- */

    for (i=0; i<strlen(radius); i++)
    {
      c = radius[i];

      switch (c)
      {

        case '-': strcat (mydns, "--"); break;
        case '@': strcat (mydns, "-a"); break;
        case '.': strcat (mydns, "-p"); break;
        case '_': strcat (mydns, "-u"); break;

        case 'a': strncat (mydns, radius+i, 1); break;
        case 'b': strncat (mydns, radius+i, 1); break;
        case 'c': strncat (mydns, radius+i, 1); break;
        case 'd': strncat (mydns, radius+i, 1); break;
        case 'e': strncat (mydns, radius+i, 1); break;
        case 'f': strncat (mydns, radius+i, 1); break;
        case 'g': strncat (mydns, radius+i, 1); break;
        case 'h': strncat (mydns, radius+i, 1); break;
        case 'i': strncat (mydns, radius+i, 1); break;
        case 'j': strncat (mydns, radius+i, 1); break;
        case 'k': strncat (mydns, radius+i, 1); break;
        case 'l': strncat (mydns, radius+i, 1); break;
        case 'm': strncat (mydns, radius+i, 1); break;
        case 'n': strncat (mydns, radius+i, 1); break;
        case 'o': strncat (mydns, radius+i, 1); break;
        case 'p': strncat (mydns, radius+i, 1); break;
        case 'q': strncat (mydns, radius+i, 1); break;
        case 'r': strncat (mydns, radius+i, 1); break;
        case 's': strncat (mydns, radius+i, 1); break;
        case 't': strncat (mydns, radius+i, 1); break;
        case 'u': strncat (mydns, radius+i, 1); break;
        case 'v': strncat (mydns, radius+i, 1); break;
        case 'w': strncat (mydns, radius+i, 1); break;
        case 'x': strncat (mydns, radius+i, 1); break;
        case 'y': strncat (mydns, radius+i, 1); break;
        case 'z': strncat (mydns, radius+i, 1); break;

        case 'A': strncat (mydns, radius+i, 1); break;
        case 'B': strncat (mydns, radius+i, 1); break;
        case 'C': strncat (mydns, radius+i, 1); break;
        case 'D': strncat (mydns, radius+i, 1); break;
        case 'E': strncat (mydns, radius+i, 1); break;
        case 'F': strncat (mydns, radius+i, 1); break;
        case 'G': strncat (mydns, radius+i, 1); break;
        case 'H': strncat (mydns, radius+i, 1); break;
        case 'I': strncat (mydns, radius+i, 1); break;
        case 'J': strncat (mydns, radius+i, 1); break;
        case 'K': strncat (mydns, radius+i, 1); break;
        case 'L': strncat (mydns, radius+i, 1); break;
        case 'M': strncat (mydns, radius+i, 1); break;
        case 'N': strncat (mydns, radius+i, 1); break;
        case 'O': strncat (mydns, radius+i, 1); break;
        case 'P': strncat (mydns, radius+i, 1); break;
        case 'Q': strncat (mydns, radius+i, 1); break;
        case 'R': strncat (mydns, radius+i, 1); break;
        case 'S': strncat (mydns, radius+i, 1); break;
        case 'T': strncat (mydns, radius+i, 1); break;
        case 'U': strncat (mydns, radius+i, 1); break;
        case 'V': strncat (mydns, radius+i, 1); break;
        case 'W': strncat (mydns, radius+i, 1); break;
        case 'X': strncat (mydns, radius+i, 1); break;
        case 'Y': strncat (mydns, radius+i, 1); break;
        case 'Z': strncat (mydns, radius+i, 1); break;

        case '0': strncat (mydns, radius+i, 1); break;
        case '1': strncat (mydns, radius+i, 1); break;
        case '2': strncat (mydns, radius+i, 1); break;
        case '3': strncat (mydns, radius+i, 1); break;
        case '4': strncat (mydns, radius+i, 1); break;
        case '5': strncat (mydns, radius+i, 1); break;
        case '6': strncat (mydns, radius+i, 1); break;
        case '7': strncat (mydns, radius+i, 1); break;
        case '8': strncat (mydns, radius+i, 1); break;
        case '9': strncat (mydns, radius+i, 1); break;

        default: strcat (mydns, "-n");
      }
    }

    mydns[63] = 0; 
  }

#endif

#ifdef MYDNS_CONVERSION_NOTHING

  void radius2mydns (char *radius, char *mydns, int mydns_size)
  {
    char c;
    int  i;

    memset ((void*)mydns, 0, mydns_size);

    for (i=0; i<strlen(radius); i++)
    {
      c = radius[i];

      switch (c)
      {

        case '-': strcat  (mydns, "--"); break;
        case '@': strcat  (mydns, ".");  break;
        case '_': strcat  (mydns, "-."); break;
        default : strncat (mydns, radius+i, 1);
      }
    }
  }

#endif

---