1 : //=============================================================================
2 : // File <$/src/cpp/dev/spy/spy.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_stdc.h"
25 : #include "src/cpp/prod/port/port_stdlib.h"
26 :
27 : #include <stdio.h>
28 : #include <fstream>
29 :
30 : #include <yaorb/CORBA.h>
31 : #include <yaorb/YAORB.h>
32 :
33 : #include "src/cpp/prod/protocol/cdr/cdr_file.h"
34 : #include "src/cpp/prod/protocol/giop/message_header.h"
35 : #include "src/cpp/prod/protocol/giop/giop.h"
36 : #include "src/cpp/prod/protocol/giop/request_header_12.h"
37 : #include "src/cpp/prod/protocol/giop/target_address.h"
38 : #include "src/cpp/prod/protocol/giop/reply_12.h"
39 : #include "src/cpp/prod/protocol/giop/reply_header_12.h"
40 : #include "src/cpp/prod/protocol/giop/cancel_request_12.h"
41 : #include "src/cpp/prod/protocol/giop/locate_request_12.h"
42 : #include "src/cpp/prod/protocol/giop/locate_reply_12.h"
43 : #include "src/cpp/prod/protocol/giop/locate_reply_header_12.h"
44 :
45 3 : void DumpOctet(CORBA::Octet o, std::ostream& str)
46 : {
47 : char buf[80] ;
48 3 : sprintf(buf, "0x%x - %dd", o, o) ;
49 3 : str << buf ;
50 : }
51 :
52 7 : void DumpLong(CORBA::ULong l, std::ostream& str)
53 : {
54 : char buf[80] ;
55 7 : sprintf(buf, "0x%x - %dd", l, l) ;
56 7 : str << buf ;
57 : }
58 :
59 4 : void DumpTargetAddress(const TargetAddress& target, std::ostream& str)
60 : {
61 4 : AddressingDisposition ad = target.GetAddressingDisposition() ;
62 :
63 4 : switch (ad)
64 : {
65 : case KeyAddr :
66 : {
67 2 : GIOPEncapsulation* key = target.GetObjectKey() ;
68 2 : str << " - (target:KeyAddr)" << std::endl ;
69 2 : str << " - encapsulation, length = " << key->GetLength() << std::endl ;
70 : break ;
71 : }
72 : case ProfileAddr :
73 : {
74 1 : IOP::TaggedProfile* profile = target.GetProfile() ;
75 1 : CORBA::ULong tag = profile->_tag ;
76 :
77 1 : str << " - (target:ProfileAddr)" << std::endl ;
78 1 : str << " - tag : " << tag << std::endl ;
79 : break ;
80 : }
81 : case ReferenceAddr :
82 : {
83 1 : const IORAddressingInfo* ior = target.GetIOR() ;
84 1 : CORBA::ULong index = ior->_selected_profile_index ;
85 1 : const char* type_id = ior->_ior._type_id ;
86 :
87 1 : str << " - (target:ReferenceAddr)" << std::endl ;
88 1 : str << " - selected profile index :" << index << std::endl ;
89 1 : str << " - ior :" << type_id << std::endl ;
90 : break ;
91 : }
92 : default :
93 : {
94 0 : str << " - (target:?) " << std::endl ;
95 0 : str << " : UNKNOWN TARGET ADDRESSING DISPOSITION" << std::endl ;
96 : }
97 : }
98 : }
99 :
100 1 : void spy_10(GIOPMessage *msg, YAORB::CDR *cdrs, std::ostream& log)
101 : {
102 1 : GIOPMessageHeader& hdr = msg->GetHeader() ;
103 1 : log << "GIOP 1.0, message : " << (int) hdr.GetGIOP10MessageType() << std::endl ;
104 : }
105 :
106 1 : void spy_11(GIOPMessage *msg, YAORB::CDR *cdrs, std::ostream& log)
107 : {
108 1 : GIOPMessageHeader& hdr = msg->GetHeader() ;
109 1 : log << "GIOP 1.1, message : " << (int) hdr.GetGIOP11MessageType() << std::endl ;
110 : }
111 :
112 12 : void spy_12(GIOPMessage *msg, YAORB::CDR *cdrs, std::ostream& log)
113 : {
114 12 : GIOPMessageHeader& hdr = msg->GetHeader() ;
115 :
116 : // the message header is already read throught CDR
117 12 : msg->cdr_body(cdrs) ;
118 :
119 9 : switch (hdr.GetGIOP12MessageType())
120 : {
121 : case GIOPRequest_type :
122 : {
123 3 : log << "Request Message" << std::endl ;
124 3 : const GIOP12RequestHeader* req = msg->GetRequest() ;
125 :
126 3 : CORBA::ULong id = req->GetRequestId() ;
127 3 : log << " - request id = " ;
128 3 : DumpLong(id, log) ;
129 : log << std::endl;
130 :
131 3 : CORBA::Octet flag = req->GetResponseFlags() ;
132 3 : log << " - response flags = " ;
133 3 : DumpOctet(flag, log) ;
134 : log << std::endl ;
135 :
136 3 : const TargetAddress & target = req->GetTarget() ;
137 3 : DumpTargetAddress(target, log) ;
138 :
139 3 : const CORBA::String_var & operation = req->GetOperation() ;
140 3 : const char* op = operation ;
141 3 : log << " - operation = " << op << std::endl ;
142 : break ;
143 : }
144 : case GIOPReply_type :
145 : {
146 1 : log << "Reply Message" << std::endl ;
147 1 : GIOP12ReplyMessage *rep = msg->GetReply() ;
148 1 : const GIOP12ReplyHeader& repH = rep->GetHeader() ;
149 :
150 1 : CORBA::ULong id = repH.GetRequestId() ;
151 1 : log << " - request id = " ;
152 1 : DumpLong(id, log) ;
153 : log << std::endl;
154 :
155 1 : GIOP12ReplyHeader::ReplyStatusType status = repH.GetReplyStatus() ;
156 1 : log << " - reply status = " ;
157 1 : switch(status)
158 : {
159 : case GIOP12ReplyHeader::NO_EXCEPTION :
160 : {
161 1 : log << "NO_EXCEPTION" ;
162 1 : break ;
163 : }
164 : case GIOP12ReplyHeader::USER_EXCEPTION :
165 : {
166 0 : log << "USER_EXCEPTION" ;
167 0 : break ;
168 : }
169 : case GIOP12ReplyHeader::SYSTEM_EXCEPTION :
170 : {
171 0 : log << "SYSTEM_EXCEPTION" ;
172 0 : break ;
173 : }
174 : case GIOP12ReplyHeader::LOCATION_FORWARD :
175 : {
176 0 : log << "LOCATION_FORWARD" ;
177 0 : break ;
178 : }
179 : case GIOP12ReplyHeader::LOCATION_FORWARD_PERM :
180 : {
181 0 : log << "LOCATION_FORWARD_PERM" ;
182 0 : break ;
183 : }
184 : case GIOP12ReplyHeader::NEEDS_ADDRESSING_MODE :
185 : {
186 0 : log << "NEEDS_ADDRESSING_MODE" ;
187 : break ;
188 : }
189 : }
190 : log << std::endl ;
191 :
192 : // const IOP::ServiceContextList& service
193 : // = repH.GetServiceContext() ;
194 :
195 : break ;
196 : }
197 : case GIOPCancelRequest_type :
198 : {
199 1 : log << "Cancel Request Message" << std::endl ;
200 1 : GIOP12CancelRequestMessage *cancel = msg->GetCancelRequest() ;
201 :
202 1 : CORBA::ULong id = cancel->GetRequestId() ;
203 1 : log << " - request id = " ;
204 1 : DumpLong(id, log) ;
205 : log << std::endl;
206 :
207 : break ;
208 : }
209 : case GIOPLocateRequest_type :
210 : {
211 1 : log << "Locate Request Message" << std::endl ;
212 1 : GIOP12LocateRequestMessage *locReq = msg->GetLocateRequest() ;
213 :
214 1 : CORBA::ULong id = locReq->GetRequestId() ;
215 1 : log << " - request id = " ;
216 1 : DumpLong(id, log) ;
217 : log << std::endl;
218 :
219 1 : const TargetAddress& target = locReq->GetTargetAddress() ;
220 1 : DumpTargetAddress(target, log) ;
221 :
222 : break ;
223 : }
224 : case GIOPLocateReply_type :
225 : {
226 1 : log << "Locate Reply Message" << std::endl ;
227 1 : GIOP12LocateReplyMessage *locRep = msg->GetLocateReply() ;
228 1 : const GIOP12LocateReplyHeader& locRepH = locRep->GetHeader() ;
229 :
230 1 : CORBA::ULong id = locRepH.GetRequestId() ;
231 1 : log << " - request id = " ;
232 1 : DumpLong(id, log) ;
233 : log << std::endl;
234 :
235 : GIOP12LocateReplyHeader::LocateStatusType status ;
236 1 : status = locRepH.GetLocateStatus() ;
237 :
238 1 : log << " - locate reply status = " ;
239 1 : switch(status)
240 : {
241 : case GIOP12LocateReplyHeader::UNKNOWN_OBJECT :
242 : {
243 0 : log << "UNKNOWN_OBJECT" ;
244 0 : break ;
245 : }
246 : case GIOP12LocateReplyHeader::OBJECT_HERE :
247 : {
248 1 : log << "OBJECT_HERE" ;
249 1 : break ;
250 : }
251 : case GIOP12LocateReplyHeader::OBJECT_FORWARD :
252 : {
253 0 : log << "OBJECT_FORWARD" ;
254 0 : break ;
255 : }
256 : case GIOP12LocateReplyHeader::OBJECT_FORWARD_PERM :
257 : {
258 0 : log << "OBJECT_FORWARD_PERM" ;
259 0 : break ;
260 : }
261 : case GIOP12LocateReplyHeader::LOC_SYSTEM_EXCEPTION :
262 : {
263 0 : log << "LOC_SYSTEM_EXCEPTION" ;
264 0 : break ;
265 : }
266 : case GIOP12LocateReplyHeader::LOC_NEEDS_ADDRESSING_MODE :
267 : {
268 0 : log << "LOC_NEEDS_ADDRESSING_MODE" ;
269 : break ;
270 : }
271 : }
272 : log << std::endl ;
273 :
274 : break ;
275 : }
276 : case GIOPCloseConnection_type :
277 : {
278 1 : log << "Close Connection Message" << std::endl ;
279 : break ;
280 : }
281 : case GIOPMessageError_type :
282 : {
283 1 : log << "Message Error Message" << std::endl ;
284 : break ;
285 : }
286 : case GIOPFragment_type :
287 : {
288 0 : log << "Fragment Message" << std::endl ;
289 : break ;
290 : }
291 : }
292 : }
293 :
294 25 : void spy(YAORB::CDR *cdrs, std::ostream& log)
295 : {
296 25 : GIOPMessage msg ;
297 25 : msg.cdr_header(cdrs) ;
298 :
299 14 : GIOPMessageHeader& hdr = msg.GetHeader() ;
300 14 : CORBA::Octet major = hdr.GetMajor() ;
301 14 : CORBA::Octet minor = hdr.GetMinor() ;
302 :
303 28 : log << "GIOP " << (int)major << "." << (int)minor << std::endl ;
304 :
305 14 : if ((major == 1) && (minor == 0))
306 : {
307 1 : spy_10(& msg, cdrs, log) ;
308 13 : } else if ((major == 1) && (minor == 1))
309 : {
310 1 : spy_11(& msg, cdrs, log) ;
311 12 : } else if ((major == 1) && (minor == 2))
312 : {
313 12 : spy_12(& msg, cdrs, log) ;
314 : } else {
315 0 : fprintf(stderr, "Unknown GIOP protocol\n") ;
316 : }
317 :
318 11 : int pos = cdrs->GetPosition() ;
319 36 : log << "final position = " << pos << std::endl ;
320 11 : }
321 :
322 25 : void spy_file(const char* filename, std::ostream& log)
323 : {
324 25 : log << "Reading " << filename << std::endl ;
325 25 : CDRFile cdrs(filename, YAORB::CDR_READ) ;
326 :
327 : try
328 : {
329 25 : spy( & cdrs, log) ;
330 : }
331 14 : catch (CORBA::Exception& e)
332 : {
333 14 : log << "Exception caught while reading stream at position " ;
334 14 : log << cdrs.GetPosition() << std::endl ;
335 :
336 : CORBA::SystemException *s = NULL ;
337 14 : s = CORBA::SystemException::_downcast(& e) ;
338 14 : if (s != NULL)
339 : {
340 : CORBA::MARSHAL *m = NULL ;
341 14 : m = CORBA::MARSHAL::_downcast(s) ;
342 14 : if (m != NULL)
343 : {
344 14 : log << "CORBA::MARSHAL" << std::endl ;
345 : }
346 :
347 14 : int minor = s->minor() ;
348 : char buf[80] ;
349 14 : sprintf(buf, "0x%x", minor) ;
350 14 : log << " - minor :" << buf << std::endl ;
351 14 : log << " - completion :" ;
352 14 : switch(s->completed())
353 : {
354 : case CORBA::COMPLETED_YES :
355 : {
356 0 : log << "COMPLETED_YES" ;
357 : break ;
358 : }
359 : case CORBA::COMPLETED_NO :
360 : {
361 0 : log << "COMPLETED_NO" ;
362 : break ;
363 : }
364 : case CORBA::COMPLETED_MAYBE :
365 : {
366 14 : log << "COMPLETED_MAYBE" ;
367 : break ;
368 : }
369 : }
370 : log << std::endl ;
371 : }
372 0 : }
373 : }
374 :
375 0 : void spy_port(int input_port, int output_port, std::ostream& log)
376 : {
377 :
378 : }
379 :
380 0 : void usage(void)
381 : {
382 0 : fprintf(stderr, "usage : spy -f file_name -l log_file\n") ;
383 0 : fprintf(stderr, " spy -i port_in -o port_out -l log_file\n") ;
384 0 : exit(-1) ;
385 : }
386 :
387 25 : int main(int argc, char* argv[])
388 : {
389 : bool use_file = false ;
390 : bool use_ports = false ;
391 : const char *log_file = NULL ;
392 : const char *input_file = NULL ;
393 : int input_port = 0 ;
394 : int output_port = 0 ;
395 :
396 25 : if ( (argc != 5)
397 : && (argc != 7) )
398 : {
399 0 : usage() ;
400 : }
401 :
402 : // consume spy
403 25 : argc -- ;
404 25 : argv ++ ;
405 :
406 75 : while (argc>0)
407 : {
408 50 : if (strcmp("-f", argv[0]) == 0)
409 : {
410 : // consume -f
411 : argc -- ;
412 : argv ++ ;
413 :
414 25 : input_file = strdup(argv[0]) ;
415 : use_file = true ;
416 :
417 : // consume input_file
418 25 : argc -- ;
419 25 : argv ++ ;
420 :
421 25 : continue ;
422 : }
423 :
424 25 : if (strcmp("-i", argv[0]) == 0)
425 : {
426 : // consume -i
427 : argc -- ;
428 : argv ++ ;
429 :
430 : input_port = atoi(argv[0]) ;
431 : use_ports = true ;
432 :
433 : // consume input_port
434 0 : argc -- ;
435 0 : argv ++ ;
436 :
437 0 : continue ;
438 : }
439 :
440 25 : if (strcmp("-o", argv[0]) == 0)
441 : {
442 : // consume -o
443 : argc -- ;
444 : argv ++ ;
445 :
446 : output_port = atoi(argv[0]) ;
447 : use_ports = true ;
448 :
449 : // consume output_port
450 0 : argc -- ;
451 0 : argv ++ ;
452 :
453 0 : continue ;
454 : }
455 :
456 25 : if (strcmp("-l", argv[0]) == 0)
457 : {
458 : // consume -l
459 : argc -- ;
460 : argv ++ ;
461 :
462 25 : log_file = strdup(argv[0]) ;
463 :
464 : // consume log_file
465 25 : argc -- ;
466 25 : argv ++ ;
467 :
468 : continue ;
469 : }
470 : }
471 :
472 25 : if (use_file && (input_file == NULL))
473 : {
474 0 : usage() ;
475 : }
476 :
477 25 : if ( use_ports
478 : && ( (input_port == 0)
479 : || (output_port == 0))
480 : )
481 : {
482 0 : usage() ;
483 : }
484 :
485 25 : if (log_file == NULL)
486 : {
487 0 : usage() ;
488 : }
489 :
490 : std::ofstream log ;
491 : log.open(log_file) ;
492 :
493 25 : if (use_file)
494 : {
495 25 : spy_file(input_file, log) ;
496 : }
497 :
498 : if (use_ports)
499 : {
500 : spy_port(input_port, output_port, log) ;
501 : }
502 :
503 : log.close() ;
504 :
505 : return 0 ;
506 : }
|
