aboutsummaryrefslogtreecommitdiffstats
path: root/epan/address_to_str.c
blob: 5fefbcd80c6c6f314ccb3de2374cb17b53da1a79 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
/* 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-int.h"
#include "to_str.h"
#include "value_string.h"
#include "addr_resolv.h"
#include "wsutil/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"

/*
 * 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=(gchar *)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=(gchar *)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=(gchar *)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=(gchar *)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 = (gchar *)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=(gchar *)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 = (guint8 *)ep_alloc(8);
    buf=(gchar *)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=(gchar *)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 ep_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=(gchar *)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=(gchar *)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, (const guint8 *)addr->data, 6, ':'); /* 17 bytes */
        break;
    case AT_IPv4:
        ip_to_str_buf((const guint8 *)addr->data, buf, buf_len);
        break;
    case AT_IPv6:
        ip6_to_str_buf_len((const guchar *)addr->data, buf, buf_len);
        break;
    case AT_IPX: /* 22 bytes */
        addrdata = (const guint8 *)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((const guint8 *)addr->data, buf, buf_len);
        break;
    case AT_USB:
        usb_addr_to_str_buf((const guint8 *)addr->data, buf, buf_len);
        break;
    case AT_OSI:
        print_nsap_net_buf((const guint8 *)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, (const guint8 *)addr->data, 1); /* 2 bytes */
        break;
    case AT_FC: /* 9 bytes */
        tempptr = bytes_to_hexstr_punct(tempptr, (const guint8 *)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, (const gchar *)addr->data, buf_len);
        break;
        case AT_EUI64: /* 24 bytes */
        tempptr = bytes_to_hexstr_punct(tempptr, (const guint8 *)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((const guint8 *)addr->data, buf, buf_len);
        break;
    case AT_IB:
        ib_addr_to_str_buf(addr, buf, buf_len);
        break;
    case AT_AX25:
        addrdata = (const guint8 *)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 */
    }
}

/*
 * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
 *
 * Local variables:
 * c-basic-offset: 4
 * tab-width: 8
 * indent-tabs-mode: nil
 * End:
 *
 * vi: set shiftwidth=4 tabstop=8 expandtab:
 * :indentSize=4:tabSize=8:noTabs=true:
 */