Release 980927
Sun Sep 27 14:25:38 1998 Petter Reinholdtsen <pere@td.org.uit.no>
* [files/drive.c]
Make sure GetDriveType32A() handles param NULL. Added some
doc on function.
Sun Sep 27 14:07:26 1998 Huw D M Davies <daviesh@abacus.physics.ox.ac.uk>
* [controls/edit.c] [windows/win.c]
Don't call SetWindowLong() in EDIT_WM_NCREATE.
Fix SetWindowLong(GWL_[EX]STYLE) to work for 16bit windows. Remove
UpdateWindow() call.
Sun Sep 27 13:41:22 1998 Alexandre Julliard <julliard@lrc.epfl.ch>
* [scheduler/*.c] [server/event.c] [server/mutex.c]
[server/semaphore.c]
Implemented server-side synchronisation objects.
Sun Sep 27 01:13:35 1998 Alex Priem <alexp@sci.kun.nl>
* [dlls/comctl32/treeview.c] [include/treeview.h] [include/comctl.h]
Treeview implementation.
* [dlls/comctl32/trackbar.c] [include/trackbar.h]
Trackbar implementation.
Sat Sep 26 20:49:13 1998 Ulrich Weigand <weigand@informatik.uni-erlangen.de>
* [if1632/thunk.c] [tools/build.c] [win32/kernel32.c]
Bugfix: several problems with flat thunks fixed.
* [memory/selector.c]
Bugfix: IsBad...Ptr16 didn't work for limit_in_pages segments.
* [scheduler/thread.c]
Bugfix: CreateThread: Allow id parameter == NULL.
* [objects/gdiobj.c]
Bugfix: IsGDIObject: Return correct object type for stock objects.
* [msdos/dpmi.c]
Bugfix: fixed typo in INT_DoRealModeInt.
* [msdos/int21.c]
Bugfix: int21 READ *must* use WIN16_hread, not _hread16.
* [if1632/kernel.spec] [if1632/dummy.c] [if1632/thunk.c]
[loader/ne/module.c] [scheduler/event.c] [scheduler/synchro.c]
[scheduler/thread.c] [win32/kernel32.c] [win32/ordinals.c]
Added names/stubs for all undocumented KERNEL routines (Win95).
Added the following undoc. 16-bit equivalents to Win32 routines:
KERNEL.441-443,449-453,456-462,471-476,479-486,488.
Added stubs for some other KERNEL routines.
* [memory/heap.c] [memory/global.c] [include/global.h]
Implemented Local32... 32-bit local heap routines (KERNEL.208-215, 229).
* [miscemu/instr.c] [loader/module.c] [include/module.h]
Implemented __GP fault handling and HasGPHandler (KERNEL.338).
* [misc/error.c]
Implemented LogParamErrorRegs (KERNEL.327).
* [loader/task.c] [include/windows.h]
Implemented GetCodeInfo (KERNEL.104).
* [loader/task.c] [scheduler/thread.c] [include/thread.h]
Implemented [GS]etThreadQueue and [GS]etFastQueue (KERNEL.463/4, 624/5).
* [if1632/gdi.spec] [objects/dc.c] [objects/dib.c]
[objects/bitmap.c] [include/windows.h]
Bugfix: fixed wrong parameter for CreateDIBSection16.
Added [GS]etDIBColorTable16, stub for GetBoundsRect16.
Partially implemented BITMAP_GetObject16 for DIBs.
* [if1632/gdi.spec] [relay32/gdi32.spec] [objects/palette.c]
Added some GDI stubs.
* [if1632/Makefile.in] [if1632/display.spec] [if1632/mouse.spec]
[if1632/keyboard.spec] [if1632/builtin.c] [windows/keyboard.c]
Added some stubs for Win16 drivers: KEYBOARD, MOUSE, DISPLAY.
* [if1632/wprocs.spec] [msdos/vxd.c]
Added some stubs for VxDs: VMM, ConfigMG, TimerAPI.
* [msdos/int2f.c]
Added some stubs for real-mode network drivers.
Sat Sep 26 18:18:18 1998 Marcus Meissner <marcus@jet.franken.de>
* [configure.in]
Merged in some more of the FreeBSD ports/emulators/wine patches.
(Maintainer(s) of this port: You can just submit these
patches to Alexandre directly.)
* [loader/pe_image.c]
Check filesize of image against size derived from header
to spot truncated executeables without crashing.
* [files/directory.c]
Set envvar "COMSPEC". One win32(!!) program crashes without it.
* [multimedia/mmio.c]
Added mmioSetInfo32.
* [include/file.h]
Return STD_ERROR_HANDLE for AUX and PRT dos handles.
* [loader/module.c]
Handle executeables with spaces in their names a bit better in
CreateProcess.
* [relay32/msvfw32.spec][if1632/msvideo.spec][multimedia/msvideo.c][include/vfw.h]
Started on MS Video support (can load Win32 ICMs).
* [tools/testrun]
A bit smarter use of ps.
* [memory/virtual.c]
Report PAGE_GUARDed pages as PAGE_PROTECTED (AutoCAD LT R17 fails
without that check (since Win95 doesn't know about PAGE_GUARD)).
Sat Sep 26 15:04:05 1998 Ove Kaaven <ovek@arcticnet.no>
* [include/miscemu.h] [if1632/builtin.c] [loader/task.c]
[miscemu/instr.c] [msdos/dpmi.c] [msdos/int21.c]
[msdos/interrupts.c] [windows/user.c]
INT_[S|G]etHandler was renamed to INT_[S|G]etPMHandler.
Added handlers to deal with real-mode interrupts; DOS
programs are now able to hook real-mode interrupts.
* [loader/dos/module.c] [msdos/dosmem.c] [msdos/int21.c]
Moved real-mode interrupt table initialization to
msdos/dosmem.c, and made new V86 tasks get a full copy
of the existing "system memory" instead of almost empty
space. Misc fixes.
* [include/dosexe.h] [loader/dos/module.c] [msdos/dpmi.c]
[msdos/int2f.c]
First shot at letting DOS programs start up DPMI (but DPMI
is still disabled for DOS programs, for pkunzip's sake).
* [include/debugger.h] [debugger/break.c] [debugger/dbg.y]
[debugger/registers.c] [debugger/memory.c] [debugger/info.c]
[loader/dos/dosvm.c]
First shot at making Wine's debugger work for DOS programs.
The -debug flag works, as do "nexti" and "stepi".
Sat Sep 26 13:13:13 1998 Juergen Schmied <juergen.schmied@metronet.de>
* [dlls/shell32/dataobject.c]
New classes IEnumFORMATETC implemented, IDataObject stubs.
* [dlls/shell32/*.*][relay32/shell32.spec]
Bugfixes.
New: ICM_InsertItem(), ILCreateFromPath().
Implemented: ILCloneFirst().
Stubs: ILIsEqual(), ILFindChild(), SHLogILFromFSIL(),
PathMatchSpec(), PathIsExe().
Changed: ILGetSize(), _ILIsDesktop(), PathCombine().
* [include/shlobj.h]
New SHLGUID's
New structures: DVTARGETDEVICE32, STGMEDIUM32, FORMATETC32,
CLIPFORMAT32.
New interfaces: IEnumFORMATETC, IDataObject, ICommDlgBrowser
IDockingWindowFrame, IServiceProvider.
* [dlls/shell32/folders.c]
Stubs for IShellLink.
* [loader/resource.c]
Small fixes.
* [misc/crtdll.c][relay32/crtdll.spec]
New __dllonexit().
* [windows/message.c]
SendNotifyMessageA, SendMessageCallBack32A half implemented.
* [controls/edit.c]
EDIT_WM_SetText set EF_UPDATE flag not for ES_MULTILINE.
* [files/file.c]
Handling of fileposition fixed.
Fri Sep 25 18:13:30 1998 Patrik Stridvall <ps@leissner.se>
* [include/windows.h] [include/wintypes.h]
[ole/ole2nls.h] [relay32/kernel32.spec]
Implemented EnumDateFormats and EnumTimeFormats.
Only adds US English support.
* [Makefile.in] [configure.in]
[dlls/Makefile.in] [dlls/psapi/Makefile.in]
[dlls/psapi/psapi_main.c]
New files to implement stubs for PSAPI.DLL (NT only).
* [relay32/Makefile.in] [relay32/builtin32.c]
[relay32/psapi.spec]
New spec file for PSAPI.DLL (NT only).
* [scheduler/handle.c]
HANDLE_GetObjPtr should only interpret the pseudo handles as the
current thread or the current process if a thread or a process is
requested.
* [include/winversion.h] [misc/version.c]
Adds the global function VERSION_GetVersion() so functions can
have different behavior depending on the -winver flag.
* [include/oledlg.h] [ole/oledlg.c]
Minor fixes.
* [windows/winproc.c]
Minor changes.
* [include/imm.h] [misc/imm.c]
Now returns correct values under both Windows 95 and NT 4.0.
Thu Sep 24 22:11:44 1998 Kristian Nielsen <kristian.nielsen@risoe.dk>
* [configure.in] [include/acconfig.h] [include/thread.h]
[scheduler/sysdeps.c]
Autoconfig test for non-reentrant libc.
Wed Sep 23 19:52:12 1998 Matthew Becker <mbecker@glasscity.net>
* [*/*.c]
Miscellaneous documentation updates and debugging output
standardizations.
* [objects/clipping.c]
Added ExtSelectClipRgn.
Wed Sep 23 00:03:28 EDT 1998 Pete Ratzlaff <pratzlaff@cfa.harvard.edu>
* [include/windows.h] [if1632/user.spec] [relay32/user32.spec]
[windows/keyboard.c]
Added, marginally implemented, GetKeyboardLayoutName().
Only returns US English keyboard name.
Tue Sep 22 16:32:41 1998 Marcel Baur <mbaur@iiic.ethz.ch>
* [programs/control/*]
New Winelib application.
Mon Sep 21 00:29:18 1998 Peter Hunnisett <hunnise@nortel.ca>
* [include/dplay.h][multimedia/dplay.c][ole/compobj.c]
Added all DirectPlayLobby interfaces and enhanced DirectPlay
and DirectPlayLobby support. Still not all that much. Useful
enough if you just need to start a program, don't try any
real dplay/lobby stuff.
* [documentation/status/directplay]
Added a very little bit.
* [graphics/ddraw.c]
- Call to SetWindowLong32A wasn't working because there was no
memory set aside when the window class was registered.
- Fixed some xlib reference counting and change the behaviour
of DirectDrawSurface3_SetPalette to mimic observed behaviour
(palette is associated will all backbuffers)
- Also stored all palette colour fields and spit back our saved
colour fields rather than query X for them.
- Added plenty of AddRef and Release traces.
- Added Xlib support for using -desktop option.
- Fixed Xlib message handling. Messages weren't being passed to
the application. Fixes mouse movements in some xlib DDraw games.
- Added a few stubs.
* [windows/win.c][include/winerror.h]
Fixed up some error handling in WIN_SetWindowLong. SetLastError
wasn't being used. Could cause problems with 0 return codes.
Added new error in winerror (1400).
* [AUTHORS] [include/authors.h]
Added myself as a Wine author.
Sun Sep 20 21:22:44 1998 Alexander Larsson <alla@lysator.liu.se>
* [loader/module.c]
Changed GetModuleFileName32A so that is returns the
long version of the filename. Note that just the name
is long, not the directories.
Sat Sep 19 20:05:30 1998 Per Ångström <pang@mind.nu>
* [controls/menu.c]
Made a couple of fixes to make life easier for applications that alter
their menus at runtime.
* [windows/defdlg.c]
Removed the cast of the return value from dialog procedures to a 16-bit
bool. The return value needs to retain all its 32 bits, since it is not
always a bool, such as when responding to the WM_NCHITTEST message.
Fri Sep 18 11:30:38 1998 Sergey Turchanov <turchanov@usa.net>
* [loader/resource.c]
Fixed very funny bug (though gravely affecting further excecution)
with FindResource[Ex]32 functions.
* [include/multimon.h] [windows/multimon.c] [relay32/user32.spec]
[include/windows.h] [windows/sysmetrics.c]
Default implementation for Multimonitor API.
* [include/windows.h] [windows/winpos.c]
Fixed incorrect declaration (and behaviour) of GetWindowRect32.
Wed Sep 16 10:21:15 1998 Gerard Patel <G.Patel@Wanadoo.fr>
* [controls/edit.c]
Fixed EDIT_EM_GetLine to use correctly length of lines.
Tue Sep 15 20:40:16 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
* [misc/tweak.c][include/tweak.h][controls/menu.c]
Replaced the tweak graphic routines by calls to DrawEdge32().
* [misc/tweak.c][include/tweak.h][documentation/win95look]
[wine.ini][*/*]
Changed "look and feel" selection. Allows Win3.1, Win95 and
Win98 (no GUI code implemented) look and feel.
* [dlls/comctl32/header.c][include/header.h][include/commctrl.h]
Started callback item support and did some minor improvements.
* [dlls/comctl32/imagelist.c]
Fixed bug in transparent image display.
ImageList_GetIcon is still buggy :-(
* [dlls/comctl32/toolbar.c]
Fixed button drawing (partial hack).
* [dlls/comctl32/commctrl.c]
Fixed MenuHelp().
* [controls/button.c]
Added 3d effect for groupbox.
* [windows/msgbox.c]
Added font support for message boxes.
* [windows/nonclient.c]
Fixed window moving bug.
* [dlls/comctl32/*.c]
Various improvements.
* [dlls/comctl32/listview.c][dlls/comctl32/rebar.c]
[include/commctrl.h]
More messages.
* [windows/syscolor.c][include/windows.h]
Introduced new Win98 system colors.
Tue Sep 15 18:29:45 1998 Wesley Filardo <eightknots@aol.com>
* [files/profile.c]
Added support in PROFILE_LoadWineIni for -config option
* [misc/main.c] [include/options.h]
Added -config option.
Tue Sep 15 18:22:26 1998 Petter Reinholdtsen <pere@td.org.uit.no>
* [documentation/Makefile.in]
Make sure directory exists before installing into it.
Tue Sep 15 01:47:33 1998 Pablo Saratxaga <pablo.sarachaga@ping.be>
* [ole/nls/*] [ole/ole2nls.c] [include/winnls.h]
Fixed a few errors and completed some NLS files.
Mon Sep 14 01:23:45 1998 Joseph Pranevich <knight@baltimore.wwaves.com>
* [include/miscemu.h] [msdos/interrupts.c]
Removed a compilation warning, added INT 25 to the list of interrupts
callable from DOS applications, added a debug message when unsupported
interrupts are used.
Sun Sep 13 19:55:22 1998 Lawson Whitney <lawson_whitney@juno.com>
* [if1632/relay.c]
CallProcEx32W should not reverse arguments.
Sun Aug 17 21:18:12 1998 Eric Pouech <eric.pouech@lemel.fr>
* [multimedia/midi.c] [multimedia/init.c] [multimedia/mmsys.c]
[include/multimedia.h] [include/mmsystem.h]
[multimedia/Makefile.in] [multimedia/midipatch.c]
[if1632/multimedia.spec]
Made MIDI input and output functional on OSS capable systems.
* [multimedia/timer.c]
Changes to trigger callbacks at the accurate pace even when
fake timers are used.
diff --git a/server/Makefile.in b/server/Makefile.in
index 01b67f1..7ec46f8 100644
--- a/server/Makefile.in
+++ b/server/Makefile.in
@@ -6,9 +6,12 @@
MODULE = server
C_SRCS = \
+ event.c \
+ mutex.c \
object.c \
process.c \
request.c \
+ semaphore.c \
socket.c \
thread.c \
trace.c
diff --git a/server/event.c b/server/event.c
new file mode 100644
index 0000000..ef9dd76
--- /dev/null
+++ b/server/event.c
@@ -0,0 +1,125 @@
+/*
+ * Server-side event management
+ *
+ * Copyright (C) 1998 Alexandre Julliard
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "winerror.h"
+#include "winnt.h"
+#include "server/thread.h"
+
+struct event
+{
+ struct object obj; /* object header */
+ int manual_reset; /* is it a manual reset event? */
+ int signaled; /* event has been signaled */
+};
+
+static void dump_event( struct object *obj, int verbose );
+static int event_signaled( struct object *obj, struct thread *thread );
+static int event_satisfied( struct object *obj, struct thread *thread );
+static void destroy_event( struct object *obj );
+
+static const struct object_ops event_ops =
+{
+ dump_event,
+ event_signaled,
+ event_satisfied,
+ destroy_event
+};
+
+
+struct object *create_event( const char *name, int manual_reset, int initial_state )
+{
+ struct event *event;
+
+ if (!(event = (struct event *)create_named_object( name, &event_ops, sizeof(*event) )))
+ return NULL;
+ if (GET_ERROR() != ERROR_ALREADY_EXISTS)
+ {
+ /* initialize it if it didn't already exist */
+ event->manual_reset = manual_reset;
+ event->signaled = initial_state;
+ }
+ return &event->obj;
+}
+
+int open_event( unsigned int access, int inherit, const char *name )
+{
+ return open_object( name, &event_ops, access, inherit );
+}
+
+int pulse_event( int handle )
+{
+ struct event *event;
+
+ if (!(event = (struct event *)get_handle_obj( current->process, handle,
+ EVENT_MODIFY_STATE, &event_ops )))
+ return 0;
+ event->signaled = 1;
+ /* wake up all waiters if manual reset, a single one otherwise */
+ wake_up( &event->obj, !event->manual_reset );
+ event->signaled = 0;
+ release_object( event );
+ return 1;
+}
+
+int set_event( int handle )
+{
+ struct event *event;
+
+ if (!(event = (struct event *)get_handle_obj( current->process, handle,
+ EVENT_MODIFY_STATE, &event_ops )))
+ return 0;
+ event->signaled = 1;
+ /* wake up all waiters if manual reset, a single one otherwise */
+ wake_up( &event->obj, !event->manual_reset );
+ release_object( event );
+ return 1;
+}
+
+int reset_event( int handle )
+{
+ struct event *event;
+
+ if (!(event = (struct event *)get_handle_obj( current->process, handle,
+ EVENT_MODIFY_STATE, &event_ops )))
+ return 0;
+ event->signaled = 0;
+ release_object( event );
+ return 1;
+}
+
+static void dump_event( struct object *obj, int verbose )
+{
+ struct event *event = (struct event *)obj;
+ assert( obj->ops == &event_ops );
+ printf( "Event manual=%d signaled=%d\n", event->manual_reset, event->signaled );
+}
+
+static int event_signaled( struct object *obj, struct thread *thread )
+{
+ struct event *event = (struct event *)obj;
+ assert( obj->ops == &event_ops );
+ return event->signaled;
+}
+
+static int event_satisfied( struct object *obj, struct thread *thread )
+{
+ struct event *event = (struct event *)obj;
+ assert( obj->ops == &event_ops );
+ /* Reset if it's an auto-reset event */
+ if (!event->manual_reset) event->signaled = 0;
+ return 0; /* Not abandoned */
+}
+
+static void destroy_event( struct object *obj )
+{
+ struct event *event = (struct event *)obj;
+ assert( obj->ops == &event_ops );
+ free( event );
+}
diff --git a/server/mutex.c b/server/mutex.c
new file mode 100644
index 0000000..df5fc9f
--- /dev/null
+++ b/server/mutex.c
@@ -0,0 +1,142 @@
+/*
+ * Server-side mutex management
+ *
+ * Copyright (C) 1998 Alexandre Julliard
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "winerror.h"
+#include "winnt.h"
+#include "server/thread.h"
+
+struct mutex
+{
+ struct object obj; /* object header */
+ struct thread *owner; /* mutex owner */
+ unsigned int count; /* recursion count */
+ int abandoned; /* has it been abandoned? */
+ struct mutex *next;
+ struct mutex *prev;
+};
+
+static void dump_mutex( struct object *obj, int verbose );
+static int mutex_signaled( struct object *obj, struct thread *thread );
+static int mutex_satisfied( struct object *obj, struct thread *thread );
+static void destroy_mutex( struct object *obj );
+
+static const struct object_ops mutex_ops =
+{
+ dump_mutex,
+ mutex_signaled,
+ mutex_satisfied,
+ destroy_mutex
+};
+
+
+struct object *create_mutex( const char *name, int owned )
+{
+ struct mutex *mutex;
+
+ if (!(mutex = (struct mutex *)create_named_object( name, &mutex_ops, sizeof(*mutex) )))
+ return NULL;
+ if (GET_ERROR() != ERROR_ALREADY_EXISTS)
+ {
+ /* initialize it if it didn't already exist */
+ mutex->count = 0;
+ mutex->owner = NULL;
+ mutex->abandoned = 0;
+ mutex->next = mutex->prev = NULL;
+ if (owned) mutex_satisfied( &mutex->obj, current );
+ }
+ return &mutex->obj;
+}
+
+int open_mutex( unsigned int access, int inherit, const char *name )
+{
+ return open_object( name, &mutex_ops, access, inherit );
+}
+
+/* release a mutex once the recursion count is 0 */
+static void do_release( struct mutex *mutex, struct thread *thread )
+{
+ assert( !mutex->count );
+ /* remove the mutex from the thread list of owned mutexes */
+ if (mutex->next) mutex->next->prev = mutex->prev;
+ if (mutex->prev) mutex->prev->next = mutex->next;
+ else thread->mutex = mutex->next;
+ mutex->owner = NULL;
+ mutex->next = mutex->prev = NULL;
+ wake_up( &mutex->obj, 0 );
+}
+
+int release_mutex( int handle )
+{
+ struct mutex *mutex;
+
+ if (!(mutex = (struct mutex *)get_handle_obj( current->process, handle,
+ MUTEX_MODIFY_STATE, &mutex_ops )))
+ return 0;
+ if (!mutex->count || (mutex->owner != current))
+ {
+ SET_ERROR( ERROR_NOT_OWNER );
+ return 0;
+ }
+ if (!--mutex->count) do_release( mutex, current );
+ release_object( mutex );
+ return 1;
+}
+
+void abandon_mutexes( struct thread *thread )
+{
+ while (thread->mutex)
+ {
+ struct mutex *mutex = thread->mutex;
+ assert( mutex->owner == thread );
+ mutex->count = 0;
+ mutex->abandoned = 1;
+ do_release( mutex, thread );
+ }
+}
+
+static void dump_mutex( struct object *obj, int verbose )
+{
+ struct mutex *mutex = (struct mutex *)obj;
+ assert( obj->ops == &mutex_ops );
+ printf( "Mutex count=%u owner=%p\n", mutex->count, mutex->owner );
+}
+
+static int mutex_signaled( struct object *obj, struct thread *thread )
+{
+ struct mutex *mutex = (struct mutex *)obj;
+ assert( obj->ops == &mutex_ops );
+ return (!mutex->count || (mutex->owner == thread));
+}
+
+static int mutex_satisfied( struct object *obj, struct thread *thread )
+{
+ struct mutex *mutex = (struct mutex *)obj;
+ assert( obj->ops == &mutex_ops );
+ assert( !mutex->count || (mutex->owner == thread) );
+
+ if (!mutex->count++) /* FIXME: avoid wrap-around */
+ {
+ assert( !mutex->owner );
+ mutex->owner = thread;
+ mutex->prev = NULL;
+ if ((mutex->next = thread->mutex)) mutex->next->prev = mutex;
+ thread->mutex = mutex;
+ }
+ if (!mutex->abandoned) return 0;
+ mutex->abandoned = 0;
+ return 1;
+}
+
+static void destroy_mutex( struct object *obj )
+{
+ struct mutex *mutex = (struct mutex *)obj;
+ assert( obj->ops == &mutex_ops );
+ free( mutex );
+}
diff --git a/server/object.c b/server/object.c
index c05a310..82f1182 100644
--- a/server/object.c
+++ b/server/object.c
@@ -10,9 +10,9 @@
#include <stdlib.h>
#include <string.h>
+#include "winerror.h"
#include "server.h"
-
-#include "server/object.h"
+#include "server/thread.h"
int debug_level = 0;
@@ -30,6 +30,16 @@
/*****************************************************************/
+void *mem_alloc( size_t size )
+{
+ void *ptr = malloc( size );
+ if (ptr) memset( ptr, 0x55, size );
+ else if (current) SET_ERROR( ERROR_OUTOFMEMORY );
+ return ptr;
+}
+
+/*****************************************************************/
+
static int get_name_hash( const char *name )
{
int hash = 0;
@@ -43,7 +53,7 @@
int hash = get_name_hash( name );
int len = strlen( name );
- if (!(ptr = (struct object_name *)malloc( sizeof(*ptr) + len )))
+ if (!(ptr = (struct object_name *)mem_alloc( sizeof(*ptr) + len )))
return NULL;
ptr->next = names[hash];
ptr->obj = obj;
@@ -64,15 +74,40 @@
}
/* initialize an already allocated object */
-void init_object( struct object *obj, const struct object_ops *ops,
- const char *name )
+/* return 1 if OK, 0 on error */
+int init_object( struct object *obj, const struct object_ops *ops,
+ const char *name )
{
obj->refcount = 1;
obj->ops = ops;
obj->head = NULL;
obj->tail = NULL;
if (!name) obj->name = NULL;
- else obj->name = add_name( obj, name );
+ else if (!(obj->name = add_name( obj, name ))) return 0;
+ return 1;
+}
+
+struct object *create_named_object( const char *name, const struct object_ops *ops, size_t size )
+{
+ struct object *obj;
+ if ((obj = find_object( name )))
+ {
+ if (obj->ops == ops)
+ {
+ SET_ERROR( ERROR_ALREADY_EXISTS );
+ return obj;
+ }
+ SET_ERROR( ERROR_INVALID_HANDLE );
+ return NULL;
+ }
+ if (!(obj = mem_alloc( size ))) return NULL;
+ if (!init_object( obj, ops, name ))
+ {
+ free( obj );
+ return NULL;
+ }
+ CLEAR_ERROR();
+ return obj;
}
/* grab an object (i.e. increment its refcount) and return the object */
@@ -102,10 +137,10 @@
/* find an object by its name; the refcount is incremented */
struct object *find_object( const char *name )
{
- int hash = get_name_hash( name );
- struct object_name *ptr = names[hash];
+ struct object_name *ptr;
+ if (!name) return NULL;
+ ptr = names[ get_name_hash( name ) ];
while (ptr && strcmp( ptr->name, name )) ptr = ptr->next;
if (!ptr) return NULL;
- grab_object( ptr->obj );
- return ptr->obj;
+ return grab_object( ptr->obj );
}
diff --git a/server/process.c b/server/process.c
index 06d3d63..3fc73fe 100644
--- a/server/process.c
+++ b/server/process.c
@@ -74,7 +74,7 @@
{
struct process *process;
- if (!(process = malloc( sizeof(*process) ))) return NULL;
+ if (!(process = mem_alloc( sizeof(*process) ))) return NULL;
if (!copy_handle_table( process, current ? current->process : NULL ))
{
@@ -219,7 +219,7 @@
count *= 2;
if (!(new_entries = realloc( process->entries, count * sizeof(struct handle_entry) )))
{
- SET_ERROR( ERROR_NOT_ENOUGH_MEMORY );
+ SET_ERROR( ERROR_OUTOFMEMORY );
return 0;
}
process->handle_count = count;
@@ -344,7 +344,7 @@
last = parent->handle_last;
}
- if (!(ptr = malloc( count * sizeof(struct handle_entry)))) return 0;
+ if (!(ptr = mem_alloc( count * sizeof(struct handle_entry)))) return 0;
process->entries = ptr;
process->handle_count = count;
process->handle_last = last;
@@ -438,6 +438,20 @@
return alloc_specific_handle( dst, entry->ptr, dst_handle, access, inherit );
}
+/* open a new handle to an existing object */
+int open_object( const char *name, const struct object_ops *ops,
+ unsigned int access, int inherit )
+{
+ struct object *obj = find_object( name );
+ if (!obj) return -1; /* FIXME: set error code */
+ if (ops && obj->ops != ops)
+ {
+ release_object( obj );
+ return -1; /* FIXME: set error code */
+ }
+ return alloc_handle( current->process, obj, access, inherit );
+}
+
/* dump a handle table on stdout */
void dump_handles( struct process *process )
{
diff --git a/server/request.c b/server/request.c
index e481d76..6ce5b35 100644
--- a/server/request.c
+++ b/server/request.c
@@ -19,7 +19,12 @@
#include "server/request.h"
#include "server/thread.h"
-
+/* check that the string is NULL-terminated and that the len is correct */
+#define CHECK_STRING(func,str,len) \
+ do { if (((str)[(len)-1] || strlen(str) != (len)-1)) \
+ fatal_protocol_error( "%s: invalid string '.*s'\n", (func), (len), (str) ); \
+ } while(0)
+
struct thread *current = NULL; /* thread handling the current request */
/* complain about a protocol error and terminate the client connection */
@@ -107,8 +112,8 @@
if (!(new_thread = create_thread( new_fd, req->pid, &reply.thandle,
&reply.phandle )))
{
- err = ERROR_NOT_ENOUGH_MEMORY;
close( new_fd );
+ err = ERROR_OUTOFMEMORY;
goto done;
}
reply.tid = new_thread;
@@ -139,11 +144,7 @@
}
current->state = RUNNING;
current->unix_pid = req->unix_pid;
- if (!(current->name = malloc( len + 1 )))
- {
- SET_ERROR( ERROR_NOT_ENOUGH_MEMORY );
- goto done;
- }
+ if (!(current->name = mem_alloc( len + 1 ))) goto done;
memcpy( current->name, data, len );
current->name[len] = '\0';
CLEAR_ERROR();
@@ -256,3 +257,118 @@
len, req->count );
sleep_on( current, req->count, (int *)data, req->flags, req->timeout );
}
+
+/* create an event */
+DECL_HANDLER(create_event)
+{
+ struct create_event_reply reply = { -1 };
+ struct object *obj;
+ char *name = (char *)data;
+ if (!len) name = NULL;
+ else CHECK_STRING( "create_event", name, len );
+
+ obj = create_event( name, req->manual_reset, req->initial_state );
+ if (obj)
+ {
+ reply.handle = alloc_handle( current->process, obj, EVENT_ALL_ACCESS, req->inherit );
+ release_object( obj );
+ }
+ send_reply( current, -1, 1, &reply, sizeof(reply) );
+}
+
+/* do an event operation */
+DECL_HANDLER(event_op)
+{
+ switch(req->op)
+ {
+ case PULSE_EVENT:
+ pulse_event( req->handle );
+ break;
+ case SET_EVENT:
+ set_event( req->handle );
+ break;
+ case RESET_EVENT:
+ reset_event( req->handle );
+ break;
+ default:
+ fatal_protocol_error( "event_op: invalid operation %d\n", req->op );
+ }
+ send_reply( current, -1, 0 );
+}
+
+/* create a mutex */
+DECL_HANDLER(create_mutex)
+{
+ struct create_mutex_reply reply = { -1 };
+ struct object *obj;
+ char *name = (char *)data;
+ if (!len) name = NULL;
+ else CHECK_STRING( "create_mutex", name, len );
+
+ obj = create_mutex( name, req->owned );
+ if (obj)
+ {
+ reply.handle = alloc_handle( current->process, obj, MUTEX_ALL_ACCESS, req->inherit );
+ release_object( obj );
+ }
+ send_reply( current, -1, 1, &reply, sizeof(reply) );
+}
+
+/* release a mutex */
+DECL_HANDLER(release_mutex)
+{
+ if (release_mutex( req->handle )) CLEAR_ERROR();
+ send_reply( current, -1, 0 );
+}
+
+/* create a semaphore */
+DECL_HANDLER(create_semaphore)
+{
+ struct create_semaphore_reply reply = { -1 };
+ struct object *obj;
+ char *name = (char *)data;
+ if (!len) name = NULL;
+ else CHECK_STRING( "create_semaphore", name, len );
+
+ obj = create_semaphore( name, req->initial, req->max );
+ if (obj)
+ {
+ reply.handle = alloc_handle( current->process, obj, SEMAPHORE_ALL_ACCESS, req->inherit );
+ release_object( obj );
+ }
+ send_reply( current, -1, 1, &reply, sizeof(reply) );
+}
+
+/* release a semaphore */
+DECL_HANDLER(release_semaphore)
+{
+ struct release_semaphore_reply reply;
+ if (release_semaphore( req->handle, req->count, &reply.prev_count )) CLEAR_ERROR();
+ send_reply( current, -1, 1, &reply, sizeof(reply) );
+}
+
+/* open a handle to a named object (event, mutex, semaphore) */
+DECL_HANDLER(open_named_obj)
+{
+ struct open_named_obj_reply reply;
+ char *name = (char *)data;
+ if (!len) name = NULL;
+ else CHECK_STRING( "open_named_obj", name, len );
+
+ switch(req->type)
+ {
+ case OPEN_EVENT:
+ reply.handle = open_event( req->access, req->inherit, name );
+ break;
+ case OPEN_MUTEX:
+ reply.handle = open_mutex( req->access, req->inherit, name );
+ break;
+ case OPEN_SEMAPHORE:
+ reply.handle = open_semaphore( req->access, req->inherit, name );
+ break;
+ default:
+ fatal_protocol_error( "open_named_obj: invalid type %d\n", req->type );
+ }
+ send_reply( current, -1, 1, &reply, sizeof(reply) );
+}
+
diff --git a/server/semaphore.c b/server/semaphore.c
new file mode 100644
index 0000000..9cdedb9
--- /dev/null
+++ b/server/semaphore.c
@@ -0,0 +1,118 @@
+/*
+ * Server-side semaphore management
+ *
+ * Copyright (C) 1998 Alexandre Julliard
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "winerror.h"
+#include "winnt.h"
+#include "server/thread.h"
+
+struct semaphore
+{
+ struct object obj; /* object header */
+ unsigned int count; /* current count */
+ unsigned int max; /* maximum possible count */
+};
+
+static void dump_semaphore( struct object *obj, int verbose );
+static int semaphore_signaled( struct object *obj, struct thread *thread );
+static int semaphore_satisfied( struct object *obj, struct thread *thread );
+static void destroy_semaphore( struct object *obj );
+
+static const struct object_ops semaphore_ops =
+{
+ dump_semaphore,
+ semaphore_signaled,
+ semaphore_satisfied,
+ destroy_semaphore
+};
+
+
+struct object *create_semaphore( const char *name, unsigned int initial, unsigned int max )
+{
+ struct semaphore *sem;
+
+ if (!max || (initial > max))
+ {
+ SET_ERROR( ERROR_INVALID_PARAMETER );
+ return NULL;
+ }
+ if (!(sem = (struct semaphore *)create_named_object( name, &semaphore_ops, sizeof(*sem) )))
+ return NULL;
+ if (GET_ERROR() != ERROR_ALREADY_EXISTS)
+ {
+ /* initialize it if it didn't already exist */
+ sem->count = initial;
+ sem->max = max;
+ }
+ return &sem->obj;
+}
+
+int open_semaphore( unsigned int access, int inherit, const char *name )
+{
+ return open_object( name, &semaphore_ops, access, inherit );
+}
+
+int release_semaphore( int handle, unsigned int count, unsigned int *prev_count )
+{
+ struct semaphore *sem;
+
+ if (!(sem = (struct semaphore *)get_handle_obj( current->process, handle,
+ SEMAPHORE_MODIFY_STATE, &semaphore_ops )))
+ return 0;
+
+ *prev_count = sem->count;
+ if (sem->count + count < sem->count || sem->count + count > sem->max)
+ {
+ SET_ERROR( ERROR_TOO_MANY_POSTS );
+ return 0;
+ }
+ if (sem->count)
+ {
+ /* there cannot be any thread waiting if the count is != 0 */
+ assert( !sem->obj.head );
+ sem->count += count;
+ }
+ else
+ {
+ sem->count = count;
+ wake_up( &sem->obj, count );
+ }
+ release_object( sem );
+ return 1;
+}
+
+static void dump_semaphore( struct object *obj, int verbose )
+{
+ struct semaphore *sem = (struct semaphore *)obj;
+ assert( obj->ops == &semaphore_ops );
+ printf( "Semaphore count=%d max=%d\n", sem->count, sem->max );
+}
+
+static int semaphore_signaled( struct object *obj, struct thread *thread )
+{
+ struct semaphore *sem = (struct semaphore *)obj;
+ assert( obj->ops == &semaphore_ops );
+ return (sem->count > 0);
+}
+
+static int semaphore_satisfied( struct object *obj, struct thread *thread )
+{
+ struct semaphore *sem = (struct semaphore *)obj;
+ assert( obj->ops == &semaphore_ops );
+ assert( sem->count );
+ sem->count--;
+ return 0; /* not abandoned */
+}
+
+static void destroy_semaphore( struct object *obj )
+{
+ struct semaphore *sem = (struct semaphore *)obj;
+ assert( obj->ops == &semaphore_ops );
+ free( sem );
+}
diff --git a/server/socket.c b/server/socket.c
index fd85741..1302467 100644
--- a/server/socket.c
+++ b/server/socket.c
@@ -279,7 +279,12 @@
while (nb_clients)
{
fd_set read = read_set, write = write_set;
-
+#if 0
+ printf( "select: " );
+ for (i = 0; i <= max_fd; i++) printf( "%c", FD_ISSET( i, &read_set ) ? 'r' :
+ (FD_ISSET( i, &write_set ) ? 'w' : '-') );
+ printf( "\n" );
+#endif
if (timeout_head)
{
struct timeval tv, now;
diff --git a/server/thread.c b/server/thread.c
index e250cc8..fff2079 100644
--- a/server/thread.c
+++ b/server/thread.c
@@ -64,7 +64,7 @@
struct thread *thread;
struct process *process;
- if (!(thread = malloc( sizeof(*thread) ))) return NULL;
+ if (!(thread = mem_alloc( sizeof(*thread) ))) return NULL;
if (pid) process = get_process_from_id( pid );
else process = create_process();
@@ -79,6 +79,7 @@
thread->process = process;
thread->unix_pid = 0; /* not known yet */
thread->name = NULL;
+ thread->mutex = NULL;
thread->wait = NULL;
thread->error = 0;
thread->state = STARTING;
@@ -250,11 +251,7 @@
SET_ERROR( ERROR_INVALID_PARAMETER );
return 0;
}
- if (!(wait = malloc( sizeof(*wait) + (count-1) * sizeof(*entry) )))
- {
- SET_ERROR( ERROR_OUTOFMEMORY );
- return 0;
- }
+ if (!(wait = mem_alloc( sizeof(*wait) + (count-1) * sizeof(*entry) ))) return 0;
thread->wait = wait;
wait->count = count;
wait->flags = flags;
@@ -396,6 +393,7 @@
/* kill a thread on the spot */
void kill_thread( struct thread *thread, int exit_code )
{
+ if (thread->state == TERMINATED) return; /* already killed */
if (thread->unix_pid) kill( thread->unix_pid, SIGTERM );
remove_client( thread->client_fd, exit_code ); /* this will call thread_killed */
}
@@ -406,6 +404,7 @@
thread->state = TERMINATED;
thread->exit_code = exit_code;
if (thread->wait) end_wait( thread );
+ abandon_mutexes( thread );
remove_process_thread( thread->process, thread );
wake_up( &thread->obj, 0 );
release_object( thread );
diff --git a/server/trace.c b/server/trace.c
index a9158ce..0850fd5 100644
--- a/server/trace.c
+++ b/server/trace.c
@@ -103,6 +103,75 @@
printf( " signaled=%d", req->signaled );
}
+static void dump_create_event_request( struct create_event_request *req )
+{
+ printf( " manual_reset=%d,", req->manual_reset );
+ printf( " initial_state=%d,", req->initial_state );
+ printf( " inherit=%d", req->inherit );
+}
+
+static void dump_create_event_reply( struct create_event_reply *req )
+{
+ printf( " handle=%d", req->handle );
+}
+
+static void dump_event_op_request( struct event_op_request *req )
+{
+ printf( " handle=%d,", req->handle );
+ printf( " op=%d", req->op );
+}
+
+static void dump_create_mutex_request( struct create_mutex_request *req )
+{
+ printf( " owned=%d,", req->owned );
+ printf( " inherit=%d", req->inherit );
+}
+
+static void dump_create_mutex_reply( struct create_mutex_reply *req )
+{
+ printf( " handle=%d", req->handle );
+}
+
+static void dump_release_mutex_request( struct release_mutex_request *req )
+{
+ printf( " handle=%d", req->handle );
+}
+
+static void dump_create_semaphore_request( struct create_semaphore_request *req )
+{
+ printf( " initial=%08x,", req->initial );
+ printf( " max=%08x,", req->max );
+ printf( " inherit=%d", req->inherit );
+}
+
+static void dump_create_semaphore_reply( struct create_semaphore_reply *req )
+{
+ printf( " handle=%d", req->handle );
+}
+
+static void dump_release_semaphore_request( struct release_semaphore_request *req )
+{
+ printf( " handle=%d,", req->handle );
+ printf( " count=%08x", req->count );
+}
+
+static void dump_release_semaphore_reply( struct release_semaphore_reply *req )
+{
+ printf( " prev_count=%08x", req->prev_count );
+}
+
+static void dump_open_named_obj_request( struct open_named_obj_request *req )
+{
+ printf( " type=%d,", req->type );
+ printf( " access=%08x,", req->access );
+ printf( " inherit=%d", req->inherit );
+}
+
+static void dump_open_named_obj_reply( struct open_named_obj_reply *req )
+{
+ printf( " handle=%d", req->handle );
+}
+
struct dumper
{
void (*dump_req)();
@@ -142,6 +211,27 @@
{ (void(*)())dump_select_request,
(void(*)())dump_select_reply,
sizeof(struct select_request) },
+ { (void(*)())dump_create_event_request,
+ (void(*)())dump_create_event_reply,
+ sizeof(struct create_event_request) },
+ { (void(*)())dump_event_op_request,
+ (void(*)())0,
+ sizeof(struct event_op_request) },
+ { (void(*)())dump_create_mutex_request,
+ (void(*)())dump_create_mutex_reply,
+ sizeof(struct create_mutex_request) },
+ { (void(*)())dump_release_mutex_request,
+ (void(*)())0,
+ sizeof(struct release_mutex_request) },
+ { (void(*)())dump_create_semaphore_request,
+ (void(*)())dump_create_semaphore_reply,
+ sizeof(struct create_semaphore_request) },
+ { (void(*)())dump_release_semaphore_request,
+ (void(*)())dump_release_semaphore_reply,
+ sizeof(struct release_semaphore_request) },
+ { (void(*)())dump_open_named_obj_request,
+ (void(*)())dump_open_named_obj_reply,
+ sizeof(struct open_named_obj_request) },
};
static const char * const req_names[REQ_NB_REQUESTS] =
@@ -156,6 +246,13 @@
"dup_handle",
"open_process",
"select",
+ "create_event",
+ "event_op",
+ "create_mutex",
+ "release_mutex",
+ "create_semaphore",
+ "release_semaphore",
+ "open_named_obj",
};
void trace_request( enum request req, void *data, int len, int fd )
