mac2eui64/trunk/mac2eui64.c

/*
 mac2eui64.c 

 Conversion from the IEEE 802 MAC format to the IEEE EUI-64 format.
 Displays values suitable for use as a 64 bit interface ID in A6 RRs.
 Also displayed are labels suitable for use with PTR RRs in the
 two defined reverse zones ip6.arpa (A6) and ip6.int (AAAA).

 Copyright (C) 2003 Trond Endrestøl <trond@ramstind.gtf.ol.no>

 This program 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 this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.

 $Ximalas$
*/
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char **argv)
{
  void Usage(const char * const argv0, int ReturnValue);
  void Version(const char * const argv0);
  void TransformMAC(const char * const argv0, const char * const argvi);

  int c;
  size_t i;

  opterr = 0;
  while ((c = getopt(argc, argv, "hv")) != -1) {
    switch (c) {
      case 'h':
        Usage(argv[0], EXIT_SUCCESS);
        break;

      case 'v':
        Version(argv[0]);
        break;

      case '?':
        fprintf(stderr, "%s: invalid option -%c\n", argv[0], optopt);
        break;

      default:
        fprintf(stderr, "%s: something is dead wrong with getopt() or with this program\n", argv[0]);
        return EXIT_FAILURE;
        break;
      }
    }

  i = optind;

  if (i == argc)
    Usage(argv[0], EXIT_FAILURE);

  TransformMAC(argv[0], argv[i++]);

  while (i < argc) {
    puts("");
    TransformMAC(argv[0], argv[i++]);
    }

  return EXIT_SUCCESS;
} /* main() */

void Usage(const char * const argv0, int ReturnValue)
{
  fprintf((ReturnValue == EXIT_SUCCESS) ? stdout : stderr,
          "Usage: %s [-h | -v | <macaddress1> [macaddress2] ... [macaddressN]]\n\n"

          "Options:\n"
          "-h      show this help\n"
          "-v      display version and copyright\n\n"

          "MAC addresses must consist of 12 hex digits with leading zeroes.\n"
          "Any punctuation is ignored. Examples of valid MAC addresses:\n\n"

          "  00:50:DA:2C:8F:55\n"
          "  00-50-DA-2C-8F-55\n"
          "  0050.DA2C.8F55\n"
          "  0050DA2C8F55\n",
          argv0);
  exit(ReturnValue);
} /* Usage() */

void Version(const char * const argv0)
{
  printf("%s version 1.0\n\n"

         "Conversion from the IEEE 802 MAC format to the IEEE EUI-64 format.\n"
         "Displays values suitable for use as a 64 bit interface ID in A6 RRs.\n"
         "Also displayed are labels suitable for use with PTR RRs in the\n"
         "two defined reverse zones ip6.arpa (A6) and ip6.int (AAAA).\n\n"

         "Copyright (C) 2003 Trond Endrestøl <trond@ramstind.gtf.ol.no>\n\n"

         "This program is free software; you can redistribute it and/or modify\n"
         "it under the terms of the GNU General Public License as published by\n"
         "the Free Software Foundation; either version 2 of the License, or\n"
         "(at your option) any later version.\n\n"

         "This program is distributed in the hope that it will be useful,\n"
         "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
         "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
         "GNU General Public License for more details.\n\n"

         "You should have received a copy of the GNU General Public License\n"
         "along with this program; if not, write to the Free Software\n"
         "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.\n",
         argv0);

  exit(EXIT_SUCCESS);
} /* Version */

