sipparser.cxx

一个SIP协议栈

        str->erase();

        if(!empty())
        {
            HdrArray::const_iterator it;
            mp_StartLine.dump(str);

            for(it = mp_HdrArray.begin(); it != mp_HdrArray.end(); ++it)
            {
                if(*it)
                {
                    (*it)->dump(str);
                }
            }
        }
    }


    //---------------------------------------------------------------------------------------
    //Divide a string into two pieces: hdr_name and hdr_content
    static void div_line(const std::mstring &line, std::mstring *hdr_name, std::mstring *hdr_content)
    {
        hdr_name->erase();
        hdr_content->erase();

        std::string::size_type posn = line.find(':');
        if(posn != std::string::npos)
        {
            hdr_name->assign(line, 0, posn);
            ++posn;
            std::string::size_type posc = line.find_first_not_of(" \t", posn);
            if(posc == std::string::npos) posc = posn;
            hdr_content->assign(line, posc, std::string::npos);
        }   
    }



    //---------------------------------------------------------------------------------------
    void 
    MsgParser::decodeContent(const std::mstring &content)
    {
        if(header(hdrnContentType).val(mpnSubVal).comparei("multipart") != 0)
        {
            contentType(0).decode(header(hdrnContentType).encode(false), false);
            setContent(content, 0);
        }
        else
        {
            std::string::size_type start = 0;
            std::mstring tmp;
            unsigned count = 0;
            int status = 0;

            while((start = content.token(&tmp, start, mp_Separator, "", 0, std::mstring::sep_single)) != string::npos)
            {
                tmp.atrim();
                if(tmp.empty()) continue;

                std::mstring hdr_name;
                std::mstring hdr_content;

                div_line(tmp, &hdr_name, &hdr_content);
                if(!hdr_name.empty() && !hdr_content.empty())
                {
                    if(MpHeader::isHeader(hdr_name, hdrnContentType))
                    {
                        if(status != 0)
                        {
                            throw MpSyntaxError("MsgParser: Unexpected 'ContentType' in multiple payload");
                        }
                        contentType(count).decode(hdr_content);
                        ++count;
                        status = 1; 
                        continue;
                    }

                    if(MpHeader::isHeader(hdr_name, hdrnContentLength))
                    {
                        if(status != 1)
                        {
                            throw MpSyntaxError("MsgParser: Unexpected 'ContentLength' in multiple payload");
                        }

                        unsigned len = atoi(hdr_content.c_str());
                        std::mstring part;
                        part.assign(content, start, len);
                        setContent(part, count-1);
                        start += len;
                        status = 0;
                    }
                }
            }
        }
    }






    //---------------------------------------------------------------------------------------
    void MsgParser::decode(const std::mstring & str, std::string::size_type len, bool chk_syntax_flag)
    {
        erase();

        setLineSep(detectLineSep(str));
        std::string::size_type cont_len = atoi(findHeader(str, hdrnContentLength, mp_Separator).c_str());

        std::string::size_type start = 0;
        std::mstring line;
        std::mstring hdr_name;
        std::mstring hdr_content;
        std::mstring hdr_token;
        bool start_line_parsed = false;

        for(;;)
        {
            start = str.token(&line, start, mp_Separator, QuoteSymb, QPairSymb, 
                              std::mstring::sep_whole_str);

            if(start == std::string::npos) break;

            line.atrim();
            if(!line.empty())
            {
                if(!start_line_parsed)
                {
                    mp_StartLine.decode(line, chk_syntax_flag);
                    start_line_parsed = true;
                }
                else
                {
                    div_line(line, &hdr_name, &hdr_content);

                    if(!hdr_name.empty() && !hdr_content.empty())
                    {
                        MpHeader * p_hdr = &insertHeader(hdr_name.c_str(), 32767);

                        if(p_hdr->is_multiple_hdr())
                        {
                            std::string::size_type strt_hdr = 0;
                            unsigned index = 0;
                            while((strt_hdr = hdr_content.token(&hdr_token, strt_hdr, ",", 
                                                               QuoteSymb, QPairSymb, 
                                                               std::mstring::sep_multiple)) != 
                                                               std::string::npos)
                            {
                                hdr_token.atrim();
                                if(index)
                                {
                                    p_hdr = &insertHeader(hdr_name.c_str(), 32767);
                                }
                                p_hdr->decode(hdr_token, chk_syntax_flag);
                                index++;
                            }
                        }
                        else
                        {
                            p_hdr->decode(hdr_content, chk_syntax_flag);
                        }
                    }
                }
            }
            if(start >= len - cont_len) break;
        }


        if(start != std::string::npos)
        {
            if(cont_len)
            {
                std::mstring content;
                content.assign(str, start, cont_len);
                decodeContent(content);
            }
        }

    }






    //---------------------------------------------------------------------------------------
    void 
    MsgParser::encodeContent(std::mstring *content)
    {
        content->erase();

        if(mp_Content.size() > 1)
        {
            header(hdrnContentType).val(mpnValue) = "application";
            header(hdrnContentType).val(mpnSubVal) = "multipart";
            ContentArray::iterator it;
            MpContentLength len;
            for(it = mp_Content.begin(); it != mp_Content.end(); ++it)
            {
                it->m_content.rtrims(mp_Separator);
                it->m_content += mp_Separator;
                content->append(it->m_type->encodeHeaderName());
                content->append(it->m_type->encode());
                content->append(mp_Separator);
                len.val(mpnValue) = it->m_content.length();
                content->append(len.encodeHeaderName());
                content->append(len.encode());
                content->append(mp_Separator);
                content->append(it->m_content);
                content->append(mp_Separator);
            }
        }
        else
        {
            if(mp_Content.size() == 1)
            {
                mp_Content[0].m_content.rtrims(mp_Separator);
                mp_Content[0].m_content += mp_Separator;
                (*content) = mp_Content[0].m_content;
                header(hdrnContentType).decode(mp_Content[0].m_type->encode());
            }
        }
        header(hdrnContentLength).val(mpnValue) = content->length();
    }



    //---------------------------------------------------------------------------------------
    std::mstring MsgParser::encode(bool chk_syntax_flag)
    {
        std::mstring ret;

        if(!empty())
        {
            std::mstring content;
            encodeContent(&content);

            HdrArray built; 
            HdrArray::const_iterator it;
            HdrArray::iterator b_it;
            ret = mp_StartLine.encode(chk_syntax_flag) + mp_Separator;

            for(it = mp_HdrArray.begin(); it != mp_HdrArray.end(); ++it)
            {
                MpHeader * p_hdr = *it;
                if(p_hdr == 0)
                {
                    throw MpAccessError(null_pointer_detected);
                }

                if(!p_hdr->empty())
                {
                    bool built_flag = false;
                    for(b_it = built.begin(); b_it != built.end(); ++b_it)
                    {
                        if(p_hdr == *b_it) 
                        {
                            built_flag = true;
                            break;
                        }
                    }

                    if(!built_flag)
                    {
                        built.push_back(p_hdr);
                        if(p_hdr->uniteDesired())
                        {
                            ret += p_hdr->encodeHeaderName();
                            std::mstring name = p_hdr->getHeaderName();
                            unsigned n = count(name.c_str());
                            unsigned i;
                            for(i = 0; i < n; i++)
                            {
                                p_hdr = &header(name.c_str(), i);
                                ret += p_hdr->encode(chk_syntax_flag);
                                if(i != n - 1) ret += ", ";
                                built.push_back(p_hdr);
                            }
                            ret += mp_Separator;
                        }
                        else
                        {
                            ret += p_hdr->encodeHeaderName() + 
                                   p_hdr->encode(chk_syntax_flag) + 
                                   mp_Separator;
                        }
                    }
                }
            }

            ret += mp_Separator;
            ret += content;
        }

        return ret;
    }


    //---------------------------------------------------------------------------------------
    void MsgParser::checkSyntax()
    {
        mp_StartLine.checkSyntax();

        HdrArray::iterator it = mp_HdrArray.begin();
        for(; it != mp_HdrArray.end(); ++it)
        {
            MpHeader * p_hdr = *it;
            if(p_hdr == 0)
            {
                throw MpAccessError(null_pointer_detected);
            }
            p_hdr->checkSyntax();
        }
    }



    //---------------------------------------------------------------------------------------
    MpContentType & 
    MsgParser::contentType(unsigned index)
    {
        Content cont;
        while(mp_Content.size() <= index)
        {
            cont.m_type = new MpContentType;
            mp_Content.push_back(cont);
        }
        return *(mp_Content[index].m_type);
    }

    //---------------------------------------------------------------------------------------
    const MpContentType & 
    MsgParser::contentType(unsigned index) const
    {
        if(index < mp_Content.size()) return *(mp_Content[index].m_type);
        throw MpAccessError("MsgParser: Out of content index");
    }


    //---------------------------------------------------------------------------------------
    const std::mstring & 
    MsgParser::getContent(unsigned index) const
    {
        if(index < mp_Content.size()) return mp_Content[index].m_content;
        throw MpAccessError("MsgParser: Out of content index");
    }


    //---------------------------------------------------------------------------------------
    void 
    MsgParser::setContent(const std::string & content, unsigned index)
    {
        Content cont;
        while(mp_Content.size() <= index)
        {
            cont.m_type = new MpContentType;
            mp_Content.push_back(cont);
        }
        mp_Content[index].m_content = content;
    }


    //---------------------------------------------------------------------------------------
    void 
    MsgParser::removeContent(unsigned index)
    {
        if(index < mp_Content.size()) 
        {
            if(mp_Content[index].m_type) delete mp_Content[index].m_type;
            mp_Content.erase(ContentArray::iterator(mp_Content.begin() + index));
        }
    }


}