Bandwidth library

Functions related to bandwidth (unit) More...

Collaboration diagram for Bandwidth library:

Data Structures
struct	GNUNET_BANDWIDTH_Value32NBO
	32-bit bandwidth used for network exchange by GNUnet, in bytes per second. More...
struct	GNUNET_BANDWIDTH_Tracker
	Struct to track available bandwidth. More...

Macros
#define	GNUNET_BANDWIDTH_ZERO   GNUNET_BANDWIDTH_value_init (0)
	Convenience definition to use for 0-bandwidth. More...
#define	GNUNET_BANDWIDTH_VALUE_MAX   GNUNET_BANDWIDTH_value_init (UINT32_MAX)
	Maximum possible bandwidth value. More...

Typedefs
typedef void(*	GNUNET_BANDWIDTH_TrackerUpdateCallback) (void *cls)
	Callback to be called by the bandwidth tracker if the tracker was updated and the client should update it's delay values. More...
typedef void(*	GNUNET_BANDWIDTH_ExcessNotificationCallback) (void *cls)
	Callback to be called by the bandwidth tracker if the tracker was updated and the client should update it's delay values. More...

Functions
struct GNUNET_BANDWIDTH_Value32NBO	GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second)
	Create a new bandwidth value. More...
uint64_t	GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO bps, struct GNUNET_TIME_Relative deadline)
	At the given bandwidth, calculate how much traffic will be available until the given deadline. More...
struct GNUNET_TIME_Relative	GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps, uint64_t size)
	At the given bandwidth, calculate how long it would take for 'size' bytes to be transmitted. More...
struct GNUNET_BANDWIDTH_Value32NBO	GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2)
	Compute the MIN of two bandwidth values. More...
struct GNUNET_BANDWIDTH_Value32NBO	GNUNET_BANDWIDTH_value_max (struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2)
	Compute the MAX of two bandwidth values. More...
struct GNUNET_BANDWIDTH_Value32NBO	GNUNET_BANDWIDTH_value_sum (struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2)
	Compute the SUM of two bandwidth values. More...
void	GNUNET_BANDWIDTH_tracker_init (struct GNUNET_BANDWIDTH_Tracker *av, GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, void *update_cb_cls, struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, uint32_t max_carry_s)
	Initialize bandwidth tracker. More...
void	GNUNET_BANDWIDTH_tracker_init2 (struct GNUNET_BANDWIDTH_Tracker *av, GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, void *update_cb_cls, struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, uint32_t max_carry_s, GNUNET_BANDWIDTH_ExcessNotificationCallback excess_cb, void *excess_cb_cls)
	Initialize bandwidth tracker. More...
void	GNUNET_BANDWIDTH_tracker_notification_stop (struct GNUNET_BANDWIDTH_Tracker *av)
	Stop notifying about tracker updates and excess notifications. More...
int	GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av, ssize_t size)
	Notify the tracker that a certain number of bytes of bandwidth have been consumed. More...
struct GNUNET_TIME_Relative	GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av, size_t size)
	Compute how long we should wait until consuming size bytes of bandwidth in order to stay within the given quota. More...
int64_t	GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker *av)
	Compute how many bytes are available for consumption right now. More...
void	GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av, struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit)
	Update quota of bandwidth tracker. More...

Detailed Description

Functions related to bandwidth (unit)

Macro Definition Documentation

GNUNET_BANDWIDTH_ZERO

#define GNUNET_BANDWIDTH_ZERO   GNUNET_BANDWIDTH_value_init (0)

Convenience definition to use for 0-bandwidth.

Definition at line 155 of file gnunet_bandwidth_lib.h.

GNUNET_BANDWIDTH_VALUE_MAX

#define GNUNET_BANDWIDTH_VALUE_MAX   GNUNET_BANDWIDTH_value_init (UINT32_MAX)

Maximum possible bandwidth value.

Definition at line 171 of file gnunet_bandwidth_lib.h.

Typedef Documentation

GNUNET_BANDWIDTH_TrackerUpdateCallback

typedef void(* GNUNET_BANDWIDTH_TrackerUpdateCallback) (void *cls)

Callback to be called by the bandwidth tracker if the tracker was updated and the client should update it's delay values.

Parameters

cls	a closure to pass

Definition at line 79 of file gnunet_bandwidth_lib.h.

GNUNET_BANDWIDTH_ExcessNotificationCallback