void TransformMAC(const char * const argv0, const char * const argvi)
{
  int ConstructMAC(const char *argvi, unsigned char *MAC);
  void ConstructEUI64(const unsigned char * const MAC, unsigned char * const EUI64);
  void InvertUniversalLocalBit(unsigned char * const EUI64);

  void PrintMAC(const unsigned char * const MAC);
  void PrintEUI64(const unsigned char * const EUI64);
  void PrintEUI64_InterfaceID(const unsigned char * const EUI64);
  void PrintEUI64_IP6_INT(const unsigned char * const EUI64);
  void PrintEUI64_IP6_ARPA(const unsigned char * const EUI64);

  unsigned char MAC[6], EUI64[8];

  if (ConstructMAC(argvi, MAC)) {
    fprintf(stderr, "%s: invalid MAC address: %s\n", argv0, argvi);
    return;
    }

  ConstructEUI64(MAC, EUI64);

  PrintMAC(MAC);
  PrintEUI64(EUI64);

  /* Transform the EUI-64 address into
     the Modified EUI-64 address for use as
     the value for the interface ID */
  InvertUniversalLocalBit(EUI64);

  PrintEUI64_InterfaceID(EUI64);
  PrintEUI64_IP6_INT(EUI64);
  PrintEUI64_IP6_ARPA(EUI64);
} /* TransformMAC() */

int ConstructMAC(const char *argvi, unsigned char * MAC)
{
  unsigned char ConstructHexByte(unsigned char MSNybble, unsigned char LSNybble);

  int ReturnValue = EXIT_SUCCESS, NumDigits = 0;
  size_t i = 0;
  unsigned char MSNybble, LSNybble;

  while (*argvi) {
    if (isxdigit(*argvi)) {
      NumDigits++;
      MSNybble = *argvi++;

      if (!isxdigit(*argvi)) {
        break;
        }

      NumDigits++;
      LSNybble = *argvi;

      MAC[i++] = ConstructHexByte(MSNybble, LSNybble);
      }

    argvi++;
    }

  if (NumDigits != 12)
    ReturnValue = EXIT_FAILURE;

  return ReturnValue;
} /* ConstructMAC() */

unsigned char ConstructHexByte(unsigned char MSNybble, unsigned char LSNybble)
{
  unsigned char Byte;

  MSNybble = toupper(MSNybble);
  LSNybble = toupper(LSNybble);

  if (MSNybble >= 'A') {
    MSNybble = 0x0A + MSNybble - 'A';
    }
  else {
    MSNybble -= '0';
    }

  if (LSNybble >= 'A') {
    LSNybble = 0x0A + LSNybble - 'A';
    }
  else {
    LSNybble -= '0';
    }

  Byte = (MSNybble << 4) | LSNybble;

  return Byte;
} /* ConstructHexByte() */

void ConstructEUI64(const unsigned char * const MAC, unsigned char * const EUI64)
{
  EUI64[0] = MAC[0];
  EUI64[1] = MAC[1];
  EUI64[2] = MAC[2];
  EUI64[3] = 0xFF;
  EUI64[4] = 0xFE;
  EUI64[5] = MAC[3];
  EUI64[6] = MAC[4];
  EUI64[7] = MAC[5];
} /* ConstructEUI64() */

void InvertUniversalLocalBit(unsigned char * const EUI64)
{
  if (EUI64[0] & 0x02)
    EUI64[0] &= ~0x02;
  else
    EUI64[0] |= 0x02;
} /* InvertUniversalLocalBit() */

void PrintMAC(const unsigned char * const MAC)
{
  printf("MAC:\t\t%02X:%02X:%02X:%02X:%02X:%02X\n",
         MAC[0], MAC[1], MAC[2], MAC[3], MAC[4], MAC[5]);
} /* PrintMAC() */

void PrintEUI64(const unsigned char * const EUI64)
{
  printf("EUI-64:\t\t%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
         EUI64[0], EUI64[1], EUI64[2], EUI64[3],
         EUI64[4], EUI64[5], EUI64[6], EUI64[7]);
} /* PrintEUI64() */

void PrintEUI64_InterfaceID(const unsigned char * const EUI64)
{
  printf("Interface ID:\t::%02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
         EUI64[0], EUI64[1], EUI64[2], EUI64[3],
         EUI64[4], EUI64[5], EUI64[6], EUI64[7]);
} /* PrintEUI64_InterfaceID() */

