STDMETHODIMP ExplorerBar::Save( LPSTREAM inStream, BOOL inClearDirty )
{
DEBUG_UNUSED( inStream );
DEBUG_UNUSED( inClearDirty );
return( S_OK );
}
STDMETHODIMP ExplorerBar::ResizeBorderDW( LPCRECT inBorder, IUnknown *inPunkSite, BOOL inReserved )
{
DEBUG_UNUSED( inBorder );
DEBUG_UNUSED( inPunkSite );
DEBUG_UNUSED( inReserved );
return( E_NOTIMPL );
}
// Not called for explorer bars
STDMETHODIMP ExplorerBar::GetCommandString(UINT idCmd, UINT uType, UINT* pwReserved, LPSTR pszName, UINT cchMax)
{
DEBUG_UNUSED( idCmd );
DEBUG_UNUSED( uType );
DEBUG_UNUSED( pwReserved );
DEBUG_UNUSED( pszName );
DEBUG_UNUSED( cchMax );
return E_NOTIMPL;
}
// ------------------------------------------------------
// OnSetCursor
//
// This is called when Windows wants to know what cursor
// to display. So we tell it.
//
BOOL
CPrinterSetupWizardSheet::OnSetCursor(CWnd * pWnd, UINT nHitTest, UINT message)
{
DEBUG_UNUSED(pWnd);
DEBUG_UNUSED(nHitTest);
DEBUG_UNUSED(message);
SetCursor(m_active);
return TRUE;
}
void
CPrinterSetupWizardSheet::OnContextMenu(CWnd * pWnd, CPoint pos)
{
DEBUG_UNUSED(pWnd);
DEBUG_UNUSED(pos);
CAbout dlg;
dlg.DoModal();
}
void DNSSD_API
CConfigPropertySheet::BrowseDomainsReply
(
DNSServiceRef sdRef,
DNSServiceFlags flags,
uint32_t interfaceIndex,
DNSServiceErrorType errorCode,
const char * replyDomain,
void * context
)
{
CConfigPropertySheet * self = reinterpret_cast<CConfigPropertySheet*>(context);
CString decoded;
OSStatus err;
DEBUG_UNUSED( sdRef );
DEBUG_UNUSED( interfaceIndex );
if ( errorCode )
{
goto exit;
}
check( replyDomain );
// Ignore local domains
if ( strcmp( replyDomain, "local." ) == 0 )
{
goto exit;
}
err = self->DecodeDomainName( replyDomain, decoded );
require_noerr( err, exit );
// Remove trailing '.'
decoded.TrimRight( '.' );
if ( flags & kDNSServiceFlagsAdd )
{
self->m_browseDomains.push_back( decoded );
}
else
{
self->m_browseDomains.remove( decoded );
}
exit:
return;
}
afx_msg LRESULT
CConfigPropertySheet::OnRegistryChanged( WPARAM inWParam, LPARAM inLParam )
{
DEBUG_UNUSED( inWParam );
DEBUG_UNUSED( inLParam );
if ( GetActivePage() == &m_firstPage )
{
m_firstPage.OnRegistryChanged();
}
return 0;
}
OSStatus
CPrinterSetupWizardSheet::OnAddService(
Printer * printer,
uint32_t inInterfaceIndex,
const char * inName,
const char * inType,
const char * inDomain)
{
Service * service = NULL;
OSStatus err = kNoErr;
DEBUG_UNUSED( inName );
DEBUG_UNUSED( inDomain );
try
{
service = new Service;
}
catch (...)
{
service = NULL;
}
require_action( service, exit, err = E_OUTOFMEMORY );
service->printer = printer;
service->ifi = inInterfaceIndex;
service->type = inType;
service->domain = inDomain;
service->qtotal = 1;
service->refs = 1;
service->serviceRef = NULL;
printer->services.push_back( service );
//
// if the printer is selected, then we'll want to start a
// resolve on this guy
//
if ( printer == m_selectedPrinter )
{
StartResolve( service );
}
exit:
return err;
}
bool
com_ximeta_driver_NDASProtocolTransport::HandleProtocolServiceFeature (
SCSIProtocolFeature feature,
void * serviceValue
)
{
DEBUG_UNUSED ( feature );
DEBUG_UNUSED ( serviceValue );
DbgIOLog(DEBUG_MASK_DISK_TRACE, ("HandleProtocolServiceFeature: Entered. feature %d\n", (uint32_t)feature));
return false;
}
LRESULT
CCPApplet::OnNewInquire(NEWCPLINFO* pInfo)
{
DEBUG_UNUSED( pInfo );
return 1;
}
void DNSSD_API
CSecondPage::OnBrowse(
DNSServiceRef inRef,
DNSServiceFlags inFlags,
uint32_t inInterfaceIndex,
DNSServiceErrorType inErrorCode,
const char * inName,
const char * inType,
const char * inDomain,
void * inContext )
{
DEBUG_UNUSED(inRef);
CSecondPage * self;
bool moreComing = (bool) (inFlags & kDNSServiceFlagsMoreComing);
require_noerr( inErrorCode, exit );
self = reinterpret_cast <CSecondPage*>( inContext );
require_quiet( self, exit );
if ( inFlags & kDNSServiceFlagsAdd )
{
self->OnAddPrinter( inInterfaceIndex, inName, inType, inDomain, moreComing );
}
else
{
self->OnRemovePrinter( inName, inType, inDomain, moreComing );
}
exit:
return;
}
OSStatus
CPrinterSetupWizardSheet::InstallPrinterIPP(Printer * printer, Service * service)
{
DEBUG_UNUSED( service );
HANDLE hPrinter = NULL;
PRINTER_INFO_2 pInfo;
OSStatus err;
//
// add the printer
//
ZeroMemory(&pInfo, sizeof(PRINTER_INFO_2));
pInfo.pPrinterName = printer->actualName.GetBuffer();
pInfo.pPortName = printer->portName.GetBuffer();
pInfo.pDriverName = printer->model.GetBuffer();
pInfo.pPrintProcessor = L"winprint";
pInfo.pLocation = service->location.GetBuffer();
pInfo.Attributes = PRINTER_ATTRIBUTE_NETWORK | PRINTER_ATTRIBUTE_LOCAL;
hPrinter = AddPrinter(NULL, 2, (LPBYTE)&pInfo);
err = translate_errno( hPrinter, errno_compat(), kUnknownErr );
require_noerr( err, exit );
exit:
if ( hPrinter != NULL )
{
ClosePrinter(hPrinter);
}
return err;
}
void ExplorerBarWindow::OnDoubleClick( NMHDR *inNMHDR, LRESULT *outResult )
{
HTREEITEM item;
ServiceInfo * service;
OSStatus err;
DEBUG_UNUSED( inNMHDR );
item = mTree.GetSelectedItem();
require( item, exit );
// Tell Internet Explorer to go to the URL if it's about item
if ( item == m_about )
{
CString url;
check( mOwner );
url.LoadString( IDS_ABOUT_URL );
mOwner->GoToURL( url );
}
else
{
service = reinterpret_cast < ServiceInfo * > ( mTree.GetItemData( item ) );
require_quiet( service, exit );
err = StartResolve( service );
require_noerr( err, exit );
}
exit:
*outResult = 0;
}
void CSecondPage::OnTvnKeyDownBrowseList( NMHDR * pNMHDR, LRESULT * pResult)
{
DEBUG_UNUSED( pNMHDR );
m_gotChoice = true;
*pResult = 0;
}
static IOReturn
CriticalCompleteStatic (
OSObject * refCon,
void * val1,
void * val2,
void * val3,
void * val4
)
{
DEBUG_UNUSED ( val2 );
DEBUG_UNUSED ( val3 );
DEBUG_UNUSED ( val4 );
( ( com_ximeta_driver_NDASProtocolTransport * ) refCon )->CriticalComplete ( ( com_ximeta_driver_NDASSCSICommand *) val1 );
return kIOReturnSuccess;
}
afx_msg BOOL
CSecondPage::OnSetCursor(CWnd * pWnd, UINT nHitTest, UINT message)
{
DEBUG_UNUSED(pWnd);
DEBUG_UNUSED(nHitTest);
DEBUG_UNUSED(message);
CPrinterSetupWizardSheet * psheet;
psheet = reinterpret_cast<CPrinterSetupWizardSheet*>(GetParent());
require_quiet( psheet, exit );
SetCursor(psheet->GetCursor());
exit:
return TRUE;
}
LONG
CPrinterSetupWizardSheet::OnProcessEvent(WPARAM inWParam, LPARAM inLParam)
{
DEBUG_UNUSED(inLParam);
m_driverThreadExitCode = (DWORD) inWParam;
m_driverThreadFinished = true;
return 0;
}
STDMETHODIMP ExplorerBar::UIActivateIO( BOOL inActivate, LPMSG inMsg )
{
DEBUG_UNUSED( inMsg );
if( inActivate )
{
mWindow.SetFocus();
}
return( S_OK );
}
STDMETHODIMP ExplorerBar::QueryContextMenu(HMENU hShellContextMenu, UINT iContextMenuFirstItem, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
{
DEBUG_UNUSED( idCmdLast );
DEBUG_UNUSED( uFlags );
CMenu menubar;
menubar.LoadMenu(IDR_CONTEXT_MENU);
CMenu * menu = menubar.GetSubMenu(0);
CMenu shellmenu;
shellmenu.Attach(hShellContextMenu);
UINT iShellItem = iContextMenuFirstItem; //! remove plus one
UINT idShellCmd = idCmdFirst;
int n = menu->GetMenuItemCount();
for (int i=0; i<n; ++i)
{
MENUITEMINFO mii;
TCHAR sz[128] = {0};
ZeroMemory(&mii, sizeof(mii));
mii.fMask = MIIM_TYPE | MIIM_ID;
mii.fType = MFT_STRING;
mii.cbSize = sizeof(mii);
mii.cch = LENGTHOF(sz);
mii.dwTypeData = sz;
menu->GetMenuItemInfo(i, &mii, TRUE);
mii.wID = idShellCmd++;
shellmenu.InsertMenuItem(iShellItem++, &mii, TRUE);
}
shellmenu.Detach();
return n;
}
STDMETHODIMP ExplorerBar::CloseDW( DWORD inReserved )
{
DEBUG_UNUSED( inReserved );
ShowDW( FALSE );
if( mWindow.GetSafeHwnd() )
{
mWindow.SendMessage( WM_CLOSE );
}
return( S_OK );
}
LRESULT
CCPApplet::OnStartParms(CWnd * pParentWnd, LPCTSTR extra)
{
DEBUG_UNUSED( pParentWnd );
if ( extra )
{
m_pageNumber = ::_ttoi( extra ) - 1;
}
return 0;
}
SCSIServiceResponse
com_ximeta_driver_NDASProtocolTransport::AbortSCSICommand (
SCSITaskIdentifier request
)
{
DEBUG_UNUSED ( request );
SCSIServiceResponse serviceResponse = kSCSIServiceResponse_FUNCTION_REJECTED;
DbgIOLog(DEBUG_MASK_DISK_WARNING, ("AbortSCSICommand: Entered.\n"));
return serviceResponse;
}
// -------------------------------------------------------
// MatchGeneric
//
// This function will attempt to find a generic printer
// driver for a printer that we weren't able to match
// specifically
//
BOOL
CThirdPage::MatchGeneric( Manufacturers & manufacturers, Printer * printer, Service * service, Manufacturer ** manufacturer, Model ** model )
{
CString pdl;
BOOL ok = FALSE;
DEBUG_UNUSED( printer );
check( service );
Queue * q = service->SelectedQueue();
check( q );
Manufacturers::iterator iter = manufacturers.find( kGenericManufacturer );
require_action_quiet( iter != manufacturers.end(), exit, ok = FALSE );
*manufacturer = iter->second;
pdl = q->pdl;
pdl.MakeLower();
if ( m_genericPCL && ( pdl.Find( kPDLPCLKey ) != -1 ) )
{
*model = m_genericPCL;
ok = TRUE;
}
else if ( m_genericPostscript && ( pdl.Find( kPDLPostscriptKey ) != -1 ) )
{
*model = m_genericPostscript;
ok = TRUE;
}
exit:
return ok;
}
void DNSSD_API
CPrinterSetupWizardSheet::OnBrowse(
DNSServiceRef inRef,
DNSServiceFlags inFlags,
uint32_t inInterfaceIndex,
DNSServiceErrorType inErrorCode,
const char * inName,
const char * inType,
const char * inDomain,
void * inContext )
{
DEBUG_UNUSED(inRef);
CPrinterSetupWizardSheet * self;
bool moreComing = (bool) (inFlags & kDNSServiceFlagsMoreComing);
CPropertyPage * active;
Printer * printer = NULL;
Service * service = NULL;
OSStatus err = kNoErr;
require_noerr( inErrorCode, exit );
self = reinterpret_cast <CPrinterSetupWizardSheet*>( inContext );
require_quiet( self, exit );
active = self->GetActivePage();
require_quiet( active, exit );
// Have we seen this printer before?
printer = self->Lookup( inName );
if ( printer )
{
service = printer->LookupService( inType );
}
if ( inFlags & kDNSServiceFlagsAdd )
{
if (printer == NULL)
{
// If not, then create a new one
printer = self->OnAddPrinter( inInterfaceIndex, inName, inType, inDomain, moreComing );
require_action( printer, exit, err = kUnknownErr );
}
if ( !service )
{
err = self->OnAddService( printer, inInterfaceIndex, inName, inType, inDomain );
require_noerr( err, exit );
}
else
{
service->refs++;
}
}
else if ( printer )
{
check( service );
err = self->OnRemoveService( service );
require_noerr( err, exit );
if ( printer->services.size() == 0 )
{
err = self->OnRemovePrinter( printer, moreComing );
require_noerr( err, exit );
}
}
exit:
return;
}
Printer*
CPrinterSetupWizardSheet::OnAddPrinter(
uint32_t inInterfaceIndex,
const char * inName,
const char * inType,
const char * inDomain,
bool moreComing)
{
Printer * printer = NULL;
DWORD printerNameCount;
OSStatus err;
DEBUG_UNUSED( inInterfaceIndex );
DEBUG_UNUSED( inType );
DEBUG_UNUSED( inDomain );
try
{
printer = new Printer;
}
catch (...)
{
printer = NULL;
}
require_action( printer, exit, err = E_OUTOFMEMORY );
printer->window = this;
printer->name = inName;
err = UTF8StringToStringObject(inName, printer->displayName);
check_noerr( err );
printer->actualName = printer->displayName;
printer->installed = false;
printer->deflt = false;
printer->resolving = 0;
// Compare this name against printers that are already installed
// to avoid name clashes. Rename as necessary
// to come up with a unique name.
printerNameCount = 2;
for (;;)
{
CPrinterSetupWizardSheet::PrinterNames::iterator it;
// <rdar://problem/4141221> Don't use find to do comparisons because we need to
// do a case insensitive string comparison
for ( it = m_printerNames.begin(); it != m_printerNames.end(); it++ )
{
if ( (*it).CompareNoCase( printer->actualName ) == 0 )
{
break;
}
}
if (it != m_printerNames.end())
{
printer->actualName.Format(L"%s (%d)", printer->displayName, printerNameCount);
}
else
{
break;
}
printerNameCount++;
}
m_printers.push_back( printer );
if ( GetActivePage() == &m_pgSecond )
{
m_pgSecond.OnAddPrinter( printer, moreComing );
}
exit:
return printer;
}
void DNSSD_API
CSecondPage::OnQuery(
DNSServiceRef inRef,
DNSServiceFlags inFlags,
uint32_t inInterfaceIndex,
DNSServiceErrorType inErrorCode,
const char * inFullName,
uint16_t inRRType,
uint16_t inRRClass,
uint16_t inRDLen,
const void * inRData,
uint32_t inTTL,
void * inContext)
{
DEBUG_UNUSED( inTTL );
DEBUG_UNUSED( inRRClass );
DEBUG_UNUSED( inRRType );
DEBUG_UNUSED( inFullName );
DEBUG_UNUSED( inInterfaceIndex );
DEBUG_UNUSED( inRef );
Service * service = NULL;
Queue * q;
CSecondPage * self;
bool qtotalDefined = false;
bool moreComing = (bool) (inFlags & kDNSServiceFlagsMoreComing);
OSStatus err = kNoErr;
require_noerr( inErrorCode, exit );
service = reinterpret_cast<Service*>( inContext );
require_quiet( service, exit);
self = service->printer->window;
require_quiet( self, exit );
if ( ( inFlags & kDNSServiceFlagsAdd ) && ( inRDLen > 0 ) && ( inRData != NULL ) )
{
const char * inTXT = ( const char * ) inRData;
//
// create a new queue
//
try
{
q = new Queue;
}
catch (...)
{
q = NULL;
}
require_action( q, exit, err = E_OUTOFMEMORY );
err = service->printer->window->ParseTextRecord( service, inRDLen, inTXT, qtotalDefined, q->name, q->priority );
require_noerr( err, exit );
if ( !qtotalDefined )
{
q->name = L"";
}
//
// add this queue
//
service->queues.push_back( q );
if ( service->queues.size() == service->qtotal )
{
//
// else if moreComing is not set, then we're going
// to assume that we're done
//
self->StopOperation( service->serviceRef );
//
// sort the queues
//
service->queues.sort( OrderQueueFunc );
//
// we've completely resolved this service
//
self->OnResolveService( service );
}
}
exit:
if ( err && service && ( service->serviceRef != NULL ) )
{
service->printer->window->StopOperation( service->serviceRef );
}
return;
}
void DNSSD_API
CSecondPage::OnResolve(
DNSServiceRef inRef,
DNSServiceFlags inFlags,
uint32_t inInterfaceIndex,
DNSServiceErrorType inErrorCode,
const char * inFullName,
const char * inHostName,
uint16_t inPort,
uint16_t inTXTSize,
const char * inTXT,
void * inContext )
{
DEBUG_UNUSED(inFullName);
DEBUG_UNUSED(inInterfaceIndex);
DEBUG_UNUSED(inFlags);
DEBUG_UNUSED(inRef);
CSecondPage * self;
Service * service;
Queue * q;
bool qtotalDefined = false;
uint32_t qpriority = kDefaultPriority;
CString qname;
int idx;
OSStatus err;
require_noerr( inErrorCode, exit );
service = reinterpret_cast<Service*>( inContext );
require_quiet( service, exit);
check( service->refs != 0 );
self = service->printer->window;
require_quiet( self, exit );
err = self->StopOperation( service->serviceRef );
require_noerr( err, exit );
//
// hold on to the hostname...
//
err = UTF8StringToStringObject( inHostName, service->hostname );
require_noerr( err, exit );
//
// <rdar://problem/3739200> remove the trailing dot on hostname
//
idx = service->hostname.ReverseFind('.');
if ((idx > 1) && ((service->hostname.GetLength() - 1) == idx))
{
service->hostname.Delete(idx, 1);
}
//
// hold on to the port
//
service->portNumber = ntohs(inPort);
//
// parse the text record.
//
err = self->ParseTextRecord( service, inTXTSize, inTXT, qtotalDefined, qname, qpriority );
require_noerr( err, exit );
if ( service->qtotal == 1 )
{
//
// create a new queue
//
try
{
q = new Queue;
}
catch (...)
{
q = NULL;
}
require_action( q, exit, err = E_OUTOFMEMORY );
if ( qtotalDefined )
{
q->name = qname;
}
q->priority = qpriority;
service->queues.push_back( q );
//
// we've completely resolved this service
//
self->OnResolveService( service );
}
else
{
//
// if qtotal is more than 1, then we need to get additional
// text records. if not, then this service is considered
// resolved
//
err = DNSServiceQueryRecord(&service->serviceRef, 0, inInterfaceIndex, inFullName, kDNSServiceType_TXT, kDNSServiceClass_IN, OnQuery, (void*) service );
require_noerr( err, exit );
err = self->StartOperation( service->serviceRef );
require_noerr( err, exit );
}
exit:
return;
}
void DNSSD_API
ExplorerBarWindow::BrowseCallBack(
DNSServiceRef inRef,
DNSServiceFlags inFlags,
uint32_t inInterfaceIndex,
DNSServiceErrorType inErrorCode,
const char * inName,
const char * inType,
const char * inDomain,
void * inContext )
{
ServiceHandlerEntry * obj;
ServiceInfo * service;
OSStatus err;
DEBUG_UNUSED( inRef );
obj = NULL;
service = NULL;
require_noerr( inErrorCode, exit );
obj = reinterpret_cast < ServiceHandlerEntry * > ( inContext );
check( obj );
check( obj->obj );
//
// set the UI to hold off on updates
//
obj->obj->mTree.SetRedraw(FALSE);
try
{
service = new ServiceInfo;
require_action( service, exit, err = kNoMemoryErr );
err = UTF8StringToStringObject( inName, service->displayName );
check_noerr( err );
service->name = strdup( inName );
require_action( service->name, exit, err = kNoMemoryErr );
service->type = strdup( inType );
require_action( service->type, exit, err = kNoMemoryErr );
service->domain = strdup( inDomain );
require_action( service->domain, exit, err = kNoMemoryErr );
service->ifi = inInterfaceIndex;
service->handler = obj;
service->refs = 1;
if (inFlags & kDNSServiceFlagsAdd) obj->obj->OnServiceAdd (service);
else obj->obj->OnServiceRemove(service);
service = NULL;
}
catch( ... )
{
dlog( kDebugLevelError, "BrowseCallBack: exception thrown\n" );
}
exit:
//
// If no more coming, then update UI
//
if (obj && obj->obj && ((inFlags & kDNSServiceFlagsMoreComing) == 0))
{
obj->obj->mTree.SetRedraw(TRUE);
obj->obj->mTree.Invalidate();
}
if( service )
{
delete service;
}
}
OSStatus
CSecondPage::OnRemovePrinter(
const char * inName,
const char * inType,
const char * inDomain,
bool moreComing)
{
DEBUG_UNUSED( inDomain );
DEBUG_UNUSED( inType );
Printer * printer;
OSStatus err = kNoErr;
check( IsWindow( m_hWnd ) );
m_browseList.SetRedraw(FALSE);
printer = Lookup( inName );
if ( printer )
{
Service * service;
service = printer->LookupService( inType );
if ( service && ( --service->refs == 0 ) )
{
if ( service->serviceRef != NULL )
{
err = StopResolve( service );
require_noerr( err, exit );
}
printer->services.remove( service );
delete service;
}
if ( printer->services.size() == 0 )
{
//
// check to make sure if we're the only item in the control...i.e.
// the list size is 1.
//
if (m_browseList.GetCount() > 1)
{
//
// if we're not the only thing in the list, then
// simply remove it from the list
//
m_browseList.DeleteItem( printer->item );
}
else
{
//
// if we're the only thing in the list, then redisplay
// it with the no rendezvous printers message
//
InitBrowseList();
}
m_printers.remove( printer );
if ( m_selected == printer )
{
m_selected = NULL;
m_selectedName = "";
}
delete printer;
}
}
exit:
if (!moreComing)
{
m_browseList.SetRedraw(TRUE);
m_browseList.Invalidate();
}
return err;
}
void DNSSD_API
ExplorerBarWindow::ResolveCallBack(
DNSServiceRef inRef,
DNSServiceFlags inFlags,
uint32_t inInterfaceIndex,
DNSServiceErrorType inErrorCode,
const char * inFullName,
const char * inHostName,
uint16_t inPort,
uint16_t inTXTSize,
const char * inTXT,
void * inContext )
{
ExplorerBarWindow * obj;
ServiceHandlerEntry * handler;
OSStatus err;
DEBUG_UNUSED( inRef );
DEBUG_UNUSED( inFlags );
DEBUG_UNUSED( inErrorCode );
DEBUG_UNUSED( inFullName );
require_noerr( inErrorCode, exit );
handler = (ServiceHandlerEntry *) inContext;
check( handler );
obj = handler->obj;
check( obj );
try
{
ResolveInfo * resolve;
int idx;
dlog( kDebugLevelNotice, "resolved %s on ifi %d to %s\n", inFullName, inInterfaceIndex, inHostName );
// Stop resolving after the first good result.
obj->StopResolve();
// Post a message to the main thread so it can handle it since MFC is not thread safe.
resolve = new ResolveInfo;
require_action( resolve, exit, err = kNoMemoryErr );
UTF8StringToStringObject( inHostName, resolve->host );
// rdar://problem/3841564
//
// strip trailing dot from hostname because some flavors of Windows
// have trouble parsing it.
idx = resolve->host.ReverseFind('.');
if ((idx > 1) && ((resolve->host.GetLength() - 1) == idx))
{
resolve->host.Delete(idx, 1);
}
resolve->port = ntohs( inPort );
resolve->ifi = inInterfaceIndex;
resolve->handler = handler;
err = resolve->txt.SetData( inTXT, inTXTSize );
check_noerr( err );
obj->OnResolve(resolve);
}
catch( ... )
{
dlog( kDebugLevelError, "ResolveCallBack: exception thrown\n" );
}
exit:
return;
}
