---
name: "ACE_INET_Addr"
section: "3"
platform: "linux"
package: "libace-doc"
version: "5.0.7-4"
release: "Debian 2.2 (Potato)"
platforms: ["linux"]
url: "https://new.carta.tech/ACE_INET_Addr"
---

# ACE\_INET\_Addr(3)

Defines a C++ wrapper facade for the Internet domain address family format.

## NAME

ACE\_INET\_Addr -  Defines a C++ wrapper facade for the Internet domain address family format.

## SYNOPSIS

```
#include <ace/INET_Addr.h>
class ACE_INET_Addr : public ACE_Addr
{
  public:
    ACE_INET_Addr (void);
    ACE_INET_Addr (const ACE_INET_Addr &);
    ACE_INET_Addr (const sockaddr_in *, int len);
    ACE_INET_Addr (u_short port_number, const ASYS_TCHAR host_name[]);
    ACE_INET_Addr (const ASYS_TCHAR address[]);
    ACE_INET_Addr (
        u_short port_number,
        ACE_UINT32 ip_addr = INADDR_ANY
        );
    ACE_INET_Addr (
        const ASYS_TCHAR port_name[],
        const ASYS_TCHAR host_name[],
        const ASYS_TCHAR protocol[] = ASYS_TEXT ("tcp")
        );
    ACE_INET_Addr (
        const ASYS_TCHAR port_name[],
        ACE_UINT32 ip_addr,
        const ASYS_TCHAR protocol[] = ASYS_TEXT ("tcp")
        );
    ~ACE_INET_Addr (void);
    int set (const ACE_INET_Addr &);
    int set (
        u_short port_number,
        const ASYS_TCHAR host_name[],
        int encode = 1
        );
    int set (
        u_short port_number,
        ACE_UINT32 ip_addr = INADDR_ANY,
        int encode = 1
        );
    int set (
        const ASYS_TCHAR port_name[],
        const ASYS_TCHAR host_name[],
        const ASYS_TCHAR protocol[] = ASYS_TEXT ("tcp")
        );
    int set (
        const ASYS_TCHAR port_name[],
        ACE_UINT32 ip_addr,
        const ASYS_TCHAR protocol[] = ASYS_TEXT ("tcp")
        );
    int set (const ASYS_TCHAR addr[]);
    int set (const sockaddr_in *, int len);
    virtual void *get_addr (void) const;
    virtual void set_addr (void *, int len);
    virtual int addr_to_string (
        ASYS_TCHAR buffer[],
        size_t size,
        int ipaddr_format = 1
        ) const;
    virtual int string_to_addr (const ASYS_TCHAR address[]);
    void set_port_number (u_short, int encode = 1);
    u_short get_port_number (void) const;
    int get_host_name (
        ASYS_TCHAR hostname[],
        size_t hostnamelen
        ) const;
    const ASYS_TCHAR *get_host_name (void) const;
    const char *get_host_addr (void) const;
    ACE_UINT32 get_ip_address (void) const;
    int operator == (const ACE_INET_Addr &SAP) const;
    int operator != (const ACE_INET_Addr &SAP) const;
    virtual u_long hash (void) const;
    void dump (void) const;
    ACE_ALLOC_HOOK_DECLARE;
  private:
    sockaddr_in inet_addr_;
};
```

## Initialization methods.

```
ACE_INET_Addr (void);
```

Default constructor.

```
ACE_INET_Addr (const ACE_INET_Addr &);
```

Copy constructor.

```
ACE_INET_Addr (const sockaddr_in *, int len);
```

Creates an ACE\_INET\_Addr from a sockaddr\_in structure.

```
ACE_INET_Addr (u_short port_number, const ASYS_TCHAR host_name[]);
```

Creates an ACE\_INET\_Addr from a port\_number and the remote host\_name.

```
ACE_INET_Addr (const ASYS_TCHAR address[]);
```

Initializes an ACE\_INET\_Addr from the address, which can be "ip-number:port-number" (e.g., "tango.cs.wustl.edu:1234" or "128.252.166.57:1234").  If there is no ':' in the address it is assumed to be a port number, with the IP address being INADDR\_ANY.

```
ACE_INET_Addr (u_short port_number, ACE_UINT32 ip_addr = INADDR_ANY);
```

Creates an ACE\_INET\_Addr from a port\_number and an Internet ip\_addr.  This method assumes that port\_number and ip\_addr are in host byte order.

```
ACE_INET_Addr (
    const ASYS_TCHAR port_name[],
    const ASYS_TCHAR host_name[],
    const ASYS_TCHAR protocol[] = ASYS_TEXT ("tcp")
    );
```

Uses getservbyname to create an ACE\_INET\_Addr from a port\_name, the remote host\_name, and the protocol.

```
ACE_INET_Addr (
    const ASYS_TCHAR port_name[],
    ACE_UINT32 ip_addr,
    const ASYS_TCHAR protocol[] = ASYS_TEXT ("tcp")
    );
```

