锘??xml version="1.0" encoding="utf-8" standalone="yes"?>
]]>
#include聽
"
stdafx.h
"
#include聽
"
ace/OS_NS_time.h
"
#include聽
"
ace/Log_Msg.h
"
#include聽
"
ace/Reactor.h
"
#include聽
"
ace/Event_Handler.h
"
#include聽
"
ace/INET_Addr.h
"
#include聽
"
ace/SOCK_Dgram.h
"
#include聽
"
ace/TP_Reactor.h
"
#include聽
"
ace/WFMO_Reactor.h
"
class
聽ClientRecv聽:聽
public
聽ACE_Event_Handler
{
public
:
聽聽聽聽
virtual
聽
~
ClientRecv聽()
{}
聽聽聽聽
int
聽open聽(
const
聽ACE_INET_Addr聽
&
bind_addr);
聽聽聽聽
//
聽Get聽this聽handler's聽I/O聽handle.
聽聽聽聽
virtual
聽ACE_HANDLE聽get_handle聽(
void
)聽
const
聽聽聽聽
{聽
return
聽
this
->
udp.get_handle();聽}
聽聽聽聽
virtual
聽
int
聽handle_input聽(ACE_HANDLE聽fd聽
=
聽ACE_INVALID_HANDLE);
聽聽聽聽
//
聽Called聽when聽this聽handler聽is聽removed聽from聽the聽ACE_Reactor.
聽聽聽聽
virtual
聽
int
聽handle_close聽(ACE_HANDLE聽handle,
聽聽聽聽聽聽聽聽ACE_Reactor_Mask聽close_mask);
聽聽聽聽
聽聽聽聽ACE_SOCK_Dgram聽udp;
}
;

