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
|
// -*- C++ -*-
//=============================================================================
/**
* @file Name_Handler.h
*
* $Id$
*
* @author Prashant Jain
* @author Gerhard Lenzer
* @author and Douglas C. Schmidt
*/
//=============================================================================
#ifndef ACE_NAME_HANDLER_H
#define ACE_NAME_HANDLER_H
#include "ace/Acceptor.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/SOCK_Acceptor.h"
#include "ace/SString.h"
#include "ace/Svc_Handler.h"
#include "ace/Naming_Context.h"
#include "ace/Name_Request_Reply.h"
#include "ace/Null_Mutex.h"
#include "ace/svc_export.h"
#if defined ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT
template class ACE_Svc_Export ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>;
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT */
/**
* @class ACE_Name_Handler
*
* @brief Product object created by <ACE_Name_Acceptor>. An
* <ACE_Name_Handler> exchanges messages with a <ACE_Name_Proxy>
* object on the client-side.
*
* This class is the main workhorse of the <ACE_Name_Server>. It
* handles client requests to bind, rebind, resolve, and unbind
* names. It also schedules and handles timeouts that are used to
* support "timed waits." Clients used timed waits to bound the
* amount of time they block trying to get a name.
*/
class ACE_Svc_Export ACE_Name_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
{
public:
/// Pointer to a member function of ACE_Name_Handler returning int
typedef int (ACE_Name_Handler::*OPERATION) (void);
/// Pointer to a member function of ACE_Naming_Context returning int
typedef int (ACE_Naming_Context::*LIST_OP) (ACE_PWSTRING_SET &, const ACE_NS_WString &);
/// Pointer to a member function of ACE_Name_Handler returning ACE_Name_Request
typedef ACE_Name_Request (ACE_Name_Handler::*REQUEST) (ACE_NS_WString *);
// = Initialization and termination.
/// Default constructor.
ACE_Name_Handler (ACE_Thread_Manager * = 0);
/// Activate this instance of the <ACE_Name_Handler> (called by the
/// <ACE_Strategy_Acceptor>).
virtual int open (void * = 0);
protected:
// = Helper routines for the operations exported to clients.
/// Give up waiting (e.g., when a timeout occurs or a client shuts
/// down unexpectedly).
virtual int abandon (void);
// = Low level routines for framing requests, dispatching
// operations, and returning replies.
/// Receive, frame, and decode the client's request.
virtual int recv_request (void);
/// Dispatch the appropriate operation to handle the client's
/// request.
virtual int dispatch (void);
/// Create and send a reply to the client.
virtual int send_reply (ACE_INT32 status,
ACE_UINT32 errnum = 0);
/// Special kind of reply
virtual int send_request (ACE_Name_Request &);
// = Demultiplexing hooks.
/// Return the underlying <ACE_HANDLE>.
virtual ACE_HANDLE get_handle (void) const;
/// Callback method invoked by the <ACE_Reactor> when client events
/// arrive.
virtual int handle_input (ACE_HANDLE);
// = Timer hook.
/// Enable clients to limit the amount of time they wait for a name.
virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg);
/// Ensure dynamic allocation...
~ACE_Name_Handler (void);
private:
/// Table of pointers to member functions
OPERATION op_table_[ACE_Name_Request::MAX_ENUM];
struct LIST_ENTRY
{
LIST_OP operation_;
// A member function pointer that performs the appropriate
// operation (e.g., LIST_NAMES, LIST_VALUES, or LIST_TYPES).
REQUEST request_factory_;
// A member function pointer that serves as a factory to create a
// request that is passed back to the client.
const char *description_;
// Name of the operation we're dispatching (used for debugging).
};
/// This is the table of pointers to functions that we use to
/// simplify the handling of list requests.
LIST_ENTRY list_table_[ACE_Name_Request::MAX_LIST];
/// Cache request from the client.
ACE_Name_Request name_request_;
/// Special kind of reply for resolve and listnames.
ACE_Name_Request name_request_back_;
/// Cache reply to the client.
ACE_Name_Reply name_reply_;
/// Address of client we are connected with.
ACE_INET_Addr addr_;
/// Naming Context
ACE_Naming_Context *naming_context_;
ACE_Naming_Context *naming_context (void);
/// Handle binds.
int bind (void);
/// Handle rebinds.
int rebind (void);
/// Handle binds and rebinds.
int shared_bind (int rebind);
/// Handle find requests.
int resolve (void);
/// Handle unbind requests.
int unbind (void);
/// Handle LIST_NAMES, LIST_VALUES, and LIST_TYPES requests.
int lists (void);
/// Handle LIST_NAME_ENTRIES, LIST_VALUE_ENTRIES, and
/// LIST_TYPE_ENTRIES requests.
int lists_entries (void);
/// Create a name request.
ACE_Name_Request name_request (ACE_NS_WString *one_name);
/// Create a value request.
ACE_Name_Request value_request (ACE_NS_WString *one_name);
/// Create a type request.
ACE_Name_Request type_request (ACE_NS_WString *one_name);
};
/**
* @class ACE_Name_Acceptor
*
* @brief This class contains the service-specific methods that can't
* easily be factored into the <ACE_Strategy_Acceptor>.
*/
class ACE_Name_Acceptor : public ACE_Strategy_Acceptor<ACE_Name_Handler, ACE_SOCK_ACCEPTOR>
{
public:
/// Dynamic linking hook.
virtual int init (int argc, ACE_TCHAR *argv[]);
/// Parse svc.conf arguments.
int parse_args (int argc, ACE_TCHAR *argv[]);
/// Naming context for acceptor /for the listening port/
ACE_Naming_Context *naming_context (void);
private:
/// The scheduling strategy is designed for Reactive services.
ACE_Schedule_All_Reactive_Strategy<ACE_Name_Handler> scheduling_strategy_;
/// The Naming Context
ACE_Naming_Context naming_context_;
};
ACE_SVC_FACTORY_DECLARE (ACE_Name_Acceptor)
#endif /* ACE_NAME_HANDLER_H */
|
