'Gui-less' windows executable

[Bit byte]

I want to create a GUI-less windows executable (i.e. an executable that
has no gui) and no console. The idea is to have this running as a kind
of daemon (it can't be a service, for reasons I wont go into here ..).

I can't seem to find any code that shows how to do this which is
probably not suprising since Windows is essentially GUI oriented.

One possible hack is to go to the trouble of creating a window and then
making it invisible, but that seems aterrible waste of resources - is
there a cleaner way to do this?

[Sean M. DonCarlos]

You have to have at least one window somewhere, so that Windows can process
messages sent to your application by the system.

However, in Windows 2000 and later, you can make this window a message-only
window. A message-only window has no UI, but can send and receive messages.

You create a message-only window by calling CreateWindowEx and passing in
the value HWND_MESSAGE for the hWndParent parameter.

Sean
"Bit byte" wrote:

I want to create a GUI-less windows executable (i.e. an executable that
has no gui) and no console. The idea is to have this running as a kind
of daemon (it can't be a service, for reasons I wont go into here ..).

I can't seem to find any code that shows how to do this which is
probably not suprising since Windows is essentially GUI oriented.

One possible hack is to go to the trouble of creating a window and then
making it invisible, but that seems aterrible waste of resources - is
there a cleaner way to do this?

[Frederico Pissarra]

"Sean M. DonCarlos" <se********@new sgroups.nospam> escreveu na mensagem
news:FA******** *************** ***********@mic rosoft.com...

You have to have at least one window somewhere, so that Windows can
process
messages sent to your application by the system.
There is no need to create a window if you don't need a message loop...
However, in Windows 2000 and later, you can make this window a
message-only
window. A message-only window has no UI, but can send and receive
messages.

You create a message-only window by calling CreateWindowEx and passing in
the value HWND_MESSAGE for the hWndParent parameter.

Great tip! Thanks!
Sean

"Bit byte" wrote:

I want to create a GUI-less windows executable (i.e. an executable that
has no gui) and no console. The idea is to have this running as a kind
of daemon (it can't be a service, for reasons I wont go into here ..).

[]s
Fred

[Frederico Pissarra]

"Bit byte" <fl**@flop.co m> escreveu na mensagem
news:se******** ************@bt .com...

I want to create a GUI-less windows executable (i.e. an executable that has
no gui) and no console. The idea is to have this running as a kind of
daemon (it can't be a service, for reasons I wont go into here ..).

I can't seem to find any code that shows how to do this which is probably
not suprising since Windows is essentially GUI oriented.

One possible hack is to go to the trouble of creating a window and then
making it invisible, but that seems aterrible waste of resources - is
there a cleaner way to do this?

It's perfectly possible to write non console applications GUIless.... just
don't create any window!

There are some problems, f.i:: Timer will not work properly, because it
needs a message loop;

-----------%<------------%<----------
#define WIN32_LEAN_AND_ MEAN
#include <windows.h>
#include <stdio.h>

int WINAPI WinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow)
{
/* Example: Write a text file */
FILE *f;

f = fopen("test.txt ", "w");
fprintf(f, "Hello\n");
fclose(f);

return 0;
}

-----------%<------------%<----------

[]s
Fred

[Jeff Suddeth]

"Frederico Pissarra" <[e-mail] > wrote in message
news:ux******** ******@TK2MSFTN GP05.phx.gbl...

It's perfectly possible to write non console applications GUIless.... just
don't create any window!

Here is another way, but it is more complicated. You can use the
FreeConsole() API. But then you have to write some kind of controller
program that starts the server with CreateProcess() and communicates with
that process through some IPC mechanism to shut it down or send other
commands.

[adebaene]

Bit byte wrote:

I want to create a GUI-less windows executable (i.e. an executable that
has no gui) and no console. The idea is to have this running as a kind
of daemon (it can't be a service, for reasons I wont go into here ..).

I can't seem to find any code that shows how to do this which is
probably not suprising since Windows is essentially GUI oriented.

One possible hack is to go to the trouble of creating a window and then
making it invisible, but that seems aterrible waste of resources - is
there a cleaner way to do this?

Create a GUI subsystem app (ie, one where the start function is
WinMain. With Visual C++, you create such an exe by using the flag
"/subsystem:windo ws" for the linker).

Simply do NOT create any window in WinMain : just put your processing
stuff here.

Arnaud
MVP - VC

[William DePalo [MVP VC++]]

"Bit byte" <fl**@flop.co m> wrote in message
news:se******** ************@bt .com...

I want to create a GUI-less windows executable (i.e. an executable that has
no gui) and no console. The idea is to have this running as a kind of
daemon (it can't be a service, for reasons I wont go into here ..).

As others have mentioned, an option is simply to create a windowed
application (check teh docs for WinMain) and simply choose to create no
windows.

Alternatively, you can create a console application - it's useful to have a
console for debugging - and then to create the process that runs it with
CreateProcess() with the DETACHED_PROCES S or CREATE_NO_WINDO W flag. Check
the docs for the details.

Regards,
Will

[Sean M. DonCarlos]

> > You have to have at least one window somewhere, so that Windows can

process messages sent to your application by the system.

There is no need to create a window if you don't need a message loop...

Perhaps I should make sure to wake up fully before answering posts! :)

Yes, if you don't need a message loop, then you don't need a window. Thanks
for catching my mistake, Fred.

Sean

[Bit byte]

William DePalo [MVP VC++] wrote:

"Bit byte" <fl**@flop.co m> wrote in message
news:se******** ************@bt .com...

I want to create a GUI-less windows executable (i.e. an executable that has
no gui) and no console. The idea is to have this running as a kind of
daemon (it can't be a service, for reasons I wont go into here ..).

As others have mentioned, an option is simply to create a windowed
application (check teh docs for WinMain) and simply choose to create no
windows.

Alternatively, you can create a console application - it's useful to have a
console for debugging - and then to create the process that runs it with
CreateProcess() with the DETACHED_PROCES S or CREATE_NO_WINDO W flag. Check
the docs for the details.

Regards,
Will

Hi Will,

I like your approach the best. I have looked up the docu (and searched
Google), but all examples so far seem generic and not specific to the
scenario I described here. Could you please provide me with a 'boiler
plate' sample that I can start from.

This could be as simple as :

//Parent
int main(int argc, char* argv[]){
CreateProcess(/*RequiredParams */); //It would be very useful if you
could show the parent passing some data to the child
}
//child
int main(int argc, char* argv[]){
fprintf(fp,"I was started succesfully\n") ;
return ;
}
Thanks

[William DePalo [MVP VC++]]

"Bit byte" <fl**@flop.co m> wrote in message
news:uI******** ************@bt .com...

I like your approach the best.
:-)
I have looked up the docu (and searched Google), but all examples so far
seem generic and not specific to the scenario I described here. Could you
please provide me with a 'boiler plate' sample that I can start from.

OK. This example starts the built-in messenger application to pop-up a
message box on the workstation where the user "william" is logged in

char szDir[MAX_PATH + 1];
STARTUPINFO si = { 0 };
PROCESS_INFORMA TION pi = { 0 };

GetSystemDirect ory(szDir, MAX_PATH);

si.cb = sizeof(si);

if ( CreateProcess(" c:\\windows\\sy stem32\\cmd.exe ", // executable
"/C net send william hello", //
arguments
NULL, NULL, FALSE,
NORMAL_PRIORITY _CLASS | CREATE_NO_WINDO W,
NULL,
szDir,
// default directory
&si,
&pi) )
{
// Don't leak handles

CloseHandle(pi. hProcess);
CloseHandle(pi. hThread);
}

My quick hack is an ANSI application. In a UNICODE build, you'd be better
off not using string literals but rather wide-character string buffers
because (at least one of ) the parameters need to be writable.

Regards,
Will