Using TCP sockets edit

lindex [fconfigure $sock -sockname] 0

proc ip:address {} {
    # find out localhost's IP address
    # courtesy David Gravereaux, Heribert Dahms
    set TheServer [socket -server none -myaddr [info hostname] 0]
    set MyIP [lindex [fconfigure $TheServer -sockname] 0]
    close $TheServer
    return $MyIP
}

proc myIP {} {
    if { [ catch {
        set ip 127.0.0.1
        set sid [ socket -async [ info hostname ] 22 ]
        set ip  [ lindex [ fconfigure $sid -sockname ] 0 ]
        ::close $sid
    } err ] } {
        catch { ::close $sid }
        puts stderr "myIP error: '$err' on port 22 (sshd). using 127.0.0.1"
    }
    return $ip
}

proc myip {{port 302}} {    # Figure out what this machine's IP address is.
    global myip
    set tss [socket -server tserv $port]
    set ts2 [socket [info hostname] $port]
    set myip [lindex [fconfigure $ts2 -sockname] 0]
    close $tss
    close $ts2
    return $myip
}

    # This is reporter.tcl.
    socket -server accept 6584
    proc accept {handle origination other} {
        set message "Origination address is $origination."
        puts $message
        puts $handle $message
        close $handle
    }
    vwait forever

    telnet $TARGET 6584

 proc getIp {{target www.google.com} {port 80}} {
     set s [socket $target $port]
     set res [fconfigure $s -sockname]
     close $s
     lindex $res 0
 }

$ rlwrap tclsh
 proc getIp {{target www.google.com} {port 80}} {
     set s [socket $target $port]
     set res [fconfigure $s -sockname]
     close $s
     lindex $res 0
 }
% getIp
10.0.0.28
% 

 set anyport 5555 ;# Any random port number
 set sock [socket -async $host $anyport]
 puts [fconfigure $sock -sockname]
 close $sock

DNS edit

Using DNS root servers

    proc ip:external {} {
        #this uses the TCP DNS port of the DNS root-servers. 
        #If these aren't reachable, you probably don't
        #have a working external internet connection anyway.
        set MyIP ""
        foreach a {a b c d e f g h i j k} {
            catch {
                set external [socket $a.root-servers.net 53]
                set MyIP [lindex [fconfigure $external -sockname] 0]
                close $external                                
            } 
            if { ![string equal $MyIP ""] } { break }
        }
        return $MyIP
    }

Using special-purpose DNS servers

Parsing ifconfig (*nix) and ipconfig (Windows) edit

 proc ifConfig { args } {
     if { [ catch {
        set interfaces [ list ]
        if { [ file executable /usr/sbin/ifconfig ] } {
           catch { ::exec /usr/sbin/ifconfig -a } data
        } elseif { [ file executable /sbin/ifconfig ] } {
           catch { ::exec /sbin/ifconfig -a } data
        } else {
           return -code error "can't find 'ifconfig' executable!"
        }
        set fid [ open /etc/hosts r ]
        set hostdata [ read $fid [ file size /etc/hosts ] ]
        ::close $fid
        foreach line [ split $hostdata "\n" ] {
           array set hosts \
              [ list [ lindex $line 0 ] [ lrange $line 1 end ] ]
        }   
        foreach line [ split $data "\n" ] {
           regexp {^[a-z]+\d+} $line if
           if { [ regexp {^\s+inet\s+(?:addr:)?(\S+)} $line -> ip ] } {
              lappend interfaces [ list $if $ip $hosts($ip) ]
           }
        }
     } err ] } {
        return -code error "ifConfig: $err"
     }
     return $interfaces
 }

