[irc/evilnet/x3.git] / src / hosthiding.c

/* hosthiding.c - Host hiding
 * Copyright 2000-2006 X3 Development Team
 *
 * This file is part of x3.
 *
 * x3 is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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 srvx; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */

#include "conf.h"
#include "common.h"
#include "hash.h"
#include "hosthiding.h"

 /* The implementation here was originally done by Gary S. Brown.  I have
    borrowed the tables directly, and made some minor changes to the
    crc32-function (including changing the interface). //ylo */

  /* ====================================================================== */
  /*  COPYRIGHT (C) 1986 Gary S. Brown.  You may use this program, or       */
  /*  code or tables extracted from it, as desired without restriction.     */
  /*                                                                        */
  /*  First, the polynomial itself and its table of feedback terms.  The    */
  /*  polynomial is                                                         */
  /*  X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0   */
  /*                                                                        */
  /*  Note that we take it "backwards" and put the highest-order term in    */
  /*  the lowest-order bit.  The X^32 term is "implied"; the LSB is the     */
  /*  X^31 term, etc.  The X^0 term (usually shown as "+1") results in      */
  /*  the MSB being 1.                                                      */
  /*                                                                        */
  /*  Note that the usual hardware shift register implementation, which     */
  /*  is what we're using (we're merely optimizing it by doing eight-bit    */
  /*  chunks at a time) shifts bits into the lowest-order term.  In our     */
  /*  implementation, that means shifting towards the right.  Why do we     */
  /*  do it this way?  Because the calculated CRC must be transmitted in    */
  /*  order from highest-order term to lowest-order term.  UARTs transmit   */
  /*  characters in order from LSB to MSB.  By storing the CRC this way,    */
  /*  we hand it to the UART in the order low-byte to high-byte; the UART   */
  /*  sends each low-bit to hight-bit; and the result is transmission bit   */
  /*  by bit from highest- to lowest-order term without requiring any bit   */
  /*  shuffling on our part.  Reception works similarly.                    */
  /*                                                                        */
  /*  The feedback terms table consists of 256, 32-bit entries.  Notes:     */
  /*                                                                        */
  /*      The table can be generated at runtime if desired; code to do so   */
  /*      is shown later.  It might not be obvious, but the feedback        */
  /*      terms simply represent the results of eight shift/xor opera-      */
  /*      tions for all combinations of data and CRC register values.       */
  /*                                                                        */
  /*      The values must be right-shifted by eight bits by the "updcrc"    */
  /*      logic; the shift must be unsigned (bring in zeroes).  On some     */
  /*      hardware you could probably optimize the shift in assembler by    */
  /*      using byte-swap instructions.                                     */
  /*      polynomial $edb88320                                              */
  /*                                                                        */
  /*  --------------------------------------------------------------------  */

static unsigned long crc32_tab[] = {
  0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
  0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
  0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
  0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
  0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
  0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
  0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
  0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
  0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
  0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
  0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
  0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
  0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
  0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
  0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
  0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
  0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
  0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
  0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
  0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
  0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
  0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
  0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
  0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
  0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
  0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
  0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
  0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
  0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
  0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
  0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
  0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
  0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
  0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
  0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
  0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
  0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
  0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
  0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
  0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
  0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
  0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
  0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
  0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
  0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
  0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
  0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
  0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
  0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
  0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
  0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
  0x2d02ef8dL
};

/* Return a 32-bit CRC of the contents of the buffer. */

unsigned long
crc32 (const unsigned char *s, unsigned int len)
{
  unsigned int i;
  unsigned long crc32val;

  crc32val = 0;
  for (i = 0; i < len; i++) {
      crc32val = crc32_tab[(crc32val ^ s[i]) & 0xff] ^ (crc32val >> 8);
  }
  return crc32val;
}


int
str2arr (char **pparv, char *string, char *delim)
{
  char *tok;
  int pparc = 0;

  tok = (char *) strtok (string, delim);
  while (tok != NULL) {
      pparv[pparc++] = tok;
      tok = (char *) strtok (NULL, delim);
  }

  return pparc;
}

