4022b48d09f3ea3b0c7e2d328df839d7a084d058
[sim/e2-interface.git] / e2sim / previous / e2apv1sim / ricsim / src / ASN1 / asn / buffer.hpp
1 #pragma once
2 /******************************************************************************
3 *
4 *   Copyright (c) 2019 AT&T Intellectual Property.
5 *   Copyright (c) 2018-2019 Nokia.
6 *
7 *   Licensed under the Apache License, Version 2.0 (the "License");
8 *   you may not use this file except in compliance with the License.
9 *   You may obtain a copy of the License at
10 *
11 *       http://www.apache.org/licenses/LICENSE-2.0
12 *
13 *   Unless required by applicable law or agreed to in writing, software
14 *   distributed under the License is distributed on an "AS IS" BASIS,
15 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 *   See the License for the specific language governing permissions and
17 *   limitations under the License.
18 *
19 *******************************************************************************/
20
21 // Standard Includes: ANSI C/C++, MSA, and Third-Party Libraries
22 #include <cstring>
23
24 // Local Includes: Application specific classes, functions, and libraries
25 #include "asn/error_context.hpp"
26 #include "value_traits.hpp"
27
28 //#define CODEC_BIT_TRACE_ENABLE
29 #ifdef CODEC_BIT_TRACE_ENABLE
30         #define CODEC_BIT_TRACE(FMT, args...) printf("%s[%u]:" FMT "\n", std::strrchr(__FILE__, '/') + 1, __LINE__, ##args)
31 #else
32         #define CODEC_BIT_TRACE(...)
33 #endif
34
35 namespace asn {
36
37 template <class IE, class VALUE, bool LSB>
38 struct bit_accessor;
39
40 template <bool LSB>
41 struct bit_accessor_cross_byte;
42
43 template <typename PTR>
44 class buffer
45 {
46 public:
47         typedef PTR pointer;
48
49         explicit buffer(error_context& err)
50                 : m_errCtx(err)
51         {}
52
53         void reset(pointer data, u32 size)
54         {
55                 m_start         = data;
56                 m_end           = m_start + size;
57                 m_current   = m_start;
58                 m_shift     = 0;
59         }
60
61         u32 getOffset() const          { return begin() - m_start; }
62
63         u32 getBytesLeft() const       { return end() - begin(); }
64         u32 getBytesUsed() const       { return getOffset() + (get_shift() ? 1 : 0); }
65
66         u8 get_shift() const           { return m_shift; }
67         void reset_shift()             { m_shift = 0; }
68         void byte_align()              { if (get_shift()) { m_shift = 0; ++m_current; } }
69
70         pointer advance(u32 delta)     { pointer p = begin(); m_current += delta; return p; }
71
72         pointer begin() const          { return m_current; }
73
74         void set_begin(pointer ptr, u8 bit_shift)
75         {
76                 if (m_start <= ptr && ptr <= end())
77                 {
78                         m_current = ptr;
79                         m_shift = bit_shift;
80                 }
81         }
82
83         pointer end() const            { return m_end; }
84         void set_end(pointer v)        { m_end = v; }
85
86         bool checkAlignment(char const* name, u8 const mask = 0xFF)
87         {
88                 if (0 == (get_shift() & mask)) return true;
89                 m_errCtx.alignmentError(name, get_shift());
90                 return false;
91         }
92
93         bool checkBytesLeft(char const* name, u32 const num_bytes)
94         {
95                 if (getBytesLeft() >= num_bytes) return true;
96                 m_errCtx.lengthErrorBytes(name, getBytesLeft(), num_bytes);
97                 return false;
98         }
99
100         bool checkBitsLeft(char const* name, u32 const num_bits)
101         {
102                 if (getBitsLeft() >= num_bits) return true;
103                 m_errCtx.lengthErrorBits(name, getBitsLeft(), num_bits);
104                 return false;
105         }
106
107         bool checkBytesAndAlignment(char const* name, u32 const num_bytes, u8 const mask = 0xFF)
108         {
109                 if (getBytesLeft() >= num_bytes)
110                 {
111                         if (0 == (get_shift() & mask)) return true;
112                         m_errCtx.alignmentError(name, get_shift());
113                 }
114                 else
115                 {
116                         m_errCtx.lengthErrorBytes(name, getBytesLeft(), num_bytes);
117                 }
118                 return false;
119         }
120
121         pointer getBytes(char const* name, u32 num_bytes)
122         {
123                 if (checkBytesAndAlignment(name, num_bytes))
124                 {
125                         return advance(num_bytes);
126                 }
127                 return nullptr;
128         }
129
130         //NOTE! num_bytes should be set to minimal number of bytes expected
131         pointer getBytes(char const* name, u32 max_requested, u32& num_bytes)
132         {
133                 if (checkAlignment(name))
134                 {
135                         u32 const left = getBytesLeft();
136                         if (left >= num_bytes)
137                         {
138                                 num_bytes = (left > max_requested) ? max_requested : left;
139                                 return advance(num_bytes);
140                         }
141
142                         m_errCtx.lengthErrorBytes(name, getBytesLeft(), num_bytes);
143                 }
144                 return nullptr;
145         }
146
147         bool putByte(char const* name, u8 byte)
148         {
149                 if (checkBytesAndAlignment(name, 1))
150                 {
151                         begin()[0] = byte;
152                         ++m_current;
153                         return true;
154                 }
155                 return false;
156         }
157
158         bool putBytes(char const* name, void const* in, u32 num_bytes)
159         {
160                 if (checkBytesAndAlignment(name, num_bytes))
161                 {
162                         std::memcpy(begin(), in, num_bytes);
163                         m_current += num_bytes;
164                         return true;
165                 }
166                 return false;
167         }
168         
169         bool checkAlignment(u8 const mask = 0xFF)
170         {
171                 if (0 == (get_shift() & mask)) return true;
172                 m_errCtx.alignmentError(get_shift());
173                 return false;
174         }
175
176         bool checkBytesLeft(u32 const num_bytes)
177         {
178                 if (getBytesLeft() >= num_bytes) return true;
179                 m_errCtx.lengthErrorBytes(getBytesLeft(), num_bytes);
180                 return false;
181         }
182
183         bool checkBitsLeft(u32 const num_bits)
184         {
185                 if (getBitsLeft() >= num_bits) return true;
186                 m_errCtx.lengthErrorBits(getBitsLeft(), num_bits);
187                 return false;
188         }
189
190         bool checkBytesAndAlignment(u32 const num_bytes, u8 const mask = 0xFF)
191         {
192                 if (getBytesLeft() >= num_bytes)
193                 {
194                         if (0 == (get_shift() & mask)) return true;
195                         m_errCtx.alignmentError(get_shift());
196                 }
197                 else
198                 {
199                         m_errCtx.lengthErrorBytes(getBytesLeft(), num_bytes);
200                 }
201                 return false;
202         }
203
204         pointer getBytes(u32 num_bytes)
205         {
206                 if (checkBytesAndAlignment(num_bytes))
207                 {
208                         return advance(num_bytes);
209                 }
210                 return nullptr;
211         }
212
213         //NOTE! num_bytes should be set to minimal number of bytes expected
214         pointer getBytes(u32 max_requested, u32& num_bytes)
215         {
216                 if (checkAlignment())
217                 {
218                         u32 const left = getBytesLeft();
219                         if (left >= num_bytes)
220                         {
221                                 num_bytes = (left > max_requested) ? max_requested : left;
222                                 return advance(num_bytes);
223                         }
224
225                         m_errCtx.lengthErrorBytes(getBytesLeft(), num_bytes);
226                 }
227                 return nullptr;
228         }
229
230         bool putByte(u8 byte)
231         {
232                 if (checkBytesAndAlignment(1))
233                 {
234                         begin()[0] = byte;
235                         ++m_current;
236                         return true;
237                 }
238                 return false;
239         }
240
241         bool putBytes(void const* in, u32 num_bytes)
242         {
243                 if (num_bytes)
244                 {
245                         if(checkBytesAndAlignment(num_bytes))
246                         {
247                                 std::memcpy(begin(), in, num_bytes);
248                                 m_current += num_bytes;
249                         }
250                         else
251                                 return false;
252                 }
253                 return true;
254         }
255
256         char const* toString() const
257         {
258                 static char sz[64];
259                 u8 const* p = begin();
260                 snprintf(sz, sizeof(sz), "%02X %02X %02X %02X [%02X]=%p@%u..%p -%u bits: +%u bytes", p[-4], p[-3], p[-2], p[-1], p[0], p
261                         , getOffset(), end(), get_shift(), getBytesLeft());
262                 return sz;
263         }
264
265 private:
266         template <class IE, class VALUE, bool LSB>
267         friend class bit_accessor;
268         
269         template <bool LSB>
270         friend struct bit_accessor_cross_byte;
271
272         template <typename U>
273         void push_u8(U value)          { *m_current++ = static_cast<u8>(value); }
274         template <typename U>
275         void put_u8(U value)           { m_current[0] = static_cast<u8>(value); }
276
277 //khxm68: TODO: won't compile without it. WTF?!
278 #pragma GCC diagnostic push
279 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
280         u8 get_u8() const              { return m_current[0]; }
281 #pragma GCC diagnostic pop
282         u8 extract_u8(u8 value, u8 mask, u8 shift) const
283                 { return (get_u8() & ~(mask << shift)) | ((value & mask) << shift); }
284
285         u16 get_u16() const            { return (static_cast<u16>(m_current[0]) << 8) | m_current[1]; }
286         u16 extract_u16(u16 value, u16 mask, u16 shift) const
287                 { return (get_u16() & ~(mask << shift)) | ((value & mask) << shift); }
288
289         u32 get_u24() const            { return (static_cast<u32>(m_current[0]) << 16) | (static_cast<u32>(m_current[1]) << 8) | m_current[2]; }
290         u32 extract_u24(u32 value, u32 mask, u32 shift) const
291                 { return (get_u24() & ~(mask << shift)) | ((value & mask) << shift); }
292
293         u32 get_u32() const            { return (static_cast<u32>(m_current[0]) << 24) | (static_cast<u32>(m_current[1]) << 16) | (static_cast<u32>(m_current[2]) << 8) | m_current[3]; }
294         u32 extract_u32(u32 value, u32 mask, u32 shift) const
295                 { return (get_u32() & ~(mask << shift)) | ((value & mask) << shift); }
296
297         u32 getBitsLeft() const        { return begin() == end() ? 0 : (getBytesLeft()*8 - get_shift()); }
298
299         void bit_advance(u8 num_bits)
300         {
301                 m_shift += num_bits;
302                 if (get_shift() > 7)
303                 {
304                         reset_shift();
305                         m_current++;
306                 }
307         }
308
309         pointer  m_current;
310         pointer  m_end;
311         pointer  m_start;
312         u8       m_shift;
313         error_context& m_errCtx;
314 };
315
316 template <class IE>     //LSB 1..7 bits
317 struct bit_accessor<IE, stdex::value::_8, true>
318 {
319         static_assert(IE::length::value > 0 && IE::length::value < 8, "something wrong with traits!");
320
321         static void put(u8 value, buffer<u8*>& buf)
322         {
323                 u8 const mask = static_cast<u8>((1u << IE::length::value) - 1);
324                 u8 const shift = buf.get_shift();
325                 u8 const data = buf.extract_u8(value, mask, shift);
326                 buf.put_u8(data);
327
328                 CODEC_BIT_TRACE("put shift=%u(%u) data[%u]=%02X(%02X) mask=%04X: %s", shift, buf.get_shift()
329                         , IE::length::value, data, value, mask, buf.toString());
330
331                 buf.bit_advance(IE::length::value);
332         }
333
334         static u8 get(buffer<u8 const*>& buf)
335         {
336                 u8 const mask = static_cast<u8>((1u << IE::length::value) - 1);
337                 u8 const shift = buf.get_shift();
338                 u8 const data = (buf.get_u8() >> shift) & mask;
339
340                 CODEC_BIT_TRACE("get shift=%u(%u) data[%u]=%02X mask=%02X: %s", shift, buf.get_shift()
341                         , IE::length::value, data, mask, buf.toString());
342
343                 buf.bit_advance(IE::length::value);
344                 return data;
345         }
346 };
347
348 template <class IE>     //LSB 9..15 bits
349 struct bit_accessor<IE, stdex::value::_16, true>
350 {
351         static_assert(IE::length::value > 8 && IE::length::value < 16, "something wrong with traits!");
352
353         static void put(u16 value, buffer<u8*>& buf)
354         {
355                 u16 const mask = static_cast<u16>((1u << IE::length::value) - 1);
356                 u16 const shift = buf.get_shift();
357                 u16 const data = buf.extract_u16(value, mask, shift);
358                 buf.push_u8(data >> 8);
359                 buf.put_u8(data);
360
361                 CODEC_BIT_TRACE("put shift=%u(%u) data[%u]=%04X(%04X) mask=%04X: %s", shift, buf.get_shift()
362                         , IE::length::value, data, value, mask, buf.toString());
363
364                 buf.bit_advance(IE::length::value - 8);
365         }
366
367         static u16 get(buffer<u8 const*>& buf)
368         {
369                 u16 const mask = static_cast<u16>((1u << IE::length::value) - 1);
370                 u16 const shift = buf.get_shift();
371                 u16 const data = (buf.get_u16() >> shift) & mask;
372                 buf.m_current += 1;
373
374                 CODEC_BIT_TRACE("get shift=%u(%u) data[%u]=%04X mask=%04X: %s", shift, buf.get_shift()
375                         , IE::length::value, data, mask, buf.toString());
376
377                 buf.bit_advance(IE::length::value - 8);
378                 return data;
379         }
380 };
381
382 template <class IE>     //LSB 17..24 bits
383 struct bit_accessor<IE, stdex::value::_24, true>
384 {
385         static_assert(IE::length::value > 16 && IE::length::value <= 24, "something wrong with traits!");
386
387         static void put(u32 value, buffer<u8*>& buf)
388         {
389                 u32 const mask = static_cast<u32>((1u << IE::length::value) - 1);
390                 u32 const shift = buf.get_shift();
391                 u32 const data = buf.extract_u24(value, mask, shift);
392
393                 buf.push_u8(data >> 16);
394                 buf.push_u8(data >> 8);
395                 buf.put_u8(data);
396
397                 CODEC_BIT_TRACE("put shift=%u(%u) data[%u]=%06X(%06X) mask=%06X: %s", shift, buf.get_shift()
398                         , IE::length::value, data, value, mask, buf.toString());
399
400                 buf.bit_advance(IE::length::value - 16);
401         }
402
403         static u32 get(buffer<u8 const*>& buf)
404         {
405                 u32 const mask = static_cast<u32>((1u << IE::length::value) - 1);
406                 u32 const shift = buf.get_shift();
407                 u32 const data = (buf.get_u24() >> shift) & mask;
408                 buf.m_current += 2;
409
410                 CODEC_BIT_TRACE("get shift=%u(%u) data[%u]=%06X mask=%06X: %s", shift, buf.get_shift()
411                         , IE::length::value, data, mask, buf.toString());
412
413                 buf.bit_advance(IE::length::value - 16);
414                 return data;
415         }
416 };
417
418 template <class IE>     //LSB 25..31 bits
419 struct bit_accessor<IE, stdex::value::_32, true>
420 {
421         static_assert(IE::length::value > 24 && IE::length::value < 32, "something wrong with traits!");
422
423         static void put(u32 value, buffer<u8*>& buf)
424         {
425                 u32 const mask = static_cast<u32>((1u << IE::length::value) - 1);
426                 u32 const shift = buf.get_shift();
427                 u32 const data = buf.extract_u32(value, mask, shift);
428
429                 buf.push_u8(data >> 24);
430                 buf.push_u8(data >> 16);
431                 buf.push_u8(data >> 8);
432                 buf.put_u8(data);
433
434                 CODEC_BIT_TRACE("put shift=%u(%u) data[%u]=%08X(%08X) mask=%08X: %s", shift, buf.get_shift()
435                         , IE::length::value, data, value, mask, buf.toString());
436
437                 buf.bit_advance(IE::length::value - 24);
438         }
439
440         static u32 get(buffer<u8 const*>& buf)
441         {
442                 u32 const mask = static_cast<u32>((1u << IE::length::value) - 1);
443                 u32 const shift = buf.get_shift();
444                 u32 const data = (buf.get_u32() >> shift) & mask;
445                 buf.m_current += 3;
446
447                 CODEC_BIT_TRACE("get shift=%u(%u) data[%u]=%08X mask=%08X: %s", shift, buf.get_shift()
448                         , IE::length::value, data, mask, buf.toString());
449
450                 buf.bit_advance(IE::length::value - 24);
451                 return data;
452         }
453 };
454
455
456 template <class IE>     //MSB 1..7 bits
457 struct bit_accessor<IE, stdex::value::_8, false>
458 {
459         static_assert(IE::length::value > 0 && IE::length::value < 8, "something wrong with traits!");
460
461         static void put(u8 value, buffer<u8*>& buf)
462         {
463                 u8 const mask = static_cast<u8>((1u << IE::length::value) - 1);
464                 u8 const shift = 8 - buf.get_shift() - IE::length::value;
465                 u8 const data = buf.extract_u8(value, mask, shift);
466                 buf.put_u8(data);
467
468                 CODEC_BIT_TRACE("put shift=%u(%u) data[%u]=%02X(%02X) mask=%04X: %s", shift, buf.get_shift()
469                         , IE::length::value, data, value, mask, buf.toString());
470
471                 buf.bit_advance(IE::length::value);
472         }
473
474         static u8 get(buffer<u8 const*>& buf)
475         {
476                 u8 const mask = static_cast<u8>((1u << IE::length::value) - 1);
477                 u8 const shift = 8 - buf.get_shift() - IE::length::value;
478                 u8 const data = (buf.get_u8() >> shift) & mask;
479
480                 CODEC_BIT_TRACE("get shift=%u(%u) data[%u]=%02X mask=%02X: %s", shift, buf.get_shift()
481                         , IE::length::value, data, mask, buf.toString());
482
483                 buf.bit_advance(IE::length::value);
484                 return data;
485         }
486 };
487
488 template <class IE>     //MSB 9..15 bits
489 struct bit_accessor<IE, stdex::value::_16, false>
490 {
491         static_assert(IE::length::value > 8 && IE::length::value < 16, "something wrong with traits!");
492
493         static void put(u16 value, buffer<u8*>& buf)
494         {
495                 u16 const mask = static_cast<u16>((1u << IE::length::value) - 1);
496                 u16 const shift = 16 - buf.get_shift() - IE::length::value;
497                 u16 const data = buf.extract_u16(value, mask, shift);
498
499                 buf.push_u8(data >> 8);
500                 buf.put_u8(data);
501
502                 CODEC_BIT_TRACE("put shift=%u(%u) data[%u]=%04X(%04X) mask=%04X: %s", shift, buf.get_shift()
503                         , IE::length::value, data, value, mask, buf.toString());
504
505                 buf.bit_advance(IE::length::value - 8);
506         }
507
508         static u16 get(buffer<u8 const*>& buf)
509         {
510                 u16 const mask = static_cast<u16>((1u << IE::length::value) - 1);
511                 u16 const shift = 16 - buf.get_shift() - IE::length::value;
512                 u16 const data = (buf.get_u16() >> shift) & mask;
513                 buf.m_current += 1;
514
515                 CODEC_BIT_TRACE("get shift=%u(%u) data[%u]=%04X mask=%04X: %s", shift, buf.get_shift()
516                         , IE::length::value, data, mask, buf.toString());
517
518                 buf.bit_advance(IE::length::value - 8);
519                 return data;
520         }
521 };
522
523
524 template <class IE>     //MSB 17..24 bits
525 struct bit_accessor<IE, stdex::value::_24, false>
526 {
527         static_assert(IE::length::value > 16 && IE::length::value <= 24, "something wrong with traits!");
528
529         static void put(u32 value, buffer<u8*>& buf)
530         {
531                 u32 const mask = static_cast<u32>((1u << IE::length::value) - 1);
532                 u32 const shift = 24 - buf.get_shift() - IE::length::value;
533                 u32 const data = buf.extract_u24(value, mask, shift);
534
535                 buf.push_u8(data >> 16);
536                 buf.push_u8(data >> 8);
537                 buf.put_u8(data);
538
539                 CODEC_BIT_TRACE("put shift=%u(%u) data[%u]=%06X(%06X) mask=%06X: %s", shift, buf.get_shift()
540                         , IE::length::value, data, value, mask, buf.toString());
541
542                 buf.bit_advance(IE::length::value - 16);
543         }
544
545         static u32 get(buffer<u8 const*>& buf)
546         {
547                 u32 const mask = static_cast<u32>((1u << IE::length::value) - 1);
548                 u32 const shift = 24 - buf.get_shift() - IE::length::value;
549                 u32 const data = (buf.get_u24() >> shift) & mask;
550                 buf.m_current += 2;
551
552                 CODEC_BIT_TRACE("get shift=%u(%u) data[%u]=%06X mask=%06X: %s", shift, buf.get_shift()
553                         , IE::length::value, data, mask, buf.toString());
554
555                 buf.bit_advance(IE::length::value - 16);
556                 return data;
557         }
558 };
559
560 template <class IE>     //MSB 25..31 bits
561 struct bit_accessor<IE, stdex::value::_32, false>
562 {
563         static_assert(IE::length::value > 24 && IE::length::value < 32, "something wrong with traits!");
564
565         static void put(u32 value, buffer<u8*>& buf)
566         {
567                 u32 const mask = static_cast<u32>((1u << IE::length::value) - 1);
568                 u32 const shift = 32 - buf.get_shift() - IE::length::value;
569                 u32 const data = buf.extract_u32(value, mask, shift);
570
571                 buf.push_u8(data >> 24);
572                 buf.push_u8(data >> 16);
573                 buf.push_u8(data >> 8);
574                 buf.put_u8(data);
575
576                 CODEC_BIT_TRACE("put shift=%u(%u) data[%u]=%08X(%08X) mask=%08X: %s", shift, buf.get_shift()
577                         , IE::length::value, data, value, mask, buf.toString());
578
579                 buf.bit_advance(IE::length::value - 24);
580         }
581
582         static u32 get(buffer<u8 const*>& buf)
583         {
584                 u32 const mask = static_cast<u32>((1u << IE::length::value) - 1);
585                 u32 const shift = 32 - buf.get_shift() - IE::length::value;
586                 u32 const data = (buf.get_u32() >> shift) & mask;
587                 buf.m_current += 3;
588
589                 CODEC_BIT_TRACE("get shift=%u(%u) data[%u]=%08X mask=%08X: %s", shift, buf.get_shift()
590                         , IE::length::value, data, mask, buf.toString());
591
592                 buf.bit_advance(IE::length::value - 24);
593                 return data;
594         }
595 };
596
597 /********************************************************************************
598 bit_accessor_cross_byte
599 *********************************************************************************/
600 template<>
601 struct bit_accessor_cross_byte<false> //MSB
602 {
603         static bool put(u8 value, u8 length, buffer<u8*>& buf)
604         {
605                 u8 spare = 8 - buf.get_shift();
606
607                 if (spare < length)
608                 {
609                         length -= spare;
610                         u8 chunk = value >> length;
611                         u8 const mask = static_cast<u8>((1u << spare) - 1);
612                         u8 data = buf.extract_u8(chunk, mask, 0);
613                         buf.put_u8(data);
614
615                         buf.bit_advance(spare);
616                 }
617                 if (buf.checkBytesLeft(1))
618                 {
619                         u8 const mask = static_cast<u8>((1u << length) - 1);
620                         u8 const shift = 8 - buf.get_shift() - length;
621                         u8 data = buf.extract_u8(value, mask, shift);
622                         buf.put_u8(data);
623
624                         buf.bit_advance(length);
625
626                         return true;
627                 }
628                 return false;
629         }
630
631         static u8 get(u8 length, buffer<u8 const*>& buf)
632         {
633                 u8 rval {0};
634                 u8 const mask = static_cast<u8>((1u << length) - 1);
635                 u8 const spare = 8 - buf.get_shift();
636                 if (spare < length)
637                 {
638                         length -= spare;
639                         rval = buf.get_u8() << length;
640                         buf.bit_advance(spare);
641                 }
642                 if (length && buf.checkBytesLeft(1))
643                 {
644                         u8 val = buf.get_u8();
645                         val = val >> (8 - length - buf.get_shift());
646                         rval |= val;
647                         rval &= mask;
648                         buf.bit_advance(length);
649                 }
650                 return rval;
651         }
652
653         static void padByte(buffer<u8*>& buf)
654         {
655                 if (buf.get_shift())
656                 {
657                         u8 mask = static_cast<u8>((1u << buf.get_shift()) - 1);
658                         mask = mask << (8 - buf.get_shift());
659                         buf.begin()[0] &= mask;
660                         buf.bit_advance(8 - buf.get_shift());
661                 }
662         }
663
664         static void padByte(buffer<u8 const*>& buf)
665         {
666                 if(buf.get_shift())
667                         buf.bit_advance(8 - buf.get_shift());
668         }
669
670         static bool put(const u8* in, size_t len, buffer<u8*>& buf, u8 trail_bitsqty)
671         {
672                 if (len)
673                 {
674                         if (trail_bitsqty)
675                         {
676                                 buf.putBytes(in, len - 1);
677                                 u8 last_byte = in[len - 1];
678                                 last_byte = last_byte >> (8 - trail_bitsqty);
679                                 return put(last_byte, trail_bitsqty, buf);
680                         }
681                         buf.putBytes(in, len);
682                 }
683                 return true;
684         }
685 };
686
687 }       //end: namespace asn
688
689