switch $tcl_platform(platform) {
    unix {

     ########################
     # Parse network configuration information
     # for unix-like systems
     ####
     proc ifconfig {} { 
        variable iplist {}

        set buffer [exec /sbin/ifconfig]
        set scan "inet addr:"
        
        set addrlist {}
        foreach line [split $buffer \n] {
            if [regexp HWaddr $line] {
                lappend addrlist [lindex $line 0] [lindex $line end]
            }
            if ![regexp $scan $line] continue
            set s [expr [string first $scan $line 0] + \
                       [string length $scan]]
            set f [expr [string first " " $line $s] - 1]
            
            set addr [string range $line $s $f]        
            
            if { $addr != "127.0.0.1" } {
                lappend addrlist $addr
            }
        }

        foreach {device mac addr} $addrlist {
            set device [string tolower $device]

            if [catch {exec ps ax | grep dhcpcd | grep $device}] {
                set dhcp no
            } else {
                set dhcp yes
            }
            set dhcp [linux_dhcp_device $device]
            lappend iplist [list $device $addr $mac $dhcp]
        }
        return $iplist
      }
    }
    windows {

     #####################
     # Parse network configuration information
     # Windows NT/98/ME/2K/XP
     # (Also nabs the mac number for the network card
     # this is a quick copy and paste from my workstation 
     # inventory script)
     ####
     proc ifconfig {} {
        set iplist {}

        # Load IP info
        
        catch {
            exec ipconfig /all
        } data

        set buffer [split $data \n] 

        set mac_address {}
        foreach line $buffer {
            if [regexp -nocase {Description} $line] {
                set val [string trim [lindex [split $line :] end]]
                lappend mac_addresses $val
            }
            if [regexp -nocase {Physical Address} $line] {
                set val [string trim [lindex [split $line :] end]]
                regsub -all {\-} $val : val
                lappend mac_addresses [string tolower $val]
            }
            if [regexp -nocase {DHCP Enabled} $line] {
                set val [string trim [lindex [split $line :] end]]
                lappend mac_addresses [string tolower $val]                
            }

            if [regexp -nocase {IP Address} $line] {
                set val [string trim [lindex [split $line :] end]]
                lappend mac_addresses $val
            }
        }

        set devices -1
        set ppp 0
        foreach {desc mac dhcp ip} $mac_addresses {
            if [regexp desc "PPP"] {
                set device ppp[incr ppp]
            }  else {
                set device eth[incr devices]
            }
            lappend iplist [list $device $ip $mac $dhcp]
        }
        return $iplist
     }
    }
    default {
       proc ifconfig {} { error "Unsupported Platform" }
    }
}

 proc get_ips {} {
    # default ip_list to one element consisting of localhost.
    # If the regexp call succeeds, ip will be set a list of
    # the IPs. If the computer is not multihomed, the list will consist
    # of one element
    set ip_list {}

    # initialize status variables and warning messages
    set warning {}
    set fail 0
    set re_status 0
    # normal
    if {[catch {set ipconfig_pid [open |ipconfig]} err]} {
        # query the host for its actual IP configuration
        # get the stack trace and flatten it into one line to make it log-able
        set localInfo [split $::errorInfo \n]
        set warning "Warning: Unable to query the host for its IP\
                configuration. IP configure returned: $err\
                Stack trace: $localInfo"
    } else {
        # get the data from the ipconfig command
        set results [split [read $ipconfig_pid] \n]
        close $ipconfig_pid
        # loop over the results, searching for IP addresses.
        foreach line $results {
            if {[catch {regexp {IP Address[\. ]+: ([0-9\.]+)}\
                    $line match ip} re_status]} {
                set localInfo [split $::errorInfo \n]
                set warning "Warning: Failed to run regexp on the\
                        the ipconfig output.\
                        Result: $re_status Stack trace: $localInfo"
            } elseif {$re_status == 1} {
                lappend ip_list $ip
            }
        }
    }

    append msg "Harvested IP address(es) $ip_list" " $warning"
    # report msg here
    puts $msg
    # return ip
    if {[llength $ip_list] == 0} {
        return localhost
    } else {
        return $ip_list
    }
 }
 # unit tests
 # 0. run success case
 # 1. Change the call to ipconfig to:  catch {exec ipconfig; error foo}
 # 2. Change the regexp pattern to:  {fooIP Address[\. ]+: ([0-9\.]+)}
 # 3. Append ;error foo to the catch around the regexp

Recent changes

proc getIP {type bin} {
   set data [exec $bin $type | grep inet]
   return [string range $data [expr [string first ":" $data]+1] \
   [expr [string first " " $data [expr [string first ":" $data]+1]]-1]]
}
puts [getIP ppp0 /sbin/ifconfig]

Using ping edit

Using web services edit

package require http
proc whatIP {} {
    regexp {Your IP Address:</B><BR>\n([0-9.]*)} [http::data [http::geturl whatismyipaddress.com]] {} ip
    return $ip
}

Using TWAPI edit

package require twapi
twapi::get_ip_addresses

 package require twapi
 
 puts ips:[lsearch -all -inline -not -exact [::twapi::get_ip_addresses] 127.0.0.1]\n
 
 proc getiptohost hostip {
     package require twapi
         
     set idx [::twapi::get_outgoing_interface $hostip]
     array set iplist [lsearch -all -inline -not -exact [::twapi::get_netif_info $idx -ipaddresses] 127.0.0.1]
 
     if {[info exists iplist(-ipaddresses)]} {
         return [lindex $iplist(-ipaddresses) 0 0]
     } else {
         puts "error"
     }
 }
 
 puts "getting route..."
 puts [getiptohost $::argv]

 C:\temp>getip2host 1.1.1.1
 ips:74.125.19.68 192.168.56.1
 getting route...
 74.125.19.68

 C:\temp>getip2host 192.168.56.123
 ips:74.125.19.68 192.168.56.1

 getting route...
 192.168.56.1