typedef void(* GNUNET_BANDWIDTH_ExcessNotificationCallback) (void *cls)

Callback to be called by the bandwidth tracker if the tracker was updated and the client should update it's delay values.

Parameters

cls	a closure to pass

Definition at line 88 of file gnunet_bandwidth_lib.h.

Function Documentation

GNUNET_BANDWIDTH_value_init()

struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_init

(

uint32_t

bytes_per_second

)

Create a new bandwidth value.

Parameters

bytes_per_second

value to create

Returns

the new bandwidth value

Definition at line 1 of file bandwidth.c.

{
  struct GNUNET_BANDWIDTH_Value32NBO ret;
 
  ret.value__ = htonl (bytes_per_second);
  return ret;
}

Referenced by bandwidth_changed_cb(), free_address(), GAS_addresses_add(), GAS_addresses_update(), GNUNET_BANDWIDTH_tracker_get_available(), GST_neighbours_handle_quota_message(), libgnunet_plugin_transport_udp_init(), peerinfo_it(), and unset_primary_address().

Here is the caller graph for this function:

GNUNET_BANDWIDTH_value_get_available_until()

uint64_t GNUNET_BANDWIDTH_value_get_available_until	(	struct GNUNET_BANDWIDTH_Value32NBO	bps,
		struct GNUNET_TIME_Relative	deadline
	)

At the given bandwidth, calculate how much traffic will be available until the given deadline.

Parameters

bps	bandwidth
deadline	when is the deadline

Returns

number of bytes available at bps until deadline

Definition at line 97 of file bandwidth.c.

{
  uint64_t b;
 
  b = ntohl (bps.value__);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Bandwidth has %llu bytes available until deadline in %s\n",
       (unsigned long long) ((b * deadline.rel_value_us + 500000LL)
                             / 1000000LL),
       GNUNET_STRINGS_relative_time_to_string (deadline, GNUNET_YES));
  return (b * deadline.rel_value_us + 500000LL) / 1000000LL;
}

References deadline, GNUNET_ERROR_TYPE_DEBUG, GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, LOG, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by GNUNET_BANDWIDTH_tracker_get_available().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_BANDWIDTH_value_get_delay_for()

struct GNUNET_TIME_Relative GNUNET_BANDWIDTH_value_get_delay_for	(	struct GNUNET_BANDWIDTH_Value32NBO	bps,
		uint64_t	size
	)

At the given bandwidth, calculate how long it would take for 'size' bytes to be transmitted.

Parameters

bps	bandwidth
size	number of bytes we want to have available

Returns

how long it would take

At the given bandwidth, calculate how long it would take for 'size' bytes to be transmitted.

Parameters

bps	bandwidth
size	number of bytes we want to have available

Returns

how long it would take

Definition at line 97 of file bandwidth.c.

{
  uint64_t b;
  struct GNUNET_TIME_Relative ret;
 
  b = ntohl (bps.value__);
  if (0 == b)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Bandwidth suggests delay of infinity (zero bandwidth)\n");
    return GNUNET_TIME_UNIT_FOREVER_REL;
  }
  ret.rel_value_us = size * 1000LL * 1000LL / b;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Bandwidth suggests delay of %s for %llu bytes of traffic\n",
       GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES),
       (unsigned long long) size);
  return ret;
}

GNUNET_BANDWIDTH_value_min()

struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_min	(	struct GNUNET_BANDWIDTH_Value32NBO	b1,
		struct GNUNET_BANDWIDTH_Value32NBO	b2
	)

Compute the MIN of two bandwidth values.

Parameters

b1	first value
b2	second value

Returns

the min of b1 and b2

Definition at line 1 of file bandwidth.c.

{
  return GNUNET_BANDWIDTH_value_init (
    GNUNET_MIN (ntohl (b1.value__), ntohl (b2.value__)));
}

Referenced by neighbours_connect_notification(), and send_outbound_quota_to_clients().

Here is the caller graph for this function:

GNUNET_BANDWIDTH_value_max()

struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_max	(	struct GNUNET_BANDWIDTH_Value32NBO	b1,
		struct GNUNET_BANDWIDTH_Value32NBO	b2
	)

Compute the MAX of two bandwidth values.

Parameters

b1	first value
b2	second value

Returns

the min of b1 and b2

Definition at line 1 of file bandwidth.c.