/* Regular user host */
void
make_virthost (char *curr, char *host, char *virt)
{
  static char mask[HOSTLEN + 1];
  char *parv[HOSTLEN + 1], *parv2[HOSTLEN + 1], s[HOSTLEN + 1], s2[HOSTLEN + 2];
  int parc = 0, parc2 = 0, len = 0;
  unsigned int hash[8];

  if ((strlen(host) < 3) || (strlen(curr) < 3))
    return;

  strncpy (s, curr, HOSTLEN);
  strncpy (s2, host, HOSTLEN);

  parc = str2arr (parv, s, ".");
  parc2 = str2arr (parv2, s2, ".");

  hash[0] = ((crc32 ((unsigned char *)parv[3], strlen (parv[3])) + KEY2) ^ KEY) ^ KEY3;
  hash[1] = ((crc32 ((unsigned char *)parv[2], strlen (parv[2])) + KEY2) ^ KEY) ^ KEY3;

  hash[0] <<= 2;
  hash[0] >>= 2;

  hash[1] <<= 2;
  hash[1] >>= 2;

  if (parc2 == 4) {
    len = strlen (parv2[3]);
    if (strchr ("0123456789", parv2[3][len - 1])) {
       hash[2] = ((crc32 ((unsigned char *)parv[1], strlen (parv[1])) + KEY2) ^ KEY) ^ KEY3;

       hash[2] <<= 2;
       hash[2] >>= 2;

       snprintf(mask, HOSTLEN, "%x.%x.%x.IP", hash[0], hash[1], hash[2]);
    } else {
       snprintf(mask, HOSTLEN, "%x.%x.%s.%s.%s",
               hash[0], hash[1], parv2[parc2 - 3], parv2[parc2 - 2],
               parv2[parc2 - 1]);
    }
  } else {
    if (parc2 >= 4) {
      snprintf(mask, HOSTLEN, "%x.%x.%s.%s.%s",
              hash[0], hash[1], parv2[parc2 - 3], parv2[parc2 - 2],
              parv2[parc2 - 1]);
    } else {
       snprintf(mask, HOSTLEN, "%x.%x.%s.%s",
               hash[0], hash[1], parv2[parc2 - 2],
               parv2[parc2 - 1]);
    }
  }
  safestrncpy (virt, mask, HOSTLEN);
  return;
}

