forked from mozilla/gecko-dev
-
Notifications
You must be signed in to change notification settings - Fork 2
/
nsNativeAppSupportOS2.cpp
1851 lines (1636 loc) · 63.4 KB
/
nsNativeAppSupportOS2.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Bill Law law@netscape.com
* IBM Corp.
* Rich Walsh dragtext@e-vertise.com
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifdef MOZ_OS2_HIGH_MEMORY
// os2safe.h has to be included before os2.h, needed for high mem
#include <os2safe.h>
#endif
#define INCL_PM
#define INCL_GPI
#define INCL_DOS
#define INCL_DOSERRORS
#include <os2.h>
#include "nsNativeAppSupportBase.h"
#include "nsNativeAppSupportOS2.h"
#include "nsAppRunner.h"
#include "nsXULAppAPI.h"
#include "nsString.h"
#include "nsIBrowserDOMWindow.h"
#include "nsICommandLineRunner.h"
#include "nsCOMPtr.h"
#include "nsXPIDLString.h"
#include "nsIComponentManager.h"
#include "nsIServiceManager.h"
#include "nsPIDOMWindow.h"
#include "nsIDOMChromeWindow.h"
#include "nsXPCOM.h"
#include "nsISupportsPrimitives.h"
#include "nsISupportsArray.h"
#include "nsIWindowWatcher.h"
#include "nsIDocShell.h"
#include "nsIDocShellTreeItem.h"
#include "nsIBaseWindow.h"
#include "nsIWidget.h"
#include "nsIAppShellService.h"
#include "nsIXULWindow.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIPromptService.h"
#include "nsNetCID.h"
#include "nsNetUtil.h"
#include "nsIObserver.h"
#include "nsIObserverService.h"
// These are needed to load a URL in a browser window.
#include "nsIDOMLocation.h"
#include "nsIJSContextStack.h"
#include "nsIWebNavigation.h"
#include "nsIWindowMediator.h"
#include <stdlib.h>
#include "prprf.h"
#define kMailtoUrlScheme "mailto:"
/* trying to keep this like Window's COPYDATASTRUCT, but a compiler error is
* forcing me to add chBuff so that we can append the data to the end of the
* structure
*/
typedef struct _COPYDATASTRUCT
{
ULONG dwData;
ULONG cbData;
PVOID lpData;
CHAR chBuff;
}COPYDATASTRUCT, *PCOPYDATASTRUCT;
#define WM_COPYDATA (WM_USER + 60)
char szCommandLine[2*CCHMAXPATH];
static HWND hwndForDOMWindow( nsISupports * );
static
nsresult
GetMostRecentWindow(const PRUnichar* aType, nsIDOMWindow** aWindow) {
nsresult rv;
nsCOMPtr<nsIWindowMediator> med( do_GetService( NS_WINDOWMEDIATOR_CONTRACTID, &rv ) );
if ( NS_FAILED( rv ) )
return rv;
if ( med )
return med->GetMostRecentWindow( aType, aWindow );
return NS_ERROR_FAILURE;
}
static
void
activateWindow( nsIDOMWindow *win ) {
// Try to get native window handle.
HWND hwnd = hwndForDOMWindow( win );
if ( hwnd ) {
/* if we are looking at a client window, then we really probably want
* the frame so that we can manipulate THAT
*/
LONG id = WinQueryWindowUShort( hwnd, QWS_ID );
if( id == FID_CLIENT )
{
hwnd = WinQueryWindow( hwnd, QW_PARENT );
}
// Restore the window in case it is minimized.
// Use the OS call, if possible.
WinSetWindowPos( hwnd, 0L, 0L, 0L, 0L, 0L,
SWP_SHOW | SWP_RESTORE | SWP_ACTIVATE );
} else {
// Use internal method.
win->Focus();
}
}
#ifdef DEBUG_law
#undef MOZ_DEBUG_DDE
#define MOZ_DEBUG_DDE 1
#endif
// Simple Win32 mutex wrapper.
struct Mutex {
Mutex( const char *name )
: mName( name ),
mHandle( 0 ),
mState( 0xFFFF ) {
/* OS/2 named semaphores must begin with "\\SEM32\\" to be valid */
mName.Insert("\\SEM32\\", 0);
APIRET rc = DosCreateMutexSem(mName.get(), &mHandle, 0, FALSE);
if (rc != NO_ERROR) {
#if MOZ_DEBUG_DDE
printf("CreateMutex error = 0x%08X\n", (int)rc);
#endif
}
}
~Mutex() {
if ( mHandle ) {
// Make sure we release it if we own it.
Unlock();
APIRET rc = DosCloseMutexSem(mHandle);
if (rc != NO_ERROR) {
#if MOZ_DEBUG_DDE
printf("CloseHandle error = 0x%08X\n", (int)rc);
#endif
}
}
}
BOOL Lock( DWORD timeout ) {
if ( mHandle ) {
#if MOZ_DEBUG_DDE
printf( "Waiting (%d msec) for DDE mutex...\n", (int)timeout );
#endif
mState = DosRequestMutexSem( mHandle, timeout );
#if MOZ_DEBUG_DDE
printf( "...wait complete, result = 0x%08X\n", (int)mState );
#endif
return (mState == NO_ERROR);
} else {
return FALSE;
}
}
void Unlock() {
if ( mHandle && mState == NO_ERROR ) {
#if MOZ_DEBUG_DDE
printf( "Releasing DDE mutex\n" );
#endif
DosReleaseMutexSem( mHandle );
mState = 0xFFFF;
}
}
private:
nsCString mName;
HMTX mHandle;
DWORD mState;
};
/* DDE Notes
*
* This section describes the Win32 DDE service implementation for
* Mozilla. DDE is used on Win32 platforms to communicate between
* separate instances of mozilla.exe (or other Mozilla-based
* executables), or, between the Win32 desktop shell and Mozilla.
*
* The first instance of Mozilla will become the "server" and
* subsequent executables (and the shell) will use DDE to send
* requests to that process. The requests are DDE "execute" requests
* that pass the command line arguments.
*
* Mozilla registers the DDE application "Mozilla" and currently
* supports only the "WWW_OpenURL" topic. This should be reasonably
* compatible with applications that interfaced with Netscape
* Communicator (and its predecessors?). Note that even that topic
* may not be supported in a compatible fashion as the command-line
* options for Mozilla are different than for Communiator.
*
* It is imperative that at most one instance of Mozilla execute in
* "server mode" at any one time. The "native app support" in Mozilla
* on Win32 ensures that only the server process performs XPCOM
* initialization (that is not required for subsequent client processes
* to communicate with the server process).
*
* To guarantee that only one server starts up, a Win32 "mutex" is used
* to ensure only one process executes the server-detection code. That
* code consists of initializing DDE and doing a DdeConnect to Mozilla's
* application/topic. If that connection succeeds, then a server process
* must be running already.
*
* Otherwise, no server has started. In that case, the current process
* calls DdeNameService to register that application/topic. Only at that
* point does the mutex get released.
*
* There are a couple of subtleties that one should be aware of:
*
* 1. It is imperative that DdeInitialize be called only after the mutex
* lock has been obtained. The reason is that at shutdown, DDE
* notifications go out to all initialized DDE processes. Thus, if
* the mutex is owned by a terminating intance of Mozilla, then
* calling DdeInitialize and then WaitForSingleObject will cause the
* DdeUninitialize from the terminating process to "hang" until the
* process waiting for the mutex times out (and can then service the
* notification that the DDE server is terminating). So, don't mess
* with the sequence of things in the startup/shutdown logic.
*
* 2. All mutex requests are made with a reasonably long timeout value and
* are designed to "fail safe" (i.e., a timeout is treated as failure).
*
* 3. An attempt has been made to minimize the degree to which the main
* Mozilla application logic needs to be aware of the DDE mechanisms
* implemented herein. As a result, this module surfaces a very
* large-grained interface, consisting of simple start/stop methods.
* As a consequence, details of certain scenarios can be "lost."
* Particularly, incoming DDE requests can arrive after this module
* initiates the DDE server, but before Mozilla is initialized to the
* point where those requests can be serviced (e.g., open a browser
* window to a particular URL). Since the client process sends the
* request early on, it may not be prepared to respond to that error.
* Thus, such situations may fail silently. The design goal is that
* they fail harmlessly. Refinements on this point will be made as
* details emerge (and time permits).
*/
/* Update 2001 March
*
* A significant DDE bug in Windows is causing Mozilla to get wedged at
* startup. This is detailed in Bugzill bug 53952
* (http://bugzilla.mozilla.org/show_bug.cgi?id=53952).
*
* To resolve this, we are using a new strategy:
* o Use a "message window" to detect that Mozilla is already running and
* to pass requests from a second instance back to the first;
* o Run only as a "DDE server" (not as DDE client); this avoids the
* problematic call to DDEConnect().
*
* We still use the mutex semaphore to protect the code that detects
* whether Mozilla is already running.
*/
class nsNativeAppSupportOS2 : public nsNativeAppSupportBase,
public nsIObserver
{
public:
NS_DECL_NSIOBSERVER
NS_DECL_ISUPPORTS_INHERITED
// Overrides of base implementation.
NS_IMETHOD Start( bool *aResult );
NS_IMETHOD Stop( bool *aResult );
NS_IMETHOD Quit();
NS_IMETHOD Enable();
// The "old" Start method (renamed).
NS_IMETHOD StartDDE();
// Utility function to handle a Win32-specific command line
// option: "-console", which dynamically creates a Windows
// console.
void CheckConsole();
private:
static HDDEDATA APIENTRY HandleDDENotification( ULONG idInst,
USHORT uType,
USHORT uFmt,
HCONV hconv,
HSZ hsz1,
HSZ hsz2,
HDDEDATA hdata,
ULONG dwData1,
ULONG dwData2 );
static void HandleCommandLine(const char* aCmdLineString, nsIFile* aWorkingDir, PRUint32 aState);
static void ParseDDEArg( HSZ args, int index, nsCString& string);
static void ParseDDEArg( const char* args, int index, nsCString& aString);
static void ActivateLastWindow();
static HDDEDATA CreateDDEData( DWORD value );
static HDDEDATA CreateDDEData( LPBYTE value, DWORD len );
static bool InitTopicStrings();
static int FindTopic( HSZ topic );
static nsresult OpenWindow( const char *urlstr, const char *args );
static nsresult OpenBrowserWindow();
static int mConversations;
enum {
topicOpenURL,
topicActivate,
topicCancelProgress,
topicVersion,
topicRegisterViewer,
topicUnRegisterViewer,
topicGetWindowInfo,
// Note: Insert new values above this line!!!!!
topicCount // Count of the number of real topics
};
static HSZ mApplication, mTopics[ topicCount ];
static DWORD mInstance;
static bool mCanHandleRequests;
static char mMutexName[];
static bool mUseDDE;
friend struct MessageWindow;
}; // nsNativeAppSupportOS2
NS_INTERFACE_MAP_BEGIN(nsNativeAppSupportOS2)
NS_INTERFACE_MAP_ENTRY(nsIObserver)
NS_INTERFACE_MAP_END_INHERITING(nsNativeAppSupportBase)
NS_IMPL_ADDREF_INHERITED(nsNativeAppSupportOS2, nsNativeAppSupportBase)
NS_IMPL_RELEASE_INHERITED(nsNativeAppSupportOS2, nsNativeAppSupportBase)
void
nsNativeAppSupportOS2::CheckConsole() {
return;
}
// Create and return an instance of class nsNativeAppSupportOS2.
nsresult
NS_CreateNativeAppSupport( nsINativeAppSupport **aResult ) {
nsNativeAppSupportOS2 *pNative = new nsNativeAppSupportOS2;
if (!pNative) return NS_ERROR_OUT_OF_MEMORY;
// Check for dynamic console creation request.
pNative->CheckConsole();
*aResult = pNative;
NS_ADDREF( *aResult );
return NS_OK;
}
// Constants
#define MOZ_DDE_APPLICATION "Mozilla"
#define MOZ_STARTUP_MUTEX_NAME "StartupMutex"
#define MOZ_DDE_START_TIMEOUT 30000
#define MOZ_DDE_STOP_TIMEOUT 15000
#define MOZ_DDE_EXEC_TIMEOUT 15000
// The array entries must match the enum ordering!
const char * const topicNames[] = { "WWW_OpenURL",
"WWW_Activate",
"WWW_CancelProgress",
"WWW_Version",
"WWW_RegisterViewer",
"WWW_UnRegisterViewer",
"WWW_GetWindowInfo" };
// Static member definitions.
int nsNativeAppSupportOS2::mConversations = 0;
HSZ nsNativeAppSupportOS2::mApplication = 0;
HSZ nsNativeAppSupportOS2::mTopics[nsNativeAppSupportOS2::topicCount] = { 0 };
DWORD nsNativeAppSupportOS2::mInstance = 0;
bool nsNativeAppSupportOS2::mCanHandleRequests = false;
// Added this as pmddeml has no api like this
int DdeCmpStringHandles( HSZ hsz1, HSZ hsz2 )
{
char chhsz1[CCHMAXPATH], chhsz2[CCHMAXPATH];
int rc = -1;
/* I am assuming that the strings will never be more that CCHMAXPATH in
* length. Safe bet (for now). To find true length, call WinDdeQueryString
* and pass in (hsz, NULL, 0L, 0) and it will return iLength. Passing 0
* for codepage will use the codepage of the current thread.
*/
WinDdeQueryString( hsz1, chhsz1, sizeof( chhsz1 ), 0 );
WinDdeQueryString( hsz2, chhsz2, sizeof( chhsz2 ),0 );
rc = stricmp( chhsz1, chhsz2 );
return(rc);
}
char *GetCommandLine()
{
/* This function is meant to be like the Window's GetCommandLine() function.
* The value returned by pPIB->pib_pchcmd is of the format:
* <executable>\0<command line parameters>. So the first string is the
* .exe and the second string is what followed on the command line. Dorky,
* but I guess it'll have to do.
*/
PTIB pTIB = NULL;
PPIB pPIB = NULL;
APIRET rc = NO_ERROR;
char *pchParam = NULL;
rc = DosGetInfoBlocks( &pTIB, &pPIB );
if( rc == NO_ERROR )
{
INT iLen = 0;
char *pchTemp = NULL;
pchParam = pPIB->pib_pchcmd;
strcpy( szCommandLine, pchParam );
iLen = strlen( pchParam );
/* szCommandLine[iLen] is '\0', so see what's next. Probably be another
* '\0', a space or start of the arguments
*/
pchTemp = &(pchParam[iLen+1]);
/* At this point, szCommandLine holds just the program name. Now we
* go for the parameters. If our next value is a space, ignore it
* and go for the next character
*/
if( *pchTemp )
{
szCommandLine[iLen] = ' ';
iLen++;
if( *pchTemp == ' ' )
{
pchTemp++;
}
strcpy( &(szCommandLine[iLen]), pchTemp );
}
}
return( szCommandLine );
}
typedef struct _DDEMLFN
{
PFN *fn;
ULONG ord;
} DDEMLFN, *PDDEMLFN;
DDEMLFN ddemlfnTable[] =
{
{ (PFN *)&WinDdeAbandonTransaction ,100 },
{ (PFN *)&WinDdeAccessData ,101 },
{ (PFN *)&WinDdeAddData ,102 },
{ (PFN *)&WinDdeSubmitTransaction ,103 },
{ (PFN *)&WinDdeCompareStringHandles ,104 },
{ (PFN *)&WinDdeConnect ,105 },
{ (PFN *)&WinDdeConnectList ,106 },
{ (PFN *)&WinDdeCreateDataHandle ,107 },
{ (PFN *)&WinDdeCreateStringHandle ,108 },
{ (PFN *)&WinDdeDisconnect ,109 },
{ (PFN *)&WinDdeDisconnectList ,110 },
{ (PFN *)&WinDdeEnableCallback ,111 },
{ (PFN *)&WinDdeFreeDataHandle ,112 },
{ (PFN *)&WinDdeFreeStringHandle ,113 },
{ (PFN *)&WinDdeGetData ,114 },
{ (PFN *)&WinDdeInitialize ,116 },
{ (PFN *)&WinDdeKeepStringHandle ,117 },
{ (PFN *)&WinDdeNameService ,118 },
{ (PFN *)&WinDdePostAdvise ,119 },
{ (PFN *)&WinDdeQueryConvInfo ,120 },
{ (PFN *)&WinDdeQueryNextServer ,121 },
{ (PFN *)&WinDdeQueryString ,122 },
{ (PFN *)&WinDdeReconnect ,123 },
{ (PFN *)&WinDdeSetUserHandle ,124 },
{ (PFN *)&WinDdeUninitialize ,126 },
{ (PFN *)NULL , 0 }
};
/* SetupOS2ddeml makes sure that we can get pointers to all of the DDEML
* functions in demlfnTable using entrypoints. If we can't find one of them
* or can't load pmddeml.dll, then returns FALSE
*/
BOOL SetupOS2ddeml()
{
BOOL bRC = FALSE;
HMODULE hmodDDEML = NULLHANDLE;
APIRET rc = NO_ERROR;
rc = DosLoadModule( NULL, 0, "PMDDEML", &hmodDDEML );
if( rc == NO_ERROR )
{
int i;
/* all of this had better work. Get ready to be a success! */
bRC = TRUE;
for( i=0; ddemlfnTable[i].ord != 0; i++ )
{
rc = DosQueryProcAddr( hmodDDEML, ddemlfnTable[i].ord, NULL,
ddemlfnTable[i].fn );
if( rc != NO_ERROR )
{
/* we're horked. Return rc = horked */
bRC = FALSE;
break;
}
}
} /* load PMDDEML */
return( bRC );
}
char nsNativeAppSupportOS2::mMutexName[ 128 ] = { 0 };
// Message window encapsulation.
struct MessageWindow {
// ctor/dtor are simplistic
MessageWindow() {
// Try to find window.
HATOMTBL hatomtbl;
HENUM henum;
HWND hwndNext;
char classname[CCHMAXPATH];
mHandle = NULLHANDLE;
hatomtbl = WinQuerySystemAtomTable();
mMsgWindowAtom = WinFindAtom(hatomtbl, className());
if (mMsgWindowAtom == 0)
{
// If there is not atom in the system table for this class name, then
// we can assume that the app is not currently running.
mMsgWindowAtom = WinAddAtom(hatomtbl, className());
} else {
// Found an existing atom for this class name. Cycle through existing
// windows and see if one with our window id and class name already
// exists
henum = WinBeginEnumWindows(HWND_OBJECT);
while ((hwndNext = WinGetNextWindow(henum)) != NULLHANDLE)
{
if (WinQueryWindowUShort(hwndNext, QWS_ID) == (USHORT)mMsgWindowAtom)
{
WinQueryClassName(hwndNext, CCHMAXPATH, classname);
if (strcmp(classname, className()) == 0)
{
mHandle = hwndNext;
break;
}
}
}
}
}
HWND getHWND() {
return mHandle;
}
// Class name: appName + "MessageWindow"
static const char *className() {
static char classNameBuffer[128];
static char *mClassName = 0;
if ( !mClassName ) {
sprintf( classNameBuffer,
"%s%s",
gAppData->name,
"MessageWindow" );
mClassName = classNameBuffer;
}
return mClassName;
}
// Create: Register class and create window.
NS_IMETHOD Create() {
// Register the window class.
NS_ENSURE_TRUE( WinRegisterClass( 0, className(),
(PFNWP)&MessageWindow::WindowProc,
0L, 0 ),
NS_ERROR_FAILURE );
/* Giving a size but offscreen so that won't be seen, even if all
* goes wrong. Giving a size so that can be seen and understood by
* tools
*/
const char * pszClassName = className();
mHandle = WinCreateWindow( HWND_OBJECT,
pszClassName,
NULL, // name
WS_DISABLED, // style
0,0, // x, y
0,0, // cx,cy
HWND_DESKTOP,// owner
HWND_BOTTOM, // hwndbehind
(USHORT)mMsgWindowAtom, // id
NULL, // pCtlData
NULL ); // pres params
#if MOZ_DEBUG_DDE
printf( "Message window = 0x%08X\n", (int)mHandle );
#endif
return NS_OK;
}
// Destory: Get rid of window and reset mHandle.
NS_IMETHOD Destroy() {
nsresult retval = NS_OK;
if ( mHandle ) {
HATOMTBL hatomtbl = WinQuerySystemAtomTable();
WinDeleteAtom(hatomtbl, mMsgWindowAtom);
// DestroyWindow can only destroy windows created from
// the same thread.
BOOL desRes = WinDestroyWindow( mHandle );
if ( FALSE != desRes ) {
mHandle = NULL;
}
else {
retval = NS_ERROR_FAILURE;
}
}
return retval;
}
// SendRequest: Construct a data buffer <commandline>\0<workingdir>\0,
// then pass the string via WM_COPYDATA to the message window.
NS_IMETHOD SendRequest( const char *cmd )
{
/* Nothing like WM_COPYDATA in OS/2, where the OS allows pointers to be
* passed to a different process and automatically accessible by that
* process. So we have to create shared mem on our side and then the
* process that gets the WM_COPYDATA message has to do a
* DosGetSharedMem on this pointer to be able to access the data
*/
COPYDATASTRUCT *pcds;
PVOID pvData = NULL;
if (!cmd)
return NS_ERROR_FAILURE;
ULONG ulSize = sizeof(COPYDATASTRUCT)+strlen(cmd)+1+CCHMAXPATH;
#ifdef MOZ_OS2_HIGH_MEMORY
APIRET rc = DosAllocSharedMem( &pvData, NULL, ulSize,
PAG_COMMIT | PAG_READ | PAG_WRITE | OBJ_GETTABLE | OBJ_ANY);
if (rc != NO_ERROR) { // Did the kernel handle OBJ_ANY?
// Try again without OBJ_ANY and if the first failure was not caused
// by OBJ_ANY then we will get the same failure, else we have taken
// care of pre-FP13 systems where the kernel couldn't handle it.
rc = DosAllocSharedMem( &pvData, NULL, ulSize,
PAG_COMMIT | PAG_READ | PAG_WRITE | OBJ_GETTABLE);
if (rc != NO_ERROR) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
#else
if (DosAllocSharedMem( &pvData, NULL, ulSize,
PAG_COMMIT | PAG_READ | PAG_WRITE | OBJ_GETTABLE | OBJ_ANY))
return NS_ERROR_OUT_OF_MEMORY;
#endif
// We used to set dwData to zero, when we didn't send the
// working dir. Now we're using it as a version number.
// The commandline goes in the buffer space immediately after
// the COPYDATASTRUCT; the current directory follows that.
pcds = (COPYDATASTRUCT *)(pvData);
pcds->dwData = 1;
char * ptr = &(pcds->chBuff);
pcds->lpData = ptr;
strcpy( ptr, cmd);
pcds->cbData = strlen( ptr) + 1;
ptr += pcds->cbData;
if (DosQueryPathInfo( ".", FIL_QUERYFULLNAME, ptr, CCHMAXPATH)) {
ptr[0] = '.';
ptr[1] = '\0';
}
pcds->cbData += strlen( ptr) + 1;
WinSendMsg( mHandle, WM_COPYDATA, 0, (MPARAM)pcds );
DosFreeMem( pvData );
return NS_OK;
}
// Window proc.
static
MRESULT EXPENTRY WindowProc( HWND msgWindow, ULONG msg, MPARAM wp, MPARAM lp )
{
// We have to return a FALSE from WM_CREATE
if ( msg == WM_CREATE )
return (MRESULT)FALSE;
if ( msg != WM_COPYDATA )
return (MRESULT)TRUE;
// This is an incoming request.
COPYDATASTRUCT *cds = (COPYDATASTRUCT*)lp;
DosGetSharedMem( (PVOID)cds, PAG_READ|PAG_WRITE );
nsCOMPtr<nsILocalFile> workingDir;
// a "1" or greater indicates that the other process's working
// directory follows the commandline string - locate & convert it
if (cds->dwData >= 1) {
char* wdpath = strchr( (char*)cds->lpData, 0) + 1;
NS_NewNativeLocalFile(nsDependentCString(wdpath),
false, getter_AddRefs(workingDir));
}
nsNativeAppSupportOS2::HandleCommandLine((char*)cds->lpData,
workingDir, nsICommandLine::STATE_REMOTE_AUTO);
return (MRESULT)TRUE;
}
private:
HWND mHandle;
USHORT mMsgWindowAtom;
}; // struct MessageWindow
bool nsNativeAppSupportOS2::mUseDDE = false;
/* Start: Tries to find the "message window" to determine if it
* exists. If so, then Mozilla is already running. In that
* case, we use the handle to the "message" window and send
* a request corresponding to this process's command line
* options.
*
* If not, then this is the first instance of Mozilla. In
* that case, we create and set up the message window.
*
* The checking for existence of the message window must
* be protected by use of a mutex semaphore.
*/
NS_IMETHODIMP
nsNativeAppSupportOS2::Start( bool *aResult ) {
NS_ENSURE_ARG( aResult );
NS_ENSURE_TRUE( mInstance == 0, NS_ERROR_NOT_INITIALIZED );
nsresult rv = NS_ERROR_FAILURE;
*aResult = false;
// see if DDE should be enabled AND remove OS/2-specific
// options the app's commandline handler won't recognize
// (-console was handled earlier by StartOS2App())
for (int i = 1; i < gArgc; i++) {
if (stricmp("-dde", gArgv[i]) == 0 ||
stricmp("/dde", gArgv[i]) == 0)
mUseDDE = true;
else
if (stricmp("-console", gArgv[i]) != 0 &&
stricmp("/console", gArgv[i]) != 0)
continue;
for (int j = i; j < gArgc; j++)
gArgv[j] = gArgv[j+1];
gArgc--;
i--;
}
// if this is a standalone instance, turn off DDE regardless of the
// commandline, then skip out before we look for another instance
if (getenv("MOZ_NO_REMOTE")) {
mUseDDE = false;
*aResult = true;
return NS_OK;
}
// Grab mutex first.
// Build mutex name from app name.
PR_snprintf( mMutexName, sizeof mMutexName, "%s%s", gAppData->name, MOZ_STARTUP_MUTEX_NAME );
Mutex startupLock = Mutex( mMutexName );
NS_ENSURE_TRUE( startupLock.Lock( MOZ_DDE_START_TIMEOUT ), NS_ERROR_FAILURE );
/* We need to have a message queue to do the MessageWindow stuff (for both
* Create() and SendRequest()). If we don't have one, make it now.
* If we are going to end up going away right after ::Start() returns,
* then make sure to clean up the message queue.
*/
MQINFO mqinfo;
HAB hab;
HMQ hmqCurrent = WinQueryQueueInfo( HMQ_CURRENT, &mqinfo,
sizeof( MQINFO ) );
if( !hmqCurrent ) {
hab = WinInitialize( 0 );
hmqCurrent = WinCreateMsgQueue( hab, 0 );
}
// Search for existing message window.
MessageWindow msgWindow;
if ( msgWindow.getHWND() ) {
// We are a client process. Pass request to message window.
char *cmd = GetCommandLine();
rv = msgWindow.SendRequest( cmd );
} else {
// We will be server.
rv = msgWindow.Create();
if ( NS_SUCCEEDED( rv ) ) {
// Start up DDE server
if (mUseDDE)
this->StartDDE();
// Tell caller to spin message loop.
*aResult = true;
}
}
startupLock.Unlock();
if( *aResult == false )
{
/* This process isn't going to continue much longer. Make sure that we
* clean up the message queue
*/
if (hmqCurrent)
WinDestroyMsgQueue(hmqCurrent);
if (hab)
WinTerminate(hab);
}
return rv;
}
bool
nsNativeAppSupportOS2::InitTopicStrings() {
for ( int i = 0; i < topicCount; i++ ) {
if ( !( mTopics[ i ] = WinDdeCreateStringHandle( (PSZ)topicNames[ i ], CP_WINANSI ) ) ) {
return false;
}
}
return true;
}
int
nsNativeAppSupportOS2::FindTopic( HSZ topic ) {
for ( int i = 0; i < topicCount; i++ ) {
if ( DdeCmpStringHandles( topic, mTopics[i] ) == 0 ) {
return i;
}
}
return -1;
}
// Start DDE server.
//
// This used to be the Start() method when we were using DDE as the
// primary IPC mechanism between secondary Mozilla processes and the
// initial "server" process.
//
// Now, it simply initializes the DDE server. The caller must check
// that this process is to be the server, and, must acquire the DDE
// startup mutex semaphore prior to calling this routine. See ::Start(),
// above.
NS_IMETHODIMP
nsNativeAppSupportOS2::StartDDE() {
NS_ENSURE_TRUE( mInstance == 0, NS_ERROR_NOT_INITIALIZED );
/* Get entrypoints for PMDDEML */
BOOL bDDEML = SetupOS2ddeml();
/* If we couldn't initialize DDEML, set mUSEDDE to false */
/* so we don't do anything else DDE related */
if (!bDDEML) {
mUseDDE = false;
return NS_OK;
}
// Initialize DDE.
NS_ENSURE_TRUE( DDEERR_NO_ERROR == WinDdeInitialize( &mInstance,
nsNativeAppSupportOS2::HandleDDENotification,
APPCLASS_STANDARD,
0 ),
NS_ERROR_FAILURE );
// Allocate DDE strings.
NS_ENSURE_TRUE( ( mApplication = WinDdeCreateStringHandle( (char*) gAppData->name, CP_WINANSI ) ) && InitTopicStrings(),
NS_ERROR_FAILURE );
// Next step is to register a DDE service.
NS_ENSURE_TRUE( WinDdeNameService( mInstance, mApplication, 0, DNS_REGISTER ), NS_ERROR_FAILURE );
#if MOZ_DEBUG_DDE
printf( "DDE server started\n" );
#endif
return NS_OK;
}
// If no DDE conversations are pending, terminate DDE.
NS_IMETHODIMP
nsNativeAppSupportOS2::Stop( bool *aResult ) {
NS_ENSURE_ARG( aResult );
NS_ENSURE_TRUE( mInstance, NS_ERROR_NOT_INITIALIZED );
nsresult rv = NS_OK;
*aResult = true;
if (!mUseDDE) {
return rv;
}
Mutex ddeLock( mMutexName );
if ( ddeLock.Lock( MOZ_DDE_STOP_TIMEOUT ) ) {
if ( mConversations == 0 ) {
this->Quit();
} else {
*aResult = false;
}
ddeLock.Unlock();
}
else {
// No DDE application name specified, but that's OK. Just
// forge ahead.
*aResult = true;
}
return rv;
}
NS_IMETHODIMP
nsNativeAppSupportOS2::Observe(nsISupports* aSubject, const char* aTopic,
const PRUnichar* aData)
{
if (strcmp(aTopic, "quit-application") == 0) {
Quit();
} else {
NS_ERROR("Unexpected observer topic.");
}
return NS_OK;
}
// Terminate DDE regardless.
NS_IMETHODIMP
nsNativeAppSupportOS2::Quit() {
// If another process wants to look for the message window, they need
// to wait to hold the lock, in which case they will not find the
// window as we will destroy ours under our lock.
// When the mutex goes off the stack, it is unlocked via destructor.
Mutex mutexLock(mMutexName);
NS_ENSURE_TRUE(mutexLock.Lock(MOZ_DDE_START_TIMEOUT), NS_ERROR_FAILURE);
// If we've got a message window to receive IPC or new window requests,
// get rid of it as we are shutting down.
// Note: Destroy calls DestroyWindow, which will only work on a window
// created by the same thread.
MessageWindow mw;
mw.Destroy();
if ( mInstance ) {
// Unregister application name.
WinDdeNameService( mInstance, mApplication, 0, DNS_UNREGISTER );
// Clean up strings.
if ( mApplication ) {
WinDdeFreeStringHandle( mApplication );
mApplication = 0;
}
for ( int i = 0; i < topicCount; i++ ) {
if ( mTopics[i] ) {
WinDdeFreeStringHandle( mTopics[i] );