{
  return GNUNET_BANDWIDTH_value_init (
    GNUNET_MAX (ntohl (b1.value__), ntohl (b2.value__)));
}

Referenced by GST_neighbours_handle_quota_message().

Here is the caller graph for this function:

GNUNET_BANDWIDTH_value_sum()

struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_sum	(	struct GNUNET_BANDWIDTH_Value32NBO	b1,
		struct GNUNET_BANDWIDTH_Value32NBO	b2
	)

Compute the SUM of two bandwidth values.

Parameters

b1	first value
b2	second value

Returns

the sum of b1 and b2

Definition at line 1 of file bandwidth.c.

{
  return GNUNET_BANDWIDTH_value_init (ntohl (b1.value__) + ntohl (b2.value__));
}

GNUNET_BANDWIDTH_tracker_init()

void GNUNET_BANDWIDTH_tracker_init	(	struct GNUNET_BANDWIDTH_Tracker *	av,
		GNUNET_BANDWIDTH_TrackerUpdateCallback	update_cb,
		void *	update_cb_cls,
		struct GNUNET_BANDWIDTH_Value32NBO	bytes_per_second_limit,
		uint32_t	max_carry_s
	)

Initialize bandwidth tracker.

Note that in addition to the 'max_carry_s' limit, we also always allow at least GNUNET_MAX_MESSAGE_SIZE to accumulate. So if the bytes-per-second limit is so small that within 'max_carry_s' not even GNUNET_MAX_MESSAGE_SIZE is allowed to accumulate, it is ignored and replaced by GNUNET_MAX_MESSAGE_SIZE (which is in bytes).

Parameters

av	tracker to initialize
update_cb	callback to notify a client about the tracker being updated
update_cb_cls	cls for the update_cb callback
bytes_per_second_limit	initial limit to assume
max_carry_s	maximum number of seconds unused bandwidth may accumulate before it expires

Definition at line 279 of file bandwidth.c.

{
  GNUNET_BANDWIDTH_tracker_init2 (av,
                                  update_cb,
                                  update_cb_cls,
                                  bytes_per_second_limit,
                                  max_carry_s,
                                  NULL,
                                  NULL);
}

References GNUNET_BANDWIDTH_tracker_init2().

Referenced by GAS_reservations_set_bandwidth(), libgnunet_plugin_transport_udp_init(), and setup_neighbour().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_BANDWIDTH_tracker_init2()

void GNUNET_BANDWIDTH_tracker_init2	(	struct GNUNET_BANDWIDTH_Tracker *	av,
		GNUNET_BANDWIDTH_TrackerUpdateCallback	update_cb,
		void *	update_cb_cls,
		struct GNUNET_BANDWIDTH_Value32NBO	bytes_per_second_limit,
		uint32_t	max_carry_s,
		GNUNET_BANDWIDTH_ExcessNotificationCallback	excess_cb,
		void *	excess_cb_cls
	)

Initialize bandwidth tracker.

Note that in addition to the 'max_carry_s' limit, we also always allow at least GNUNET_MAX_MESSAGE_SIZE to accumulate. So if the bytes-per-second limit is so small that within 'max_carry_s' not even GNUNET_MAX_MESSAGE_SIZE is allowed to accumulate, it is ignored and replaced by GNUNET_MAX_MESSAGE_SIZE (which is in bytes).

Parameters

av	tracker to initialize
update_cb	callback to notify a client about the tracker being updated
update_cb_cls	cls for the update_cb callback
bytes_per_second_limit	initial limit to assume
max_carry_s	maximum number of seconds unused bandwidth may accumulate before it expires
excess_cb	callback to notify if we have excess bandwidth
excess_cb_cls	closure for excess_cb

Note that in addition to the 'max_carry_s' limit, we also always allow at least GNUNET_MAX_MESSAGE_SIZE to accumulate. So if the bytes-per-second limit is so small that within 'max_carry_s' not even GNUNET_MAX_MESSAGE_SIZE is allowed to accumulate, it is ignored and replaced by GNUNET_MAX_MESSAGE_SIZE (which is in bytes).

To stop notifications about updates and excess callbacks use GNUNET_BANDWIDTH_tracker_notification_stop().

Parameters

av	tracker to initialize
update_cb	callback to notify a client about the tracker being updated
update_cb_cls	cls for the callback
bytes_per_second_limit	initial limit to assume
max_carry_s	maximum number of seconds unused bandwidth may accumulate before it expires
excess_cb	callback to notify if we have excess bandwidth
excess_cb_cls	closure for excess_cb