void
make_virtip (char *curr, char *host, char *virt)
{
  static char mask[HOSTLEN + 1];
  char *parv[HOSTLEN + 1], *parv2[HOSTLEN + 1], s[HOSTLEN + 1], s2[HOSTLEN + 2];
  int parc = 0, parc2 = 0, len = 0;
  unsigned int hash[8];

  if ((strlen(host) < 3) || (strlen(curr) < 3))
    return;

  strncpy (s, curr, HOSTLEN);
  strncpy (s2, host, HOSTLEN);

  parc = str2arr (parv, s, ".");
  parc2 = str2arr (parv2, s2, ".");

  hash[0] = ((crc32 ((unsigned char *)parv[3], strlen (parv[3])) + KEY2) ^ KEY) ^ KEY3;
  hash[1] = ((crc32 ((unsigned char *)parv[2], strlen (parv[2])) + KEY2) ^ KEY) ^ KEY3;

  hash[0] <<= 2;
  hash[0] >>= 2;

  hash[1] <<= 2;
  hash[1] >>= 2;

  len = strlen (parv2[3]);
  if (strchr ("0123456789", parv2[3][len - 1])) {
    hash[2] = ((crc32 ((unsigned char *)parv[1], strlen (parv[1])) + KEY2) ^ KEY) ^ KEY3;

    hash[2] <<= 2;
    hash[2] >>= 2;

    snprintf(mask, HOSTLEN, "%x.%x.%x.IP", hash[0], hash[1], hash[2]);
  } else {
    snprintf(mask, HOSTLEN, "%x.%x.%s.%s.%s",
            hash[0], hash[1], parv2[parc2 - 3], parv2[parc2 - 2],
            parv2[parc2 - 1]);
  }

  safestrncpy(virt, mask, SOCKIPLEN + 30);
  return;
}
Commit	Line	Data
37ef8ee3	1	/* hosthiding.c - Host hiding
	2	* Copyright 2000-2006 X3 Development Team
	3	*
	4	* This file is part of x3.
	5	*
	6	* x3 is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with srvx; if not, write to the Free Software Foundation,
	18	* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
	19	*/
	20
	21	#include "conf.h"
	22	#include "common.h"
	23	#include "hash.h"
	24	#include "hosthiding.h"
	25
	26	/* The implementation here was originally done by Gary S. Brown. I have
	27	borrowed the tables directly, and made some minor changes to the
	28	crc32-function (including changing the interface). //ylo */
	29
	30	/* ====================================================================== */
	31	/* COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or */
	32	/* code or tables extracted from it, as desired without restriction. */
	33	/* */
	34	/* First, the polynomial itself and its table of feedback terms. The */
	35	/* polynomial is */
	36	/* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
	37	/* */
	38	/* Note that we take it "backwards" and put the highest-order term in */
	39	/* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
	40	/* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
	41	/* the MSB being 1. */
	42	/* */
	43	/* Note that the usual hardware shift register implementation, which */
	44	/* is what we're using (we're merely optimizing it by doing eight-bit */
	45	/* chunks at a time) shifts bits into the lowest-order term. In our */
	46	/* implementation, that means shifting towards the right. Why do we */
	47	/* do it this way? Because the calculated CRC must be transmitted in */
	48	/* order from highest-order term to lowest-order term. UARTs transmit */
	49	/* characters in order from LSB to MSB. By storing the CRC this way, */
	50	/* we hand it to the UART in the order low-byte to high-byte; the UART */
	51	/* sends each low-bit to hight-bit; and the result is transmission bit */
	52	/* by bit from highest- to lowest-order term without requiring any bit */
	53	/* shuffling on our part. Reception works similarly. */
	54	/* */
	55	/* The feedback terms table consists of 256, 32-bit entries. Notes: */
	56	/* */
	57	/* The table can be generated at runtime if desired; code to do so */
	58	/* is shown later. It might not be obvious, but the feedback */
	59	/* terms simply represent the results of eight shift/xor opera- */
	60	/* tions for all combinations of data and CRC register values. */
	61	/* */
	62	/* The values must be right-shifted by eight bits by the "updcrc" */
	63	/* logic; the shift must be unsigned (bring in zeroes). On some */
	64	/* hardware you could probably optimize the shift in assembler by */
