root/trunk/libffado/src/libutil/cmd_serialize.cpp

Revision 864, 6.7 kB (checked in by ppalmers, 16 years ago)

update license to GPLv2 or GPLv3 instead of GPLv2 or any later version. Update copyrights to reflect the new year

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1 /*
2  * Copyright (C) 2005-2008 by Daniel Wagner
3  *
4  * This file is part of FFADO
5  * FFADO = Free Firewire (pro-)audio drivers for linux
6  *
7  * FFADO is based upon FreeBoB
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 2 of the License, or
12  * (at your option) version 3 of the License.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  */
23
24 #include "cmd_serialize.h"
25
26 #include <iostream>
27 #include <iomanip>
28
29 #include <netinet/in.h>
30
31
32 namespace Util {
33   namespace Cmd {
34
35
36 IMPL_DEBUG_MODULE( CoutSerializer, CoutSerializer, DEBUG_LEVEL_NORMAL );
37 IMPL_DEBUG_MODULE( StringSerializer, StringSerializer, DEBUG_LEVEL_NORMAL );
38 IMPL_DEBUG_MODULE( BufferSerialize, BufferSerialize, DEBUG_LEVEL_NORMAL );
39 IMPL_DEBUG_MODULE( BufferDeserialize, BufferDeserialize, DEBUG_LEVEL_NORMAL );
40
41 bool
42 CoutSerializer::write( byte_t d, const char* name )
43 {
44     debugOutput( DEBUG_LEVEL_NORMAL, "  %3d:        0x%02x %-40.40s\n", m_cnt, d, name );
45     m_cnt += sizeof( byte_t );
46
47     return true;
48 }
49
50 bool
51 CoutSerializer::write( uint16_t d, const char* name )
52 {
53     debugOutput( DEBUG_LEVEL_NORMAL, "  %3d:    0x%04x %-40.40s\n", m_cnt, d, name );
54     m_cnt += sizeof( uint16_t );
55
56     return true;
57 }
58
59 bool
60 CoutSerializer::write( quadlet_t d, const char* name )
61 {
62     debugOutput( DEBUG_LEVEL_NORMAL, "  %3d: 0x%08x %-40.40s\n", m_cnt, d, name );
63     m_cnt += sizeof( quadlet_t );
64     return true;
65 }
66
67 bool
68 CoutSerializer::write( const char * v, size_t len, const char* name )
69 {
70     debugOutput( DEBUG_LEVEL_NORMAL, "  %3d: %s %-40.40s\n", m_cnt, v, name );
71     m_cnt += len;
72     return true;
73 }
74 //////////////////////////////////////////////////
75
76 bool
77 StringSerializer::write( byte_t d, const char* name )
78 {
79     char* result;
80     asprintf( &result, "  %3d:\t0x%02x\t%s\n", m_cnt, d, name );
81
82     m_string += result;
83     free( result );
84
85     m_cnt += sizeof( byte_t );
86
87     return true;
88 }
89
90 bool
91 StringSerializer::write( uint16_t d, const char* name )
92 {
93     char* result;
94     asprintf( &result, "  %3d:\t0x%04x\t%s\n", m_cnt, d, name );
95
96     m_string += result;
97     free( result );
98
99     m_cnt += sizeof( uint16_t );
100
101     return true;
102 }
103
104 bool
105 StringSerializer::write( quadlet_t d, const char* name )
106 {
107     char* result;
108     asprintf( &result, "  %3d:\t0x%08x\t%s\n", m_cnt, d, name );
109
110     m_string += result;
111     free( result );
112
113     m_cnt += sizeof( quadlet_t );
114     return true;
115 }
116
117 bool
118 StringSerializer::write( const char * v, size_t len, const char* name )
119 {
120     char* result;
121     asprintf( &result, "  %3d:\t%s\t%s\n", m_cnt, v, name );
122
123     m_string += result;
124     free( result );
125
126     m_cnt += len;
127     return true;
128 }
129 //////////////////////////////////////////////////
130
131 bool
132 BufferSerialize::write( byte_t value, const char* name )
133 {
134     bool result = false;
135     if ( isCurPosValid() ) {
136         *m_curPos = value;
137         m_curPos += sizeof( byte_t );
138         result = true;
139     }
140     return result;
141 }
142
143 bool
144 BufferSerialize::write( uint16_t value, const char* name )
145 {
146     byte_t hi = (value & 0xFF00) >> 8;
147     byte_t lo = value & 0xFF;
148
149     bool result = false;
150     if ( isCurPosValid() ) {
151         *m_curPos = hi;
152         m_curPos += sizeof( byte_t );
153         if ( isCurPosValid() ) {
154             *m_curPos = lo;
155             m_curPos += sizeof( byte_t );
156             result = true;
157         }
158     }
159     return result;
160 }
161
162 bool
163 BufferSerialize::write( quadlet_t value,  const char* name )
164 {
165     bool result = false;
166     if ( isCurPosValid() ) {
167         * ( quadlet_t* )m_curPos = value;
168         m_curPos += sizeof( quadlet_t );
169         result = true;
170     }
171     return result;
172 }
173
174 bool
175 BufferSerialize::write( const char * v, size_t len, const char* name )
176 {
177     bool result = false;
178     if ( isCurPosValid() ) {
179         m_curPos += len;
180         // avoid write beyond buffer
181         if ( isCurPosValid() ) {
182             m_curPos -= len;
183             memcpy(m_curPos, v, len);
184             m_curPos += len;
185             result = true;
186         }
187     }
188     return result;
189 }
190
191 bool
192 BufferSerialize::isCurPosValid() const
193 {
194     if ( static_cast<size_t>( ( m_curPos - m_buffer ) ) >= m_length ) {
195         return false;
196     }
197     return true;
198 }
199
200 //////////////////////////////////////////////////
201
202 bool
203 BufferDeserialize::read( byte_t* value )
204 {
205     bool result = false;
206     if ( isCurPosValid() ) {
207         *value = *m_curPos;
208         m_curPos += sizeof( byte_t );
209         result = true;
210     }
211     return result;
212 }
213
214 bool
215 BufferDeserialize::read( uint16_t* value )
216 {
217     byte_t hi;
218     byte_t lo;
219     bool result = false;
220     if ( isCurPosValid() ) {
221         hi = *((byte_t *)m_curPos);
222         m_curPos += sizeof( byte_t );
223         if ( isCurPosValid() ) {
224             lo = *((byte_t *)m_curPos);
225             m_curPos += sizeof( byte_t );
226             *value=(hi << 8) | lo;
227             result = true;
228         }
229     }
230     return result;
231 }
232
233 bool
234 BufferDeserialize::read( quadlet_t* value )
235 {
236     bool result = false;
237     if ( isCurPosValid() ) {
238         *value = *( ( quadlet_t* )m_curPos );
239         m_curPos += sizeof( quadlet_t );
240         result = true;
241     }
242     return result;
243 }
244
245 bool
246 BufferDeserialize::read( char** value, size_t length )
247 {
248     bool result = false;
249     if ( isCurPosValid() ) {
250         *value = ( char* )m_curPos;
251
252         m_curPos += length-1;
253         if ( !isCurPosValid() ) {
254             debugError("Read past end of response\n");
255             result=false;
256         } else {
257             m_curPos++;
258             result = true;
259         }
260     }
261     return result;
262 }
263
264 bool
265 BufferDeserialize::peek( byte_t* value )
266 {
267     bool result = false;
268     if ( isCurPosValid() ) {
269         *value = *m_curPos;
270         result = true;
271     }
272     return result;
273 }
274
275 bool
276 BufferDeserialize::peek( uint16_t* value, size_t offset )
277 {
278     byte_t hi;
279     byte_t lo;
280     bool result = false;
281     m_curPos+=offset;
282     if ( isCurPosValid() ) {
283         hi = *((byte_t *)m_curPos);
284         m_curPos += sizeof( byte_t );
285         if ( isCurPosValid() ) {
286             lo = *((byte_t *)m_curPos);
287             *value=(hi << 8) | lo;
288             result = true;
289         }
290         m_curPos -= sizeof( byte_t );
291     }
292     m_curPos-=offset;
293     return result;
294 }
295
296 bool
297 BufferDeserialize::skip( size_t length ) {
298     m_curPos+=length;
299     return true;
300 }
301
302 bool
303 BufferDeserialize::isCurPosValid() const
304 {
305     if ( static_cast<size_t>( ( m_curPos - m_buffer ) ) >= m_length ) {
306         return false;
307     }
308     return true;
309 }
310
311   }
312 }
Note: See TracBrowser for help on using the browser.