MAC vendor lookup: Difference between revisions

=={{header|Ada}}==

{{libheader|AWS}}

 

with AWS.Client;

Lookup ("23-45-67"); delay 1.500;

Lookup ("foobar");

{{out}}

<pre>88:53:2E:67:07:BE Intel Corporate

Normally something like this would just be mapping the lookup across an array, but that doesn't let us control the timing of the request dispatch. To insert a delay between requests we have to create a traditional function ("tradfn") with a for loop.

 

]load HttpCommand

 

⍝ the result is an array (a 1-row by N-column matrix). to print out one vendor

⍝ per line, we reshape it to be N rows by 1 column instead.

 

{{Out}}

=={{header|AppleScript}}==

set macList to {"88:53:2E:67:07:BE", "D4:F4:6F:C9:EF:8D", ¬

"FC:FB:FB:01:FA:21", "4c:72:b9:56:fe:bc", "00-14-22-01-23-45"}

set text item delimiters to linefeed

return table as string

 

If this is part of a larger script you probably want to save and restore the text item delimiters:

 

set text item delimiters to linefeed

set tableText to table as string

set text item delimiters to savedTID

 

{{out}}

=={{header|Arturo}}==

 

print [mac "=>" read ~"http://api.macvendors.com/|mac|"]

pause 1500

 

{{out}}

 

=={{header|AutoHotkey}}==

WebRequest := ComObjCreate("WinHttp.WinHttpRequest.5.1")

WebRequest.Open("GET", "http://api.macvendors.com/" MAC)

WebRequest.Send()

return WebRequest.ResponseText

Outputs:<pre>Dell Inc.</pre>

 

=={{header|BaCon}}==

This code requires BaCon 3.8.2 or higher.

 

website$ = "api.macvendors.com"

CLOSE NETWORK mynet

 

{{out}}

<pre>Hon Hai Precision Ind. Co.,Ltd.</pre>

=={{header|C}}==

Takes MAC address as input, prints usage on incorrect invocation, requires [https://curl.haxx.se/libcurl/ libcurl]

#include <curl/curl.h>

#include <string.h>

return EXIT_FAILURE;

}

Invocation and output :

<pre>

=={{header|C sharp|C#}}==

 

using System.Net;

using System.Net.Http;

Console.ReadLine();

}

 

{{out}}

=={{header|C++}}==

{{libheader|Boost}}

// the Boost documentation.

 

}

return EXIT_FAILURE;

 

{{out}}

 

=={{header|Common Lisp}}==

 

(defun mac-vendor (mac)

(format t "~%Vendor is ~a" vendor)

(error "~%Not a MAC address: ~a" mac))))

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| IdHttp}}

program MAC_Vendor_Lookup;

 

Writeln(macLookUp('BC:5F:F4'));

readln;

{{out}}

<pre>Samsung Electronics Co.,Ltd

 

=={{header|Factor}}==

sequences threads ;

 

"FC:FB:FB:01:FA:21"

"10-11-22-33-44-55-66"

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

Var f = Freefile

Dim As String tmp

Next i

Sleep

{{out}}

<pre>

 

=={{header|Free Pascal}}==

 

uses

end;

end;

 

{{out}}

 

=={{header|Go}}==

 

import (

fmt.Println(macLookUp("BC:5F:F4"))

}

{{Out}}

<pre>Samsung Electronics Co.,Ltd

{{libheader|http-client}}

 

{- stack

script

putStr $ printf "%-17s" mac ++ " = "

vendor <- lookupMac mgr mac

 

{{Out}}

=={{header|J}}==

'''Solution

'''Example Usage

(,&' ' , lookupMACvendor)&> addr

88:53:2E:67:07:BE Intel Corporate

FC:FB:FB:01:FA:21 Cisco Systems, Inc

D4:F4:6F:C9:EF:8D Apple, Inc.

 

=={{header|Java}}==

 

import java.io.BufferedReader;

}

}

 

=={{header|Javascript}}==

