1 : //==============================================================================
2 : // File <$/src/cpp/prod/protocol/giop/message_header.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 : #include <yaorb/CORBA.h>
23 : #include <yaorb/YAORB.h>
24 :
25 : #include "src/cpp/prod/protocol/cdr/msg.h"
26 : #include "src/cpp/prod/protocol/giop/message_header.h"
27 :
28 : const int MASK_ORDER = 0x01 ;
29 : const int MASK_FRAGMENT = 0x02 ;
30 :
31 33 : GIOPMessageHeader::GIOPMessageHeader()
32 : : _magic(),
33 : _version(),
34 : _flags(0),
35 : _message_type(0),
36 33 : _message_size(0)
37 : {}
38 :
39 33 : GIOPMessageHeader::~GIOPMessageHeader()
40 33 : {}
41 :
42 : CORBA::Octet
43 16 : GIOPMessageHeader::GetMajor(void) const
44 : {
45 : return _version._major ;
46 : }
47 :
48 : CORBA::Octet
49 16 : GIOPMessageHeader::GetMinor(void) const
50 : {
51 : return _version._minor ;
52 : }
53 :
54 : CORBA::Boolean
55 0 : GIOPMessageHeader::IsLastFragment(void) const
56 : {
57 : return ((_flags & MASK_FRAGMENT) ? false : true) ;
58 : }
59 :
60 : CORBA::ULong
61 2 : GIOPMessageHeader::GetMessageSize(void) const
62 : {
63 : return _message_size ;
64 : }
65 :
66 : void
67 4 : GIOPMessageHeader::SetMessageSize(CORBA::ULong size)
68 : {
69 4 : _message_size = size ;
70 : }
71 :
72 : GIOP_10_MessageType_e
73 1 : GIOPMessageHeader::GetGIOP10MessageType(void) const
74 : {
75 : return (GIOP_10_MessageType_e) _message_type ;
76 : }
77 :
78 : GIOP_11_MessageType_e
79 1 : GIOPMessageHeader::GetGIOP11MessageType(void) const
80 : {
81 : return (GIOP_11_MessageType_e) _message_type ;
82 : }
83 :
84 : GIOP_12_MessageType_e
85 60 : GIOPMessageHeader::GetGIOP12MessageType(void) const
86 : {
87 : return (GIOP_12_MessageType_e) _message_type ;
88 : }
89 :
90 : void
91 : GIOPMessageHeader::SetGIOP10MessageType(
92 0 : GIOP_10_MessageType_e type)
93 : {
94 0 : _magic[0] ='G' ;
95 0 : _magic[1] ='I' ;
96 0 : _magic[2] ='O' ;
97 0 : _magic[3] ='P' ;
98 0 : _version._major = 1 ;
99 0 : _version._minor = 0 ;
100 0 : _flags = 0 ; // FIXME
101 0 : _message_type = type ;
102 0 : _message_size = 0 ; // FIXME
103 : }
104 :
105 : void
106 : GIOPMessageHeader::SetGIOP11MessageType(
107 0 : GIOP_11_MessageType_e type)
108 : {
109 0 : _magic[0] ='G' ;
110 0 : _magic[1] ='I' ;
111 0 : _magic[2] ='O' ;
112 0 : _magic[3] ='P' ;
113 0 : _version._major = 1 ;
114 0 : _version._minor = 1 ;
115 0 : _flags = 0 ; // FIXME
116 0 : _message_type = type ;
117 0 : _message_size = 0 ; // FIXME
118 : }
119 :
120 : void
121 : GIOPMessageHeader::SetGIOP12MessageType(
122 4 : GIOP_12_MessageType_e type)
123 : {
124 4 : _magic[0] ='G' ;
125 4 : _magic[1] ='I' ;
126 4 : _magic[2] ='O' ;
127 4 : _magic[3] ='P' ;
128 4 : _version._major = 1 ;
129 4 : _version._minor = 2 ;
130 4 : _flags = 0 ; // FIXME
131 4 : _message_type = type ;
132 4 : _message_size = 0 ; // FIXME
133 : }
134 :
135 : void
136 37 : GIOPMessageHeader::cdr(YAORB::CDR* cdrs)
137 : {
138 : //--------------------------------------------------------------------------
139 : // Magic 'GIOP'
140 : //--------------------------------------------------------------------------
141 :
142 37 : cdrs->cdr_OctetArray(& _magic[0], 4) ;
143 :
144 37 : if (_magic[0] != 'G')
145 : {
146 1 : ThrowMarshal(cdrs) ;
147 : }
148 :
149 36 : if (_magic[1] != 'I')
150 : {
151 1 : ThrowMarshal(cdrs) ;
152 : }
153 :
154 35 : if (_magic[2] != 'O')
155 : {
156 1 : ThrowMarshal(cdrs) ;
157 : }
158 :
159 34 : if (_magic[3] != 'P')
160 : {
161 1 : ThrowMarshal(cdrs) ;
162 : }
163 :
164 : //--------------------------------------------------------------------------
165 : // Versions 1.0, 1.1 or 1.2
166 : //--------------------------------------------------------------------------
167 :
168 33 : cdrs->cdr_Octet(& _version._major) ;
169 :
170 33 : if (_version._major != 1)
171 : {
172 1 : ThrowMarshal(cdrs) ; // FIXME : not marshall, should be ???
173 : }
174 :
175 32 : cdrs->cdr_Octet(& _version._minor) ;
176 :
177 32 : if ( (_version._minor != 0)
178 : && (_version._minor != 1)
179 : && (_version._minor != 2) )
180 : {
181 1 : ThrowMarshal(cdrs) ; // FIXME : not marshall, should be ???
182 : }
183 :
184 : //--------------------------------------------------------------------------
185 : // Flags (1.0 : byte order), 1.1 & 1.2 : byte order + fragment flag
186 : //--------------------------------------------------------------------------
187 :
188 31 : cdrs->cdr_Octet(& _flags) ;
189 :
190 31 : if (_version._minor == 0)
191 : {
192 : // GIOP 1.0 : Boolean byte_order
193 4 : if ( (_flags != 0) && (_flags != 1))
194 : {
195 1 : ThrowMarshal(cdrs) ;
196 : }
197 :
198 3 : if (_flags == 0)
199 : {
200 1 : cdrs->SetBigEndian() ;
201 : }
202 : else
203 : {
204 2 : cdrs->SetLittleEndian() ;
205 : }
206 : }
207 :
208 30 : if ( (_version._minor == 1)
209 : || (_version._minor == 2) )
210 : {
211 : // GIOP 1.1 & GIOP 1.2 : Octet flags b7b6b5b4b3b2b1b0
212 : // b0 : byte ordering
213 : // b1 : fragment flag
214 : // b2-b7 : reserved
215 :
216 27 : if ((_flags & MASK_ORDER) == 0)
217 : {
218 13 : cdrs->SetBigEndian() ;
219 : }
220 : else
221 : {
222 14 : cdrs->SetLittleEndian() ;
223 : }
224 : }
225 :
226 : //--------------------------------------------------------------------------
227 : // Message type. The Fragment message (6) is only for 1.1 and 1.2
228 : //--------------------------------------------------------------------------
229 :
230 30 : cdrs->cdr_Octet(& _message_type) ;
231 :
232 30 : if ( (_version._minor == 0)
233 : && (_message_type > 6 ) )
234 : {
235 2 : ThrowMarshal(cdrs) ;
236 : }
237 :
238 28 : if ( ( (_version._minor == 1)
239 : || (_version._minor == 2) )
240 : && (_message_type > 7)
241 : )
242 : {
243 2 : ThrowMarshal(cdrs) ;
244 : }
245 :
246 : //--------------------------------------------------------------------------
247 : // GIOP 1.1 : Only Request and Reply can be fragmented.
248 : //--------------------------------------------------------------------------
249 :
250 26 : if ( (_version._minor == 1)
251 : && (_flags & MASK_FRAGMENT)
252 : && (_message_type != GIOPRequest_type)
253 : && (_message_type != GIOPReply_type)
254 : && (_message_type != GIOPFragment_type)
255 : )
256 : {
257 0 : ThrowMarshal(cdrs) ;
258 : }
259 :
260 : //--------------------------------------------------------------------------
261 : // GIOP 1.2 : Request, Reply, LocateRequest & LocateReply can be fragmented.
262 : //--------------------------------------------------------------------------
263 :
264 25 : if ( (_version._minor == 2)
265 : && (_flags & MASK_FRAGMENT)
266 : && (_message_type != GIOPRequest_type)
267 : && (_message_type != GIOPReply_type)
268 : && (_message_type != GIOPLocateRequest_type)
269 : && (_message_type != GIOPLocateReply_type)
270 : && (_message_type != GIOPFragment_type)
271 : )
272 : {
273 0 : ThrowMarshal(cdrs) ;
274 : }
275 :
276 : //--------------------------------------------------------------------------
277 : // Message size
278 : //--------------------------------------------------------------------------
279 :
280 26 : cdrs->cdr_ULong(& _message_size) ;
281 :
282 : //--------------------------------------------------------------------------
283 : // GIOP 1.2 fragmented messages must end at a 8 bytes boundary
284 : //--------------------------------------------------------------------------
285 :
286 26 : if ( (_version._minor == 2)
287 : && (_flags & MASK_FRAGMENT)
288 : && ((_message_size + GIOP_MESSAGE_HEADER_SIZE) % 8 != 0)
289 : )
290 : {
291 0 : ThrowMarshal(cdrs) ;
292 : }
293 :
294 : return ;
295 : }
296 :
|
