void KeywordList( void ) {
//===========================
bool morelist;
if( RecNextOpr( OPR_EQU ) ) {
morelist = true;
} else {
if( Permission( IO_UNIT ) ) {
Unit();
AdvanceITPtr();
} else {
NextComma();
}
if( FormatIdentifier() ) {
if( Permission( IO_FMT ) ) {
FormatIdd();
AdvanceITPtr();
} else {
NextComma();
}
}
morelist = RecComma();
}
if( morelist ) {
for(;;) {
GetItem();
if( !RecComma() ) break;
}
}
CheckList(); // check that list had necessities ( unit )
// also remember if end= is specified
}
static void Form( void ) {
//======================
Permission( IO_FMT ); // remember FMT=
Permission( IO_UNIT ); // default UNIT=*
FormatIdd();
AdvanceITPtr();
}
// send an async message to a service asynchronously
Boolean ModuleController::ModuleSendAsync(const pegasus_module & handle,
Uint32 msg_handle,
Uint32 destination_q,
AsyncRequest *message,
void *callback_parm)
{
//printf("verifying handle %p, controller at %p \n", &handle, this);
if ( false == verify_handle(const_cast<pegasus_module *>(&handle)))
throw(Permission(pegasus_thread_self()));
if (message->op == NULL)
{
message->op = get_op();
message->op->put_request(message);
}
callback_handle *cb = new callback_handle(const_cast<pegasus_module *>(&handle),
callback_parm);
message->setRouting(msg_handle);
message->resp = getQueueId();
message->block = false;
message->dest = destination_q;
return SendAsync(message->op,
destination_q,
_async_handleEnqueue,
this,
cb);
}
// send a message to a module within another service asynchronously
Boolean ModuleController::ModuleSendAsync(const pegasus_module & handle,
Uint32 msg_handle,
Uint32 destination_q,
const String & destination_module,
AsyncRequest *message,
void *callback_parm)
{
if ( false == verify_handle(const_cast<pegasus_module *>(&handle)))
throw(Permission(pegasus_thread_self()));
AsyncOpNode *op = get_op();
AsyncModuleOperationStart *request =
new AsyncModuleOperationStart(msg_handle,
op,
destination_q,
getQueueId(),
true,
destination_module,
message);
request->dest = destination_q;
callback_handle *cb = new callback_handle(const_cast<pegasus_module *>(&handle), callback_parm);
return SendAsync(op,
destination_q,
_async_handleEnqueue,
this,
cb);
}
// send a message to another service
AsyncReply *ModuleController::ClientSendWait(const client_handle & handle,
Uint32 destination_q,
AsyncRequest *request)
{
if( false == const_cast<client_handle &>(handle).authorized(CLIENT_SEND_WAIT))
throw Permission(pegasus_thread_self());
return _send_wait(destination_q, request);
}
void ModuleController::async_thread_exec(const pegasus_module & handle,
PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
void *parm)
{
if ( false == verify_handle(const_cast<pegasus_module *>(&handle)))
throw(Permission(pegasus_thread_self()));
_async_thread_exec(thread_func, parm);
}
Boolean ModuleController::ClientSendForget(const client_handle & handle,
Uint32 destination_q,
AsyncRequest *message)
{
if( false == const_cast<client_handle &>(handle).authorized(CLIENT_SEND_FORGET))
throw Permission(pegasus_thread_self());
return _send_forget(destination_q, message);
}
Boolean ModuleController::ModuleSendForget(const pegasus_module & handle,
Uint32 destination_q,
AsyncRequest *message)
{
if(false == verify_handle(const_cast<pegasus_module *>( &handle)))
throw(Permission(pegasus_thread_self()));
return _send_forget(destination_q, message);
}
// sendwait to another service
AsyncReply * ModuleController::ModuleSendWait(const pegasus_module & handle,
Uint32 destination_q,
AsyncRequest *request)
{
if ( false == verify_handle(const_cast<pegasus_module *>(&handle)))
throw(Permission(pegasus_thread_self()));
return _send_wait(destination_q, request);
}
void ModuleController::client_async_thread_exec(
const client_handle & handle,
PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
void *parm)
{
if( false == const_cast<client_handle &>(handle).authorized(CLIENT_ASYNC_THREAD_EXEC))
throw Permission(pegasus_thread_self());
_async_thread_exec(thread_func, parm);
}
// given a name, find a service's queue id
Uint32 ModuleController::find_service(const pegasus_module & handle,
const String & name)
{
if ( false == verify_handle(const_cast<pegasus_module *>(&handle)) )
throw Permission(pegasus_thread_self());
Array<Uint32> services;
Base::find_services(name, 0, 0, &services);
return( services[0]);
}
void IAllocation::addPermission(const std::string& ip)
{
//Mutex::ScopedLock lock(_mutex);
// If the permission is already in the list then refresh it.
for (auto it = _permissions.begin(); it != _permissions.end(); ++it) {
if ((*it).ip == ip) {
TraceL << "Refreshing permission: " << ip << endl;
(*it).refresh();
return;
}
}
// Otherwise create it...
TraceL << "Create permission: " << ip << endl;
_permissions.push_back(Permission(ip));
}
static void UnitOrList( void ) {
//============================
// The io statement can have a unit id by itself or have a keyword list
// in brackets.
InitIO();
if( RecNextOpr( OPR_LBR ) && RecNOpn() ) {
AdvanceITPtr();
DoKWList();
} else {
Permission( IO_UNIT ); // remembers unit= specified
Unit();
AdvanceITPtr();
}
ReqEOS();
GStartIO();
FiniIO();
}
pegasus_module * ModuleController::get_module_reference(const pegasus_module & my_handle,
const String & module_name)
{
if ( false == verify_handle(const_cast<pegasus_module *>(&my_handle)))
throw(Permission(pegasus_thread_self()));
pegasus_module *module, *ref = NULL;
_module_lock lock(&_modules);
module = _modules.next(0);
while(module != NULL)
{
if(module->get_name() == module_name)
{
ref = new pegasus_module(*module);
break;
}
module = _modules.next(module);
}
return ref;
}
Uint32 ModuleController::find_module_in_service(const pegasus_module & handle,
const String & name)
{
if ( false == verify_handle(const_cast<pegasus_module *>(&handle)))
throw(Permission(pegasus_thread_self()));
Uint32 result = 0 ;
AutoPtr<FindModuleInService> request(new FindModuleInService(get_next_xid(),
0,
true,
_meta_dispatcher->getQueueId(),
name));
request->dest = _meta_dispatcher->getQueueId();
AutoPtr<FindModuleInServiceResponse>
response(static_cast<FindModuleInServiceResponse *>(SendWait(request.get())));
if( response.get() != NULL)
result = response->_module_service_queue;
return result;
}
// send an async message to another service
Boolean ModuleController::ClientSendAsync(const client_handle & handle,
Uint32 msg_handle,
Uint32 destination_q,
AsyncRequest *message,
void (*async_callback)(Uint32, Message *, void *) ,
void *callback_parm)
{
if( false == const_cast<client_handle &>(handle).authorized(CLIENT_SEND_ASYNC))
throw Permission(pegasus_thread_self());
pegasus_module *temp = new pegasus_module(this,
String(PEGASUS_MODULENAME_TEMP),
this,
0,
async_callback,
0);
return ModuleSendAsync( *temp,
msg_handle,
destination_q,
message,
callback_parm);
}
static void GetItem( void ) {
//===============================
IOKW kw;
kw = RecIOKW();
if( Permission( kw ) ) {
AdvanceITPtr();
ReqEquSign();
switch( kw ) {
case IO_ACCESS:
CharItem( FC_SET_ACC );
break;
case IO_ACTION:
CharItem( FC_SET_ACTION );
break;
case IO_BLANK:
CharItem( FC_SET_BLNK );
break;
case IO_BLOCKSIZE:
BlockSize();
break;
case IO_CARRIAGECONTROL:
CharItem( FC_SET_CCTRL );
break;
case IO_DIRECT:
CharItem( FC_SET_DIR );
break;
case IO_END:
LabelItem( FC_SET_END );
break;
case IO_ERR:
LabelItem( FC_SET_ERR );
break;
case IO_EXIST:
BoolInq( FC_SET_EXST );
break;
case IO_FILE:
FileItem();
break;
case IO_FMT:
FormatIdd();
break;
case IO_FORM:
CharItem( FC_SET_FORM );
break;
case IO_FMTTED:
CharItem( FC_SET_FMTD );
break;
case IO_IOSTAT:
IntInq( FC_SET_IOS );
break;
case IO_NAME:
CharItem( FC_SET_NAME );
break;
case IO_NAMED:
BoolInq( FC_SET_NMD );
break;
case IO_NXTREC:
IntInq( FC_SET_NREC );
break;
case IO_NUMBER:
IntInq( FC_SET_NUMB );
break;
case IO_OPENED:
BoolInq( FC_SET_OPEN );
break;
case IO_REC:
IntItem( FC_SET_REC );
break;
case IO_RECL:
Recl();
break;
case IO_RECORDTYPE:
CharItem( FC_SET_RECTYPE );
break;
case IO_SEQ:
CharItem( FC_SET_SEQ );
break;
case IO_SHARE:
CharItem( FC_SET_SHARE );
break;
case IO_STATUS:
CharItem( FC_SET_STAT );
break;
case IO_UNFMTD:
CharItem( FC_SET_UFMTD );
break;
case IO_UNIT:
Unit();
break;
}
AdvanceITPtr();
} else {
NextComma();
}
}
INT CALLBACK ShareDialog::dialogProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
switch ( msg )
{
case WM_COMMAND:
{
switch ( wParam )
{
case IDCANCEL:
{
EndDialog(hWnd,0);
}
break;
case IDOK:
{
std::string name = WinUtil::WindowUtil::getWindowText(GetDlgItem(m_setupPage.getHwnd(),IDC_EDIT_VIRTUALNAME));
std::string path = WinUtil::WindowUtil::getWindowText(GetDlgItem(m_setupPage.getHwnd(),IDC_EDIT_PATH));
std::string oldPath = m_pShare->getPath();
if ( name.empty() ) {
MessageBox(hWnd,WinUtil::ResourceUtil::loadString(IDS_INVALIDVIRTUALNAME).c_str(),APP_NAME,MB_ICONEXCLAMATION);
break;
}
if ( path.empty() ) {
MessageBox(hWnd,WinUtil::ResourceUtil::loadString(IDS_INVALIDPATH).c_str(),APP_NAME,MB_ICONEXCLAMATION);
break;
}
// make sure a share with this name doesn't already exist
if ( !boost::iequals(m_pShare->getName(),name)
&& ShareManager::getInstance()->findShareByName(name,NULL) ) {
MessageBox(hWnd,WinUtil::ResourceUtil::loadString(IDS_SHAREEXISTS).c_str(),APP_NAME,MB_ICONEXCLAMATION);
break;
}
m_setupPage.savePage(m_pShare);
m_permissionsPage.savePage(m_pShare);
// check if path was changed
if ( !m_pShare->getGuid().empty() && m_pShare->getPath()!=oldPath ) {
if ( MessageBox(this->getHwnd(),"Share path has been changed. Do you want to re-index this share?",
TEXT(APP_NAME),MB_ICONQUESTION | MB_YESNO)==IDYES ) {
Indexer::getInstance()->queue(IndexerJob(m_pShare->getDbId(),false));
}
}
// check if no permissions was set
if ( m_pShare->getPermissions().empty() )
{
if ( MessageBox(this->getHwnd(),"Should all authenticated users be able to access this share?",
TEXT(APP_NAME),MB_ICONQUESTION | MB_YESNO)==IDYES )
{
// add permission for everyone
m_pShare->addPermission(Permission("","","",true));
}
}
EndDialog(hWnd,1);
}
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR pNmhdr = (LPNMHDR)lParam;
if ( pNmhdr->hwndFrom==m_hTreeView && pNmhdr->code==TVN_SELCHANGING )
{
HTREEITEM selectedItem = TreeView_GetSelection(m_hTreeView);
DialogWindow *pSelectedDialog = (DialogWindow*)WinUtil::TreeViewUtil::getItemParam(m_hTreeView,selectedItem);
if ( pSelectedDialog!=NULL ) {
ShowWindow(pSelectedDialog->getHwnd(),SW_HIDE);
}
}
else if ( pNmhdr->hwndFrom==m_hTreeView && pNmhdr->code==TVN_SELCHANGED )
{
HTREEITEM selectedItem = TreeView_GetSelection(m_hTreeView);
DialogWindow *pSelectedDialog = (DialogWindow*)WinUtil::TreeViewUtil::getItemParam(m_hTreeView,selectedItem);
if ( pSelectedDialog!=NULL ) {
ShowWindow(pSelectedDialog->getHwnd(),SW_SHOW);
}
}
}
break;
}
return 0;
}
void Permissions::setAllPermissions()
{
for (int i = FIRST_PERMISSION; i < LAST_PERMISSION; ++i) {
addPermission(Permission(i));
}
}
