Hostname: Difference between revisions

=={{header|Ada}}==

Works with GCC/GNAT

with GNAT.Sockets;

 

begin

Put_Line (GNAT.Sockets.Host_Name);

 

=={{header|ALGOL 68}}==

<!-- {{does not works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - No such library function.}} -->

{{works with|POSIX|.1}}

get(read OF execve child pipe("/bin/hostname","hostname",""), hostname);

 

=={{header|AppleScript}}==

host name of (system info)

 

=={{header|AutoHotkey}}==

 

via Windows Management Instrumentation (WMI)

 

=={{header|AWK}}==

 

{{noticebox||WARNING: the following purported solution makes an assumption about environment variables that may not be applicable in all circumstances.}}

 

=={{header|BaCon}}==

 

=={{header|Batch File}}==

Since Windows 2000 :

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PROC_initsockets

PRINT "hostname: " FN_gethostname

 

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

 

{{works with|POSIX|.1}}

#include <stdio.h>

#include <limits.h>

char name[_POSIX_HOST_NAME_MAX + 1];

return gethostname(name, sizeof name) == -1 || printf("%s\n", name) < 0 ? EXIT_FAILURE : EXIT_SUCCESS;

 

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

 

=={{header|Caché ObjectScript}}==

=={{header|Clojure}}==

 

(.. java.net.InetAddress getLocalHost getHostName)

 

java -cp clojure.jar clojure.main -e "(.. java.net.InetAddress getLocalHost getHostName)"

 

=={{header|COBOL}}==

program-id. hostname.

 

goback.

end program hostname.

 

=={{header|CoffeeScript}}==

os = require 'os'

console.log os.hostname()

 

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

Another operating system feature that is implemented differently across lisp implementations. Here we show how to create a function that obtains the required result portably by working differently for each supported implementation. This technique is heavily used to make portable lisp libraries.

#+(or sbcl ccl) (machine-instance)

#+clisp (let ((s (machine-instance))) (subseq s 0 (position #\Space s)))

 

{{libheader|CFFI}}

Another way is to use the [[FFI]] to access POSIX' <code>gethostname(2)</code>:

 

(buf :pointer) (len :unsigned-long))

 

(unless (zerop (c-gethostname buf 256))

(error "Can't get hostname"))

 

 

=={{header|D}}==

 

