NSAPI_PUBLIC int netbuf_grab(netbuf *buf, int sz) {
int n;
if(!buf->inbuf) {
buf->inbuf = (unsigned char *) MALLOC(sz);
buf->maxsize = sz;
}
else if(sz > buf->maxsize) {
buf->inbuf = (unsigned char *) REALLOC(buf->inbuf, sz);
buf->maxsize = sz;
}
PR_ASSERT(buf->pos == buf->cursize);
buf->pos = 0;
buf->cursize = 0;
while(1) {
switch(n = net_read(buf->sd,(char *)(buf->inbuf),sz,buf->rdtimeout)) {
case IO_EOF:
return IO_EOF;
case IO_ERROR: {
buf->errmsg = system_errmsg();
return IO_ERROR;
}
default:
buf->cursize = n;
return n;
}
}
}
PRBool NTStatsServer::init(void)
{
PRBool retval = PR_FALSE;
//Sleep(15000);
if ((retval = createStatsChannel()) != PR_TRUE)
{
PR_ASSERT(0);
ereport(LOG_FAILURE,
XP_GetAdminStr(DBT_NTStatsServer_ErrorChannelCreation));
return retval;
}
// We need to create a global bound thread as this thread
// doesn't wait on PR APIs. It waits on MsgWaitForMultipleObjects
// By default, it seems PR_CreateThread creates a fibre which
// hangs the StatsPollThread.
if (start(PR_SYSTEM_THREAD, PR_UNJOINABLE_THREAD,
0, PR_PRIORITY_NORMAL, PR_GLOBAL_BOUND_THREAD) == PR_FAILURE)
{
PRInt32 err = PR_GetError();
PRInt32 oserr = PR_GetOSError();
ereport(LOG_FAILURE,
XP_GetAdminStr(DBT_StatsManager_FailedToCreateThread),
system_errmsg());
}
return PR_TRUE;
}
char *_add_table_event(EVENT_HANDLER *handler)
{
HANDLE event;
char *err;
EVENT_HANDLER *tmp;
if(!(event = CreateEvent(NULL, FALSE, FALSE, handler->event_name))) {
err = (char *)MALLOC(ERR_MSG_LEN);
util_snprintf(err, ERR_MSG_LEN, "could not open create event %s (%s)",
handler->event_name, system_errmsg());
TERMINATE_HANDLER_THREAD();
return err;
}
if (!events) {
events = (HANDLE *)MALLOC(sizeof(HANDLE));
} else {
events = (HANDLE *)REALLOC(events, (sizeof(events) + sizeof(HANDLE)));
}
events[event_number -1] = event;
if (!handler_table) {
handler_table = handler;
} else {
/* Prevent duplicate handlers from being entered */
for (tmp = handler_table; tmp; tmp = tmp->next) {
if (!strcmp(tmp->event_name, handler->event_name)) {
return NULL;
}
}
handler->next = handler_table;
handler_table = handler;
}
return NULL;
}
NSAPI_PUBLIC int netbuf_getbytes(netbuf *buf, char *buffer, int size)
{
int bytes;
if (!buf->inbuf) {
buf->inbuf = (unsigned char *) MALLOC(buf->maxsize);
} else {
if (buf->pos < buf->cursize) {
int bytes_in_buffer = buf->cursize - buf->pos;
if (bytes_in_buffer > size)
bytes_in_buffer = size;
memcpy(buffer, &(buf->inbuf[buf->pos]), bytes_in_buffer);
buf->pos += bytes_in_buffer;
return bytes_in_buffer;
}
}
/* The netbuf is empty. Read data directly into the caller's buffer */
bytes = net_read(buf->sd, buffer, size, buf->rdtimeout);
if (bytes == 0)
return NETBUF_EOF;
if (bytes < 0) {
buf->errmsg = system_errmsg();
return NETBUF_ERROR;
}
return bytes;
}
char *initialize_event_handler(char *serverid)
{
char *err;
char mutex_name[EVENT_LEN];
HANDLE event;
/* First create the global lock -acquire ownership immediately */
util_snprintf(mutex_name, EVENT_LEN, "%s.event_handler", serverid);
eventMutex = CreateMutex(NULL, TRUE, mutex_name);
if (eventMutex == NULL) {
err = (char *)MALLOC(ERR_MSG_LEN);
util_snprintf(err, ERR_MSG_LEN, "Failed to create mutex for event handler %s",
system_errmsg());
return err;
}
/* Create the resume and suspend event names */
util_snprintf(resume, EVENT_LEN, "%s.resume", serverid);
util_snprintf(suspend, EVENT_LEN, "%s.suspend", serverid);
/* Create the global event to resume the event handler thread */
if(!(event = CreateEvent(NULL, FALSE, FALSE, resume))) {
err = (char *)MALLOC(ERR_MSG_LEN);
util_snprintf(err, ERR_MSG_LEN, "could not open create event %s (%s)",
resume, system_errmsg());
RELEASE_EVENT_LOCK;
return err;
}
resumeEvent = (HANDLE *)MALLOC(sizeof(HANDLE));
resumeEvent[0] = event;
if (!handler_thread) {
if (err = _create_handler_thread()) {
RELEASE_EVENT_LOCK;
return err;
}
}
/* Release mutex */
RELEASE_EVENT_LOCK;
return NULL;
}
void _wait_for_resume(void *arg)
{
DWORD wait_result;
if ((wait_result = WaitForMultipleObjects( 1, resumeEvent,
FALSE, INFINITE)) == WAIT_FAILED) {
ereport(LOG_FAILURE, XP_GetAdminStr(DBT_couldNotWaitOnResumeEventEventS_),
system_errmsg());
return;
}
}
Result Context::createNsprErrorResult()
{
PRInt32 prerr = PR_GetError();
PR_ASSERT(prerr != 0);
if (prerr == PR_OUT_OF_MEMORY_ERROR)
return Result::out_of_memory;
return createErrorResult(system_errmsg());
}
NSAPI_PUBLIC ACLListHandle_t *
ACL_ParseString( NSErr_t *errp, char *buffer )
{
ACLListHandle_t *handle = NULL;
int eid = 0;
int rv = 0;
const char *errmsg;
ACL_InitAttr2Index();
if ( acl_parse_crit == NULL )
acl_parse_crit = crit_init();
crit_enter( acl_parse_crit );
if ( acl_InitScanner( errp, NULL, buffer ) < 0 ) {
rv = ACLERRNOMEM;
eid = ACLERR1920;
nserrGenerate(errp, rv, eid, ACL_Program, 0);
} else {
handle = ACL_ListNew(errp);
if ( handle == NULL ) {
rv = ACLERRNOMEM;
eid = ACLERR1920;
nserrGenerate(errp, rv, eid, ACL_Program, 0);
} else if ( acl_PushListHandle( handle ) < 0 ) {
rv = ACLERRNOMEM;
eid = ACLERR1920;
nserrGenerate(errp, rv, eid, ACL_Program, 0);
} else if ( acl_Parse() ) {
rv = ACLERRPARSE;
eid = ACLERR1780;
}
if ( acl_EndScanner() < 0 ) {
rv = ACLERROPEN;
eid = ACLERR1500;
errmsg = system_errmsg();
nserrGenerate(errp, rv, eid, ACL_Program, 2, "buffer", errmsg);
}
}
if ( rv || eid ) {
ACL_ListDestroy(errp, handle);
handle = NULL;
}
crit_exit( acl_parse_crit );
return(handle);
}
char *_resume_handler()
{
HANDLE resume_event;
char *err;
resume_event = OpenEvent(EVENT_ALL_ACCESS, FALSE, resume);
if (resume_event == NULL) {
err = (char *)MALLOC(ERR_MSG_LEN);
util_snprintf(err, ERR_MSG_LEN, "could not open resume event (%s)",
system_errmsg());
return err;
}
if(!SetEvent(resume_event)) {
err = (char *)MALLOC(ERR_MSG_LEN);
util_snprintf(err, ERR_MSG_LEN, "cannot set reset event (%s)",
system_errmsg());
return err;
}
return NULL;
}
char *_create_rotation_thread()
{
char *err;
handler_thread = systhread_start(15, 65536, _wait_for_events,
NULL);
if (handler_thread == NULL) {
err = (char *)MALLOC(ERR_MSG_LEN);
util_snprintf(err, ERR_MSG_LEN, "Failed to start event handler thread %s",
system_errmsg());
return err;
}
return NULL;
}
//-----------------------------------------------------------------------------
// HpuxProcessStats::init
//-----------------------------------------------------------------------------
PRStatus HpuxProcessStats::init()
{
struct pst_static s_pst_static;
memset(&s_pst_static,sizeof(s_pst_static),0);
if(pstat_getstatic(&s_pst_static, sizeof(s_pst_static),1,0)==-1){
ereport(LOG_FAILURE, XP_GetAdminStr(DBT_ProcessStats_OpenFailed), system_errmsg());
return PR_FAILURE;
}
long page_size = s_pst_static.page_size;
page_size_kb = page_size/1024;
mem_total_kb = s_pst_static.physical_memory * page_size_kb;
return PR_SUCCESS;
}
void _wait_for_events(void *argument)
{
DWORD wait_result;
while(TRUE) {
if ((wait_result = WaitForMultipleObjects( event_number, events,
FALSE, INFINITE)) == WAIT_FAILED) {
ereport(LOG_WARN, XP_GetAdminStr(DBT_eventHandlerFailedToWaitOnEvents_),
system_errmsg());
ENTER_EVENT_LOCK;
TERMINATE_HANDLER_THREAD();
RELEASE_EVENT_LOCK;
} else {
ENTER_EVENT_LOCK;
_execute_event_handler(wait_result - WAIT_OBJECT_0);
ResetEvent(events[wait_result - WAIT_OBJECT_0]);
RELEASE_EVENT_LOCK;
}
}
}
NSAPI_PUBLIC int netbuf_next(netbuf *buf, int advance) {
int n;
if(!buf->inbuf)
buf->inbuf = (unsigned char *) MALLOC(buf->maxsize);
while(1) {
switch(n = net_read(buf->sd,(char *)(buf->inbuf),buf->maxsize,buf->rdtimeout)) {
case IO_EOF:
return IO_EOF;
case IO_ERROR:
buf->errmsg = system_errmsg();
return IO_ERROR;
default:
buf->pos = advance;
buf->cursize = n;
return buf->inbuf[0];
}
}
}
char *_create_handler_thread()
{
char *err;
/* The first event the thread will wait on is the event to suspend
* the event handler thread */
if (err = _create_event(suspend, _wait_for_resume, NULL)) {
return err;
}
handler_thread = systhread_start(15, 65536, _wait_for_events,
NULL);
if (handler_thread == NULL) {
err = (char *)MALLOC(ERR_MSG_LEN);
util_snprintf(err, ERR_MSG_LEN, "Failed to start event handler thread %s",
system_errmsg());
return err;
}
return NULL;
}
PRStatus HpuxProcessStats::getMemUsage(MemUsageInfo *info)
{
struct pst_status pst_status_buf;
if(pstat_getproc(&pst_status_buf,sizeof(pst_status_buf),0,getpid())== -1){
ereport(LOG_FAILURE, XP_GetAdminStr(DBT_ProcessStats_ReadFailed), system_errmsg());
return PR_FAILURE;
}
/*
vtsize--text,vdsize--data, vssize--stack, vshmsize--shared memory,
vmmsize--mem-maped files, vusize--U area, viosize-- IO dev mapping
*/
info->process_size_in_Kbytes = (pst_status_buf.pst_vtsize+pst_status_buf.pst_vdsize
+pst_status_buf.pst_vssize+pst_status_buf.pst_vshmsize+pst_status_buf.pst_vmmsize
+pst_status_buf.pst_vusize+pst_status_buf.pst_viosize)*page_size_kb;
info->process_resident_size_in_Kbytes =(pst_status_buf.pst_rssize)*page_size_kb;
/*
multiply 0x8000 to convert the format to high byte to conforming the definition
of fraction_sys_memory_usage as Solaris.
*/
info->fraction_system_memory_usage = info->process_resident_size_in_Kbytes*0x8000/mem_total_kb;
return PR_SUCCESS;
}
PRStatus initVS(VirtualServer* incoming, const VirtualServer* current)
{
if (!fnInit) return PR_SUCCESS;
// Call (*fnInit) for every matching directive in this VS
PRStatus rv = PR_SUCCESS;
httpd_objset* objset = vs_get_httpd_objset(incoming);
int countObjects = objset_get_number_objects(objset);
int iObject;
for (iObject = 0; iObject < countObjects; iObject++) {
const httpd_object* object = objset_get_object(objset, iObject);
int countDirectiveTables = object_get_num_directives(object);
int iDirectiveTable;
for (iDirectiveTable = 0; iDirectiveTable < countDirectiveTables; iDirectiveTable++) {
const dtable* dir_table = object_get_directive_table(object, iDirectiveTable);
int countDirectives = directive_table_get_num_directives(dir_table);
int iDirective;
for (iDirective = 0; iDirective < countDirectives; iDirective++) {
const directive* dir = directive_table_get_directive(dir_table, iDirective);
const FuncStruct* fs = directive_get_funcstruct(dir);
if (fs && fs->func == fn) {
if ((*fnInit)(dir, incoming, current) != REQ_PROCEED)
rv = PR_FAILURE;
}
}
}
}
if (rv == PR_SUCCESS) {
if (objset_interpolative(objset) != PR_SUCCESS)
ereport(LOG_VERBOSE, "Unable to interpolate objset for virtual server %s (%s)", vs_get_id(incoming), system_errmsg());
}
return rv;
}
NSAPI_PUBLIC int netbuf_buf2file(netbuf *buf, SYS_FILE sd, int len)
{
register int n = len, t, ns;
ns = 0;
/* First, flush the current buffer */
t = buf->cursize - buf->pos;
if((n != -1) && (t > n))
t = n;
if((t) && (sd != SYS_NET_ERRORFD)) {
#if defined(OSF1) || defined(HPUX) || defined(SNI)
OSF_label4:
#endif
if(system_fwrite(sd, (char *)&buf->inbuf[buf->pos], t) == IO_ERROR) {
#if defined(OSF1) || defined(HPUX) || defined(SNI)
if(errno == EINTR) goto OSF_label4;
#endif
buf->errmsg = system_errmsg();
return IO_ERROR;
}
ns += t;
}
buf->pos += t;
if(n != -1) {
n -= t;
if(!n)
return ns;
}
else
t = buf->maxsize;
/* Now, keep blasting until done */
while(1) {
if(n != -1)
t = (n < buf->maxsize ? n : buf->maxsize);
#if defined(OSF1) || defined(HPUX) || defined(SNI)
OSF_label5:
#endif
switch(netbuf_grab(buf, t)) {
case IO_ERROR:
#if defined(OSF1) || defined(HPUX) || defined(SNI)
if(errno == EINTR) goto OSF_label5;
#endif
return IO_ERROR;
case IO_EOF:
if(n == -1)
return ns;
else {
buf->errmsg = "premature EOF";
return IO_ERROR;
}
default:
if(sd != SYS_NET_ERRORFD) {
#if defined(OSF1) || defined(HPUX)
OSF_label6:
#endif
if(system_fwrite(sd, (char *)(buf->inbuf), buf->cursize) == IO_ERROR) {
#if defined(OSF1) || defined(HPUX)
if(errno == EINTR) goto OSF_label6;
#endif
buf->errmsg = system_errmsg();
return IO_ERROR;
}
ns += buf->cursize;
}
if(n != -1) {
n -= buf->cursize;
if(!n)
return ns;
}
break;
}
}
}
/*
* perform netbuf_buf2sd in a timely manner enforcing a timeout handling
* the netbuf_grab() that can potentially receive just one char at a time
* it can go on for a long time -- potentially leading to tying the thread
* resources to the request forever.
*
* timeout can be PR_INTERVAL_NO_TIMEOUT -- no timeout will be enforced.
*/
NSAPI_PUBLIC int netbuf_buf2sd_timed(netbuf *buf,
SYS_NETFD sd, int len, PRIntervalTime timeout)
{
register int n = len, t, ns;
ns = 0;
register PRIntervalTime start = 0;
/* Note the starting time */
if (timeout != PR_INTERVAL_NO_TIMEOUT)
start = PR_IntervalNow();
/* First, flush the current buffer */
t = buf->cursize - buf->pos;
if((n != -1) && (t > n))
t = n;
if((t) && (sd != SYS_NET_ERRORFD)) {
#if defined(OSF1) || defined(HPUX) || defined(SNI)
OSF_label1:
#endif
if(net_write(sd, (char *)&buf->inbuf[buf->pos], t) == IO_ERROR) {
#if defined(OSF1) || defined(HPUX) || defined(SNI)
if(errno == EINTR) goto OSF_label1;
#endif
buf->errmsg = system_errmsg();
return IO_ERROR;
}
ns += t;
}
buf->pos += t;
if(n != -1) {
n -= t;
if(!n)
return ns;
}
else
t = buf->maxsize;
/* Now, keep blasting until done */
while(1) {
/* Check to see if this client is taking too long to process */
if (timeout != PR_INTERVAL_NO_TIMEOUT &&
PR_IntervalNow() > (start + timeout)) {
PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
buf->errmsg = system_errmsg();
return IO_ERROR;
}
if(n != -1)
t = (n < buf->maxsize ? n : buf->maxsize);
#if defined(OSF1) || defined(HPUX) || defined(SNI)
OSF_label2:
#endif
switch(netbuf_grab(buf, t)) {
case IO_ERROR:
#if defined(OSF1) || defined(HPUX) || defined(SNI)
if(errno == EINTR) goto OSF_label2;
#endif
return IO_ERROR;
case IO_EOF:
if(n == -1)
return ns;
else {
PR_SetError(PR_END_OF_FILE_ERROR, 0);
buf->errmsg = system_errmsg();
return IO_ERROR;
}
default:
if(sd != SYS_NET_ERRORFD) {
#if defined(OSF1) || defined(HPUX)
OSF_label3:
#endif
if(net_write(sd, (char *)(buf->inbuf), buf->cursize) == IO_ERROR) {
#if defined(OSF1) || defined(HPUX)
if(errno == EINTR) goto OSF_label3;
#endif
buf->errmsg = system_errmsg();
return IO_ERROR;
}
buf->pos += buf->cursize;
ns += buf->cursize;
}
if(n != -1) {
n -= buf->cursize;
if(!n)
return ns;
}
break;
}
}
}
NSAPI_PUBLIC char *ldapu_err2string(int err)
{
const char *rv;
switch(err) {
/* Error codes defined in certmap.h */
case LDAPU_SUCCESS:
rv = "success";
break;
case LDAPU_FAILED:
rv = "ldap search didn't find an ldap entry";
break;
case LDAPU_CERT_MAP_FUNCTION_FAILED:
rv = "Cert mapping function failed";
break;
case LDAPU_CERT_SEARCH_FUNCTION_FAILED:
rv = "Cert search function failed";
break;
case LDAPU_CERT_VERIFY_FUNCTION_FAILED:
rv = "Cert verify function failed";
break;
case LDAPU_CERT_MAP_INITFN_FAILED:
rv = "Certmap InitFn function failed";
break;
/* Error codes returned by ldapdb.c */
case LDAPU_ERR_URL_INVALID_PREFIX:
rv = "invalid local ldap database url prefix -- must be ldapdb://";
break;
case LDAPU_ERR_URL_NO_BASEDN:
rv = "base dn is missing in ldapdb url";
break;
case LDAPU_ERR_OUT_OF_MEMORY:
rv = "out of memory";
break;
case LDAPU_ERR_LDAP_INIT_FAILED:
rv = "Couldn't initialize connection to the ldap directory server";
break;
case LDAPU_ERR_BIND_FAILED:
rv = "Couldn't bind to the ldap directory server";
break;
case LDAPU_ERR_LCACHE_INIT_FAILED:
rv = "Couldn't initialize connection to the local ldap directory";
break;
case LDAPU_ERR_LDAP_SET_OPTION_FAILED:
rv = "ldap_set_option failed for local ldap database";
break;
case LDAPU_ERR_NO_DEFAULT_CERTDB:
rv = "default cert database not initialized when using LDAP over SSL";
break;
/* Errors returned by ldapauth.c */
case LDAPU_ERR_CIRCULAR_GROUPS:
rv = "Circular groups were detected during group membership check";
break;
case LDAPU_ERR_URL_PARSE_FAILED:
rv = "Invalid member URL";
break;
case LDAPU_ERR_INVALID_STRING:
rv = "Invalid string";
break;
case LDAPU_ERR_INVALID_STRING_INDEX:
rv = "Invalid string index";
break;
case LDAPU_ERR_MISSING_ATTR_VAL:
rv = "Missing attribute value from the search result";
break;
/* Errors returned by dbconf.c */
case LDAPU_ERR_CANNOT_OPEN_FILE:
rv = "cannot open the config file";
break;
case LDAPU_ERR_DBNAME_IS_MISSING:
rv = "database name is missing";
break;
case LDAPU_ERR_PROP_IS_MISSING:
rv = "database property is missing";
break;
case LDAPU_ERR_DIRECTIVE_IS_MISSING:
rv = "illegal directive in the config file";
break;
case LDAPU_ERR_NOT_PROPVAL:
rv = "internal error - LDAPU_ERR_NOT_PROPVAL";
break;
/* Error codes returned by certmap.c */
case LDAPU_ERR_NO_ISSUERDN_IN_CERT:
rv = "cannot extract issuer DN from the cert";
break;
case LDAPU_ERR_NO_ISSUERDN_IN_CONFIG_FILE:
rv = "issuer DN missing for non-default certmap";
break;
case LDAPU_ERR_CERTMAP_INFO_MISSING:
rv = "cert to ldap entry mapping information is missing";
break;
case LDAPU_ERR_MALFORMED_SUBJECT_DN:
rv = "Found malformed subject DN in the certificate";
break;
case LDAPU_ERR_MAPPED_ENTRY_NOT_FOUND:
rv = "Certificate couldn't be mapped to an ldap entry";
break;
case LDAPU_ERR_UNABLE_TO_LOAD_PLUGIN:
rv = "Unable to load certmap plugin library";
break;
case LDAPU_ERR_MISSING_INIT_FN_IN_CONFIG:
rv = "InitFn must be provided when using certmap plugin library";
break;
case LDAPU_ERR_MISSING_INIT_FN_IN_LIB:
rv = "Could not find InitFn in the certmap plugin library";
break;
case LDAPU_ERR_CERT_VERIFY_FAILED:
rv = "Could not matching certificate in User's LDAP entry";
break;
case LDAPU_ERR_CERT_VERIFY_NO_CERTS:
rv = "User's LDAP entry doesn't have any certificates to compare";
break;
case LDAPU_ERR_MISSING_LIBNAME:
rv = "Library name is missing in the config file";
break;
case LDAPU_ERR_MISSING_INIT_FN_NAME:
rv = "Init function name is missing in the config file";
break;
case LDAPU_ERR_WRONG_ARGS:
rv = "ldaputil API function called with wrong arguments";
break;
case LDAPU_ERR_RENAME_FILE_FAILED:
rv = "Renaming of file failed";
break;
case LDAPU_ERR_MISSING_VERIFYCERT_VAL:
rv = "VerifyCert property value must be on or off";
break;
case LDAPU_ERR_CANAME_IS_MISSING:
rv = "Cert issuer name is missing";
break;
case LDAPU_ERR_CAPROP_IS_MISSING:
rv = "property name is missing";
break;
case LDAPU_ERR_UNKNOWN_CERT_ATTR:
rv = "unknown cert attribute";
break;
case LDAPU_ERR_EMPTY_LDAP_RESULT:
rv = "ldap search returned empty result";
break;
case LDAPU_ERR_MULTIPLE_MATCHES:
rv = "ldap search returned multiple matches when one expected";
break;
case LDAPU_ERR_MISSING_RES_ENTRY:
rv = "Could not extract entry from the ldap search result";
break;
case LDAPU_ERR_MISSING_UID_ATTR:
rv = "ldap entry is missing the 'uid' attribute value";
break;
case LDAPU_ERR_INVALID_ARGUMENT:
rv = "invalid argument passed to the certmap API function";
break;
case LDAPU_ERR_INVALID_SUFFIX:
rv = "invalid LDAP directory suffix";
break;
/* Error codes returned by cert.c */
case LDAPU_ERR_EXTRACT_SUBJECTDN_FAILED:
rv = "Couldn't extract the subject DN from the certificate";
break;
case LDAPU_ERR_EXTRACT_ISSUERDN_FAILED:
rv = "Couldn't extract the issuer DN from the certificate";
break;
case LDAPU_ERR_EXTRACT_DERCERT_FAILED:
rv = "Couldn't extract the original DER encoding from the certificate";
break;
/* Error codes returned LdapSession.cpp */
case LDAPU_ERR_DOMAIN_NOT_ACTIVE:
rv = "The domain is not active";
break;
case LDAPU_ERR_USER_NOT_ACTIVE:
rv = "The user is not active";
break;
case LDAPU_ERR_NOT_IMPLEMENTED:
rv = "function not implemented yet";
break;
case LDAPU_ERR_INTERNAL:
rv = "ldaputil internal error";
break;
default:
if (err > 0) {
/* LDAP errors are +ve */
rv = ldap_err2string(err);
}
else {
rv = system_errmsg();
}
break;
}
return (char*)rv; // jpierre : may have to reinvestigate this cast
}
PRStatus initVS(VirtualServer* incoming, const VirtualServer* current)
{
PRStatus rv = PR_SUCCESS;
if (fnInit) {
if ((*fnInit)(incoming, current) == REQ_PROCEED) {
if (incoming) {
if (objset_interpolative(vs_get_httpd_objset(incoming)) != PR_SUCCESS)
ereport(LOG_VERBOSE, "Unable to interpolate objset for virtual server %s (%s)", vs_get_id(incoming), system_errmsg());
}
} else {
rv = PR_FAILURE;
}
}
return rv;
}
char *verbose_error()
{
/* Initialize error hash tables */
HashNtErrors();
return alert_word_wrap(system_errmsg(), WORD_WRAP_WIDTH, "\\n");
}