Using the registry on Windows edit

 proc regpath {args} {
     join $args "\\"
 }

 proc ipConfig {} {
     global tcl_platform
     if {$tcl_platform(os) eq "Windows NT"} {
         # Windows NT/2k/XP
         set regroot [regpath HKEY_LOCAL_MACHINE Software \
             Microsoft "Windows NT" CurrentVersion NetworkCards]
         foreach key [registry keys $regroot] {
             set net [regpath $regroot $key]
             set name [registry get $net Description]
             puts "Description=$name"
             set service [registry get $net ServiceName]
             set path [regpath HKEY_LOCAL_MACHINE System \
                 CurrentControlSet Services \
                 $service Parameters Tcpip]
             set vars [registry values $path]
             foreach var $vars {
                 set val [registry get $path $var]
                 puts $var=$val
             }
             puts ""
         }
     } else {
         # Windows 95/98/ME
         set regroot [regpath HKEY_LOCAL_MACHINE System \
             CurrentControlSet Services Class]
         set net [regpath $regroot Net]
         foreach key [registry keys $net] {
             set name [registry get [regpath $net $key] DriverDesc]
             puts "Description=$name"
             set path [regpath $regroot NetTrans $key]
             set vars [registry values $path]
             foreach var $vars {
                 set val [registry get $path $var]
                 puts $var=$val
             }
             puts ""
         }
     }
 }

Using TclX on *nix edit

    host_info addresses [info hostname]

Using Ceptcl edit

% cepResolve [info hostname]
192.168.2.2

% cepResolve google.com -addresses
74.125.45.100 74.125.127.100 74.125.67.100

Using UDP sockets edit

 package require udp
 set udp_socket [udp_open 15351 reuse]
 chan configure $udp_socket -blocking 0 -buffering none -mcastadd {224.0.0.251} -mcastloop 1 -remote {224.0.0.251 15351}
 chan puts -nonewline $::udp_socket [info hostname]
 chan event $udp_socket readable read_data
 proc read_data {} {
     if {[chan read $::udp_socket] eq [info hostname]} {
         set ::ip_address [lindex [chan configure $::udp_socket -peer] 0]
         proc get_ip_address {} {
             return $::ip_address
         }
         chan close $::udp_socket
    }
 }

Linux command line commands edit

[~]$ ip route get 64.64.64.64/24
64.64.64.64 via 192.168.0.1 dev wlan0  src 192.168.0.102 
    cache 

[~]$ ip route show cache 133.40.3.100
133.40.3.100 via 192.168.0.1 dev wlan0  src 192.168.0.102 
    cache 
133.40.3.100 from 192.168.0.102 via 192.168.0.1 dev wlan0 
    cache 

 ifconfig if

 netstat -i

 netstat -te

here

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <net/if.h>
 #include <arpa/inet.h>



 int main(int argc, char *argv[]) {
    struct ifreq ifr;
    int sock, j, k;
    char *p, addr[32], mask[32], mac[32];


    if (argc<2) {
        fprintf(stderr,"missing argument, example: eth0\n");
        return 1;
    }


    sock=socket(PF_INET, SOCK_STREAM, 0);
    if (-1==sock) {
        perror("socket() ");
        return 1;
    }


    strncpy(ifr.ifr_name,argv[1],sizeof(ifr.ifr_name)-1);
    ifr.ifr_name[sizeof(ifr.ifr_name)-1]='\0';


    if (-1==ioctl(sock, SIOCGIFADDR, &ifr)) {
        perror("ioctl(SIOCGIFADDR) ");
        return 1;
    }
    p=inet_ntoa(((struct sockaddr_in *)(&ifr.ifr_addr))->sin_addr);
    strncpy(addr,p,sizeof(addr)-1);
    addr[sizeof(addr)-1]='\0';


    if (-1==ioctl(sock, SIOCGIFNETMASK, &ifr)) {
        perror("ioctl(SIOCGIFNETMASK) ");
        return 1;
    }
    p=inet_ntoa(((struct sockaddr_in *)(&ifr.ifr_netmask))->sin_addr);
    strncpy(mask,p,sizeof(mask)-1);
    mask[sizeof(mask)-1]='\0';


    if (-1==ioctl(sock, SIOCGIFHWADDR, &ifr)) {
        perror("ioctl(SIOCGIFHWADDR) ");
        return 1;
    }
    for (j=0, k=0; j<6; j++) {
        k+=snprintf(mac+k, sizeof(mac)-k-1, j ? ":%02X" : "%02X",
            (int)(unsigned int)(unsigned char)ifr.ifr_hwaddr.sa_data[j]);
    }
    mac[sizeof(mac)-1]='\0';


    printf("\n");
    printf("name:    %s\n",ifr.ifr_name);
    printf("address: %s\n",addr);
    printf("netmask: %s\n",mask);
    printf("macaddr: %s\n",mac);
    printf("\n");


    close(sock);
    return 0;
 }

here

http://www.codeproject.com/KB/IP/obafindingipinformation.aspx

Windows command line commands edit

 global env
 exec myip [exec ypcat -k hosts | grep $env(HOST) | awk {{print $1}}]

 proc getIP {} {
     set fd [open "|nslookup" r]
     fconfigure $fd -buffering line
     gets $fd line
     gets $fd line
     return [string trim [string range $line 9 end]]        
 }

Editing a page on the Tcler's wiki ;-) edit

Recent changes

Discussion edit

See also edit

• Tnm/Scotty/TkInEd
• Regular Expression Examples
• Entry box validation for IP address
• DNS
• TWAPI Network Configuration module [2]

Threads on comp.lang.tcl

• [3]
• [4] (link broken 2015-03-18)

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References