void main() {

writeln(Socket.hostName());

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

else

Writeln('error getting host name');

 

=={{header|E}}==

 

 

Not exactly a good way to do it. A better way ought to be introduced along with a proper socket interface. [[Category:E examples needing attention]]

 

=={{header|Emacs Lisp}}==

 

=={{header|F_Sharp|F#}}==

 

=={{header|Factor}}==

 

=={{header|Forth}}==

{{works with|GNU Forth|0.7.0}}

 

 

=={{header|Fortran}}==

 

The function/subroutine <tt>HOSTNM</tt> is a GNU extension.

character(len=128) :: name

call hostnm(name)

print *, name

 

Using fortran 2003 C-interoperability we can call posix C function gethostname (unix system call) directly

program test_hostname

use, intrinsic :: iso_c_binding

 

end program test_hostname

 

=={{header|FreeBASIC}}==

 

' On Windows 10, the command line utility HOSTNAME.EXE prints the 'hostname' to the console.

Print

Print "Press any key to quit"

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=11d7f489117d7909da509050103b7891 Click this link to run this code]'''

 

Print System.Host

 

Output:

<pre>

=={{header|Go}}==

Use [https://golang.org/pkg/os/#Hostname <code>os.Hostname</code>].

 

import (

func main() {

fmt.Println(os.Hostname())

 

=={{header|Groovy}}==

 

 

=={{header|Harbour}}==

 

=={{header|Haskell}}==

{{libheader|network}}

main = do hostName <- getHostName

 

Or if you don't want to depend on the network package being installed, you can implement it on your own (this implementation is based on the implementation in the network package).

 

 

 

import Foreign.Marshal.Array ( allocaArray0, peekArray0 )

 

main = do hostName <- getHostName

 

=={{header|Icon}} and {{header|Unicon}}==

write(&host)

 

=={{header|IDL}}==

 

=={{header|J}}==

 

load 'socket'

NB. and the hostname is fetched only once, then use a 'one-liner' to accomplish it:

 

 

=={{header|Java}}==

 

=={{header|JavaScript}}==

{{works with|JScript}}

var hostname = network.computerName;

 

=={{header|jq}}==

]</pre>

 

 

=={{header|Julia}}==

println(gethostname())

 

{{out}}

<pre>

harlan

</pre>

 

=={{header|Kotlin}}==

 

import java.net.InetAddress

fun main(args: Array<String>) {

println(InetAddress.getLocalHost().hostName)

 

=={{header|Lasso}}==

This will ge the hostname as reported by the web server

-> www.myserver.com

 

This will ge the hostname as reported by the system OS

 

data

}

 

-> mymachine.local

 

=={{header|LFE}}==

 

(net_adm:localhost)

 

=={{header|Liberty BASIC}}==

struct SIZE,sz As Long

SIZE.sz.struct=Len(lpBuffer$)

CurrentComputerName$=Trim$(Left$(lpBuffer$, SIZE.sz.struct))

 

 

=={{header|Limbo}}==

As with nearly anything in Inferno, it boils down to reading a file:

 

 

include "sys.m"; sys: Sys;

raise "fail:errors";

}

 

Sys->ATOMICIO is usually 8 kilobytes; this version truncates if you have a ridiculously long hostname.

=={{header|Lingo}}==

{{libheader|Shell Xtra}}

sx = xtra("Shell").new()

if the platform contains "win" then

else

hostname = sx.shell_cmd("hostname", RETURN).line[1]

 

=={{header|LiveCode}}==

 

=={{header|Lua}}==

Requires: LuaSocket

 

=={{header|Maple}}==

 

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

 

=={{header|MATLAB}}==

This is a built-in MATLAB function. "failed" is a Boolean which will be false if the command sent to the OS succeeds. "hostname" is a string containing the system's hostname, provided that the external command <tt>hostname</tt> exists.

 

 

=={{header|mIRC Scripting Language}}==

 

=={{header|Modula-3}}==

 

IMPORT IO, OSConfig;

BEGIN

IO.Put(OSConfig.HostName() & "\n");

 

=={{header|MUMPS}}==

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols binary

 

say InetAddress.getLocalHost.getHostName

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

 

=={{header|Oberon-2}}==

Works with oo2c version 2

MODULE HostName;

IMPORT

Out.Object("Host: " + ProcessParameters.GetEnv("HOSTNAME"));Out.Ln

END HostName.

Output:

<pre>

Host: localhost.localdomain

</pre>

 

=={{header|Objeck}}==

use Net;

 

}

}

 

=={{header|OCaml}}==

 

=={{header|Octave}}==

Similarly to [[Discover the Hostname#MATLAB|MATLAB]], we could call system command <tt>hostname</tt> to know the hostname. But we can also call the internal function <tt>uname()</tt> which returns a structure holding several informations, among these the hostname (nodename):

 

 

=={{header|ooRexx}}==

A solution using ActiveX/OLE on Windows

 

 

and one using the Windows environment variables

 

 

===UNIX Platform===

:'''Note:''' The '''<tt>address command</tt>''' clause causes the contents of the literal string that follows it to be sent to the command shell.

 

 

 

Command output can also be captured by the program to allow further processing.

In the following examples output written to STDOUT/STDERR is piped into '''<tt>rxqueue</tt>''' which sends it in turn to a Rexx queue for further processing by the program:

 

address command "echo $HOSTNAME | rxqueue"

address command "hostname -f | rxqueue"

say q_~right(2)':' hn

end q_

 

A utility class is also provided as a wrapper around the external data queue:

 

qq = .rexxqueue~new()

address command "echo $HOSTNAME | rxqueue"

say q_~right(2)':' hn

end q_

 

=={{header|Oz}}==

 

=={{header|PARI/GP}}==

Running the <code>hostname</code> or <code>uname</code> program and capturing its output (the first line of output) in a string.

 

 

=={{header|Pascal}}==

For Windows systems see the [[Hostname#Delphi | Delphi]] example.

On Unix systems, FreePascal has the function GetHostName:

 

uses

begin

writeln('The name of this computer is: ', GetHostName);

Output example on Mac OS X:

<pre>

 

{{libheader|Sys::Hostname}}

 

 

=={{header|PHP}}==

 

 

{{works with|PHP|5.3+}}

 

=={{header|PicoLisp}}==

This will just print the hostname:

To use it as a string in a program:

 

=={{header|Pike}}==

 

int main(){

write(gethostname() + "\n");

 

=={{header|PL/SQL}}==

BEGIN

DBMS_OUTPUT.PUT_LINE(UTL_INADDR.GET_HOST_NAME);

 

=={{header|Pop11}}==

 

=={{header|PowerBASIC}}==

This retreives the localhost's name:

 

 

This attempts to retreive the name of an arbitrary machine on the network (assuming ipAddress& is valid):

 

 

=={{header|PowerShell}}==

Windows systems have the <code>ComputerName</code> environment variable which can be used:

Also PowerShell can use .NET classes and methods:

 

=={{header|PureBasic}}==

{{works with|PureBasic|4.41}}

 

=={{header|Python}}==

{{works with|Python|2.5}}

 

=={{header|R}}==

Sys.info provides information about the platform that R is running on. The following code returns the hostname as a string.

Note that Sys.info isn't guaranteed to be available on all platforms. As an alternative, you can call an OS command.

... or retrieve an environment variable

env_var <- ifelse(.Platform$OS.type == "windows", "COMPUTERNAME", "HOSTNAME")

Sys.getenv(env_var)

 

=={{header|Racket}}==

#lang racket/base

(gethostname)

 

=={{header|REBOL}}==

 

=={{header|REXX}}==

<br>Other names could be used for the 3rd argument.

<br><br>The &nbsp; ''computername'' &nbsp; is the same as the output for the &nbsp; '''hostname.exe''' &nbsp; program.

'''output''' (using Windows/XP)

<pre>

This REXX solution is for R4 and ROO under the Microsoft NT family of Windows (XP, Vista, 7, etc).

<br>Other names could be used for the 3rd argument.

 

===MS DOS (without Windows), userid===

Under Microsoft DOS (with no Windows), the closest thing to a name of a host would be the userid.

 

===MS DOS (without Windows), version of DOS===

But perhaps the name or version of the MS DOS system would be more appropriate than the userid.

Each REXX interpreter has their own name (some have multiple names) for the environmental variables.

<br>Different operating systems may call their hostnames by different identifiers.

This solution is platform specific and uses features that are available to the Regina implementation of Rexx.

:Tested with Regina on Mac OS X. Should work on other UNIX/Linux distros.

address command "hostname -f" with output stem hn.

do q_ = 1 to hn.0

say hn.q_

end q_

 

=={{header|Ruby}}==

 

=={{header|Run BASIC}}==

print UserInfo$ ' Information about the user's web browser

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

{{works with|Chicken Scheme}}

{{works with|Guile}}

 

=={{header|Seed7}}==

which returns the hostname.

 

include "socket.s7i";

 

begin

writeln(getHostname);

 

=={{header|Sidef}}==

Or:

 

=={{header|Slate}}==

 

 

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

 

=={{header|SQL}}==

{{works with|Oracle}}

select host_name from v$instance;

 

=={{header|SQL PL}}==

{{works with|Db2 LUW}}

SELECT HOST_NAME FROM SYSIBMADM.ENV_SYS_INFO

Output:

<pre>

 

</pre>

 

=={{header|Swift}}==

Swift 3

 

=={{header|Tcl}}==

The basic introspection tool in TCL is the <tt>info</tt> command. It can be used to find out about the version of the current Tcl or Tk, the available commands and libraries, variables, functions, the level of recursive interpreter invocation, and, amongst a myriad other things, the name of the current machine:

 

 

=={{header|Toka}}==

1024 chars is-array foo

foo 1024 gethostname

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

host=HOST ()

 

=={{header|UNIX Shell}}==

or

 

=={{header|Ursa}}==

 

=={{header|Ursala}}==

The user-defined hostname function ignores its argument and returns a string.

 

For example, the following function returns the square root of its argument

if it's running on host kremvax, but otherwise returns the square.

 

 

=={{header|VBScript}}==

Set objNetwork = CreateObject("WScript.Network")

WScript.Echo objNetwork.ComputerName

 

=={{header|Vim Script}}==

 

=={{header|zkl}}==

Or open a server socket, which contains the hostname.