1 : //=============================================================================
2 : // File <$/src/cpp/prod/CORBA/YAOrb.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //=============================================================================
21 :
22 : // Portability
23 : #include "yaorb/config.h"
24 : #include "src/cpp/prod/port/port_time.h"
25 : #include "src/cpp/prod/port/port_stdc.h"
26 : #include "src/cpp/prod/port/port_socket.h"
27 : #include "src/cpp/prod/port/port_unistd.h"
28 :
29 : #include <sys/types.h>
30 : #include <sys/select.h>
31 : #include <rpc/types.h>
32 : #include <stdio.h>
33 :
34 : #include <yaorb/CORBA.h>
35 : #include <yaorb/YAORB.h>
36 :
37 : #include "src/cpp/prod/CORBA/YAOrb.h"
38 : #include "src/cpp/prod/CORBA/YARemoteOrb.h"
39 : #include "src/cpp/prod/boot/boot.h"
40 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
41 : #include "src/cpp/prod/tool/Assert.h"
42 : #include "src/cpp/prod/protocol/iop/iop.h"
43 : #include "src/cpp/prod/protocol/iiop/iiop.h"
44 : #include "src/cpp/prod/protocol/cdr/cdr_memory.h"
45 :
46 : // Max number of pending connect request on the _listning socket.
47 : const int NUMBER_OF_CONNECTIONS = 5 ;
48 :
49 : //==============================================================================
50 : // SERVICES
51 : //==============================================================================
52 : #define SERVICE_ROOT_POA (const char*)"RootPOA"
53 : #define SERVICE_POA_CURRENT (const char*)"POACurrent"
54 : #define SERVICE_INTERFACE_REPOSITORY (const char*)"InterfaceRepository"
55 : #define SERVICE_NAME_SERVICE (const char*)"NameService"
56 : #define SERVICE_TRADING_SERVICE (const char*)"TradingService"
57 : #define SERVICE_SECURITY_CURRENT (const char*)"SecurityCurrent"
58 : #define SERVICE_TRANSACTION_CURRENT (const char*)"TransactionCurrent"
59 : #define SERVICE_DYN_ANY_FACTORY (const char*)"DynAnyFactory"
60 :
61 : //==============================================================================
62 : // YAORB.
63 : //==============================================================================
64 :
65 7 : YAOrb::YAOrb(const char * confFileName)
66 : : _state(OrbState_Running),
67 : _refCount(1),
68 7 : _confFileName(confFileName)
69 : {
70 : }
71 :
72 1 : YAOrb::~YAOrb()
73 : {
74 1 : }
75 :
76 : void
77 6 : YAOrb::IncRefCount(void)
78 : {
79 6 : _refCount ++ ;
80 : }
81 :
82 : void
83 6 : YAOrb::DecRefCount(void)
84 : {
85 6 : _refCount -- ;
86 :
87 6 : if (_refCount == 0)
88 : {
89 0 : delete this ;
90 : }
91 : }
92 :
93 : static CORBA::Octet convert(char hi, char lo)
94 : {
95 : CORBA::Octet result = 0 ;
96 :
97 1392 : if ( ('0' <= hi) && (hi <= '9'))
98 : {
99 1308 : result = hi - '0' ;
100 : }
101 84 : else if (('a' <= hi) && (hi <= 'f'))
102 : {
103 0 : result = hi - 'a' + 0x0A ;
104 : }
105 84 : else if (('A' <= hi) && (hi <= 'F'))
106 : {
107 84 : result = hi - 'A' + 0x0A ;
108 : }
109 : else
110 : {
111 0 : NON_DEV("Throw BAD_PARAM") ;
112 : }
113 :
114 : result <<= 4 ;
115 :
116 1392 : if ( ('0' <= lo) && (lo <= '9'))
117 : {
118 1232 : result += lo - '0' ;
119 : }
120 160 : else if (('a' <= lo) && (lo <= 'f'))
121 : {
122 40 : result += lo - 'a' + 0x0A ;
123 : }
124 120 : else if (('A' <= lo) && (lo <= 'F'))
125 : {
126 120 : result += lo - 'A' + 0x0A ;
127 : }
128 : else
129 : {
130 0 : NON_DEV("Throw BAD_PARAM") ;
131 : }
132 :
133 : return result ;
134 : }
135 :
136 : //=============================================================================
137 : // Convert between an object reference and a string.
138 : // REFERENCE : 99-07-17, section 13.6.6, page 13-21.
139 : //=============================================================================
140 :
141 4 : CORBA::Object_ptr YAOrb::stringToObject(const char* str)
142 : {
143 : ASSERT(str != NULL) ;
144 4 : int len = strlen(str) ;
145 4 : CORBA::Object_var result = CORBA::Object::_nil() ;
146 :
147 : //--------------------------------------------------------------------------
148 : // Sanity checks on the input string
149 : //--------------------------------------------------------------------------
150 :
151 : const int minimum_len = 4 + 2 + 8 ;
152 : const int prefix_len = 4 ;
153 : const char* const prefix_data = "IDL:" ;
154 :
155 4 : if ( (len < minimum_len)
156 : || ((len % 2) != 0)
157 : )
158 : {
159 : // minimum length : "IDL:" + endianess (+ padding) + encapsulation
160 : // String should have an even number of hexadecimal characters
161 : return result._retn() ;
162 : }
163 :
164 4 : if (strncmp(str, prefix_data, prefix_len) != 0)
165 : {
166 : // String should begin with "IDL:"
167 : return result._retn() ;
168 : }
169 :
170 : //--------------------------------------------------------------------------
171 : // Decode the hexadecimal string representation in memory.
172 : //--------------------------------------------------------------------------
173 :
174 4 : int data_len = (len - prefix_len) / 2 ;
175 4 : CORBA::Octet *data = new CORBA::Octet[data_len] ;
176 4 : const char* str2 = str + prefix_len ;
177 : int index = 0 ;
178 : char hi ;
179 : char lo ;
180 :
181 1396 : while (index < data_len)
182 : {
183 1392 : hi = *str2 ;
184 : str2 ++ ;
185 1392 : lo = *str2 ;
186 1392 : str2 ++ ;
187 :
188 1392 : data[index] = convert(hi, lo) ;
189 :
190 1392 : index ++ ;
191 : }
192 :
193 : //--------------------------------------------------------------------------
194 : // Demangle a GIOP Encapsulation from memory.
195 : //--------------------------------------------------------------------------
196 :
197 4 : CDRMemory cdrs(data, data_len, YAORB::CDR_READ) ;
198 :
199 4 : cdrs.cdr_ByteOrder() ;
200 :
201 4 : GIOPEncapsulation encapsulation ;
202 4 : encapsulation.cdr(& cdrs) ;
203 :
204 4 : delete [] data ;
205 : data = NULL ;
206 :
207 : //--------------------------------------------------------------------------
208 : // Demangle an IOP::IOR from the encapsulation.
209 : //--------------------------------------------------------------------------
210 :
211 4 : data = encapsulation.GetData() ;
212 4 : data_len = encapsulation.GetLength() ;
213 :
214 4 : CDRMemory cdrs2(data, data_len, YAORB::CDR_READ) ;
215 :
216 4 : cdrs2.cdr_ByteOrder() ;
217 4 : IOP::IOR ior ;
218 4 : ior.cdr(& cdrs2) ;
219 :
220 : //--------------------------------------------------------------------------
221 : // Find an existing object with this IOP::IOR
222 : //--------------------------------------------------------------------------
223 :
224 : CORBA::Boolean isLocal = FALSE ;
225 4 : isLocal = IsLocalIOR(ior) ;
226 :
227 4 : if (isLocal == TRUE)
228 : {
229 0 : result = ResolveLocalIOR(ior) ;
230 : }
231 : else
232 : {
233 4 : result = ResolveDistantIOR(ior) ;
234 : }
235 :
236 4 : return result._retn() ;
237 : }
238 :
239 : CORBA::Object_ptr
240 4 : YAOrb::ResolveDistantIOR(IOP::IOR & ior)
241 : {
242 4 : CORBA::Object_var result = CORBA::Object::_nil() ;
243 :
244 : //--------------------------------------------------------------------------
245 : // Find where the remote orb is.
246 : //--------------------------------------------------------------------------
247 :
248 4 : CORBA::String_var host ;
249 : int port = -1 ;
250 4 : GIOPEncapsulation objKey ;
251 : bool iiopFound = false ;
252 :
253 8 : int profile_len = ior._profiles.length() ;
254 : int index ;
255 :
256 : CORBA::Octet *data = NULL ;
257 : CORBA::ULong data_len ;
258 :
259 4 : for (index = 0 ;
260 : index < profile_len ;
261 : index ++)
262 : {
263 4 : const IOP::TaggedProfile & profile = ior._profiles[index] ;
264 4 : data = profile._profile_data.GetData() ;
265 4 : data_len = profile._profile_data.GetLength() ;
266 :
267 4 : CDRMemory cdrs(data, data_len, YAORB::CDR_READ) ;
268 :
269 4 : switch(profile._tag)
270 : {
271 : case IOP::TAG_INTERNET_IOP :
272 : {
273 4 : IIOP::ProfileBody iiop ;
274 4 : cdrs.cdr_ByteOrder() ;
275 4 : iiop.cdr(& cdrs) ;
276 :
277 4 : host = iiop._host ;
278 4 : port = iiop._port ;
279 4 : objKey = iiop._object_key ;
280 4 : iiopFound = true ;
281 : }
282 : default :
283 : {
284 : // Do **NOT** raise anything.
285 : // Just ignore unsupported transport protocols.
286 : }
287 : }
288 : }
289 :
290 4 : if (iiopFound == false)
291 : {
292 0 : NON_DEV("Throw exception ?") ;
293 : return result._retn() ;
294 : }
295 :
296 : //--------------------------------------------------------------------------
297 : // Find or create a new orb proxie pointing to the remote orb.
298 : //--------------------------------------------------------------------------
299 : YARemoteOrb *remoteOrb = NULL ;
300 :
301 4 : NON_DEV("Hash table for remote orb") ;
302 4 : remoteOrb = new YARemoteOrb(host, port) ;
303 :
304 : //--------------------------------------------------------------------------
305 : // Find or create a new proxie pointing to the remote object.
306 : //--------------------------------------------------------------------------
307 :
308 4 : const char* id = ior._type_id ;
309 4 : YAORB::RepositoryID rep_id(id) ;
310 :
311 4 : YAORB::StubInfo* stubInfo = YAORB::StubMgr::FindStubInfo(& rep_id) ;
312 :
313 4 : YAORB::Ref ref(remoteOrb, objKey) ;
314 :
315 4 : if (stubInfo != NULL)
316 : {
317 4 : result = stubInfo->createStub(ref) ;
318 : }
319 : else
320 : {
321 0 : NON_DEV("Dynamic Invocation Interface") ;
322 : }
323 :
324 4 : return result._retn() ;
325 : }
326 :
327 1 : char* YAOrb::objectToString(CORBA::Object_ptr obj)
328 : {
329 1 : NON_DEV("objectToString") ;
330 1 : char *str = new char[80] ;
331 1 : strcpy(str, "DUMMY STRING") ;
332 : return str ;
333 : }
334 :
335 : CORBA::Boolean
336 : YAOrb::readConf(
337 : const char * section,
338 : const char * entry,
339 4 : String & value)
340 : {
341 : return FALSE ;
342 : }
343 :
|