var mac = "88:53:2E:67:07:BE";

function findmac(){

 

findmac();

{{out}}

<pre>Intel Corporate</pre>

 

=={{header|Julia}}==

 

using Requests

for addr in ["88:53:2E:67:07:BE", "FC:FB:FB:01:FA:21", "D4:F4:6F:C9:EF:8D", "23:45:67"]

println("$addr -> ", getvendor(addr))

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.net.URL

val macs = arrayOf("FC-A1-3E", "FC:FB:FB:01:FA:21", "88:53:2E:67:07:BE", "D4:F4:6F:C9:EF:8D")

for (mac in macs) println(lookupVendor(mac))

 

{{out}}

=={{header|Logo}}==

{{works with|UCB Logo}}

make "mac_list [88:53:2E:67:07:BE D4:F4:6F:C9:EF:8D FC:FB:FB:01:FA:21

4c:72:b9:56:fe:bc 00-14-22-01-23-45]

]

bye

{{Out}}

<pre>Intel Corporate

 

=={{header|Lua}}==

-- Created by James A. Donnell Jr.

-- www.JamesDonnell.com

 

local macAddress = "FC-A1-3E-2A-1C-33"

 

=={{header|M2000 Interpreter}}==

Module Checkit {

httpGet$=lambda$ (url$, timeout=500)->{

}

Checkit

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Outputs:<pre>Dell Inc.</pre>

 

=={{header|Nim}}==

 

 

for mac in ["FC-A1-3E", "FC:FB:FB:01:FA:21", "BC:5F:F4"]:

 

{{out}}

</pre>

=={{header|OCaml}}==

(* build with ocamlfind ocamlopt -package netclient -linkpkg macaddr.ml -o macaddr *)

 

 

 

{{out}}

<pre>

 

=={{header|Perl}}==

use v5.18.2;

use warnings;

# }

# return;

 

{{out}}

=={{header|Phix}}==

{{libheader|Phix/libcurl}}

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- libcurl</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">test</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"00-11-22-33-44-55-66"</span> <span style="color: #000080;font-style:italic;">-- CIMSYS Inc

<span style="color: #7060A8;">curl_easy_cleanup</span><span style="color: #0000FF;">(</span><span style="color: #000000;">curl</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">curl_global_cleanup</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

=={{header|PHP}}==

{{trans|AppleScript}}

$apiRoot = "https://api.macvendors.com";

$macList = array("88:53:2E:67:07:BE", "D4:F4:6F:C9:EF:8D",

}

curl_close($curl);

 

{{Out}}

=={{header|PowerShell}}==

{{trans|AppleScript}}

$macAddresses = @("88:53:2E:67:07:BE", "D4:F4:6F:C9:EF:8D",

"FC:FB:FB:01:FA:21", "4c:72:b9:56:fe:bc",

(Invoke-WebRequest "$apiRoot/$_").Content

Start-Sleep 1.5

 

{{Out}}

{{libheader|requests}}

 

 

for addr in ['88:53:2E:67:07:BE', 'FC:FB:FB:01:FA:21',

'D4:F4:6F:C9:EF:8D', '23:45:67']:

vendor = requests.get('http://api.macvendors.com/' + addr).text

{{out}}

<pre>88:53:2E:67:07:BE Intel Corporate

 

=={{header|Racket}}==

 

(require net/url)

"FC:FB:FB:01:FA:21"

"D4:F4:6F:C9:EF:8D"))))

 

{{out}}

Apparently there is some rate limiting on place now, sleep a bit between requests.

 

my $ua = HTTP::UserAgent.new;

00:0d:4b

23:45:67

{{out}}

<pre>ASRock Incorporation

 

=={{header|Red}}==

{{out}}

<pre>MAC address: 88:53:2E:67:07:BE

=={{header|REXX}}==

This REXX version only works under Microsoft Windows and Regina REXX.

win_command = 'getmac' /*name of the Microsoft Windows command*/

win_command_options = '/v /fo list' /*options of " " " */

