static void doChildren(int argc, char **argv)
{
const char *arguments = "debugger children last";
struct child_blackbox blackbox;
const char *blackbox_file, *p;
char event_name[MAX_PATH];
PROCESS_INFORMATION pi;
STARTUPINFOA si;
HANDLE event;
char *cmd;
BOOL ret;
if (!strcmp(argv[3], "last")) return;
blackbox_file = argv[3];
p = strrchr(blackbox_file, '\\');
p = p ? p+1 : blackbox_file;
strcpy(event_name, p);
strcat(event_name, "_init");
event = OpenEventA(EVENT_ALL_ACCESS, FALSE, event_name);
child_ok(event != NULL, "OpenEvent failed, last error %d.\n", GetLastError());
SetEvent(event);
CloseHandle(event);
p = strrchr(blackbox_file, '\\');
p = p ? p+1 : blackbox_file;
strcpy(event_name, p);
strcat(event_name, "_attach");
event = OpenEventA(EVENT_ALL_ACCESS, FALSE, event_name);
child_ok(event != NULL, "OpenEvent failed, last error %d.\n", GetLastError());
WaitForSingleObject(event, INFINITE);
CloseHandle(event);
cmd = HeapAlloc(GetProcessHeap(), 0, strlen(argv[0]) + strlen(arguments) + 2);
sprintf(cmd, "%s %s", argv[0], arguments);
memset(&si, 0, sizeof(si));
si.cb = sizeof(si);
ret = CreateProcessA(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
child_ok(ret, "CreateProcess failed, last error %d.\n", GetLastError());
child_ok(WaitForSingleObject(pi.hProcess, 10000) == WAIT_OBJECT_0,
"Timed out waiting for the child to exit\n");
ret = CloseHandle(pi.hThread);
child_ok(ret, "CloseHandle failed, last error %d.\n", GetLastError());
ret = CloseHandle(pi.hProcess);
child_ok(ret, "CloseHandle failed, last error %d.\n", GetLastError());
blackbox.failures = child_failures;
save_blackbox(blackbox_file, &blackbox, sizeof(blackbox));
HeapFree(GetProcessHeap(), 0, cmd);
}
BOOL __stdcall ProcessRequest(HWND hwnd, LPARAM param)
{
char szBuf[MAX_PATH];
TEnumData *lParam = (TEnumData*)param;
DWORD pid = 0;
GetWindowThreadProcessId(hwnd, &pid);
if (pid != 0) {
// old system would get a window's pid and the module handle that created it
// and try to OpenEvent() a event object name to it (prefixed with a string)
// this was fine for most Oses (not the best way) but now actually compares
// the class string (a bit slower) but should get rid of those bugs finally.
HANDLE hMirandaWorkEvent = OpenEventA(EVENT_ALL_ACCESS, false, CreateProcessUID(pid, szBuf, sizeof(szBuf)));
if (hMirandaWorkEvent != 0) {
GetClassNameA(hwnd, szBuf, sizeof(szBuf));
if ( lstrcmpA(szBuf, MIRANDACLASS) != 0) {
// opened but not valid.
logA("ProcessRequest(%d, %p): class %s differs from %s\n", pid, hwnd, szBuf, MIRANDACLASS);
CloseHandle(hMirandaWorkEvent);
return true;
}
}
// if the event object exists, a shlext.dll running in the instance must of created it.
if (hMirandaWorkEvent != 0) {
logA("ProcessRequest(%d, %p): window found\n", pid, hwnd);
// prep the request
ipcPrepareRequests(IPC_PACKET_SIZE, lParam->ipch, REQUEST_ICONS | REQUEST_GROUPS | REQUEST_CONTACTS | REQUEST_NEWICONS);
// slots will be in the order of icon data, groups contacts, the first
// slot will contain the profile name
DWORD replyBits = ipcSendRequest(hMirandaWorkEvent, lParam->hWaitFor, lParam->ipch, 1000);
// replyBits will be REPLY_FAIL if the wait timed out, or it'll be the request
// bits as sent or a series of *_NOTIMPL bits where the request bit were, if there are no
// contacts to speak of, don't bother showing this instance of Miranda }
if (replyBits != REPLY_FAIL && lParam->ipch->ContactsBegin != NULL) {
logA("ProcessRequest(%d, %p): IPC succeeded\n", pid, hwnd);
// load the address again, the server side will always overwrite it
lParam->ipch->pClientBaseAddress = lParam->ipch;
// fixup all the pointers to be relative to the memory map
// the base pointer of the client side version of the mapped file
ipcFixupAddresses(lParam->ipch);
// store the PID used to create the work event object
// that got replied to -- this is needed since each contact
// on the final menu maybe on a different instance and another OpenEvent() will be needed.
lParam->pid = pid;
// check out the user options from the server
lParam->bShouldOwnerDraw = (lParam->ipch->dwFlags & HIPC_NOICONS) == 0;
// process the icons
BuildSkinIcons(lParam);
// process other replies
BuildMenus(lParam);
}
// close the work object
CloseHandle(hMirandaWorkEvent);
}
}
return true;
}
HOOKFUNC HANDLE WINAPI MyOpenEventA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName)
{
HANDLE rv = OpenEventA(dwDesiredAccess, bInheritHandle, lpName);
debuglog(LCF_SYNCOBJ, __FUNCTION__ " returned 0x%X.\n", rv);
EnterCriticalSection(&s_handleCS);
std::set<HANDLE>& handles = s_threadIdHandles[GetCurrentThreadId()];
handles.insert(rv);
LeaveCriticalSection(&s_handleCS);
return rv;
}
static int event_exists(int sig)
{
char name[EVT_NAME_LEN];
HANDLE h;
make_name(name, sig);
if (!(h = OpenEventA(EVENT_MODIFY_STATE, FALSE, name)))
return 0;
CloseHandle(h);
return 1;
}
static inline bool capture_alive(void)
{
HANDLE event = OpenEventA(EVENT_ALL_ACCESS, false, keepalive_name);
if (event) {
CloseHandle(event);
return true;
}
return false;
}
HOOKFUNC HANDLE WINAPI MyOpenEventA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName)
{
ENTER();
HANDLE rv = OpenEventA(dwDesiredAccess, bInheritHandle, lpName);
LEAVE(rv);
EnterCriticalSection(&s_handleCS);
std::set<HANDLE>& handles = s_threadIdHandles[GetCurrentThreadId()];
handles.insert(rv);
LeaveCriticalSection(&s_handleCS);
return rv;
}
static void dummy_process(char *event_name)
{
HANDLE event = OpenEventA(EVENT_ALL_ACCESS, FALSE, event_name);
while (TRUE)
{
SetEvent(event);
OutputDebugStringA("test");
Sleep(5);
}
}
static int sig_event(int sig)
{
char name[EVT_NAME_LEN];
HANDLE h;
make_name(name, sig);
if (!(h = OpenEventA(EVENT_MODIFY_STATE, FALSE, name))) {
make_name(name, EVT_RUNNING);
if (!(h = OpenEvent(EVENT_MODIFY_STATE, FALSE, name)))
return -1;
CloseHandle(h);
return 0;
}
SetEvent(h);
CloseHandle(h);
return 1;
}
inline void kill_wrapper( ProcessId pid, int sig, int port, const BSONObj& opt ) {
#ifdef _WIN32
if (sig == SIGKILL || port == 0) {
verify( registry._handles.count(pid) );
TerminateProcess(registry._handles[pid], 1); // returns failure for "zombie" processes.
return;
}
std::string eventName = getShutdownSignalName(pid.asUInt32());
HANDLE event = OpenEventA(EVENT_MODIFY_STATE, FALSE, eventName.c_str());
if (event == NULL) {
int gle = GetLastError();
if (gle != ERROR_FILE_NOT_FOUND) {
warning() << "kill_wrapper OpenEvent failed: " << errnoWithDescription();
}
else {
log() << "kill_wrapper OpenEvent failed to open event to the process "
<< pid.asUInt32() << ". It has likely died already";
}
return;
}
ON_BLOCK_EXIT(CloseHandle, event);
bool result = SetEvent(event);
if (!result) {
error() << "kill_wrapper SetEvent failed: " << errnoWithDescription();
return;
}
#else
int x = kill( pid.toNative(), sig );
if ( x ) {
if ( errno == ESRCH ) {
}
else {
log() << "killFailed: " << errnoWithDescription() << endl;
verify( x == 0 );
}
}
#endif
}
BOOL CNameEvent::OpenEvent()
{
assert(ISNULL(m_hEvent));
if (ISNOTNULL(m_hEvent))
{
DOLOG("the Event already opened!");
return FALSE;
}
m_hEvent = OpenEventA(EVENT_MODIFY_STATE, FALSE, m_cbEventName);
assert(ISNOTNULL(m_hEvent));
if (ISNULL(m_hEvent))
{
DOLOG("open Event failed! " + GetLastError());
return FALSE;
}
return TRUE;
}
/*
* ::createIpcEvent
*/
int createIpcEvent(IpcEvent *evt, const int reserved, const int isInitiallySet,
const int isCreateOnly, const char *name) {
int retval = 0;
#ifdef _WIN32
if ((*evt = CreateEventA(NULL, reserved, isInitiallySet, name)) == NULL) {
retval = GetLastError();
/* If event already exists and open is allowed, try to open it. */
if ((retval == ERROR_ALREADY_EXISTS) && !isCreateOnly) {
if ((*evt = OpenEventA(EVENT_MODIFY_STATE | SYNCHRONIZE, FALSE, name))
!= NULL) {
retval = 0;
} else {
retval = GetLastError();
}
}
}
#else /* _WIN32 */
char *n = (char *) malloc(strlen(name) + 2);
if (n != NULL) {
strcpy(n, "/");
strcat(n, name);
if ((*evt = sem_open(n, (isCreateOnly ? O_CREAT : 0), 0666,
(isInitiallySet ? 1 : 0))) == SEM_FAILED) {
retval = errno;
}
free(n);
} else {
retval = ENOMEM;
}
#endif /* _WIN32 */
return retval;
}
/** Send a kill signal to a windows version of GridLAB-D
@return 0 on successfull completion, -1 on error (e.g., no such signal, no such process)
**/
int kill(pid_t pid, /**< the window process id */
int sig) /**< the signal id (see signal.h) */
{
char name[32];
HANDLE hEvent;
sprintf(name,"gridlabd.%u.%u",pid,sig==0?SIGINT:sig); /* use INT for sig==0 just to check */
hEvent = OpenEventA(EVENT_MODIFY_STATE,FALSE,name);
/* existence check only */
if ( sig==0 )
{
if ( hEvent!=NULL )
{
CloseHandle(hEvent);
return 0;
}
else
{
errno = ESRCH;
return -1;
}
}
/* valid signal needs to be sent */
else if (hEvent==NULL)
{
errno = EINVAL; // TODO distinguish between bad signal and bad pid
output_error("unable to signal gridlabd process %d with signal %d (error %d)", pid, sig, GetLastError());
return -1;
}
else
{
SetEvent(hEvent);
output_verbose("signal %d sent to gridlabd process %d", sig, pid);
CloseHandle(hEvent);
return 0;
}
}
static HANDLE open_event(int sig)
{
char name[EVT_NAME_LEN];
make_name(name, sig);
return OpenEventA(EVENT_MODIFY_STATE, FALSE, name);
}
BOOL InitDataSharer(PDataSharer p_data_sharer,TCHAR *shared_memory_name,int shared_memory_size,BOOL is_server)
{
HANDLE MapFileHandle=INVALID_HANDLE_VALUE;
PBYTE shared_buffer;
#define READ_EVENT_POSTIFX TEXT("_read")
#define WRITE_EVENT_POSTIFX TEXT("_write")
int event_name_len=(_tcslen(shared_memory_name)+max(_tcslen(READ_EVENT_POSTIFX),_tcslen(WRITE_EVENT_POSTIFX))+10)*sizeof(TCHAR);
char *event_name=(char *)malloc(event_name_len);
memset(event_name,0,event_name_len);
#ifdef UNICODE
_snprintf(event_name,event_name_len/sizeof(TCHAR)-1,"%ws%ws",shared_memory_name,READ_EVENT_POSTIFX);
#else
_snprintf(event_name,event_name_len-1,"%s%s",shared_memory_name,READ_EVENT_POSTIFX);
#endif
dprintf(TEXT("%s: Creating Event[%s]\n"),__FUNCTION__,event_name);
//Init R/W Event
if(1 || is_server)
{
p_data_sharer->EventHandleForReading=CreateEventA(NULL,TRUE,FALSE,(LPCSTR)event_name);
}else
{
p_data_sharer->EventHandleForReading=OpenEventA(EVENT_ALL_ACCESS,TRUE,(LPCSTR)event_name);
}
if (!p_data_sharer->EventHandleForReading)
{
//error
dprintf(TEXT("%s: Creating Event Failed\n"), __FUNCTION__);
return FALSE;
}
memset(event_name,0,event_name_len);
#ifdef UNICODE
_snprintf(event_name,(event_name_len)/sizeof(TCHAR)-1,"%ws%ws",shared_memory_name,WRITE_EVENT_POSTIFX);
#else
_snprintf(event_name,event_name_len-1,"%s%s",shared_memory_name,WRITE_EVENT_POSTIFX);
#endif
dprintf(TEXT("Creating Event[%s]\n"),event_name);
if(1 || is_server)
{
p_data_sharer->EventHandleForWriting= CreateEventA(NULL,TRUE,FALSE,(LPCSTR)event_name);
}else
{
p_data_sharer->EventHandleForWriting=OpenEventA(EVENT_ALL_ACCESS,TRUE,(LPCSTR)event_name);
}
free(event_name);
if (!p_data_sharer->EventHandleForWriting)
{
//error
dprintf(TEXT("%s: Creating Event Failed\n"), __FUNCTION__);
return FALSE;
}
if(!is_server)
{
//Creates Map
MapFileHandle=OpenFileMappingA(
FILE_MAP_ALL_ACCESS, // read/write access
FALSE, // do not inherit the name
(LPCSTR)shared_memory_name); // name of mapping object
}
if(MapFileHandle==INVALID_HANDLE_VALUE || !MapFileHandle)
{
//Creates Map
MapFileHandle=CreateFileMappingA(
INVALID_HANDLE_VALUE,
NULL,
PAGE_READWRITE,
0,
shared_memory_size+sizeof(MemoryHeader),
(LPCSTR)shared_memory_name);
}
if (MapFileHandle!=INVALID_HANDLE_VALUE && MapFileHandle)
{
dprintf(TEXT("%s: Created Shared Memory[%s]\n"),__FUNCTION__,shared_memory_name);
shared_buffer=(PBYTE)MapViewOfFile(
MapFileHandle,
FILE_MAP_ALL_ACCESS, // read/write permission
0,
0,
shared_memory_size+sizeof(MemoryHeader));
if(shared_buffer)
{
dprintf(TEXT("%s: shared_buffer=%X\n"),
__FUNCTION__,
shared_buffer);
//Init Shared Memory Header(R/W Pointer,Size)
p_data_sharer->MemoryHeaderPtr=(PMemoryHeader)shared_buffer;
if(is_server && p_data_sharer->MemoryHeaderPtr)
{
p_data_sharer->MemoryHeaderPtr->BufferSize=shared_memory_size;
p_data_sharer->MemoryHeaderPtr->ReadPoint=p_data_sharer->MemoryHeaderPtr->WritePoint=0;
}
dprintf(TEXT("%s: p_data_sharer->MemoryHeaderPtr->Data=%X\n"),
__FUNCTION__,
p_data_sharer->MemoryHeaderPtr->Data);
#ifndef USE_SINGLE_THREAD_FOR_SHARED_MEMORY
InitializeCriticalSection(&p_data_sharer->critical_section);
#endif
return TRUE;
}
}
dprintf(TEXT("%s: Returning False\n"), __FUNCTION__);
return FALSE;
}
HRESULT RequestTransfer(TShellExt *Self, int idxCmd)
{
// get the contact information
MENUITEMINFOA mii = { 0 };
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID | MIIM_DATA;
if ( !GetMenuItemInfoA(Self->hRootMenu, Self->idCmdFirst + idxCmd, false, &mii))
return E_INVALIDARG;
// get the pointer
TMenuDrawInfo *psd = (TMenuDrawInfo*)mii.dwItemData;
// the ID stored in the item pointer and the ID for the menu must match
if (psd == NULL || psd->wID != mii.wID)
return E_INVALIDARG;
// is there an IDataObject instance?
HRESULT hr = E_INVALIDARG;
if (Self->pDataObject != NULL) {
// OpenEvent() the work object to see if the instance is still around
char szBuf[100];
HANDLE hTransfer = OpenEventA(EVENT_ALL_ACCESS, false, CreateProcessUID(psd->pid, szBuf, sizeof(szBuf)));
if (hTransfer != 0) {
// map the ipc file again
HANDLE hMap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, IPC_PACKET_SIZE, IPC_PACKET_NAME);
if (hMap != 0 && GetLastError() != ERROR_ALREADY_EXISTS) {
// map it to process
THeaderIPC *pipch = (THeaderIPC*)MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
if (pipch != NULL) {
// create the name of the object to be signalled by the ST
lstrcpyA(pipch->SignalEventName, CreateUID(szBuf, sizeof(szBuf)));
// create it
HANDLE hReply = CreateEventA(NULL, false, false, pipch->SignalEventName);
if (hReply != 0) {
if (psd->fTypes & dtCommand) {
if (psd->MenuCommandCallback)
hr = psd->MenuCommandCallback(pipch, hTransfer, hReply);
}
else {
// prepare the buffer
ipcPrepareRequests(IPC_PACKET_SIZE, pipch, REQUEST_XFRFILES);
// get all the files into the packet
if (ipcGetFiles(pipch, Self->pDataObject, psd->hContact) == S_OK) {
// need to wait for the ST to open the mapping object
// since if we close it before it's opened it the data it
// has will be undefined
int replyBits = ipcSendRequest(hTransfer, hReply, pipch, 200);
if (replyBits != REPLY_FAIL) // they got the files!
hr = S_OK;
}
}
// close the work object name
CloseHandle(hReply);
}
// unmap it from this process
UnmapViewOfFile(pipch);
}
// close the map
CloseHandle(hMap);
}
// close the handle to the ST object name
CloseHandle(hTransfer);
}
}
return hr;
}
void am_log_init(int id, int status) {
int i;
char opened = 0;
am_agent_instance_init_init(id);
if (am_log_handle == NULL) {
am_log_handle = (struct am_shared_log *) malloc(sizeof (struct am_shared_log));
if (am_log_handle == NULL) {
return;
}
} else if (am_log_handle->reader_pid == getpid()) {
return;
}
am_log_handle->reader_pid = getpid();
snprintf(am_log_handle->area_file_name, sizeof (am_log_handle->area_file_name),
#ifdef __sun
"/am_log_%d"
#else
AM_GLOBAL_PREFIX"am_log_%d"
#endif
, id);
am_log_handle->area_size = page_size(sizeof (struct am_log));
#ifdef _WIN32
am_log_handle->area_file_id = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
0, (DWORD) am_log_handle->area_size, am_log_handle->area_file_name);
if (am_log_handle->area_file_id == NULL) return;
if (NULL != am_log_handle->area_file_id && GetLastError() == ERROR_ALREADY_EXISTS) {
opened = 1;
}
if (am_log_handle->area_file_id != NULL) {
am_log_handle->area = MapViewOfFile(am_log_handle->area_file_id, FILE_MAP_ALL_ACCESS,
0, 0, am_log_handle->area_size);
}
if (am_log_handle->area != NULL) {
if (status == AM_SUCCESS || status == AM_EAGAIN) {
struct am_log *log = (struct am_log *) am_log_handle->area;
memset(log, 0, am_log_handle->area_size);
log->bucket_count = AM_LOG_QUEUE_SIZE;
log->bucket_size = AM_LOG_MESSAGE_SIZE;
log->in = log->out = log->read_count = log->write_count = 0;
for (i = 0; i < AM_MAX_INSTANCES; i++) {
struct log_files *f = &log->files[i];
f->fd_audit = f->fd_debug = -1;
f->used = AM_FALSE;
f->instance_id = 0;
f->level_debug = f->level_audit = AM_LOG_LEVEL_NONE;
f->max_size_debug = f->max_size_audit = 0;
}
am_log_lck.exit = CreateEvent(NULL, FALSE, FALSE, get_global_name(AM_GLOBAL_PREFIX"am_log_exit", id));
if (am_log_lck.exit == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
am_log_lck.exit = OpenEventA(SYNCHRONIZE, TRUE, get_global_name(AM_GLOBAL_PREFIX"am_log_exit", id));
}
am_log_lck.lock = CreateMutex(NULL, FALSE, get_global_name(AM_GLOBAL_PREFIX"am_log_lock", id));
if (am_log_lck.lock == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
am_log_lck.lock = OpenMutexA(SYNCHRONIZE, TRUE, get_global_name(AM_GLOBAL_PREFIX"am_log_lock", id));
}
am_log_lck.new_data_cond = CreateEvent(NULL, FALSE, FALSE, get_global_name(AM_GLOBAL_PREFIX"am_log_queue_empty", id));
if (am_log_lck.new_data_cond == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
am_log_lck.new_data_cond = OpenEventA(SYNCHRONIZE, TRUE, get_global_name(AM_GLOBAL_PREFIX"am_log_queue_empty", id));
}
am_log_lck.new_space_cond = CreateEvent(NULL, FALSE, FALSE, get_global_name(AM_GLOBAL_PREFIX"am_log_queue_overflow", id));
if (am_log_lck.new_space_cond == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
am_log_lck.new_space_cond = OpenEventA(SYNCHRONIZE, TRUE, get_global_name(AM_GLOBAL_PREFIX"am_log_queue_overflow", id));
}
log->owner = getpid();
am_log_handle->reader_thr = CreateThread(NULL, 0,
(LPTHREAD_START_ROUTINE) am_log_worker, NULL, 0, NULL);
}
}
#else
am_log_handle->area_file_id = shm_open(am_log_handle->area_file_name, O_CREAT | O_EXCL | O_RDWR, 0666);
if (am_log_handle->area_file_id == -1 && EEXIST != errno) {
return;
}
if (am_log_handle->area_file_id == -1) {
/* already there, open without O_EXCL and go; if
* something goes wrong, close and cleanup */
am_log_handle->area_file_id = shm_open(am_log_handle->area_file_name, O_RDWR, 0666);
if (am_log_handle->area_file_id == -1) {
fprintf(stderr, "am_log_init() shm_open failed (%d)\n", errno);
free(am_log_handle);
am_log_handle = NULL;
return;
} else {
opened = 1;
}
} else {
/* we just created the shm area, must setup; if
* something goes wrong, delete the shm area and
* cleanup
*/
if (ftruncate(am_log_handle->area_file_id, am_log_handle->area_size) == -1) {
fprintf(stderr, "am_log_init() ftruncate failed\n");
return;
}
}
if (am_log_handle->area_file_id != -1) {
am_log_handle->area = mmap(NULL, am_log_handle->area_size,
PROT_READ | PROT_WRITE, MAP_SHARED, am_log_handle->area_file_id, 0);
if (am_log_handle->area == MAP_FAILED) {
fprintf(stderr, "am_log_init() mmap failed (%d)\n", errno);
free(am_log_handle);
am_log_handle = NULL;
} else {
pthread_mutexattr_t exit_attr, lock_attr;
pthread_condattr_t new_data_attr, new_space_attr;
struct am_log *log = (struct am_log *) am_log_handle->area;
pthread_mutexattr_init(&exit_attr);
pthread_mutexattr_init(&lock_attr);
pthread_condattr_init(&new_data_attr);
pthread_condattr_init(&new_space_attr);
pthread_mutexattr_setpshared(&exit_attr, PTHREAD_PROCESS_SHARED);
pthread_mutexattr_setpshared(&lock_attr, PTHREAD_PROCESS_SHARED);
pthread_condattr_setpshared(&new_data_attr, PTHREAD_PROCESS_SHARED);
pthread_condattr_setpshared(&new_space_attr, PTHREAD_PROCESS_SHARED);
if (status == AM_SUCCESS || status == AM_EAGAIN) {
memset(log, 0, am_log_handle->area_size);
log->bucket_count = AM_LOG_QUEUE_SIZE;
log->bucket_size = AM_LOG_MESSAGE_SIZE;
log->in = log->out = log->read_count = log->write_count = 0;
for (i = 0; i < AM_MAX_INSTANCES; i++) {
struct log_files *f = &log->files[i];
f->fd_audit = f->fd_debug = -1;
f->used = AM_FALSE;
f->instance_id = 0;
f->level_debug = f->level_audit = AM_LOG_LEVEL_NONE;
f->max_size_debug = f->max_size_audit = 0;
}
pthread_mutex_init(&log->exit, &exit_attr);
pthread_mutex_init(&log->lock, &lock_attr);
pthread_cond_init(&log->new_data_cond, &new_data_attr);
pthread_cond_init(&log->new_space_cond, &new_space_attr);
pthread_mutex_lock(&log->exit);
pthread_create(&am_log_handle->reader_thr, NULL, am_log_worker, NULL);
log->owner = getpid();
}
pthread_mutexattr_destroy(&exit_attr);
pthread_mutexattr_destroy(&lock_attr);
pthread_condattr_destroy(&new_data_attr);
pthread_condattr_destroy(&new_space_attr);
}
}
#endif
}
inline void kill_wrapper( ProcessId pid, int sig, int port, const BSONObj& opt ) {
#ifdef _WIN32
if (sig == SIGKILL || port == 0) {
verify( registry._handles.count(pid) );
TerminateProcess(registry._handles[pid], 1); // returns failure for "zombie" processes.
return;
}
std::string eventName = getShutdownSignalName(pid.asUInt32());
HANDLE event = OpenEventA(EVENT_MODIFY_STATE, FALSE, eventName.c_str());
if (event == NULL) {
int gle = GetLastError();
if (gle != ERROR_FILE_NOT_FOUND) {
warning() << "kill_wrapper OpenEvent failed: " << errnoWithDescription();
}
else {
log() << "kill_wrapper OpenEvent failed to open event to the process "
<< pid.asUInt32()
<< ". It has likely died already or server is running an older version."
<< " Attempting to shutdown through admin command.";
// Back-off to the old way of shutting down the server on Windows, in case we
// are managing a pre-2.6.0rc0 service, which did not have the event.
//
try {
DBClientConnection conn;
conn.connect("127.0.0.1:" + BSONObjBuilder::numStr(port));
BSONElement authObj = opt["auth"];
if (!authObj.eoo()){
string errMsg;
conn.auth("admin", authObj["user"].String(),
authObj["pwd"].String(), errMsg);
if (!errMsg.empty()) {
cout << "Failed to authenticate before shutdown: "
<< errMsg << endl;
}
}
BSONObj info;
BSONObjBuilder b;
b.append("shutdown", 1);
b.append("force", 1);
conn.runCommand("admin", b.done(), info);
}
catch (...) {
// Do nothing. This command never returns data to the client and the driver
// doesn't like that.
//
}
}
return;
}
ON_BLOCK_EXIT(CloseHandle, event);
bool result = SetEvent(event);
if (!result) {
error() << "kill_wrapper SetEvent failed: " << errnoWithDescription();
return;
}
#else
int x = kill( pid.toNative(), sig );
if ( x ) {
if ( errno == ESRCH ) {
}
else {
log() << "killFailed: " << errnoWithDescription() << endl;
verify( x == 0 );
}
}
#endif
}
static void test_event(void)
{
HANDLE handle, handle2;
SECURITY_ATTRIBUTES sa;
SECURITY_DESCRIPTOR sd;
ACL acl;
DWORD ret;
BOOL val;
/* no sd */
handle = CreateEventA(NULL, FALSE, FALSE, __FILE__ ": Test Event");
ok(handle != NULL, "CreateEventW with blank sd failed with error %d\n", GetLastError());
CloseHandle(handle);
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = &sd;
sa.bInheritHandle = FALSE;
InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
/* blank sd */
handle = CreateEventA(&sa, FALSE, FALSE, __FILE__ ": Test Event");
ok(handle != NULL, "CreateEventW with blank sd failed with error %d\n", GetLastError());
CloseHandle(handle);
/* sd with NULL dacl */
SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
handle = CreateEventA(&sa, FALSE, FALSE, __FILE__ ": Test Event");
ok(handle != NULL, "CreateEventW with blank sd failed with error %d\n", GetLastError());
CloseHandle(handle);
/* sd with empty dacl */
InitializeAcl(&acl, sizeof(acl), ACL_REVISION);
SetSecurityDescriptorDacl(&sd, TRUE, &acl, FALSE);
handle = CreateEventA(&sa, FALSE, FALSE, __FILE__ ": Test Event");
ok(handle != NULL, "CreateEventW with blank sd failed with error %d\n", GetLastError());
CloseHandle(handle);
/* test case sensitivity */
SetLastError(0xdeadbeef);
handle = CreateEventA(NULL, FALSE, FALSE, __FILE__ ": Test Event");
ok( handle != NULL, "CreateEvent failed with error %u\n", GetLastError());
ok( GetLastError() == 0, "wrong error %u\n", GetLastError());
SetLastError(0xdeadbeef);
handle2 = CreateEventA(NULL, FALSE, FALSE, __FILE__ ": Test Event");
ok( handle2 != NULL, "CreateEvent failed with error %d\n", GetLastError());
ok( GetLastError() == ERROR_ALREADY_EXISTS, "wrong error %u\n", GetLastError());
CloseHandle( handle2 );
SetLastError(0xdeadbeef);
handle2 = CreateEventA(NULL, FALSE, FALSE, __FILE__ ": TEST EVENT");
ok( handle2 != NULL, "CreateEvent failed with error %d\n", GetLastError());
ok( GetLastError() == 0, "wrong error %u\n", GetLastError());
CloseHandle( handle2 );
SetLastError(0xdeadbeef);
handle2 = OpenEventA( EVENT_ALL_ACCESS, FALSE, __FILE__ ": Test Event");
ok( handle2 != NULL, "OpenEvent failed with error %d\n", GetLastError());
CloseHandle( handle2 );
SetLastError(0xdeadbeef);
handle2 = OpenEventA( EVENT_ALL_ACCESS, FALSE, __FILE__ ": TEST EVENT");
ok( !handle2, "OpenEvent succeeded\n");
ok( GetLastError() == ERROR_FILE_NOT_FOUND, "wrong error %u\n", GetLastError());
CloseHandle( handle );
/* resource notifications are events too */
if (!pCreateMemoryResourceNotification || !pQueryMemoryResourceNotification)
{
trace( "memory resource notifications not supported\n" );
return;
}
handle = pCreateMemoryResourceNotification( HighMemoryResourceNotification + 1 );
ok( !handle, "CreateMemoryResourceNotification succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
ret = pQueryMemoryResourceNotification( handle, &val );
ok( !ret, "QueryMemoryResourceNotification succeeded\n" );
ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
handle = pCreateMemoryResourceNotification( LowMemoryResourceNotification );
ok( handle != 0, "CreateMemoryResourceNotification failed err %u\n", GetLastError() );
ret = WaitForSingleObject( handle, 10 );
ok( ret == WAIT_OBJECT_0 || ret == WAIT_TIMEOUT, "WaitForSingleObject wrong ret %u\n", ret );
val = ~0;
ret = pQueryMemoryResourceNotification( handle, &val );
ok( ret, "QueryMemoryResourceNotification failed err %u\n", GetLastError() );
ok( val == FALSE || val == TRUE, "wrong value %u\n", val );
ret = CloseHandle( handle );
ok( ret, "CloseHandle failed err %u\n", GetLastError() );
handle = CreateEventA(NULL, FALSE, FALSE, __FILE__ ": Test Event");
val = ~0;
ret = pQueryMemoryResourceNotification( handle, &val );
ok( ret, "QueryMemoryResourceNotification failed err %u\n", GetLastError() );
ok( val == FALSE || val == TRUE, "wrong value %u\n", val );
CloseHandle( handle );
}
static void test_event(void)
{
HANDLE handle, handle2;
SECURITY_ATTRIBUTES sa;
SECURITY_DESCRIPTOR sd;
ACL acl;
/* no sd */
handle = CreateEventA(NULL, FALSE, FALSE, __FILE__ ": Test Event");
ok(handle != NULL, "CreateEventW with blank sd failed with error %d\n", GetLastError());
CloseHandle(handle);
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = &sd;
sa.bInheritHandle = FALSE;
InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
/* blank sd */
handle = CreateEventA(&sa, FALSE, FALSE, __FILE__ ": Test Event");
ok(handle != NULL, "CreateEventW with blank sd failed with error %d\n", GetLastError());
CloseHandle(handle);
/* sd with NULL dacl */
SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
handle = CreateEventA(&sa, FALSE, FALSE, __FILE__ ": Test Event");
ok(handle != NULL, "CreateEventW with blank sd failed with error %d\n", GetLastError());
CloseHandle(handle);
/* sd with empty dacl */
InitializeAcl(&acl, sizeof(acl), ACL_REVISION);
SetSecurityDescriptorDacl(&sd, TRUE, &acl, FALSE);
handle = CreateEventA(&sa, FALSE, FALSE, __FILE__ ": Test Event");
ok(handle != NULL, "CreateEventW with blank sd failed with error %d\n", GetLastError());
CloseHandle(handle);
/* test case sensitivity */
SetLastError(0xdeadbeef);
handle = CreateEventA(NULL, FALSE, FALSE, __FILE__ ": Test Event");
ok( handle != NULL, "CreateEvent failed with error %u\n", GetLastError());
ok( GetLastError() == 0, "wrong error %u\n", GetLastError());
SetLastError(0xdeadbeef);
handle2 = CreateEventA(NULL, FALSE, FALSE, __FILE__ ": Test Event");
ok( handle2 != NULL, "CreateEvent failed with error %d\n", GetLastError());
ok( GetLastError() == ERROR_ALREADY_EXISTS, "wrong error %u\n", GetLastError());
CloseHandle( handle2 );
SetLastError(0xdeadbeef);
handle2 = CreateEventA(NULL, FALSE, FALSE, __FILE__ ": TEST EVENT");
ok( handle2 != NULL, "CreateEvent failed with error %d\n", GetLastError());
ok( GetLastError() == 0, "wrong error %u\n", GetLastError());
CloseHandle( handle2 );
SetLastError(0xdeadbeef);
handle2 = OpenEventA( EVENT_ALL_ACCESS, FALSE, __FILE__ ": Test Event");
ok( handle2 != NULL, "OpenEvent failed with error %d\n", GetLastError());
CloseHandle( handle2 );
SetLastError(0xdeadbeef);
handle2 = OpenEventA( EVENT_ALL_ACCESS, FALSE, __FILE__ ": TEST EVENT");
ok( !handle2, "OpenEvent succeeded\n");
ok( GetLastError() == ERROR_FILE_NOT_FOUND ||
GetLastError() == ERROR_INVALID_NAME, /* win9x */
"wrong error %u\n", GetLastError());
CloseHandle( handle );
}
// this function is called from an APC into the main thread
void __stdcall ipcService(ULONG_PTR dwParam)
{
HANDLE hSignal;
TSlotIPC *pct;
LPSTR szBuf;
char szGroupStr[32];
DBVARIANT dbv;
LPSTR szMiranda;
// try to open the file mapping object the caller must make sure no other
// running instance is using this file
HANDLE hMap = OpenFileMappingA(FILE_MAP_ALL_ACCESS, false, IPC_PACKET_NAME);
if (hMap == 0)
return;
// map the file to this process
THeaderIPC *pMMT = (THeaderIPC*)MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
// if it fails the caller should of had some timeout in wait
if (pMMT != NULL && pMMT->cbSize == sizeof(THeaderIPC) && pMMT->dwVersion == PLUGIN_MAKE_VERSION(2, 0, 1, 2)) {
// toggle the right bits
int *bits = &pMMT->fRequests;
// jump right to a worker thread for file processing?
if (*bits & REQUEST_XFRFILES) {
THeaderIPC *cloned = (THeaderIPC*)mir_alloc(IPC_PACKET_SIZE);
// translate from client space to cloned heap memory
pMMT->pServerBaseAddress = pMMT->pClientBaseAddress;
pMMT->pClientBaseAddress = cloned;
CopyMemory(cloned, pMMT, IPC_PACKET_SIZE);
ipcFixupAddresses(true, cloned);
DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &cloned->Param, THREAD_SET_CONTEXT, false, 0);
mir_forkthread(&IssueTransferThread, cloned);
goto Reply;
}
// the request was to clear the MRU entries, we have no return data
if (*bits & REQUEST_CLEARMRU) {
mir_forkthread(&ClearMRUThread, NULL);
goto Reply;
}
// the IPC header may have pointers that need to be translated
// in either case the supplied data area pointers has to be
// translated to this address space.
// the server base address is always removed to get an offset
// to which the client base is added, this is what ipcFixupAddresses() does
pMMT->pServerBaseAddress = pMMT->pClientBaseAddress;
pMMT->pClientBaseAddress = pMMT;
// translate to the server space map
ipcFixupAddresses(true, pMMT);
// store the address map offset so the caller can retranslate
pMMT->pServerBaseAddress = pMMT;
// return some options to the client
if (db_get_b(0, SHLExt_Name, SHLExt_ShowNoIcons, 0) != 0)
pMMT->dwFlags = HIPC_NOICONS;
// see if we have a custom string for 'Miranda'
szMiranda = "Miranda";
lstrcpynA(pMMT->MirandaName, szMiranda, sizeof(pMMT->MirandaName) - 1);
// for the MRU menu
szBuf = Translate("Recently");
lstrcpynA(pMMT->MRUMenuName, szBuf, sizeof(pMMT->MRUMenuName) - 1);
// and a custom string for "clear entries"
szBuf = Translate("Clear entries");
lstrcpynA(pMMT->ClearEntries, szBuf, sizeof(pMMT->ClearEntries) - 1);
// if the group mode is on, check if they want the CList setting
bool bGroupMode = (BST_CHECKED == db_get_b(0, SHLExt_Name, SHLExt_UseGroups, BST_UNCHECKED));
if (bGroupMode && BST_CHECKED == db_get_b(0, SHLExt_Name, SHLExt_UseCListSetting, BST_UNCHECKED))
bGroupMode = db_get_b(0, "CList", "UseGroups", true) != 0;
int iSlot = 0;
// return profile if set
if (BST_UNCHECKED == db_get_b(0, SHLExt_Name, SHLExt_ShowNoProfile, BST_UNCHECKED)) {
pct = ipcAlloc(pMMT, 50);
if (pct != NULL) {
// will actually return with .dat if there's space for it, not what the docs say
pct->Status = STATUS_PROFILENAME;
CallService(MS_DB_GETPROFILENAME, 49, UINT_PTR(pct) + sizeof(TSlotIPC));
}
}
if (*bits & REQUEST_NEWICONS)
ipcGetSkinIcons(pMMT);
if (*bits & REQUEST_GROUPS) {
// return contact's grouping if it's present
while (bGroupMode) {
_itoa(iSlot, szGroupStr, 10);
if ( db_get_s(0, "CListGroups", szGroupStr, &dbv) != 0)
break;
pct = ipcAlloc(pMMT, lstrlenA(dbv.pszVal + 1) + 1);
// first byte has flags, need null term
if (pct != NULL) {
if (pMMT->GroupsBegin == NULL)
pMMT->GroupsBegin = pct;
pct->fType = REQUEST_GROUPS;
pct->hContact = 0;
szBuf = LPSTR(pct) + sizeof(TSlotIPC); // get the end of the slot
lstrcpyA(szBuf, dbv.pszVal + 1);
pct->hGroup = 0;
db_free(&dbv); // free the string
}
else {
// outta space
db_free(&dbv);
break;
}
iSlot++;
}
// if there was no space left, it'll } on null
if (pct == NULL)
*bits = (*bits | GROUPS_NOTIMPL) & ~REQUEST_GROUPS;
}
// SHOULD check slot space.
if (*bits & REQUEST_CONTACTS) {
if (!ipcGetSortedContacts(pMMT, &iSlot, bGroupMode))
// fail if there were no contacts AT ALL
*bits = (*bits | CONTACTS_NOTIMPL) & ~REQUEST_CONTACTS;
}
// store the number of slots allocated
pMMT->Slots = iSlot;
Reply:
// get the handle the caller wants to be signalled on
hSignal = OpenEventA(EVENT_ALL_ACCESS, false, pMMT->SignalEventName);
if (hSignal != 0) {
SetEvent(hSignal);
CloseHandle(hSignal);
}
UnmapViewOfFile(pMMT);
}
CloseHandle(hMap);
}
