This file is indexed.

/usr/include/ns3.26/ns3/uan-address.h is in libns3-dev 3.26+dfsg-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2009 University of Washington
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Leonard Tracy <lentracy@gmail.com>
 */

#ifndef UAN_ADDRESS_H
#define UAN_ADDRESS_H

#include "ns3/address.h"
#include <iostream>

namespace ns3 {

/**
 * \ingroup uan
 *
 * A class used for addressing UAN MAC's.
 *
 * This implementation uses a simple 8 bit flat addressing scheme.
 * It is unlikely that perceived underwater networks will soon
 * exceed 200 nodes (or the overlapping of two underwater networks
 * - the ocean is big), so this should provide adequate addressing
 * for most applications.
 */
class UanAddress
{
public:
  /** Constructor */
  UanAddress ();
  /**
   * Create UanAddress object with address addr.
   *
   * \param addr Byte address to assign to this address.
   */
  UanAddress (uint8_t addr);
  /** Destructor */
  virtual ~UanAddress ();

  /**
   * Convert a generic address to a UanAddress.
   *
   * \param address  Address to convert to UAN address.
   * \return UanAddress from Address.
   */
  static UanAddress ConvertFrom (const Address &address);

  /**
   * Check that a generic Address is compatible with UanAddress.
   *
   * \param address  Address to test.
   * \return True if address given is consistant with UanAddress.
   */
  static bool IsMatchingType  (const Address &address);

  /**
   * Create a generic Address.
   *
   * \return The Address.
   */
  operator Address () const;

  /**
   * Sets address to address stored in parameter.
   *
   * \param pBuffer Buffer to extract address from.
   */
  void CopyFrom (const uint8_t *pBuffer);

  /**
   * Writes address to buffer parameter.
   *
   * \param pBuffer
   */
  void CopyTo (uint8_t *pBuffer);

  /**
   * Convert to integer.
   *
   * \return 8 bit integer version of address.
   */
  uint8_t GetAsInt (void) const;

  /**
   * Get the broadcast address (255).
   *
   * \return Broadcast address.
   */
  static UanAddress GetBroadcast (void);

  /**
   * Allocates UanAddress from 0-254
   *
   * Will wrap back to 0 if more than 254 are allocated.
   * Excludes the broadcast address.
   *
   * \return The next sequential UanAddress.
   */
  static UanAddress Allocate ();


private:
  uint8_t m_address;  //!< The address.

  /**
   * Get the UanAddress type.
   *
   * \return The type value.
   */
  static uint8_t GetType (void);
  /**
   * Convert to a generic Address.
   *
   * \return The Address value.
   */
  Address ConvertTo (void) const;

  friend bool operator <  (const UanAddress &a, const UanAddress &b);
  friend bool operator == (const UanAddress &a, const UanAddress &b);
  friend bool operator != (const UanAddress &a, const UanAddress &b);
  friend std::ostream& operator<< (std::ostream& os, const UanAddress & address);
  friend std::istream& operator>> (std::istream& is, UanAddress & address);

};  // class UanAddress


/**
 * Address comparison, less than.
 *
 * \param a First address to compare.
 * \param b Second address to compare.
 * \return True if a < b.
 */
bool operator < (const UanAddress &a, const UanAddress &b);

/**
 * Address comparison, equalit.
 *
 * \param a First address to compare.
 * \param b Second address to compare.
 * \return True if a == b.
 */
bool operator == (const UanAddress &a, const UanAddress &b);

/**
 * Address comparison, unequal.
 *
 * \param a First address to compare.
 * \param b Second address to compare.
 * \return True if a != b.
 */
bool operator != (const UanAddress &a, const UanAddress &b);

/**
 * Write \pname{address} to stream \pname{os} as 8 bit integer.
 *
 * \param os The output stream.
 * \param address The address
 * \return The output stream.
 */
std::ostream& operator<< (std::ostream& os, const UanAddress & address);

/**
 * Read \pname{address} from stream \pname{is} as 8 bit integer.
 *
 * \param is The input stream.
 * \param address The address variable to set.
 * \return The input stream.
 */
std::istream& operator>> (std::istream& is, UanAddress & address);

} // namespace ns3

#endif /* UAN_ADDRESS_H */