Quic ser retry

a fake serializer for quic

object quic_ser_retry = {}

<<< member

    class `quic_ser_retry`;

>>>

<<< impl

    //TODO
    //TODO

define QUOTEME(x) QUOTEME_1(x) define QUOTEME_1(x) #x define QUIC_SER_DESER_HEADER_PATH PANTHER_IVY_BASE_DIR/quic_utils/quic_ser_deser.h include QUOTEME(QUIC_SER_DESER_HEADER_PATH)

    class `quic_ser_retry` : public ivy_binary_ser_128 {
    //class `quic_ser_retry` : public ivy_binary_ser {
        enum {quic_s_init,
              quic_s_version,
              quic_s_dcil,
              quic_s_scil,
              quic_s_dcid,
              quic_s_scid,
              quic_s_retry_token,
              quic_s_integrity_token,
              quic_s_retry_token_length
              } state;
        bool long_format;
        char hdr_type;
        int dcil;
        int scil;
        long frame_type;
        int data_remaining;
        int128_t ack_blocks_expected;
        int128_t ack_block_count;
        //long long ack_blocks_expected;
        //long long ack_block_count;
        int payload_length_pos;
        int fence;

    public:
        quic_ser_retry() : state(quic_s_init) {
        }
        virtual void  set(int128_t res) {
        //virtual void  set(long long res) {
            switch (state) {
            case quic_s_init:
            {
                //std::cerr << "ser res init " << res << "\n";
                long_format = res != 3;
                hdr_type = (long_format ? ((res & 3) << 4) : 0) | 0x43 ;
                setn(246, 1);
                state = quic_s_version;
            }
            break;
            case quic_s_version:
            {
                setn(res,4);
                state = quic_s_dcid;
            }
            break;
            case quic_s_dcid:
            {
                //std::cerr << "ser res dcid 1 " << res << "\n";
                if((res != 0 && res != 1) || scid_h == 0)
                    setn(scid_h,1);
                else
                    setn(8,1);
                if((res != 0 && res != 1) || scid_h == 0)
                    setn(res,scid_h); //scid_h
                else
                    setn(res,8);
                //std::cerr << "ser res dcid 2 " << res << "\n";
                state = quic_s_scid;
            }
            break;
            case quic_s_scid:
            {
                //std::cerr << "ser res scid_h 1 " << res << "\n";
                setn(8,1);
                setn(res,8);
                // if((res == 0 || res == 1) && scid_h != 0){
                //      setn(8,1);
                //      setn(res,8);
                // } else {
                //      setn(dcid_h,1);
                //     setn(res,dcid_h);
                // }
                //std::cerr << "ser res scid_h 1 " << res << "\n";
                state = quic_s_retry_token;
                //state = quic_s_retry_token_length;
            }
            break;
            case quic_s_retry_token:
            {
                setn(res,1);
            }
            break;
            case quic_s_integrity_token:
            {
                setn(res,16);
            }
            break;
            default:
            //std::cerr << "quic_ser_retry 2\n";
            throw deser_err();
            }
        }

        void set_var_int(int128_t res) {
            int128_t val = res & 0x3fffffffffffffff; //TODO modify with 16 bytes mask ?
        //void set_var_int(long long res) {
        //    long long val = res & 0x3fffffffffffffff;
            int bytecode = res <= 0x3f ? 0 : res <= 0x3fff ? 1 : res <= 0x3fffffff ? 2 : 3;
            int bytes = 1 << bytecode;
            val |= bytecode << ((bytes << 3) - 2);
            setn(val,bytes);
        }

        void set_pkt_num(int128_t &res) {
        //void set_pkt_num(long long &res) {
            // setn(0xc0000000 | (0x3fffffff & res),4);
            // pkt number length is low two bits of first packet byte, plus one
            setn(res,(hdr_type & 3) + 1);
        }

        virtual void open_tag(int tag, const std::string &) {
            //std::cerr << "quic_ser_retry 1\n";
            throw deser_err();
        }

        virtual void open_list_elem() {
        }

        void open_list(int len) {
            /*if (state == quic_s_retry_token_length) {
                if (long_format & ((hdr_type & 0x30) == 0x00)) {
                    set_var_int(len);
                    data_remaining = len;
                }
                state = quic_s_retry_token;
            }*/
        }
        void close_list() {
            /*if (state ==  quic_s_supported_version) {
                    while (res.size() < 1200)
                        res.push_back(0);  // pad version_negociation packet to 1200 bytes
            }*/
            if (state == quic_s_retry_token) {
                payload_length_pos = this->res.size();
                /*if (long_format) {
                    setn(0,2);  // will fill in correct value later
                }*/
                state = quic_s_integrity_token;;
            }
        }
        void close_list_elem() {}

        virtual void close_tag() {
            state = quic_s_integrity_token;
        }

        ~quic_ser_retry(){}
    };

>>>

<<< init

    //transport_error_name_map(transport_error_codes,transport_error_codes_map);

>>>