Uses getservbyname to create an ACE\_INET\_Addr from a port\_name, an Internet ip\_addr, and the protocol.  This method assumes that ip\_addr is in host byte order.

```
~ACE_INET_Addr (void);
```

Default dtor.

## Direct initialization methods.

These methods are useful after the object has been constructed.

```
int set (const ACE_INET_Addr &);
```

Initializes from another ACE\_INET\_Addr.

```
int set (
    u_short port_number,
    const ASYS_TCHAR host_name[],
    int encode = 1
    );
```

Initializes an ACE\_INET\_Addr from a port\_number and the remote host\_name.  If encode is enabled then port\_number is converted into network byte order, otherwise it is assumed to be in network byte order already and are passed straight through.

```
int set (
    u_short port_number,
    ACE_UINT32 ip_addr = INADDR_ANY,
    int encode = 1
    );
```

Initializes an ACE\_INET\_Addr from a port\_number and an Internet ip\_addr.  If encode is enabled then port\_number and ip\_addr are converted into network byte order, otherwise they are assumed to be in network byte order already and are passed straight through.

```
int set (
    const ASYS_TCHAR port_name[],
    const ASYS_TCHAR host_name[],
    const ASYS_TCHAR protocol[] = ASYS_TEXT ("tcp")
    );
```

Uses getservbyname to initialize an ACE\_INET\_Addr from a port\_name, the remote host\_name, and the protocol.

```
int set (
    const ASYS_TCHAR port_name[],
    ACE_UINT32 ip_addr,
    const ASYS_TCHAR protocol[] = ASYS_TEXT ("tcp")
    );
```

Uses getservbyname to initialize an ACE\_INET\_Addr from a port\_name, an ip\_addr, and the protocol.  This assumes that ip\_addr is already in network byte order.

```
int set (const ASYS_TCHAR addr[]);
```

Initializes an ACE\_INET\_Addr from the addr, which can be "ip-number:port-number" (e.g., "tango.cs.wustl.edu:1234" or "128.252.166.57:1234").  If there is no ':' in the address it is assumed to be a port number, with the IP address being INADDR\_ANY.

```
int set (const sockaddr_in *, int len);
```

Creates an ACE\_INET\_Addr from a sockaddr\_in structure.

```
virtual void *get_addr (void) const;
```

Return a pointer to the underlying network address.

```
virtual void set_addr (void *, int len);
```

Set a pointer to the address.

```
virtual int addr_to_string (
    ASYS_TCHAR buffer[],
    size_t size,
    int ipaddr_format = 1
    ) const;
```

Transform the current ACE\_INET\_Addr address into string format. If ipaddr\_format is non-0 this produces "ip-number:port-number" (e.g., "128.252.166.57:1234"), whereas if ipaddr\_format is 0 this produces "ip-name:port-number" (e.g., "tango.cs.wustl.edu:1234").  Returns -1 if the size of the buffer is too small, else 0.

```
virtual int string_to_addr (const ASYS_TCHAR address[]);
```

Initializes an ACE\_INET\_Addr from the address, which can be "ip-addr:port-number" (e.g., "tango.cs.wustl.edu:1234"), "ip-addr:port-name" (e.g., "tango.cs.wustl.edu:telnet"), "ip-number:port-number" (e.g., "128.252.166.57:1234"), or "ip-number:port-name" (e.g., "128.252.166.57:telnet").  If there is no ':' in the address it is assumed to be a port number, with the IP address being INADDR\_ANY.

```
void set_port_number (u_short, int encode = 1);
```

Sets the port number without affecting the host name.  If encode is enabled then port\_number is converted into network byte order, otherwise it is assumed to be in network byte order already and are passed straight through.

```
u_short get_port_number (void) const;
```

Return the port number, converting it into host byte order.

```
int get_host_name (ASYS_TCHAR hostname[], size_t hostnamelen) const;
```

Return the character representation of the name of the host, storing it in the hostname (which is assumed to be hostnamelen bytes long).  This version is reentrant.

```
const ASYS_TCHAR *get_host_name (void) const;
```

Return the character representation of the hostname (this version is non-reentrant since it returns a pointer to a static data area).

```
const char *get_host_addr (void) const;
```

Return the "dotted decimal" Internet address.

```
ACE_UINT32 get_ip_address (void) const;
```

Return the 4-byte IP address, converting it into host byte order.

```
int operator == (const ACE_INET_Addr &SAP) const;
```

Compare two addresses for equality.  The addresses are considered equal if they contain the same IP address and port number.

```
int operator != (const ACE_INET_Addr &SAP) const;
```

Compare two addresses for inequality.

```
virtual u_long hash (void) const;
```

Computes and returns hash value.

```
void dump (void) const;
```

Dump the state of an object.

```
ACE_ALLOC_HOOK_DECLARE;
```

Declare the dynamic allocation hooks.

## AUTHOR

Doug Schmidt

## LIBRARY

ace