if maker=. | MACaddr==. then say 'MAC address manufacturer not found.'

else say 'manufacturer for MAC address ' MACaddr " is " maker

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

# Project: MAC Vendor Lookup

 

url = download("api.macvendors.com/" + mac)

see url + nl

Output:

<pre>

 

=={{header|Ruby}}==

 

arr = ['88:53:2E:67:07:BE', 'FC:FB:FB:01:FA:21', 'D4:F4:6F:C9:EF:8D', '23:45:67']

vendor = Net::HTTP.get('api.macvendors.com', "/#{addr}/") rescue nil

puts "#{addr} #{vendor}"

{{out}}

<pre>88:53:2E:67:07:BE Intel Corporate

 

=={{header|Rust}}==

 

use std::{thread, time};

}

}

Output:

<pre>

 

=={{header|Scala}}==

val macs = Seq("FC-A1-3E", "FC:FB:FB:01:FA:21", "88:53:2E:67:07:BE", "D4:F4:6F:C9:EF:8D")

 

 

macs.foreach(mac => println(lookupVendor(mac)))

 

=={{header|Scheme}}==

{{works with|Chicken Scheme}}

{{libheader|http-client}}

(define api-root "http://api.macvendors.com")

(define mac-addresses '("88:53:2E:67:07:BE" "D4:F4:6F:C9:EF:8D"

(newline)

(map (lambda (burger) (sleep 2) (display (get-vendor burger)) (newline))

{{Out}}

<pre>Intel Corporate

 

=={{header|Tcl}}==

 

# finally is a bit like go's defer

foreach mac {00-14-22-01-23-45 88:53:2E:67:07:BE} {

puts "$mac\t[maclookup $mac]"

{{out}}

{{works with|Z Shell}}

Surprising that nobody had implemented the Bash / Shell version yet.

4c:72:b9:56:fe:bc 00-14-22-01-23-45)

 

sleep 2

lookup "$burger"

 

It can be made to work in a pure-POSIX shell without array variables:

{{works with|Bourne Shell}}

{{works with|Almquist Shell}}

4c:72:b9:56:fe:bc 00-14-22-01-23-45

 

sleep 2

curl -s "http://api.macvendors.com/$burger" && echo

 

And hey, just for completeness, let's toss in a [t]csh version:

 

{{works with|C Shell}}

4c:72:b9:56:fe:bc 00-14-22-01-23-45)

 

sleep 2

lookup "$burger"

 

{{out}}

 

=={{header|VBScript}}==

a=array("00-20-6b-ba-d0-cb","00-40-ae-04-87-86")

set WebRequest = CreateObject("WinHttp.WinHttpRequest.5.1")

wscript.echo mac & " -> " & WebRequest.ResponseText

next

Output:

<pre>

 

=={{header|Vlang}}==

import time

 

resp := http.get("http://api.macvendors.com/" + mac) or {println('No data from server') return ''}

return resp.body.str()

 

{{out}}

 

However, if Wren is embedded in (say) a suitable Go program, then we can ask the latter to do it for us.

class MAC {

foreign static lookup(address)

System.print(MAC.lookup("FC:FB:FB:01:FA:21"))

for (i in 1..1e8) {} // slow down request

 

which we embed in the following Go program and run it.

{{libheader|WrenGo}}

package main

 

vm.InterpretFile(fileName)

vm.Free()

 

{{out}}

{{trans|Lua}}

Uses libcurl (the multiprotocol file transfer library) to do the web query

const MAC_VENDORS="http://api.macvendors.com/";

 

vender=vender[0].del(0,vender[1]); // remove HTTP header

vender.text; // Data --> String (Data is a byte bucket)

lookUp("4c:72:b9:56:fe:bc").println();

{{out}}

<pre>

 

=={{header|Zoea}}==

program: mac_vendor_lookup

 

derive: 'http://api.macvendors.com/D4:F4:6F:C9:EF:8D'

output: 'Apple, Inc.'

 

=={{header|Zoea Visual}}==