Definition at line 252 of file bandwidth.c.

{
  av->update_cb = update_cb;
  av->update_cb_cls = update_cb_cls;
  av->consumption_since_last_update__ = 0;
  av->last_update__ = GNUNET_TIME_absolute_get ();
  av->available_bytes_per_s__ = ntohl (bytes_per_second_limit.value__);
  av->max_carry_s__ = max_carry_s;
  av->excess_cb = excess_cb;
  av->excess_cb_cls = excess_cb_cls;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Tracker %p initialized with %u Bps and max carry %u\n",
       av,
       (unsigned int) av->available_bytes_per_s__,
       (unsigned int) max_carry_s);
  update_excess (av);
}

References GNUNET_BANDWIDTH_Tracker::available_bytes_per_s__, GNUNET_BANDWIDTH_Tracker::consumption_since_last_update__, GNUNET_BANDWIDTH_Tracker::excess_cb, GNUNET_BANDWIDTH_Tracker::excess_cb_cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_TIME_absolute_get(), GNUNET_BANDWIDTH_Tracker::last_update__, LOG, GNUNET_BANDWIDTH_Tracker::max_carry_s__, GNUNET_BANDWIDTH_Tracker::update_cb, GNUNET_BANDWIDTH_Tracker::update_cb_cls, update_excess(), and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by GNUNET_BANDWIDTH_tracker_init(), and handle_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_BANDWIDTH_tracker_notification_stop()

void GNUNET_BANDWIDTH_tracker_notification_stop

(

struct GNUNET_BANDWIDTH_Tracker *

av

)

Stop notifying about tracker updates and excess notifications.

Parameters

av	the respective trackers

Definition at line 302 of file bandwidth.c.

{
  if (NULL != av->excess_task)
    GNUNET_SCHEDULER_cancel (av->excess_task);
  av->excess_task = NULL;
  av->excess_cb = NULL;
  av->excess_cb_cls = NULL;
  av->update_cb = NULL;
  av->update_cb_cls = NULL;
}

References GNUNET_BANDWIDTH_Tracker::excess_cb, GNUNET_BANDWIDTH_Tracker::excess_cb_cls, GNUNET_BANDWIDTH_Tracker::excess_task, GNUNET_SCHEDULER_cancel(), GNUNET_BANDWIDTH_Tracker::update_cb, and GNUNET_BANDWIDTH_Tracker::update_cb_cls.

Referenced by neighbour_delete().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_BANDWIDTH_tracker_consume()

int GNUNET_BANDWIDTH_tracker_consume	(	struct GNUNET_BANDWIDTH_Tracker *	av,
		ssize_t	size
	)

Notify the tracker that a certain number of bytes of bandwidth have been consumed.

Note that it is legal to consume bytes even if not enough bandwidth is available (in that case, GNUNET_BANDWIDTH_tracker_get_delay() may return non-zero delay values even for a size of zero for a while).

Parameters

av	tracker to update
size	number of bytes consumed

Returns

GNUNET_YES if this consumption is above the limit

Definition at line 368 of file bandwidth.c.

{
  int64_t nc;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Tracker %p consumes %d bytes\n",
       av,
       (int) size);
  if (size > 0)
  {
    nc = av->consumption_since_last_update__ + size;
    if (nc < av->consumption_since_last_update__)
    {
      /* integer overflow, very bad */
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    av->consumption_since_last_update__ = nc;
    update_tracker (av);
    update_excess (av);
    if (av->consumption_since_last_update__ > 0)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Tracker %p consumption %llu bytes above limit\n",
           av,
           (unsigned long long) av->consumption_since_last_update__);
      return GNUNET_YES;
    }
  }
  else
  {
    nc = av->consumption_since_last_update__ + size;
    if (nc > av->consumption_since_last_update__)
    {
      /* integer underflow, very bad */
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    av->consumption_since_last_update__ = nc;
    update_excess (av);
  }
  return GNUNET_NO;
}

References GNUNET_BANDWIDTH_Tracker::consumption_since_last_update__, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, LOG, nc, size, update_excess(), and update_tracker().

Referenced by notify_send_done(), reservations_reserve(), and transmit_next().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_BANDWIDTH_tracker_get_delay()

struct GNUNET_TIME_Relative GNUNET_BANDWIDTH_tracker_get_delay	(	struct GNUNET_BANDWIDTH_Tracker *	av,
		size_t	size
	)