65	/* using byte-swap instructions. */
66	/* polynomial $edb88320 */
67	/* */
68	/* -------------------------------------------------------------------- */
69
70	static unsigned long crc32_tab[] = {
71	0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
72	0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
73	0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
74	0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
75	0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
76	0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
77	0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
78	0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
79	0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
80	0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
81	0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
82	0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
83	0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
84	0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
85	0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
86	0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
87	0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
88	0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
89	0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
90	0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
91	0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
92	0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
93	0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
94	0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
95	0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
96	0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
97	0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
98	0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
99	0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
100	0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
101	0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
102	0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
103	0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
104	0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
105	0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
106	0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
107	0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
108	0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
109	0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
110	0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
111	0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
112	0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
113	0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
114	0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
115	0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
116	0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
117	0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
118	0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
119	0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
120	0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
121	0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
122	0x2d02ef8dL
123	};
124
125	/* Return a 32-bit CRC of the contents of the buffer. */
126
127	unsigned long
128	crc32 (const unsigned char *s, unsigned int len)
129	{
130	unsigned int i;
131	unsigned long crc32val;
132
133	crc32val = 0;
134	for (i = 0; i < len; i++) {
135	crc32val = crc32_tab[(crc32val ^ s[i]) & 0xff] ^ (crc32val >> 8);
136	}
137	return crc32val;
138	}
139
140
141	int
142	str2arr (char *pparv, char string, char *delim)
143	{
144	char *tok;
145	int pparc = 0;
146
147	tok = (char *) strtok (string, delim);
148	while (tok != NULL) {
149	pparv[pparc++] = tok;
150	tok = (char *) strtok (NULL, delim);
151	}
152
153	return pparc;
154	}
155
156	/* Regular user host */
157	void
158	make_virthost (char curr, char host, char *virt)
159	{
160	static char mask[HOSTLEN + 1];
161	char parv[HOSTLEN + 1], parv2[HOSTLEN + 1], s[HOSTLEN + 1], s2[HOSTLEN + 2];
162	int parc = 0, parc2 = 0, len = 0;
163	unsigned int hash[8];
164
165	if ((strlen(host) < 3) \|\| (strlen(curr) < 3))
166	return;
167
168	strncpy (s, curr, HOSTLEN);
169	strncpy (s2, host, HOSTLEN);
170
171	parc = str2arr (parv, s, ".");
172	parc2 = str2arr (parv2, s2, ".");
173
174	hash[0] = ((crc32 ((unsigned char *)parv[3], strlen (parv[3])) + KEY2) ^ KEY) ^ KEY3;
175	hash[1] = ((crc32 ((unsigned char *)parv[2], strlen (parv[2])) + KEY2) ^ KEY) ^ KEY3;
176
177	hash[0] <<= 2;
178	hash[0] >>= 2;
179
180	hash[1] <<= 2;
181	hash[1] >>= 2;
182
183	if (parc2 == 4) {
184	len = strlen (parv2[3]);
185	if (strchr ("0123456789", parv2[3][len - 1])) {
186	hash[2] = ((crc32 ((unsigned char *)parv[1], strlen (parv[1])) + KEY2) ^ KEY) ^ KEY3;
187
188	hash[2] <<= 2;
189	hash[2] >>= 2;
190
191	snprintf(mask, HOSTLEN, "%x.%x.%x.IP", hash[0], hash[1], hash[2]);
192	} else {
193	snprintf(mask, HOSTLEN, "%x.%x.%s.%s.%s",
194	hash[0], hash[1], parv2[parc2 - 3], parv2[parc2 - 2],
195	parv2[parc2 - 1]);
196	}
197	} else {
198	if (parc2 >= 4) {
199	snprintf(mask, HOSTLEN, "%x.%x.%s.%s.%s",
200	hash[0], hash[1], parv2[parc2 - 3], parv2[parc2 - 2],
201	parv2[parc2 - 1]);
202	} else {
203	snprintf(mask, HOSTLEN, "%x.%x.%s.%s",
204	hash[0], hash[1], parv2[parc2 - 2],
205	parv2[parc2 - 1]);
206	}
207	}
208	safestrncpy (virt, mask, HOSTLEN);
209	return;
210	}
211
212	void
213	make_virtip (char curr, char host, char *virt)
214	{
215	static char mask[HOSTLEN + 1];
216	char parv[HOSTLEN + 1], parv2[HOSTLEN + 1], s[HOSTLEN + 1], s2[HOSTLEN + 2];
217	int parc = 0, parc2 = 0, len = 0;
218	unsigned int hash[8];
219
220	if ((strlen(host) < 3) \|\| (strlen(curr) < 3))
221	return;
222
223	strncpy (s, curr, HOSTLEN);
224	strncpy (s2, host, HOSTLEN);
225
226	parc = str2arr (parv, s, ".");
227	parc2 = str2arr (parv2, s2, ".");
228
229	hash[0] = ((crc32 ((unsigned char *)parv[3], strlen (parv[3])) + KEY2) ^ KEY) ^ KEY3;
230	hash[1] = ((crc32 ((unsigned char *)parv[2], strlen (parv[2])) + KEY2) ^ KEY) ^ KEY3;
231
232	hash[0] <<= 2;
233	hash[0] >>= 2;
234
235	hash[1] <<= 2;
236	hash[1] >>= 2;
237
238	len = strlen (parv2[3]);
239	if (strchr ("0123456789", parv2[3][len - 1])) {
240	hash[2] = ((crc32 ((unsigned char *)parv[1], strlen (parv[1])) + KEY2) ^ KEY) ^ KEY3;
241
242	hash[2] <<= 2;
243	hash[2] >>= 2;
244
245	snprintf(mask, HOSTLEN, "%x.%x.%x.IP", hash[0], hash[1], hash[2]);
246	} else {
247	snprintf(mask, HOSTLEN, "%x.%x.%s.%s.%s",
248	hash[0], hash[1], parv2[parc2 - 3], parv2[parc2 - 2],
249	parv2[parc2 - 1]);
250	}
251
252	safestrncpy(virt, mask, SOCKIPLEN + 30);
253	return;
254	}
255