/**
* 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).
*
* @param av tracker to update
* @param size number of bytes consumed
* @return #GNUNET_YES if this consumption is above the limit
*/
int
GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
ssize_t size)
{
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;
}
/**
* Update quota of bandwidth tracker.
*
* @param av tracker to initialize
* @param bytes_per_second_limit new limit to assume
*/
void
GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av,
struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit)
{
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);
}
/**
* Initialize bandwidth tracker. Note that in addition to the
* 'max_carry_s' limit, we also always allow at least
* #GNUNET_SERVER_MAX_MESSAGE_SIZE to accumulate. So if the
* bytes-per-second limit is so small that within 'max_carry_s' not
* even #GNUNET_SERVER_MAX_MESSAGE_SIZE is allowed to accumulate, it is
* ignored and replaced by #GNUNET_SERVER_MAX_MESSAGE_SIZE (which is in
* bytes).
*
* To stop notifications about updates and excess callbacks use
* #GNUNET_BANDWIDTH_tracker_notification_stop().
*
* @param av tracker to initialize
* @param update_cb callback to notify a client about the tracker being updated
* @param update_cb_cls cls for the callback
* @param bytes_per_second_limit initial limit to assume
* @param max_carry_s maximum number of seconds unused bandwidth
* may accumulate before it expires
* @param excess_cb callback to notify if we have excess bandwidth
* @param excess_cb_cls closure for @a excess_cb
*/
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)
{
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);
}