Compute how long we should wait until consuming size bytes of bandwidth in order to stay within the given quota.

Parameters

av	tracker to query
size	number of bytes we would like to consume

Returns

time to wait for consumption to be OK

Compute how long we should wait until consuming size bytes of bandwidth in order to stay within the given quota.

Parameters

av	tracker to query
size	number of bytes we would like to consume

Returns

time in ms to wait for consumption to be OK

Definition at line 368 of file bandwidth.c.

{
  struct GNUNET_TIME_Relative ret;
  int64_t bytes_needed;
 
  if (0 == av->available_bytes_per_s__)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay is infinity\n", av);
    return GNUNET_TIME_UNIT_FOREVER_REL;
  }
  update_tracker (av);
  bytes_needed = size + av->consumption_since_last_update__;
  if (bytes_needed <= 0)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Tracker %p delay for %u bytes is zero\n",
         av,
         (unsigned int) size);
    return GNUNET_TIME_UNIT_ZERO;
  }
  ret.rel_value_us = (1000LL * 1000LL * bytes_needed)
                     / (unsigned long long) av->available_bytes_per_s__;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Tracker %p delay for %u bytes is %s\n",
       av,
       (unsigned int) size,
       GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
  return ret;
}

Referenced by notify_send_done(), outbound_bw_tracker_update(), reservations_reserve(), and transmit_next().

Here is the caller graph for this function:

GNUNET_BANDWIDTH_tracker_get_available()

int64_t GNUNET_BANDWIDTH_tracker_get_available

(

struct GNUNET_BANDWIDTH_Tracker *

av

)

Compute how many bytes are available for consumption right now.

quota.

Parameters

av	tracker to query

Returns

number of bytes available for consumption right now

Definition at line 464 of file bandwidth.c.

{
  struct GNUNET_BANDWIDTH_Value32NBO bps;
  uint64_t avail;
  int64_t used;
 
  update_tracker (av);
  bps = GNUNET_BANDWIDTH_value_init (av->available_bytes_per_s__);
  avail =
    GNUNET_BANDWIDTH_value_get_available_until (bps,
                                                GNUNET_TIME_absolute_get_duration (
                                                  av->last_update__));
  used = av->consumption_since_last_update__;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Tracker %p available bandwidth is %lld bytes\n",
       av,
       (long long) (int64_t) (avail - used));
  return (int64_t) (avail - used);
}

References GNUNET_BANDWIDTH_Tracker::available_bytes_per_s__, GNUNET_BANDWIDTH_Tracker::consumption_since_last_update__, GNUNET_BANDWIDTH_value_get_available_until(), GNUNET_BANDWIDTH_value_init(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_TIME_absolute_get_duration(), GNUNET_BANDWIDTH_Tracker::last_update__, LOG, and update_tracker().

Here is the call graph for this function:

GNUNET_BANDWIDTH_tracker_update_quota()

void GNUNET_BANDWIDTH_tracker_update_quota	(	struct GNUNET_BANDWIDTH_Tracker *	av,
		struct GNUNET_BANDWIDTH_Value32NBO	bytes_per_second_limit
	)

Update quota of bandwidth tracker.

Parameters

av	tracker to initialize
bytes_per_second_limit	new limit to assume

Definition at line 492 of file bandwidth.c.

{
  uint32_t old_limit;
  uint32_t new_limit;
 
  new_limit = ntohl (bytes_per_second_limit.value__);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Tracker %p bandwidth changed to %u Bps\n",
       av,
       (unsigned int) new_limit);
  update_tracker (av);
  old_limit = av->available_bytes_per_s__;
  av->available_bytes_per_s__ = new_limit;
  if (NULL != av->update_cb)
    av->update_cb (av->update_cb_cls);
  if (old_limit > new_limit)
    update_tracker (av); /* maximum excess might be less now */
  update_excess (av);
}

References GNUNET_BANDWIDTH_Tracker::available_bytes_per_s__, GNUNET_ERROR_TYPE_DEBUG, LOG, GNUNET_BANDWIDTH_Tracker::update_cb, GNUNET_BANDWIDTH_Tracker::update_cb_cls, update_excess(), update_tracker(), and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by GAS_reservations_set_bandwidth(), handle_connect(), handle_set_quota(), and set_incoming_quota().

Here is the call graph for this function:

Here is the caller graph for this function: