Provided by: libnet-mac-vendor-perl_1.262-1_all bug

NAME

       Net::MAC::Vendor - look up the vendor for a MAC

SYNOPSIS

               use Net::MAC::Vendor;

               my $mac = "00:0d:93:29:f6:c2";

               my $array = Net::MAC::Vendor::lookup( $mac );

       You can also run this as a script with as many arguments as you like. The module realizes
       it is a script, looks up the information for each MAC, and outputs it.

               perl Net/MAC/Vendor.pm 00:0d:93:29:f6:c2 00:0d:93:29:f6:c5

DESCRIPTION

       The Institute of Electrical and Electronics Engineers (IEEE) assigns an Organizational
       Unique Identifier (OUI) to manufacturers of network interfaces. Each interface has a Media
       Access Control (MAC) address of six bytes. The first three bytes are the OUI.

       This module allows you to take a MAC address and turn it into the OUI and vendor
       information. You can, for instance, scan a network, collect MAC addresses, and turn those
       addresses into vendors. With vendor information, you can often guess at what what you are
       looking at (e.g. an Apple product).

       You can use this as a module as its individual functions, or call it as a script with a
       list of MAC addresses as arguments. The module can figure it out.

       The IEEE moves the location of its OUI file. If they do that again, you can set the
       "NET_MAC_VENDER_OUI_URL" environment variable to get the new URL without updating the
       code.

       Here are some of the old URLs, which also flip-flop schemes:

               http://standards.ieee.org/regauth/oui/oui.txt
               https://standards.ieee.org/regauth/oui/oui.txt
               http://standards-oui.ieee.org/oui.txt

       There are older copies of the OUI file in the GitHub repository.

       These files are large (about 4MB), so you might want to cache a copy.

       A different source of information is linuxnet.ca that publishes sanitized and compressed
       versions of the list, such as:

               http://linuxnet.ca/ieee/oui.txt.bz2

       The module can read and decompress compressed versions (as long as the url reflects the
       compression type in the filename as the linuxnet.ca links do).

   Functions
       run( @macs )
           If I call this module as a script, this class method automatically runs. It takes the
           MAC addresses and prints the registered vendor information for each address. I can
           pass it a list of MAC addresses and run() processes each one of them. It prints out
           what it discovers.

           This method does try to use a cache of OUI to cut down on the times it has to access
           the network. If the cache is fully loaded (perhaps using "load_cache"), it may not
           even use the network at all.

       ua  Return the Mojo::UserAgent object used to fetch resources.

       lookup( MAC )
           Given the MAC address, return an anonymous array with the vendor information. The
           first element is the vendor name, and the remaining elements are the address lines.
           Different records may have different numbers of lines, although the first two should
           be consistent.

           This makes a direct request to the IEEE website for that OUI to return the information
           for that vendor.

           The "normalize_mac()" function explains the possible formats for MAC.

       normalize_mac( MAC )
           Takes a MAC address and turns it into the form I need to send to the IEEE lookup,
           which is the first six bytes in hex separated by hyphens. For instance,
           00:0d:93:29:f6:c2 turns into 00-0D-93.

           The input string can be a separated by colons or hyphens. They can omit leading 0's
           (which might make things look odd). We only need the first three bytes

                   00:0d:93:29:f6:c2   # usual form

                   00-0d-93-29-f6-c2   # with hyphens

                   00:0d:93            # first three bytes

                   0:d:93              # missing leading zero

                   :d:93               # missing all leading zeros

       fetch_oui( MAC )
           Looks up the OUI information on the IEEE website, or uses a cached version of it. Pass
           it the result of "normalize_mac()" and you should be fine.

           The "normalize_mac()" function explains the possible formants for MAC.

           To avoid multiple calls on the network, use "load_cache" to preload the entire OUI
           space into an in-memory cache. This can take a long time over a slow network, though;
           the file is about 60,000 lines.

           Also, the IEEE website has been flaky lately, so loading the cache is better. This
           distribution comes with several versions of the complete OUI data file.

       fetch_oui_from_custom( MAC, [ URL ] )
           Looks up the OUI information from the specified URL or the URL set in the
           "NET_MAC_VENDOR_OUI_SOURCE" environment variable.

           The "normalize_mac()" function explains the possible formants for MAC.

       fetch_oui_from_ieee( MAC )
           Looks up the OUI information on the IEEE website. Pass it the result of
           "normalize_mac()" and you should be fine.

           The "normalize_mac()" function explains the possible formants for MAC.

       fetch_oui_from_cache( MAC )
           Looks up the OUI information in the cached OUI information (see "load_cache").

           The "normalize_mac()" function explains the possible formats for MAC.

           To avoid multiple calls on the network, use "load_cache" to preload the entire OUI
           space into an in-memory cache.

           If it doesn't find the MAC in the cache, it returns nothing.

       extract_oui_from_html( HTML, OUI )
           Gets rid of the HTML around the OUI information. It may still be ugly. The HTML is the
           search results page of the IEEE ouisearch lookup.

           Returns false if it could not extract the information. This could mean unexpected
           input or a change in format.

       parse_oui( STRING )
           Takes a string that looks like this:

                   00-03-93   (hex)            Apple Computer, Inc.
                   000393     (base 16)        Apple Computer, Inc.
                                                                           20650 Valley Green Dr.
                                                                           Cupertino CA 95014
                                                                           UNITED STATES

           and turns it into an array of lines. It discards the first line, strips the leading
           information from the second line, and strips the leading whitespace from all of the
           lines.

           With no arguments, it returns an empty anonymous array.

       oui_url
       oui_urls
           Returns the URLs of the oui.txt resource. The IEEE likes to move this around. These
           are the default URL that "load_cache" will use, but you can also supply your own with
           the "NET_MAC_VENDOR_OUI_URL" environment variable.

       load_cache( [ SOURCE[, DEST ] ] )
           Downloads the current list of all OUIs in SOURCE, parses it with "parse_oui()", and
           stores it in the cache. The "fetch_oui()" will use this cache if it exists.

           By default, this uses the URL from "oui_url", but given an argument, it tries to use
           that.

           If the url indicates that the data is compressed, the response content is decompressed
           before being stored.

           If "load_cache" cannot load the data, it issues a warning and returns nothing.

           This previously used DBM::Deep if it was installed, but that was much too slow.
           Instead, if you want persistence, you can play with $Net::MAC::Vendor::Cached
           yourself.

           If you want to store the data fetched for later use, add a destination filename to the
           request. To fetch from the default location and store, specify "undef" as source.

Caching

       Eventually I want people to write their own caching classes so I've created some class
       methods for this.

       add_to_cache( OUI, PARSED_DATA )
           Add to the cache. This is mostly in place for a future expansion to full objects so
           you can override this in a subclass.

       get_from_cache( OUI )
           Get from the cache. This is mostly in place for a future expansion to full objects so
           you can override this in a subclass.

       get_cache_hash()
           Get the hash the built-in cache uses. You should only use this if you were using the
           old $Cached package variable.

SEE ALSO

       Net::MacMap

SOURCE AVAILABILITY

       The source is in Github:

               git://github.com/briandfoy/net-mac-vendor.git

AUTHOR

       brian d foy "<bdfoy@cpan.org>"

COPYRIGHT AND LICENSE

       Copyright © 2004-2017, brian d foy "<bdfoy@cpan.org>". All rights reserved.

       This program is free software; you can redistribute it under the Artistic License 2.0. A
       license file should have come with this distribution.