void PrintEUI64_IP6_INT(const unsigned char * const EUI64)
{
  printf("ip6.int/64:\t%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x\n",
         EUI64[7] & 0x0F, EUI64[7] >> 4,
         EUI64[6] & 0x0F, EUI64[6] >> 4,
         EUI64[5] & 0x0F, EUI64[5] >> 4,
         EUI64[4] & 0x0F, EUI64[4] >> 4,
         EUI64[3] & 0x0F, EUI64[3] >> 4,
         EUI64[2] & 0x0F, EUI64[2] >> 4,
         EUI64[1] & 0x0F, EUI64[1] >> 4,
         EUI64[0] & 0x0F, EUI64[0] >> 4);
} /* PrintEUI64_IP6_INT() */

void PrintEUI64_IP6_ARPA(const unsigned char * const EUI64)
{
  printf("ip6.arpa:\t\\[x%02X%02X%02X%02X%02X%02X%02X%02X/64]\n",
         EUI64[0], EUI64[1], EUI64[2], EUI64[3],
         EUI64[4], EUI64[5], EUI64[6], EUI64[7]);
} /* PrintEUI64_IP6_ARPA() */

/* mac2eui64.c */
1	/*
2	mac2eui64.c
3
4	Conversion from the IEEE 802 MAC format to the IEEE EUI-64 format.
5	Displays values suitable for use as a 64 bit interface ID in A6 RRs.
6	Also displayed are labels suitable for use with PTR RRs in the
7	two defined reverse zones ip6.arpa (A6) and ip6.int (AAAA).
8
9	Copyright (C) 2003 Trond Endrestøl <trond@ramstind.gtf.ol.no>
10
11	This program is free software; you can redistribute it and/or modify
12	it under the terms of the GNU General Public License as published by
13	the Free Software Foundation; either version 2 of the License, or
14	(at your option) any later version.
15
16	This program is distributed in the hope that it will be useful,
17	but WITHOUT ANY WARRANTY; without even the implied warranty of
18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	GNU General Public License for more details.
20
21	You should have received a copy of the GNU General Public License
22	along with this program; if not, write to the Free Software
23	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
24
25	$Ximalas$
26	*/
27	#include <ctype.h>
28	#include <stdio.h>
29	#include <stdlib.h>
30	#include <unistd.h>
31
32	int main(int argc, char **argv)
33	{
34	void Usage(const char * const argv0, int ReturnValue);
35	void Version(const char * const argv0);
36	void TransformMAC(const char * const argv0, const char * const argvi);
37
38	int c;
39	size_t i;
40
41	opterr = 0;
42	while ((c = getopt(argc, argv, "hv")) != -1) {
43	switch (c) {
44	case 'h':
45	Usage(argv[0], EXIT_SUCCESS);
46	break;
47
48	case 'v':
49	Version(argv[0]);
50	break;
51
52	case '?':
53	fprintf(stderr, "%s: invalid option -%c\n", argv[0], optopt);
54	break;
55
56	default:
57	fprintf(stderr, "%s: something is dead wrong with getopt() or with this program\n", argv[0]);
58	return EXIT_FAILURE;
59	break;
60	}
61	}
62
63	i = optind;
64
65	if (i == argc)
66	Usage(argv[0], EXIT_FAILURE);
67
68	TransformMAC(argv[0], argv[i++]);
69
70	while (i < argc) {
71	puts("");
72	TransformMAC(argv[0], argv[i++]);
73	}
74
75	return EXIT_SUCCESS;
76	} /* main() */
77
78	void Usage(const char * const argv0, int ReturnValue)
79	{
80	fprintf((ReturnValue == EXIT_SUCCESS) ? stdout : stderr,
81	"Usage: %s [-h \| -v \| <macaddress1> [macaddress2] ... [macaddressN]]\n\n"
82
83	"Options:\n"
84	"-h show this help\n"
85	"-v display version and copyright\n\n"
86
87	"MAC addresses must consist of 12 hex digits with leading zeroes.\n"
88	"Any punctuation is ignored. Examples of valid MAC addresses:\n\n"
89
90	" 00:50:DA:2C:8F:55\n"
91	" 00-50-DA-2C-8F-55\n"
92	" 0050.DA2C.8F55\n"
93	" 0050DA2C8F55\n",
94	argv0);
95	exit(ReturnValue);
96	} /* Usage() */
97
98	void Version(const char * const argv0)
99	{
100	printf("%s version 1.0\n\n"
101
102	"Conversion from the IEEE 802 MAC format to the IEEE EUI-64 format.\n"
103	"Displays values suitable for use as a 64 bit interface ID in A6 RRs.\n"
104	"Also displayed are labels suitable for use with PTR RRs in the\n"
105	"two defined reverse zones ip6.arpa (A6) and ip6.int (AAAA).\n\n"
106
107	"Copyright (C) 2003 Trond Endrestøl <trond@ramstind.gtf.ol.no>\n\n"
108
109	"This program is free software; you can redistribute it and/or modify\n"
110	"it under the terms of the GNU General Public License as published by\n"
111	"the Free Software Foundation; either version 2 of the License, or\n"
112	"(at your option) any later version.\n\n"
113
114	"This program is distributed in the hope that it will be useful,\n"
115	"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
116	"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
117	"GNU General Public License for more details.\n\n"
118
119	"You should have received a copy of the GNU General Public License\n"
120	"along with this program; if not, write to the Free Software\n"
121	"Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.\n",
122	argv0);
123
124	exit(EXIT_SUCCESS);
125	} /* Version */
126
127	void TransformMAC(const char * const argv0, const char * const argvi)
128	{
129	int ConstructMAC(const char argvi, unsigned char MAC);
130	void ConstructEUI64(const unsigned char * const MAC, unsigned char * const EUI64);
131	void InvertUniversalLocalBit(unsigned char * const EUI64);
132
133	void PrintMAC(const unsigned char * const MAC);
134	void PrintEUI64(const unsigned char * const EUI64);
135	void PrintEUI64_InterfaceID(const unsigned char * const EUI64);
136	void PrintEUI64_IP6_INT(const unsigned char * const EUI64);
137	void PrintEUI64_IP6_ARPA(const unsigned char * const EUI64);
138
139	unsigned char MAC[6], EUI64[8];
140
141	if (ConstructMAC(argvi, MAC)) {
142	fprintf(stderr, "%s: invalid MAC address: %s\n", argv0, argvi);
143	return;
144	}
145
146	ConstructEUI64(MAC, EUI64);
147
148	PrintMAC(MAC);
149	PrintEUI64(EUI64);
150
151	/* Transform the EUI-64 address into
152	the Modified EUI-64 address for use as
153	the value for the interface ID */
154	InvertUniversalLocalBit(EUI64);
155
156	PrintEUI64_InterfaceID(EUI64);
157	PrintEUI64_IP6_INT(EUI64);
158	PrintEUI64_IP6_ARPA(EUI64);
159	} /* TransformMAC() */
160
161	int ConstructMAC(const char argvi, unsigned char MAC)
162	{
163	unsigned char ConstructHexByte(unsigned char MSNybble, unsigned char LSNybble);
164
165	int ReturnValue = EXIT_SUCCESS, NumDigits = 0;
166	size_t i = 0;
167	unsigned char MSNybble, LSNybble;
168
169	while (*argvi) {
170	if (isxdigit(*argvi)) {
171	NumDigits++;
172	MSNybble = *argvi++;
173
174	if (!isxdigit(*argvi)) {
175	break;
176	}
177
178	NumDigits++;
179	LSNybble = *argvi;
180
181	MAC[i++] = ConstructHexByte(MSNybble, LSNybble);
182	}
183
184	argvi++;
185	}
186
187	if (NumDigits != 12)
188	ReturnValue = EXIT_FAILURE;
189
190	return ReturnValue;
191	} /* ConstructMAC() */
192
193	unsigned char ConstructHexByte(unsigned char MSNybble, unsigned char LSNybble)
194	{
195	unsigned char Byte;
196
197	MSNybble = toupper(MSNybble);
198	LSNybble = toupper(LSNybble);
199
200	if (MSNybble >= 'A') {
201	MSNybble = 0x0A + MSNybble - 'A';
202	}
203	else {
204	MSNybble -= '0';
205	}
206
207	if (LSNybble >= 'A') {
208	LSNybble = 0x0A + LSNybble - 'A';
209	}
210	else {
211	LSNybble -= '0';
212	}
213
214	Byte = (MSNybble << 4) \| LSNybble;
215
216	return Byte;
217	} /* ConstructHexByte() */
218
219	void ConstructEUI64(const unsigned char * const MAC, unsigned char * const EUI64)
220	{
221	EUI64[0] = MAC[0];
222	EUI64[1] = MAC[1];
223	EUI64[2] = MAC[2];
224	EUI64[3] = 0xFF;
225	EUI64[4] = 0xFE;
226	EUI64[5] = MAC[3];
227	EUI64[6] = MAC[4];
228	EUI64[7] = MAC[5];
229	} /* ConstructEUI64() */
230
231	void InvertUniversalLocalBit(unsigned char * const EUI64)
232	{
233	if (EUI64[0] & 0x02)
234	EUI64[0] &= ~0x02;
235	else
236	EUI64[0] \|= 0x02;
237	} /* InvertUniversalLocalBit() */
238
239	void PrintMAC(const unsigned char * const MAC)
240	{
241	printf("MAC:\t\t%02X:%02X:%02X:%02X:%02X:%02X\n",
242	MAC[0], MAC[1], MAC[2], MAC[3], MAC[4], MAC[5]);
243	} /* PrintMAC() */
244
245	void PrintEUI64(const unsigned char * const EUI64)
246	{
247	printf("EUI-64:\t\t%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
248	EUI64[0], EUI64[1], EUI64[2], EUI64[3],
249	EUI64[4], EUI64[5], EUI64[6], EUI64[7]);
250	} /* PrintEUI64() */
251
252	void PrintEUI64_InterfaceID(const unsigned char * const EUI64)
253	{
254	printf("Interface ID:\t::%02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
255	EUI64[0], EUI64[1], EUI64[2], EUI64[3],
256	EUI64[4], EUI64[5], EUI64[6], EUI64[7]);
257	} /* PrintEUI64_InterfaceID() */
258
259	void PrintEUI64_IP6_INT(const unsigned char * const EUI64)
260	{
261	printf("ip6.int/64:\t%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x\n",
262	EUI64[7] & 0x0F, EUI64[7] >> 4,
263	EUI64[6] & 0x0F, EUI64[6] >> 4,
264	EUI64[5] & 0x0F, EUI64[5] >> 4,
265	EUI64[4] & 0x0F, EUI64[4] >> 4,
266	EUI64[3] & 0x0F, EUI64[3] >> 4,
267	EUI64[2] & 0x0F, EUI64[2] >> 4,
268	EUI64[1] & 0x0F, EUI64[1] >> 4,
269	EUI64[0] & 0x0F, EUI64[0] >> 4);
270	} /* PrintEUI64_IP6_INT() */
271
272	void PrintEUI64_IP6_ARPA(const unsigned char * const EUI64)
273	{
274	printf("ip6.arpa:\t\\[x%02X%02X%02X%02X%02X%02X%02X%02X/64]\n",
275	EUI64[0], EUI64[1], EUI64[2], EUI64[3],
276	EUI64[4], EUI64[5], EUI64[6], EUI64[7]);
277	} /* PrintEUI64_IP6_ARPA() */
278
279	/* mac2eui64.c */
Name	Value
svn:eol-style	native
svn:keywords	Ximalas=%H
svn:mime-type	text/plain