Quic ser vn

a fake serializer for quic

object quic_ser_vn = {}

<<< member

    class `quic_ser_vn`;

>>>

<<< 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)

    int dcid_vn = 8;
    int scid_vn = 0;

    class `quic_ser_vn` : public ivy_binary_ser_128 {
    //class `quic_ser_vn` : 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_supported_version
              } 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_vn() : 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(hdr_type | (long_format ? 0x80 : 0), 1);
                state = quic_s_version;
            }
            break;
            case quic_s_version:
            {
                setn(res,4);
                state = quic_s_dcid;
            }
            break;
            case quic_s_dcid:
            {
                if(const char* env_p3 = std::getenv("TEST_SCIL")) {
                    std::cerr << "TEST_SCIL_VN " << env_p3 << "\n";
                    scid_vn = atoi(env_p3);
                }
                std::cerr << "ser res dcid 1 " << res << "\n";
                std::cerr << "ser res dcid_h 1 " << scid_vn << "\n";
                if (long_format) {
                    if((res != 0 && res != 1) || scid_vn == 0)
                        setn(scid_vn,1);
                    else
                        setn(8,1);
                }
                if((res != 0 && res != 1) || scid_vn == 0)
                    setn(res,scid_vn); //scid_vn
                else
                    setn(res,8);
                std::cerr << "ser res dcid 2 " << res << "\n";
                state = quic_s_scid;
            }
            break;
            case quic_s_scid:
            {
                if(const char* env_p3 = std::getenv("TEST_DCIL")) {
                    std::cerr << "TEST_DCIL_VN " << env_p3 << "\n";
                    dcid_vn = atoi(env_p3);
                }
                std::cerr << "ser res scid_h 1 " << res << "\n";
                if (long_format) {
                    if((res == 0 || res == 1) && scid_vn != 0){
                        setn(8,1);
                        setn(res,8);
                    } else {
                        setn(dcid_vn,1);
                        setn(res,dcid_vn);
                    }
                }
                std::cerr << "ser res scid_h 1 " << res << "\n";
                state = quic_s_supported_version;
            }
            break;
            case quic_s_supported_version:
            {
                std::cerr << "ser res scid_h 1 " << res << "\n";
                //TODO only work with 1 version for now
                setn(res,4);
            }
            break;
            default:
            std::cerr << "quic_ser_vn 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_vn 1\n";
            throw deser_err();
        }

        virtual void open_list_elem() {
        }

        void open_list(int len) {

        }
        void close_list() {
            /*if (state ==  quic_s_supported_version) {
                    while (res.size() < 1200)
                        res.push_back(0);  // pad version_negociation packet to 1200 bytes
            }*/
        }
        void close_list_elem() {}

        virtual void close_tag() {
            state = quic_s_supported_version;
        }

        ~quic_ser_vn(){}
    };

>>>

<<< init

    //transport_error_name_map(transport_error_codes,transport_error_codes_map);

>>>