int
ACE_Token_Proxy::renew (int requeue_position,
ACE_Synch_Options &options)
{
ACE_TRACE ("ACE_Token_Proxy::renew");
if (this->token_ == 0)
{
errno = ENOENT;
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Not open.\n")),
-1);
}
// Make sure no one calls our token_acquired until we have a chance
// to sleep first!
this->waiter_->cond_var_.mutex ().acquire ();
if (this->token_->renew (this->waiter_, requeue_position) == -1)
{
// check for error
if (errno != EWOULDBLOCK)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p renew failed\n"), ACE_TEXT ("ACE_Token_Proxy")), -1);
if (this->debug_)
ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) renew blocking for %s, owner is %s\n"),
this->name (),
token_->owner_id ()));
// no error, but would block, so block or return
return this->handle_options (options, waiter_->cond_var_);
}
else
// we have the token
{
if (this->debug_)
ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) renewed %s\n"),
this->name ()));
waiter_->cond_var_.mutex ().release ();
return 0;
}
}
void*
ACE_Threading_Helper<ACE_Thread_Mutex>::get (void)
{
void* temp = 0;
if (ACE_Thread::getspecific (key_, &temp) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) Service Config failed to get thread key value: %p\n"),
ACE_TEXT("")),
0);
return temp;
}
int
ACE_RAPI_Session::update_qos (void)
{
// Update the session QoS Parameters based on the RSVP Event Received.
if ((rsvp_error = rapi_dispatch ()) != 0)
ACELIB_ERROR_RETURN ((LM_ERROR,
"Error in rapi_dispatch () : %s\n",
rapi_errlist[rsvp_error]),
-1);
return 0;
}
int
ACE_Proactor_Timer_Handler::svc (void)
{
ACE_Time_Value absolute_time;
ACE_Time_Value relative_time;
int result = 0;
while (this->shutting_down_ == 0)
{
// Check whether the timer queue has any items in it.
if (this->proactor_.timer_queue ()->is_empty () == 0)
{
// Get the earliest absolute time.
absolute_time = this->proactor_.timer_queue ()->earliest_time ();
// Get current time from timer queue since we don't know
// which <gettimeofday> was used.
ACE_Time_Value cur_time =
this->proactor_.timer_queue ()->gettimeofday ();
// Compare absolute time with curent time received from the
// timer queue.
if (absolute_time > cur_time)
relative_time = absolute_time - cur_time;
else
relative_time = ACE_Time_Value::zero;
// Block for relative time.
result = this->timer_event_.wait (&relative_time, 0);
}
else
// The timer queue has no entries, so wait indefinitely.
result = this->timer_event_.wait ();
// Check for timer expiries.
if (result == -1)
{
switch (errno)
{
case ETIME:
// timeout: expire timers
this->proactor_.timer_queue ()->expire ();
break;
default:
// Error.
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%N:%l:(%P | %t):%p\n"),
ACE_TEXT ("ACE_Proactor_Timer_Handler::svc:wait failed")),
-1);
}
}
}
return 0;
}
int
ACE_Name_Proxy::request_reply (ACE_Name_Request &request)
{
ACE_TRACE ("ACE_Name_Proxy::request_reply");
void *buffer;
ssize_t length = request.encode (buffer);
if (length == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("encode failed")),
-1);
// Transmit request via a blocking send.
if (this->peer_.send_n (buffer, length) != length)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("send_n failed")),
-1);
else
{
ACE_Name_Reply reply;
// Receive reply via blocking read.
if (this->peer_.recv_n (&reply,
sizeof reply) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("recv failed")),
-1);
else if (reply.decode () == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("decode failed")),
-1);
errno = int (reply.errnum ());
return reply.status ();
}
}
int
ACE_Service_Config::parse_args_i (int argc, ACE_TCHAR *argv[])
{
ACE_TRACE ("ACE_Service_Config::parse_args_i");
// Using PERMUTE_ARGS (default) in order to have all
// unrecognized options and their value arguments moved
// to the end of the argument vector. We'll pick them up
// after processing our options and pass them on to the
// base class for further parsing.
//FUZZ: disable check_for_lack_ACE_OS
ACE_Get_Opt getopt (argc,
argv,
ACE_TEXT ("bs:p:"),
1 , // Start at argv[1].
0, // Do not report errors
ACE_Get_Opt::RETURN_IN_ORDER);
//FUZZ: enable check_for_lack_ACE_OS
//FUZZ: disable check_for_lack_ACE_OS
for (int c; (c = getopt ()) != -1; )
//FUZZ: enable check_for_lack_ACE_OS
switch (c)
{
case 'p':
ACE_Service_Config::pid_file_name_ = getopt.opt_arg ();
break;
case 'b':
ACE_Service_Config::be_a_daemon_ = true;
break;
case 's':
{
// There's no point in dealing with this on NT since it
// doesn't really support signals very well...
#if !defined (ACE_LACKS_UNIX_SIGNALS)
ACE_Service_Config::signum_ =
ACE_OS::atoi (getopt.opt_arg ());
if (ACE_Reactor::instance ()->register_handler
(ACE_Service_Config::signum_,
ACE_Service_Config::signal_handler_) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("cannot obtain signal handler\n")),
-1);
#endif /* ACE_LACKS_UNIX_SIGNALS */
break;
}
default:; // unknown arguments are benign
}
return 0;
} /* parse_args_i () */
// Compute the new map_size of the backing store and commit the
// memory.
int
ACE_MMAP_Memory_Pool::commit_backing_store_name (size_t rounded_bytes,
size_t & map_size)
{
ACE_TRACE ("ACE_MMAP_Memory_Pool::commit_backing_store_name");
#if defined (__Lynx__)
map_size = rounded_bytes;
#else
size_t seek_len;
if (this->write_each_page_)
// Write to the end of every block to ensure that we have enough
// space in the backing store.
seek_len = this->round_up (1); // round_up(1) is one page.
else
// We're willing to risk it all in the name of efficiency...
seek_len = rounded_bytes;
// The following loop will execute multiple times (if
// this->write_each_page == 1) or just once (if
// this->write_each_page == 0).
for (size_t cur_block = 0;
cur_block < rounded_bytes;
cur_block += seek_len)
{
map_size =
ACE_Utils::truncate_cast<size_t> (
ACE_OS::lseek (this->mmap_.handle (),
static_cast<ACE_OFF_T> (seek_len - 1),
SEEK_END));
if (map_size == static_cast<size_t> (-1)
|| ACE_OS::write (this->mmap_.handle (),
"",
1) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
this->backing_store_name_),
-1);
}
#if defined (ACE_OPENVMS)
::fsync(this->mmap_.handle());
#endif
// Increment by one to put us at the beginning of the next chunk...
++map_size;
#endif /* __Lynx__ */
return 0;
}
int
ACE_Name_Proxy::send_request (ACE_Name_Request &request)
{
ACE_TRACE ("ACE_Name_Proxy::send_request");
void *buffer;
ssize_t length = request.encode (buffer);
if (length == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("encode failed")),
-1);
// Transmit request via a blocking send.
else if (this->peer_.send_n (buffer, length) != length)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("send_n failed")),
-1);
return 0;
}
int
ACE_Remote_Token_Proxy::initiate_connection (void)
{
ACE_TRACE ("ACE_Remote_Token_Proxy::initiate_connection");
if (token_ == 0)
{
errno = ENOENT;
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ACE_Remote_Token_Proxy not open.\n")), -1);
}
ACE_SOCK_Stream *peer = ACE_Token_Connections::instance ()->get_connection ();
return peer == 0 ? 0 : 1;
}
int
ACE_Proactor_Handle_Timeout_Upcall::proactor (ACE_Proactor &proactor)
{
if (this->proactor_ == 0)
{
this->proactor_ = &proactor;
return 0;
}
else
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ACE_Proactor_Handle_Timeout_Upcall is only suppose")
ACE_TEXT (" to be used with ONE (and only one) Proactor\n")),
-1);
}
int
ACE_Remote_Token_Proxy::renew (int requeue_position,
ACE_Synch_Options &options)
{
ACE_TRACE ("ACE_Remote_Token_Proxy::renew");
if (ACE_Token_Proxy::renew (requeue_position,
ACE_Synch_Options::asynch) == -1)
{
// Check for error.
if (errno != EWOULDBLOCK)
return -1;
else if (debug_)
ACELIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) shadow: renew would block. owner %s.\n"),
this->token_->owner_id ()));
}
ACE_Token_Request request (token_->type (),
this->type (),
ACE_Token_Request::RENEW,
this->name (),
this->client_id (),
options);
request.requeue_position (requeue_position);
int result = this->request_reply (request, options);
if (result == -1)
{
{
// Save/restore errno.
ACE_Errno_Guard error (errno);
ACE_Token_Proxy::release ();
}
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p error on remote renew, releasing shadow mutex.\n"),
ACE_TEXT ("ACE_Remote_Token_Proxy")), -1);
}
else
{
if (debug_)
ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) renewed %s remotely.\n"), this->name ()));
// Make sure that the local shadow reflects our new ownership.
token_->make_owner (waiter_);
return result;
}
}
int
ACE_ARGV_T<CHAR_TYPE>::add (const CHAR_TYPE *next_arg, bool quote_arg)
{
// Only allow this to work in the "iterative" verion -- the
// ACE_ARGVs created with the one argument constructor.
if (!this->iterative_)
{
errno = EINVAL;
return -1;
}
this->length_ += ACE_OS::strlen (next_arg);
if (quote_arg && ACE_OS::strchr (next_arg, ' ') != 0)
{
this->length_ += 2;
if (ACE_OS::strchr (next_arg, '"') != 0)
for (const CHAR_TYPE * p = next_arg; *p != '\0'; ++p)
if (*p == '"') ++this->length_;
}
else
{
quote_arg = false;
}
// Put the new argument at the end of the queue.
if (this->queue_.enqueue_tail (ACE_ARGV_Queue_Entry_T<CHAR_TYPE> (next_arg, quote_arg)) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Can't add more to ARGV queue")),
-1);
++this->argc_;
// Wipe argv_ and buf_ away so that they will be recreated if the
// user calls argv () or buf ().
if (this->argv_ != 0)
{
for (int i = 0; this->argv_[i] != 0; i++)
ACE_OS::free ((void *) this->argv_[i]);
delete [] this->argv_;
this->argv_ = 0;
}
delete [] this->buf_;
this->buf_ = 0;
return 0;
}
// Close the RAPI QoS Session.
int
ACE_RAPI_Session::close (void)
{
this->rsvp_error = rapi_release(this->session_id_);
if (rsvp_error == 0)
ACELIB_ERROR_RETURN ((LM_ERROR,
"Can't release RSVP session:\n\t%s\n",
rapi_errlist[rsvp_error]),
-1);
else
ACELIB_DEBUG ((LM_DEBUG,
"rapi session with id %d released successfully.\n",
this->session_id_));
return 0;
}
int
ACE_Token_Proxy::tryacquire (void (*sleep_hook)(void *))
{
ACE_TRACE ("ACE_Token_Proxy::tryacquire");
if (this->token_ == 0)
{
errno = ENOENT;
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Not open.\n")),
-1);
}
this->waiter_->sleep_hook (sleep_hook);
return this->token_->tryacquire (waiter_);
}
size_t
Monitor_Base::count (void) const
{
if (this->data_.type_ == Monitor_Control_Types::MC_GROUP)
{
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("count: %s is a monitor group\n"),
this->name_.c_str ()),
0UL);
}
ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0UL);
return (this->data_.type_ == Monitor_Control_Types::MC_COUNTER
? static_cast<size_t> (this->data_.last_)
: this->data_.index_);
}
double
Monitor_Base::last_sample (void) const
{
if (this->data_.type_ == Monitor_Control_Types::MC_GROUP
|| this->data_.type_ == Monitor_Control_Types::MC_LIST)
{
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("last_sample: %s ")
ACE_TEXT ("is wrong monitor type\n"),
this->name_.c_str ()),
0);
}
ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0.0);
return this->data_.last_;
}
template <class HANDLER> int
ACE_Asynch_Connector<HANDLER>::connect (const ACE_INET_Addr & remote_sap,
const ACE_INET_Addr & local_sap,
int reuse_addr,
const void *act)
{
// Initiate asynchronous connect
if (this->asynch_connect_.connect (ACE_INVALID_HANDLE,
remote_sap,
local_sap,
reuse_addr,
act) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ACE_Asynch_Connect::connect")),
-1);
return 0;
}
void *
ACE_Sbrk_Memory_Pool::acquire (size_t nbytes,
size_t &rounded_bytes)
{
ACE_TRACE ("ACE_Sbrk_Memory_Pool::acquire");
rounded_bytes = this->round_up (nbytes);
// ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) acquiring more chunks, nbytes = %d, rounded_bytes = %d\n"), nbytes, rounded_bytes));
void *cp = ACE_OS::sbrk (rounded_bytes);
if (cp == MAP_FAILED)
ACELIB_ERROR_RETURN ((LM_ERROR,
"(%P|%t) cp = %u\n",
cp),
0);
else
// ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) acquired more chunks, nbytes = %d, rounded_bytes = %d, new break = %u\n"), nbytes, rounded_bytes, cp));
return cp;
}
rapi_flowspec_t *
ACE_RAPI_Session::init_flowspec_simplified(const ACE_Flow_Spec &flow_spec)
{
rapi_flowspec_t *flowsp;
ACE_NEW_RETURN (flowsp,
rapi_flowspec_t,
0);
// Extended Legacy format.
qos_flowspecx_t *csxp = &flowsp->specbody_qosx;
// Choose based on the service type : [QOS_GUARANTEEDX/QOS_CNTR_LOAD].
switch (flow_spec.service_type ())
{
case QOS_GUARANTEEDX:
csxp->xspec_R = 0 ; // Guaranteed Rate B/s. @@How does this map to the
// ACE Flow Spec Parameters.
csxp->xspec_S = flow_spec.delay_variation () ; // Slack term in MICROSECONDS
// Note there is no break !!
case QOS_CNTR_LOAD:
csxp->spec_type = flow_spec.service_type (); // qos_service_type
csxp->xspec_r = flow_spec.token_rate (); // Token Bucket Average Rate (B/s)
csxp->xspec_b = flow_spec.token_bucket_size (); // Token Bucket Rate (B)
csxp->xspec_p = flow_spec.peak_bandwidth (); // Peak Data Rate (B/s)
csxp->xspec_m = flow_spec.minimum_policed_size (); // Minimum Policed Unit (B)
csxp->xspec_M = flow_spec.max_sdu_size(); // Max Packet Size (B)
flowsp->form = RAPI_FLOWSTYPE_Simplified;
break;
default:
ACELIB_ERROR_RETURN ((LM_ERROR,
"(%N|%l) Unknown flowspec type: %u\n",flow_spec.service_type () ),
0);
}
flowsp->len = sizeof(rapi_flowspec_t);
return flowsp;
}
int
ACE_Registry_Name_Space::list_name_entries (ACE_BINDING_SET &set,
const ACE_NS_WString &pattern)
{
ACE_UNUSED_ARG(pattern);
ACE_Registry::Binding_List list;
int result = this->context_.list (list);
if (result != 0)
return result;
// Iterator through all entries
for (ACE_Registry::Binding_List::iterator i = list.begin ();
i != list.end ();
i++)
{
// Yeeesss! STL rules!
ACE_Registry::Binding &binding = *i;
if (binding.type () == ACE_Registry::OBJECT)
{
// Key
ACE_TString string = binding.name ();
ACE_NS_WString key (string.c_str ());
// Value
ACE_NS_WString value;
char *type = 0;
result = this->resolve (key,
value,
type);
if (result != 0)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ACE_Registry::Naming_Context::resolve")),
result);
// Complete binding
ACE_Name_Binding binding (key, value, type);
set.insert (binding);
}
}
return 0;
}
double
Monitor_Base::average (void) const
{
if (this->data_.type_ == Monitor_Control_Types::MC_COUNTER
|| this->data_.type_ == Monitor_Control_Types::MC_GROUP
|| this->data_.type_ == Monitor_Control_Types::MC_LIST)
{
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("average: %s is wrong monitor type\n"),
this->name_.c_str ()),
0);
}
ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0.0);
return (this->data_.index_== 0UL
? 0.0
: this->data_.sum_ / this->data_.index_);
}
int
ACE_Token_Collection::insert (ACE_Token_Proxy &new_token)
{
ACE_TRACE ("ACE_Token_Collection::insert");
TOKEN_NAME name (new_token.name ());
// Check if the new_proxy is already in the list.
if (collection_.find (name) == 1)
// One already exists, so fail.
return -1;
// Clone the new token.
ACE_Token_Proxy *temp = new_token.clone ();
if (collection_.bind (name, temp) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("bind failed\n")), -1);
return 0;
}
int
ACE_Shared_Memory_Pool::find_seg (const void* const searchPtr,
ACE_OFF_T &offset,
size_t &counter)
{
#ifndef ACE_HAS_SYSV_IPC
ACE_UNUSED_ARG (searchPtr);
ACE_UNUSED_ARG (offset);
ACE_UNUSED_ARG (counter);
ACE_NOTSUP_RETURN (-1);
#else
offset = 0;
SHM_TABLE *st = reinterpret_cast<SHM_TABLE *> (this->base_addr_);
shmid_ds buf;
for (counter = 0;
counter < this->max_segments_
&& st[counter].used_ == 1;
counter++)
{
if (ACE_OS::shmctl (st[counter].shmid_, IPC_STAT, &buf) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("shmctl")),
-1);
offset += buf.shm_segsz;
// If segment 'counter' starts at a location greater than the
// place we are searching for. We then decrement the offset to
// the start of counter-1. ([email protected])
if (((ptrdiff_t) offset + (ptrdiff_t) (this->base_addr_)) > (ptrdiff_t) searchPtr)
{
--counter;
offset -= buf.shm_segsz;
return 0;
}
// ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) segment size = %d, offset = %d\n"), buf.shm_segsz, offset));
}
return 0;
#endif
}
int
ACE_Token_Collection::renew (const ACE_TCHAR *token_name,
int requeue_position,
ACE_Synch_Options &options)
{
ACE_TRACE ("ACE_Token_Collection::renew");
TOKEN_NAME name (token_name);
ACE_Token_Proxy *temp;
// Get the token from the collection.
int result = collection_.find (name, temp);
// Did we find it?
if (result == -1)
ACELIB_ERROR_RETURN ((LM_DEBUG, ACE_TEXT ("%p %s\n"),
ACE_TEXT ("not in collection "),
token_name), -1);
// perform the operation
return temp->renew (requeue_position, options);
}
template <class HANDLER> int
ACE_Asynch_Connector<HANDLER>::open (bool pass_addresses,
ACE_Proactor *proactor,
bool validate_new_connection)
{
this->proactor (proactor);
this->pass_addresses_ = pass_addresses;
this->validate_new_connection_ = validate_new_connection;
// Initialize the ACE_Asynch_Connect
if (this->asynch_connect_.open (*this,
ACE_INVALID_HANDLE,
0,
this->proactor ()) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ACE_Asynch_Connect::open")),
-1);
return 0;
}
void *
ACE_Local_Memory_Pool::acquire (size_t nbytes,
size_t &rounded_bytes)
{
ACE_TRACE ("ACE_Local_Memory_Pool::acquire");
rounded_bytes = this->round_up (nbytes);
char *temp = 0;
ACE_NEW_RETURN (temp,
char[rounded_bytes],
0);
ACE_Auto_Basic_Array_Ptr<char> cp (temp);
if (this->allocated_chunks_.insert (cp.get ()) != 0)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) insertion into set failed\n")),
0);
return cp.release ();
}
int
ACE_Remote_Name_Space::list_type_entries (ACE_BINDING_SET &set,
const ACE_NS_WString &pattern)
{
ACE_TRACE ("ACE_Remote_Name_Space::list_type_entries");
ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
ACE_UINT32 pattern_len =
static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
ACE_Name_Request request (ACE_Name_Request::LIST_TYPE_ENTRIES,
pattern_urep.get (),
pattern_len,
0, 0, 0, 0);
if (this->ns_proxy_.send_request (request) == -1)
return -1;
ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
{
if (this->ns_proxy_.recv_reply (reply) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ACE_Remote_Name_Space::list_values")),
-1);
if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
{
ACE_NS_WString name (reply.name (),
reply.name_len () / sizeof (ACE_WCHAR_T));
ACE_NS_WString value (reply.value (),
reply.value_len () / sizeof (ACE_WCHAR_T));
ACE_Name_Binding entry (name,
value,
reply.type ());
if (set.insert (entry) == -1)
return -1;
}
}
return 0;
}
int
ACE_Token_Proxy::handle_options (ACE_Synch_Options &options,
ACE_TOKEN_CONST::COND_VAR &cv)
{
// Some operation failed with EWOULDBLOCK.
ACE_TRACE ("ACE_Token_Proxy::handle_options");
if (options[ACE_Synch_Options::USE_REACTOR] == 1)
// Asynchronous.
{
// Save/restore errno.
ACE_Errno_Guard error (errno);
cv.mutex ().release ();
ACE_RETURN (-1);
}
else
// Synchronous.
{
// Block on condition variable.
while (cv.wait ((ACE_Time_Value *) options.time_value ()) == -1)
{
// Note, this should obey whatever thread-specific
// interrupt policy is currently in place...
if (errno == EINTR)
continue;
// We come here if a timeout occurs or some serious
// ACE_Condition object error.
cv.mutex ().release ();
ACELIB_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("condition variable wait")
ACE_TEXT (" bombed.")), -1);
}
if (this->debug_)
ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) unblocking %s.\n"),
this->client_id ()));
cv.mutex ().release ();
return 0; // operation succeeded
}
}
int
ACE_Shared_Memory_Pool::in_use (ACE_OFF_T &offset,
size_t &counter)
{
offset = 0;
SHM_TABLE *st = reinterpret_cast<SHM_TABLE *> (this->base_addr_);
shmid_ds buf;
for (counter = 0;
counter < this->max_segments_ && st[counter].used_ == 1;
counter++)
{
if (ACE_OS::shmctl (st[counter].shmid_, IPC_STAT, &buf) == -1)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("shmctl")),
-1);
offset += buf.shm_segsz;
// ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) segment size = %d, offset = %d\n"), buf.shm_segsz, offset));
}
return 0;
}
int
ACE_Process_Options::command_line (const ACE_TCHAR *const argv[])
{
int i = 0;
if (argv[i])
{
ACE_OS::strcat (command_line_buf_, argv[i]);
while (argv[++i])
{
// Check to see if the next argument will overflow the
// command_line buffer.
size_t const cur_len =
ACE_OS::strlen (command_line_buf_)
+ ACE_OS::strlen (argv[i])
+ 2;
if (cur_len > command_line_buf_len_)
{
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ACE_Process:command_line: ")
ACE_TEXT ("command line is ")
ACE_TEXT ("longer than %d\n"),
command_line_buf_len_),
1);
}
ACE_OS::strcat (command_line_buf_, ACE_TEXT (" "));
ACE_OS::strcat (command_line_buf_, argv[i]);
}
}
command_line_argv_calculated_ = false;
return 0; // Success.
}
