I believe the "modern tools" way to get your ipv4 address is to parse 'ip' rather than 'ifconfig', so it'd be something like:

ip4=$(/sbin/ip -o -4 addr list eth0 | awk '{print $4}' | cut -d/ -f1)

ip6=$(/sbin/ip -o -6 addr list eth0 | awk '{print $4}' | cut -d/ -f1)

or something like that.

Why not simply do IP=$(hostname -I) ?

If you want the address of an interface, the easiest way is to install moreutils then:

anthony@Zia:~$ ifdata -pa br0

172.16.1.244

ifdata answers pretty much every question you'd be tempted to parse ifconfig output for.

If you want to find out your IP address as the outside sees it (beyond any NAT, etc.), there are plenty of services that'll do it. One is fairly easy:

anthony@Zia:~$ curl ifconfig.me

173.167.51.137

To get IPv4 and IPv6 addresses, and not assume the main interface is eth0 (these days em1 is more common), try:

ips=$(ip -o addr show up primary scope global |

      while read -r num dev fam addr rest; do echo ${addr%/*}; done)

• 
  -o uses the one-line output format, which is easier to process with read, grep, etc.


• 
  up excludes devices that aren't active


• 
  scope global excludes private/local addresses such as 127.0.0.1 and fe80::/64
  


• 
  primary excludes temporary addresses (assuming you want an address that doesn't change)

Depends what you mean by own IP address. Systems have IP addresses on several subnets (sometimes several per subnet), some of which IPv4, some IPv6 using devices like ethernet adapters, loopback interfaces, VPN tunnels, bridges, virtual interfaces...

I you mean the IP address by which another given device may reach your computer, you have to find out which subnet that is, and which version of IP we're talking about. Also, bear in mind that because of NAT performed by firewall/routers, the IP address of an interface may not be the same as a remote host sees an incoming connection from your computer coming from.

When there is fancy source routing or per protocol/port routing it can be difficult to find out which interface would be used to talk to one remote computer over a given protocol and even then, there's no guarantee that the IP address of that interface may be directly addressable by the remote computer wanting to establish a new connection to your computer.

For IPv4 (probably works for IPv6 as well), a trick that works in many unices including Linux to find out the IP address of the interface used to reach a given host is to use a connect(2) on a UDP socket and use getsockname():

For instance, on my home computer:

perl -MSocket -le 'socket(S, PF_INET, SOCK_DGRAM, getprotobyname("udp"));

connect(S, sockaddr_in(1, inet_aton("8.8.8.8")));

print inet_ntoa((sockaddr_in(getsockname(S)))[1]);'

Would be used to find out the IP address of the interface via which I would reach 8.8.8.8 (google's DNS server). It would return something like "192.168.1.123" which is the address of the interface for the default route to the internet. However, google wouldn't see a DNS request from my machine as coming from that IP address which is a private one, as there's NAT performed by my home broadband router.

connect() on a UDP socket doesn't send any packet (UDP is connection-less), but prepares the socket by querying the routing table.

ipa=$(ip route get 8.8.8.8| grep src| sed 's/.*src (.*)$/1/g')



ipa=$(hostname -i|cut -f2 -d ' ')

I don't mean to be a jerk, but there really is a right way and this is it. You trim the output of ip route to get only the source IP. Depending on what IP you are trying to reach, "my own ip address" (OP's words) will be different. If you care about reaching the public internet, using Google's 8.8.8.8 DNS server is pretty standard. So...

The short answer is:

ip route get 8.8.8.8 | sed -n '/src/{s/.*src *//p;q}'

Here's the detailed explanation

If I want the ip I use to reach the internet, I use this:

pi@et3:~ $ ip route get 8.8.8.8 | sed -n '/src/{s/.*src *//p;q}'

10.55.0.200

If I want the ip I use to reach something on my VPN, I use this:

pi@et3:~ $ ip route get 172.31.0.100 | sed -n '/src/{s/.*src *//p;q}'

172.29.0.9

This next one is really just for illustrative purposes. But, it should work on any Linux system. So, you can use this to demonstrate that, yes, all machines have multiple IP addresses at all times.

If I wanted the ip I use to reach myself, I would use this:

pi@et3:~ $ my_ip=$(getent hosts $(cat /etc/hostname) | awk '{print $1; exit}')

pi@et3:~ $ ip route get $my_ip | sed -n '/src/{s/.*src *//p;q}'

127.0.0.1

More about that sed command

First let me say that when choosing unix tools, you try to choose the tools that require the fewest pipes. So, while some answers will pipe ifconfig to grep to sed to head, that is rarely ever necessary. When you see it, it should raise a red flag that you are taking advice from someone with little experience. That doesn't make the "solution" wrong. But, it probably could use some streamlining.

I have chosen sed because it is more terse than the same workflow in awk. I don't think any other tool but those 2 would be appropriate.

Let's examine what sed -n '/src/{s/.*src *//p;q}' does:

sed            # the sed executable located via $PATH

-n             # no output unless explicitly requested

'              # begin the command space

/src/          # regex match the string 'src'

{              # begin a block of commands **

s/.*src *//    # regex match "anything followed by 'src' followed by any number of spaces" and replace it with "nothing"

p              # print (explicitly, remember) the result

;              # designate the end of the command

q              # quit

}              # end the block of commands

'              # end the command space



** all of which will be performed "on match"

  - otherwise only the first command to following the match would be performed "on match"

    - any other commands would be performed whether there was a match or not

More about my network

My ifconfig shows that I have tun0 for my VPN and eth0 for my lan.

pi@et3:~ $ ifconfig

eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500

        inet 10.55.0.200  netmask 255.255.252.0  broadcast 10.55.3.255

        inet6 fe80::71e6:5d7c:5b4b:fb25  prefixlen 64  scopeid 0x20<link>

        ether b8:27:eb:b2:96:84  txqueuelen 1000  (Ethernet)



lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536

        inet 127.0.0.1  netmask 255.0.0.0

        inet6 ::1  prefixlen 128  scopeid 0x10<host>

        loop  txqueuelen 1  (Local Loopback)



tun0: flags=4305<UP,POINTOPOINT,RUNNING,NOARP,MULTICAST>  mtu 1500

        inet 172.29.0.9  netmask 255.255.255.255  destination 172.29.0.10

        inet6 fe80::3a8e:8195:b86c:c68c  prefixlen 64  scopeid 0x20<link>

        unspec 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00  txqueuelen 100  (UNSPEC)



wlan0: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500

        ether b8:27:eb:e7:c3:d1  txqueuelen 1000  (Ethernet)

On FreeBSD you can use

dig +short `hostname -f`

This may work for other environments, depends on your set-up.

Assuming that you may have various interfaces of various name but that you want the first non-localhost one and non-ipv6, you may try:

ip=`ip addr show |grep "inet " |grep -v 127.0.0. |head -1|cut -d" " -f6|cut -d/ -f1`

I use this one-liner:

IP=$(/sbin/ifconfig | grep -e "inet:" -e "addr:" | grep -v "inet6" | grep -v "127.0.0.1" | head -n 1 | awk '{print $2}' | cut -c6-)

Uses ifconfig (widely available), does not take localhost address, does not bind you to a given interface name, does not take into account IPv6 and tries to get the IP of the first network interface available.

I needed to do this within an alias to start a radio server on my wired NIC. I used

ip addr | egrep -i "inet.+eth1" | awk -F[ /] '{print $6}' | tr -d [:space:]

Some commands are working on centos 6 or 7, the below command working on both,

#!/bin/sh



serverip=`/sbin/ifconfig eth0 | grep "inet" | awk '{print $2}' | awk 'NR==1' | cut -d':' -f2`



echo $serverip

Assuming you need your primary public IP as it seen from the rest of the world, try any of those:

wget http://ipecho.net/plain -O - -q

curl http://icanhazip.com

curl http://ifconfig.me/ip

This snippet avoids hard-coding the device name (like 'eth0') and will use ip instead of ifconfig:

/sbin/ip addr | grep 'state UP' -A2 | tail -n1 | awk '{print $2}' | cut -f1  -d'/'

It will return the IP of the first active device listed in the output of ip addr. Depending on your machine, this can be an ipv4 or ipv6 address.

To store it into a variable, use:

ip=$(/sbin/ip addr | grep 'state UP' -A2 | tail -n1 | awk '{print $2}' | cut -f1  -d'/')

myip=$(curl -kLs "http://api.ipify.org")

or

myip=$(wget -q "http://api.ipify.org" -O -)

all the solutions using awk/sed/grep seem overly complex and ugly for my situation... so i came up with this really simple solution BUT beware cus it makes some assumptions, namely the assumption that the LAST interface is the one you're interested. if you're ok with that then this is pretty clean:

ifconfig | awk '/net / { x = $2 } END { print x }'

otherwise you could do some silly if statement to test for a specific prefix or whatever criteria you may have.

Simple Command to fine IP Address with default interface.

ip route | grep src | awk '{print $NF; exit}'

Tested on All Unix OS

You should use ip (instead of ifconfig) as it's current, maintained, and perhaps most importantly for scripting purposes, it produces a consistent & parsable output. Following are a few similar approaches:

If you want the IPv4 address for your Ethernet interface eth0:

$ ip -4 -o addr show eth0 | awk '{print $4}'

192.168.1.166/24  

As a script:

$ INTFC=eth0  

$ MYIPV4=$(ip -4 -o addr show $INTFC | awk '{print $4}') 

$ echo $MYIPV4

192.168.1.166/24

The output produced above is in CIDR notation. If CIDR notation isn't wanted, it can be stripped:

$ ip -4 -o addr show eth0 | awk '{print $4}' | cut -d "/" -f 1 

192.168.1.166  

Another option that IMHO is "most elegant" gets the IPv4 address for whatever interface is used to connect to the specified remote host (8.8.8.8 in this case). Courtesy of @gatoatigrado in this answer:

$ ip route get 8.8.8.8 | awk '{ print $NF; exit }'

192.168.1.166

As a script:

$ RHOST=8.8.8.8  

$ MYIP=$(ip route get $RHOST | awk '{ print $NF; exit }')

$ echo $MYIP

192.168.1.166

This works perfectly well on a host with a single interface, but more advantageously will also work on hosts with multiple interfaces and/or route specifications.

ip would be my preferred approach, but it's certainly not the only way to skin this cat. Here's another approach that uses hostname if you prefer something easier/more concise:

$ hostname --all-ip-addresses | awk '{print $1}'  

Or, if you want the IPv6 address:

$ hostname --all-ip-addresses | awk '{print $2}'  

This may not be the most robust or correct solution, but unlike most of the other solutions, the command works on both Linux and Mac (BSD).

host `hostname` | awk '{print $NF}'

hostname -I >> file_name 

this will do everything you want