int
ClientRecv::open聽(
const
聽ACE_INET_Addr聽
&
bind_addr)
{
聽聽聽聽
if
聽(
this
->
udp.open聽(bind_addr,聽
1
)聽
==
聽
-
1
)
聽聽聽聽聽聽聽聽ACE_ERROR_RETURN聽((LM_ERROR,
聽聽聽聽聽聽聽聽ACE_TEXT聽(
"
%p\n
"
),
聽聽聽聽聽聽聽聽ACE_TEXT聽(
"
udp.open
"
)),
聽聽聽聽聽聽聽聽
-
1
);
聽聽聽聽
聽聽聽聽
return
聽
this
->
reactor聽()
->
register_handler
聽聽聽聽聽聽聽聽(
this
,聽ACE_Event_Handler::READ_MASK聽);
}
int
聽
ClientRecv::handle_close聽(ACE_HANDLE聽handle,
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ACE_Reactor_Mask聽close_mask)
{
聽聽聽聽
if
聽(close_mask聽
==
聽ACE_Event_Handler::WRITE_MASK)
聽聽聽聽聽聽聽聽
return
聽
0
;
聽聽聽聽close_mask聽
=
聽ACE_Event_Handler::ALL_EVENTS_MASK聽
|
聽聽聽聽聽聽聽聽ACE_Event_Handler::DONT_CALL;
聽聽聽聽
this
->
reactor聽()
->
remove_handler聽(
this
,聽close_mask);
聽聽聽聽
this
->
udp.close();
聽聽聽聽delete聽
this
;
聽聽聽聽
return
聽
0
;
}
int
聽
ClientRecv::handle_input聽(ACE_HANDLE聽fd聽)
{
聽聽聽聽
char
聽聽buffer[
8192
]聽
=
聽
{
0
}
;
聽聽聽聽ACE_INET_Addr聽聽peer_addr;
聽聽聽聽
if
(
-
1
聽
==
聽
this
->
udp.recv(buffer,
8192
,peer_addr))
聽聽聽聽聽聽聽聽ACE_ERROR_RETURN聽((LM_ERROR,
聽聽聽聽聽聽聽聽ACE_TEXT聽(
"
%p\n
"
),
聽聽聽聽聽聽聽聽ACE_TEXT聽(
"
udp.recv
"
)),
聽聽聽聽聽聽聽聽
-
1
);
聽聽聽聽
聽聽聽聽ACE_DEBUG((LM_INFO,
"
%s\n
"
,peer_addr.get_host_addr()));
聽聽聽聽
return
聽
0
;
}
DWORD聽WINAPI聽LoopThread(LPVOID聽lparam)
{
聽聽聽聽ACE_Reactor::instance聽()
->
run_reactor_event_loop聽();
聽聽聽聽
return
聽聽
0
;
}
int
聽_tmain(
int
聽argc,聽_TCHAR
*
聽argv[])
{
聽聽聽聽ACE_INET_Addr聽bind_addr(
10703
);
聽聽聽聽ClientRecv聽聽client;
聽聽聽聽聽聽聽聽client.reactor(ACE_Reactor::instance聽());聽聽
聽聽聽聽
if
(
-
1
聽
==
聽client.open(bind_addr))
聽聽聽聽
{
聽聽聽聽聽聽聽聽
return
聽
-
1
;
聽聽聽聽}
聽聽聽聽
聽聽聽聽CreateThread(NULL,NULL,LoopThread,
0
,
0
,
0
);
聽聽聽聽ACE_INET_Addr聽send_addr;
聽聽聽聽
for
(
int
聽i
=
1024
;i
<
3333
;i
++
)
聽聽聽聽
{
聽聽聽聽聽聽聽聽ACE_DEBUG((LM_INFO,
"
%d聽\n
"
,i));
聽聽聽聽聽聽聽聽send_addr.
set
(i,
"
192.168.3.147
"
);
聽聽聽聽聽聽聽聽Sleep(
5000
);
聽聽聽聽聽聽聽聽
if
(client.udp.send(
"
ttt
"
,
3
,send_addr)聽
==
聽
-
1
)
聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽ACE_DEBUG((LM_INFO,
"
%p
"
));
聽聽聽聽聽聽聽聽聽聽聽聽
break
;
聽聽聽聽聽聽聽聽}
聽聽聽聽}
聽聽聽聽system(
"
pause
"
);
聽聽聽聽ACE_Reactor::instance聽()
->
end_reactor_event_loop聽();
聽聽聽聽
return
聽
0
;
}
#include聽
"
ace/Singleton.h
"
#include聽
"
ace/Mutex.h
"
#include聽
"
ace/Event_Handler.h
"
#include聽
<
ace
/
NT_Service.h
>
#include聽
<
ace
/
Log_Msg.h
>
#include聽
<
iostream
>
using
聽
namespace
聽std;
class
聽MYService:
public
聽ACE_NT_Service
{
聽聽聽聽
bool
聽m_stop;
public
:
聽聽聽聽MYService():ACE_NT_Service(
"
MyACEService_4
"
,
0
,ACE_NT_SERVICE_START_TIMEOUT,
聽聽聽聽聽聽聽聽聽聽聽聽SERVICE_WIN32_OWN_PROCESS聽
|
聽SERVICE_INTERACTIVE_PROCESS),m_stop(
false
)
{
聽聽聽聽聽聽聽聽}
聽聽聽聽
virtual
聽
int
聽svc聽(
void
);
聽聽聽聽
virtual
聽
void
聽handle_control聽(DWORD聽control_code);
聽聽聽聽
virtual
聽
~
MYService()
{}
}
;
typedef聽ACE_Singleton
<
MYService,聽ACE_Mutex
>
聽SERVICE;
int
聽MYService::svc聽(
void
)
{
聽聽聽聽report_status聽(SERVICE_RUNNING);
聽聽聽聽
while
(
!
m_stop)
聽聽聽聽
{
聽聽聽聽聽聽聽聽Sleep(
2000
);
聽聽聽聽聽聽聽聽MessageBox(NULL,
"
aaa
"
,
"
error
"
,
0
);
聽聽聽聽}
聽聽聽聽
return
聽
0
;
}
void
聽MYService::handle_control聽(DWORD聽control_code)
{
聽聽聽聽
if
聽(control_code聽
==
聽SERVICE_CONTROL_SHUTDOWN
聽聽聽聽聽聽聽聽
||
聽control_code聽
==
聽SERVICE_CONTROL_STOP)
聽聽聽聽
{
聽聽聽聽聽聽聽聽report_status聽(SERVICE_STOP_PENDING);
聽聽聽聽聽聽聽聽m_stop聽
=
聽
true
;
聽聽聽聽}
聽聽聽聽ACE_NT_Service::handle_control聽(control_code);
}
ACE_NT_SERVICE_DEFINE聽(MyACEService_4,
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽MYService,
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ACE_TEXT聽(
"
MyACEService_4
"
));
int
聽main(
int
聽argc,聽_TCHAR
*
聽argv[])
{
聽聽聽聽
聽聽聽聽ACE::init聽();
聽聽聽聽ACE_NT_SERVICE_RUN聽(MyACEService_4,
聽聽聽聽聽聽聽聽SERVICE::instance聽(),
聽聽聽聽聽聽聽聽ret);
聽聽聽聽
聽聽聽聽ACE::fini聽();

/**/
/*
聽聽聽聽瀹夎鏈嶅姟
聽聽聽聽聽聽聽聽聽ACE::init聽();
聽聽聽聽SERVICE::instance()->insert();
聽聽聽聽ACE::fini聽();
*/
聽聽聽聽
return
聽
0
;
}