![Guy Harris](/assets/img/avatar_default.png)
Cast away some implicit 64-bit-to-32-bit conversion errors due to use of sizeof. Cast away some implicit 64-bit-to-32-bit conversion errors due to use of strtol() and strtoul(). Change some data types to avoid those implicit conversion warnings. When assigning a constant to a float, make sure the constant isn't a double, by appending "f" to the constant. Constify a bunch of variables, parameters, and return values to eliminate warnings due to strings being given const qualifiers. Cast away those warnings in some cases where an API we don't control forces us to do so. Enable a bunch of additional warnings by default. Note why at least some of the other warnings aren't enabled. randpkt.c and text2pcap.c are used to build programs, so they don't need to be in EXTRA_DIST. If the user specifies --enable-warnings-as-errors, add -Werror *even if the user specified --enable-extra-gcc-flags; assume they know what they're doing and are willing to have the compile fail due to the extra GCC warnings being treated as errors. svn path=/trunk/; revision=46748
642 lines
17 KiB
C
642 lines
17 KiB
C
/* address_to_str.c
|
|
* Routines for utilities to convert addresses to strings.
|
|
*
|
|
* $Id$
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* Copyright 1998 Gerald Combs
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
# include <sys/types.h> /* needed for <netinet/in.h> */
|
|
#endif
|
|
|
|
#ifdef HAVE_NETINET_IN_H
|
|
# include <netinet/in.h> /* needed for <arpa/inet.h> on some platforms */
|
|
#endif
|
|
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h> /* needed to define AF_ values on UNIX */
|
|
#endif
|
|
|
|
#ifdef HAVE_WINSOCK2_H
|
|
#include <winsock2.h> /* needed to define AF_ values on Windows */
|
|
#endif
|
|
|
|
#ifdef NEED_INET_V6DEFS_H
|
|
# include "wsutil/inet_v6defs.h"
|
|
#endif
|
|
|
|
#include "to_str.h"
|
|
#include "value_string.h"
|
|
#include "addr_resolv.h"
|
|
#include "pint.h"
|
|
#include "atalk-utils.h"
|
|
#include "sna-utils.h"
|
|
#include "osi-utils.h"
|
|
#include <epan/dissectors/packet-mtp3.h>
|
|
#include <stdio.h>
|
|
#include "emem.h"
|
|
|
|
/* private to_str.c API, don't export to .h! */
|
|
char *word_to_hex(char *out, guint16 word);
|
|
char *word_to_hex_npad(char *out, guint16 word);
|
|
char *dword_to_hex_punct(char *out, guint32 dword, char punct);
|
|
char *dword_to_hex(char *out, guint32 dword);
|
|
char *bytes_to_hexstr(char *out, const guint8 *ad, guint32 len);
|
|
char *bytes_to_hexstr_punct(char *out, const guint8 *ad, guint32 len, char punct);
|
|
|
|
/*
|
|
* If a user _does_ pass in a too-small buffer, this is probably
|
|
* going to be too long to fit. However, even a partial string
|
|
* starting with "[Buf" should provide enough of a clue to be
|
|
* useful.
|
|
*/
|
|
#define BUF_TOO_SMALL_ERR "[Buffer too small]"
|
|
|
|
/* Wrapper for the most common case of asking
|
|
* for a string using a colon as the hex-digit separator.
|
|
*/
|
|
/* XXX FIXME
|
|
remove this one later when every call has been converted to ep_address_to_str()
|
|
*/
|
|
const gchar *
|
|
ether_to_str(const guint8 *ad)
|
|
{
|
|
return bytestring_to_str(ad, 6, ':');
|
|
}
|
|
|
|
const gchar *
|
|
tvb_ether_to_str(tvbuff_t *tvb, const gint offset)
|
|
{
|
|
return bytestring_to_str(tvb_get_ptr(tvb, offset, 6), 6, ':');
|
|
}
|
|
|
|
/*
|
|
This function is very fast and this function is called a lot.
|
|
XXX update the ep_address_to_str stuff to use this function.
|
|
*/
|
|
const gchar *
|
|
ip_to_str(const guint8 *ad) {
|
|
gchar *buf;
|
|
|
|
buf=ep_alloc(MAX_IP_STR_LEN);
|
|
ip_to_str_buf(ad, buf, MAX_IP_STR_LEN);
|
|
return buf;
|
|
}
|
|
|
|
#define IPV4_LENGTH 4
|
|
const gchar *
|
|
tvb_ip_to_str(tvbuff_t *tvb, const gint offset)
|
|
{
|
|
gchar *buf;
|
|
|
|
buf=ep_alloc(MAX_IP_STR_LEN);
|
|
ip_to_str_buf(tvb_get_ptr(tvb, offset, IPV4_LENGTH), buf, MAX_IP_STR_LEN);
|
|
return buf;
|
|
}
|
|
|
|
/* XXX FIXME
|
|
remove this one later when every call has been converted to ep_address_to_str()
|
|
*/
|
|
gchar *
|
|
ip6_to_str(const struct e_in6_addr *ad) {
|
|
gchar *str;
|
|
|
|
str=ep_alloc(MAX_IP6_STR_LEN);
|
|
ip6_to_str_buf(ad, str);
|
|
return str;
|
|
}
|
|
|
|
#define IPV6_LENGTH 16
|
|
gchar *
|
|
tvb_ip6_to_str(tvbuff_t *tvb, const gint offset)
|
|
{
|
|
gchar *buf;
|
|
|
|
buf=ep_alloc(MAX_IP6_STR_LEN);
|
|
ip6_to_str_buf((const struct e_in6_addr *)tvb_get_ptr(tvb, offset, IPV6_LENGTH), buf);
|
|
return buf;
|
|
}
|
|
|
|
/* const char *
|
|
* inet_ntop6(src, dst, size)
|
|
* convert IPv6 binary address into presentation (printable) format
|
|
* author:
|
|
* Paul Vixie, 1996.
|
|
*/
|
|
static void
|
|
ip6_to_str_buf_len(const guchar* src, char *buf, size_t buf_len)
|
|
{
|
|
struct { int base, len; } best, cur;
|
|
guint words[8];
|
|
int i;
|
|
|
|
if (buf_len < MAX_IP6_STR_LEN) { /* buf_len < 40 */
|
|
g_strlcpy(buf, BUF_TOO_SMALL_ERR, buf_len); /* Let the unexpected value alert user */
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Preprocess:
|
|
* Copy the input (bytewise) array into a wordwise array.
|
|
* Find the longest run of 0x00's in src[] for :: shorthanding.
|
|
*/
|
|
for (i = 0; i < 16; i += 2) {
|
|
words[i / 2] = (src[i+1] << 0);
|
|
words[i / 2] |= (src[i] << 8);
|
|
}
|
|
best.base = -1; best.len = 0;
|
|
cur.base = -1; cur.len = 0;
|
|
for (i = 0; i < 8; i++) {
|
|
if (words[i] == 0) {
|
|
if (cur.base == -1) {
|
|
cur.base = i;
|
|
cur.len = 1;
|
|
} else
|
|
cur.len++;
|
|
} else {
|
|
if (cur.base != -1) {
|
|
if (best.base == -1 || cur.len > best.len)
|
|
best = cur;
|
|
cur.base = -1;
|
|
}
|
|
}
|
|
}
|
|
if (cur.base != -1) {
|
|
if (best.base == -1 || cur.len > best.len)
|
|
best = cur;
|
|
}
|
|
if (best.base != -1 && best.len < 2)
|
|
best.base = -1;
|
|
|
|
/* Is this address an encapsulated IPv4? */
|
|
/* XXX,
|
|
* Orginal code dated 1996 uses ::/96 as a valid IPv4-compatible addresses
|
|
* but since Feb 2006 ::/96 is deprecated one.
|
|
* Quoting wikipedia [0]:
|
|
* > The 96-bit zero-value prefix ::/96, originally known as IPv4-compatible
|
|
* > addresses, was mentioned in 1995[35] but first described in 1998.[41]
|
|
* > This class of addresses was used to represent IPv4 addresses within
|
|
* > an IPv6 transition technology. Such an IPv6 address has its first
|
|
* > (most significant) 96 bits set to zero, while its last 32 bits are the
|
|
* > IPv4 address that is represented.
|
|
* > In February 2006 the Internet Engineering Task Force (IETF) has deprecated
|
|
* > the use of IPv4-compatible addresses.[1] The only remaining use of this address
|
|
* > format is to represent an IPv4 address in a table or database with fixed size
|
|
* > members that must also be able to store an IPv6 address.
|
|
*
|
|
* If needed it can be fixed by changing next line:
|
|
* if (best.base == 0 && (best.len == 6 || (best.len == 5 && words[5] == 0xffff)))
|
|
* to:
|
|
* if (best.base == 0 && best.len == 5 && words[5] == 0xffff)
|
|
*
|
|
* [0] http://en.wikipedia.org/wiki/IPv6_address#Historical_notes
|
|
*/
|
|
|
|
if (best.base == 0 && (best.len == 6 || (best.len == 5 && words[5] == 0xffff)))
|
|
{
|
|
/* best.len == 6 -> ::IPv4; 5 -> ::ffff:IPv4 */
|
|
buf = g_stpcpy(buf, "::");
|
|
if (best.len == 5)
|
|
buf = g_stpcpy(buf, "ffff:");
|
|
ip_to_str_buf(src + 12, buf, MAX_IP_STR_LEN);
|
|
/* max: 2 + 5 + 16 == 23 bytes */
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Format the result.
|
|
*/
|
|
for (i = 0; i < 8; i++) {
|
|
/* Are we inside the best run of 0x00's? */
|
|
if (i == best.base) {
|
|
*buf++ = ':';
|
|
i += best.len;
|
|
|
|
/* Was it a trailing run of 0x00's? */
|
|
if (i == 8) {
|
|
*buf++ = ':';
|
|
break;
|
|
}
|
|
}
|
|
/* Are we following an initial run of 0x00s or any real hex? */
|
|
if (i != 0)
|
|
*buf++ = ':';
|
|
|
|
buf = word_to_hex_npad(buf, words[i]); /* max: 4B */
|
|
/* max: 8 * 4 + 7 == 39 bytes */
|
|
}
|
|
*buf = '\0'; /* 40 byte */
|
|
}
|
|
|
|
void
|
|
ip6_to_str_buf(const struct e_in6_addr *ad, gchar *buf)
|
|
{
|
|
ip6_to_str_buf_len((const guchar*)ad, buf, MAX_IP6_STR_LEN);
|
|
}
|
|
|
|
gchar*
|
|
ipx_addr_to_str(const guint32 net, const guint8 *ad)
|
|
{
|
|
gchar *buf;
|
|
char *name;
|
|
|
|
name = get_ether_name_if_known(ad);
|
|
|
|
if (name) {
|
|
buf = ep_strdup_printf("%s.%s", get_ipxnet_name(net), name);
|
|
}
|
|
else {
|
|
buf = ep_strdup_printf("%s.%s", get_ipxnet_name(net),
|
|
bytestring_to_str(ad, 6, '\0'));
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
gchar*
|
|
ipxnet_to_string(const guint8 *ad)
|
|
{
|
|
guint32 addr = pntohl(ad);
|
|
return ipxnet_to_str_punct(addr, ' ');
|
|
}
|
|
|
|
gchar *
|
|
ipxnet_to_str_punct(const guint32 ad, const char punct)
|
|
{
|
|
gchar *buf = ep_alloc(12);
|
|
|
|
*dword_to_hex_punct(buf, ad, punct) = '\0';
|
|
return buf;
|
|
}
|
|
|
|
static void
|
|
vines_addr_to_str_buf(const guint8 *addrp, gchar *buf, int buf_len)
|
|
{
|
|
if (buf_len < 14) {
|
|
g_strlcpy(buf, BUF_TOO_SMALL_ERR, buf_len); /* Let the unexpected value alert user */
|
|
return;
|
|
}
|
|
|
|
buf = dword_to_hex(buf, pntohl(&addrp[0])); /* 8 bytes */
|
|
*buf++ = '.'; /* 1 byte */
|
|
buf = word_to_hex(buf, pntohs(&addrp[4])); /* 4 bytes */
|
|
*buf = '\0'; /* 1 byte */
|
|
}
|
|
|
|
gchar *
|
|
tvb_vines_addr_to_str(tvbuff_t *tvb, const gint offset)
|
|
{
|
|
gchar *buf;
|
|
|
|
buf=ep_alloc(214); /* XXX, 14 here? */
|
|
|
|
vines_addr_to_str_buf(tvb_get_ptr(tvb, offset, VINES_ADDR_LEN), buf, 214);
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
This function is very fast and this function is called a lot.
|
|
XXX update the ep_address_to_str stuff to use this function.
|
|
*/
|
|
gchar *
|
|
eui64_to_str(const guint64 ad) {
|
|
gchar *buf;
|
|
guint8 *p_eui64;
|
|
|
|
p_eui64 = ep_alloc(8);
|
|
buf=ep_alloc(EUI64_STR_LEN);
|
|
|
|
/* Copy and convert the address to network byte order. */
|
|
*(guint64 *)(void *)(p_eui64) = pntoh64(&(ad));
|
|
|
|
g_snprintf(buf, EUI64_STR_LEN, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
|
|
p_eui64[0], p_eui64[1], p_eui64[2], p_eui64[3],
|
|
p_eui64[4], p_eui64[5], p_eui64[6], p_eui64[7] );
|
|
return buf;
|
|
}
|
|
gchar *
|
|
tvb_eui64_to_str(tvbuff_t *tvb, const gint offset, const guint encoding)
|
|
{
|
|
if(encoding)
|
|
{
|
|
return eui64_to_str(tvb_get_letoh64(tvb, offset));
|
|
}else {
|
|
return eui64_to_str(tvb_get_ntoh64(tvb, offset));
|
|
}
|
|
}
|
|
|
|
static void
|
|
usb_addr_to_str_buf(const guint8 *addrp, gchar *buf, int buf_len)
|
|
{
|
|
if(pletohl(&addrp[0])==0xffffffff){
|
|
g_snprintf(buf, buf_len, "host");
|
|
} else {
|
|
g_snprintf(buf, buf_len, "%d.%d", pletohl(&addrp[0]), pletohl(&addrp[4]));
|
|
}
|
|
}
|
|
|
|
static void
|
|
tipc_addr_to_str_buf( const guint8 *data, gchar *buf, int buf_len){
|
|
guint8 zone;
|
|
guint16 subnetwork;
|
|
guint16 processor;
|
|
guint32 tipc_address;
|
|
|
|
tipc_address = data[0];
|
|
tipc_address = (tipc_address << 8) ^ data[1];
|
|
tipc_address = (tipc_address << 8) ^ data[2];
|
|
tipc_address = (tipc_address << 8) ^ data[3];
|
|
|
|
processor = tipc_address & 0x0fff;
|
|
|
|
tipc_address = tipc_address >> 12;
|
|
subnetwork = tipc_address & 0x0fff;
|
|
|
|
tipc_address = tipc_address >> 12;
|
|
zone = tipc_address & 0xff;
|
|
|
|
g_snprintf(buf,buf_len,"%u.%u.%u",zone,subnetwork,processor);
|
|
}
|
|
|
|
static void
|
|
ib_addr_to_str_buf( const address *addr, gchar *buf, int buf_len){
|
|
if (addr->len >= 16) { /* GID is 128bits */
|
|
#define PREAMBLE_STR_LEN ((int)(sizeof("GID: ") - 1))
|
|
g_snprintf(buf,buf_len,"GID: ");
|
|
if (buf_len < PREAMBLE_STR_LEN ||
|
|
inet_ntop(AF_INET6, addr->data, buf + PREAMBLE_STR_LEN,
|
|
buf_len - PREAMBLE_STR_LEN) == NULL ) /* Returns NULL if no space and does not touch buf */
|
|
g_snprintf ( buf, buf_len, BUF_TOO_SMALL_ERR ); /* Let the unexpected value alert user */
|
|
} else { /* this is a LID (16 bits) */
|
|
guint16 lid_number;
|
|
|
|
memcpy((void *)&lid_number, addr->data, sizeof lid_number);
|
|
g_snprintf(buf,buf_len,"LID: %u",lid_number);
|
|
}
|
|
}
|
|
|
|
/* XXX FIXME
|
|
remove this one later when every call has been converted to ep_address_to_str()
|
|
*/
|
|
const gchar *
|
|
fc_to_str(const guint8 *ad)
|
|
{
|
|
return bytestring_to_str (ad, 3, '.');
|
|
}
|
|
|
|
const gchar *
|
|
tvb_fc_to_str(tvbuff_t *tvb, const gint offset)
|
|
{
|
|
return bytestring_to_str (tvb_get_ptr(tvb, offset, 3), 3, '.');
|
|
}
|
|
|
|
/* FC Network Header Network Address Authority Identifiers */
|
|
|
|
#define FC_NH_NAA_IEEE 1 /* IEEE 802.1a */
|
|
#define FC_NH_NAA_IEEE_E 2 /* IEEE Exteneded */
|
|
#define FC_NH_NAA_LOCAL 3
|
|
#define FC_NH_NAA_IP 4 /* 32-bit IP address */
|
|
#define FC_NH_NAA_IEEE_R 5 /* IEEE Registered */
|
|
#define FC_NH_NAA_IEEE_R_E 6 /* IEEE Registered Exteneded */
|
|
/* according to FC-PH 3 draft these are now reclaimed and reserved */
|
|
#define FC_NH_NAA_CCITT_INDV 12 /* CCITT 60 bit individual address */
|
|
#define FC_NH_NAA_CCITT_GRP 14 /* CCITT 60 bit group address */
|
|
|
|
gchar *
|
|
fcwwn_to_str (const guint8 *ad)
|
|
{
|
|
int fmt;
|
|
guint8 oui[6];
|
|
gchar *ethstr;
|
|
gchar *ethptr;
|
|
|
|
if (ad == NULL) return NULL;
|
|
|
|
ethstr=ep_alloc(512);
|
|
ethptr = bytes_to_hexstr_punct(ethstr, ad, 8, ':'); /* 23 bytes */
|
|
|
|
fmt = (ad[0] & 0xF0) >> 4;
|
|
|
|
switch (fmt) {
|
|
|
|
case FC_NH_NAA_IEEE:
|
|
case FC_NH_NAA_IEEE_E:
|
|
memcpy (oui, &ad[2], 6);
|
|
|
|
g_snprintf (ethptr, 512-23, " (%s)", get_manuf_name (oui));
|
|
break;
|
|
|
|
case FC_NH_NAA_IEEE_R:
|
|
oui[0] = ((ad[0] & 0x0F) << 4) | ((ad[1] & 0xF0) >> 4);
|
|
oui[1] = ((ad[1] & 0x0F) << 4) | ((ad[2] & 0xF0) >> 4);
|
|
oui[2] = ((ad[2] & 0x0F) << 4) | ((ad[3] & 0xF0) >> 4);
|
|
oui[3] = ((ad[3] & 0x0F) << 4) | ((ad[4] & 0xF0) >> 4);
|
|
oui[4] = ((ad[4] & 0x0F) << 4) | ((ad[5] & 0xF0) >> 4);
|
|
oui[5] = ((ad[5] & 0x0F) << 4) | ((ad[6] & 0xF0) >> 4);
|
|
|
|
g_snprintf (ethptr, 512-23, " (%s)", get_manuf_name (oui));
|
|
break;
|
|
|
|
default:
|
|
*ethptr = '\0';
|
|
break;
|
|
}
|
|
return (ethstr);
|
|
}
|
|
|
|
gchar *
|
|
tvb_fcwwn_to_str(tvbuff_t *tvb, const gint offset)
|
|
{
|
|
return fcwwn_to_str (tvb_get_ptr(tvb, offset, 8));
|
|
}
|
|
|
|
/* XXX FIXME
|
|
remove this one later when every call has been converted to address_to_str()
|
|
*/
|
|
const gchar *
|
|
ax25_to_str(const guint8 *ad)
|
|
{
|
|
return bytestring_to_str(ad, 7, ':');
|
|
}
|
|
|
|
/* XXX FIXME
|
|
remove this one later when every call has been converted to address_to_str()
|
|
*/
|
|
gchar *
|
|
get_ax25_name(const guint8 *ad)
|
|
{
|
|
address addr;
|
|
|
|
addr.type = AT_AX25;
|
|
addr.len = 7;
|
|
addr.data = ad;
|
|
|
|
return address_to_str( &addr );
|
|
}
|
|
|
|
/*XXX FIXME the code below may be called very very frequently in the future.
|
|
optimize it for speed and get rid of the slow sprintfs */
|
|
/* XXX - perhaps we should have individual address types register
|
|
a table of routines to do operations such as address-to-name translation,
|
|
address-to-string translation, and the like, and have this call them,
|
|
and also have an address-to-string-with-a-name routine */
|
|
/* XXX - use this, and that future address-to-string-with-a-name routine,
|
|
in "col_set_addr()"; it might also be useful to have address types
|
|
export the names of the source and destination address fields, so
|
|
that "col_set_addr()" need know nothing whatsoever about particular
|
|
address types */
|
|
/* convert an address struct into a printable string */
|
|
|
|
gchar*
|
|
ep_address_to_str(const address *addr)
|
|
{
|
|
gchar *str;
|
|
|
|
str=ep_alloc(MAX_ADDR_STR_LEN);
|
|
address_to_str_buf(addr, str, MAX_ADDR_STR_LEN);
|
|
return str;
|
|
}
|
|
|
|
/* The called routines use se_alloc'ed memory */
|
|
gchar*
|
|
se_address_to_str(const address *addr)
|
|
{
|
|
gchar *str;
|
|
|
|
str=se_alloc(MAX_ADDR_STR_LEN);
|
|
address_to_str_buf(addr, str, MAX_ADDR_STR_LEN);
|
|
return str;
|
|
}
|
|
|
|
void
|
|
address_to_str_buf(const address *addr, gchar *buf, int buf_len)
|
|
{
|
|
const guint8 *addrdata;
|
|
struct atalk_ddp_addr ddp_addr;
|
|
guint16 ieee_802_15_4_short_addr;
|
|
|
|
char temp[32];
|
|
char *tempptr = temp;
|
|
|
|
if (!buf || !buf_len)
|
|
return;
|
|
|
|
switch(addr->type){
|
|
case AT_NONE:
|
|
buf[0] = '\0';
|
|
break;
|
|
case AT_ETHER: /* 18 bytes */
|
|
tempptr = bytes_to_hexstr_punct(tempptr, addr->data, 6, ':'); /* 17 bytes */
|
|
break;
|
|
case AT_IPv4:
|
|
ip_to_str_buf(addr->data, buf, buf_len);
|
|
break;
|
|
case AT_IPv6:
|
|
ip6_to_str_buf_len(addr->data, buf, buf_len);
|
|
break;
|
|
case AT_IPX: /* 22 bytes */
|
|
addrdata = addr->data;
|
|
tempptr = bytes_to_hexstr(tempptr, &addrdata[0], 4); /* 8 bytes */
|
|
*tempptr++ = '.'; /* 1 byte */
|
|
tempptr = bytes_to_hexstr(tempptr, &addrdata[4], 6); /* 12 bytes */
|
|
break;
|
|
case AT_SNA:
|
|
sna_fid_to_str_buf(addr, buf, buf_len);
|
|
break;
|
|
case AT_ATALK:
|
|
memcpy(&ddp_addr, addr->data, sizeof ddp_addr);
|
|
atalk_addr_to_str_buf(&ddp_addr, buf, buf_len);
|
|
break;
|
|
case AT_VINES:
|
|
vines_addr_to_str_buf(addr->data, buf, buf_len);
|
|
break;
|
|
case AT_USB:
|
|
usb_addr_to_str_buf(addr->data, buf, buf_len);
|
|
break;
|
|
case AT_OSI:
|
|
print_nsap_net_buf(addr->data, addr->len, buf, buf_len);
|
|
break;
|
|
case AT_ARCNET: /* 5 bytes */
|
|
tempptr = g_stpcpy(tempptr, "0x"); /* 2 bytes */
|
|
tempptr = bytes_to_hexstr(tempptr, addr->data, 1); /* 2 bytes */
|
|
break;
|
|
case AT_FC: /* 9 bytes */
|
|
tempptr = bytes_to_hexstr_punct(tempptr, addr->data, 3, '.'); /* 8 bytes */
|
|
break;
|
|
case AT_SS7PC:
|
|
mtp3_addr_to_str_buf((const mtp3_addr_pc_t *)addr->data, buf, buf_len);
|
|
break;
|
|
case AT_STRINGZ:
|
|
g_strlcpy(buf, addr->data, buf_len);
|
|
break;
|
|
case AT_EUI64: /* 24 bytes */
|
|
tempptr = bytes_to_hexstr_punct(tempptr, addr->data, 8, ':'); /* 23 bytes */
|
|
break;
|
|
case AT_URI: {
|
|
int copy_len = addr->len < (buf_len - 1) ? addr->len : (buf_len - 1);
|
|
memcpy(buf, addr->data, copy_len );
|
|
buf[copy_len] = '\0';
|
|
}
|
|
break;
|
|
case AT_TIPC:
|
|
tipc_addr_to_str_buf(addr->data, buf, buf_len);
|
|
break;
|
|
case AT_IB:
|
|
ib_addr_to_str_buf(addr, buf, buf_len);
|
|
break;
|
|
case AT_AX25:
|
|
addrdata = addr->data;
|
|
g_snprintf(buf, buf_len, "%c%c%c%c%c%c-%02d",
|
|
(addrdata[0] >> 1) & 0x7f, (addrdata[1] >> 1) & 0x7f, (addrdata[2] >> 1) & 0x7f,
|
|
(addrdata[3] >> 1) & 0x7f, (addrdata[4] >> 1) & 0x7f, (addrdata[5] >> 1) & 0x7f,
|
|
(addrdata[6] >> 1) & 0x0f );
|
|
break;
|
|
case AT_IEEE_802_15_4_SHORT:
|
|
ieee_802_15_4_short_addr = pletohs(addr->data);
|
|
if (ieee_802_15_4_short_addr == 0xffff)
|
|
g_snprintf(buf, buf_len, "Broadcast");
|
|
else
|
|
g_snprintf(buf, buf_len, "0x%04x", ieee_802_15_4_short_addr);
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
}
|
|
|
|
/* copy to output buffer */
|
|
if (tempptr != temp) {
|
|
size_t temp_len = (size_t) (tempptr - temp);
|
|
|
|
if (temp_len < (size_t) buf_len) {
|
|
memcpy(buf, temp, temp_len);
|
|
buf[temp_len] = '\0';
|
|
} else
|
|
g_strlcpy(buf, BUF_TOO_SMALL_ERR, buf_len);/* Let the unexpected value alert user */
|
|
}
|
|
}
|
|
|