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
 reverse zone ip6.arpa.

 Updated in 2015 to conform to ISO C 2011.

 Copyright (C) 2003 Trond Endrestøl <Trond.Endrestol@ximalas.info>

 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>

void Usage(const char * const argv0, int ReturnValue) __attribute__((noreturn));
void Version(const char * const argv0) __attribute__((noreturn));
void TransformMAC(const char * const argv0, const char * const argvi);

int main(int argc, char **argv)
{
  int c;
  ssize_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"
         "reverse zone ip6.arpa.\n\n"

         "Updated in 2015 to conform to ISO C 2011.\n\n"

         "Copyright (C) 2003 Trond Endrestøl <Trond.Endrestol@ximalas.info>\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 */

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_ARPA(const unsigned char * const EUI64);
//void PrintEUI64_IP6_INT(const unsigned char * const EUI64);

void TransformMAC(const char * const argv0, const char * const argvi)
{
  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_ARPA(EUI64);
  //PrintEUI64_IP6_INT(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 = (unsigned char)*argvi++;

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

      NumDigits++;
      LSNybble = (unsigned char)*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 ConstructHexByte(unsigned char MSNybble, unsigned char LSNybble)
{
  unsigned char Byte;

  MSNybble = (unsigned char)toupper(MSNybble);
  LSNybble = (unsigned char)toupper(LSNybble);

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

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

  Byte = (unsigned char)((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_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]);

  printf("ip6.arpa/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_ARPA() */

//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() */

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