mpitems.cxx

一个SIP协议栈

        std::string::size_type start = 0; 
        std::mstring user;
        std::mstring ts;

        //user:passwd
        start = toktrim(str, &user, 0, ";");

        //isub and postd
        start = toktrim(str, &ts, start, ";");
        if(ts.comparei("isub=", 5) == 0) mp_ISub = &(ts[5]);
        if(ts.comparei("postd=", 6) == 0) mp_PostD = &(ts[6]);

        start = toktrim(str, &ts, start, ";");
        if(ts.comparei("isub=", 5) == 0) mp_ISub = &(ts[5]);
        if(ts.comparei("postd=", 6) == 0) mp_PostD = &(ts[6]);

        //user
        start = toktrim(user, &mp_User, 0, ":");

        //password
        start = toktrim(user, &mp_Passwd, start, ":");
        if(chk_syntax_flag) checkSyntax();
    }


    //---------------------------------------------------------------------------------------
    void MpUserInfo::checkSyntax() const
    {
        ValAssistant::check(mpiUserInfo, mpnUser,   mp_User);
        ValAssistant::check(mpiUserInfo, mpnPasswd, mp_Passwd);
        ValAssistant::check(mpiUserInfo, mpnISub,   mp_ISub);
        ValAssistant::check(mpiUserInfo, mpnPostD,  mp_PostD);
    }


    //---------------------------------------------------------------------------------------
    void MpUserInfo::erase()
    {
        mp_User = "";
        mp_Passwd = "";
        mp_ISub = "";
        mp_PostD = "";
    }


    //---------------------------------------------------------------------------------------
    MpParseItem & MpUserInfo::operator [] (const char * name)
    {
        throw MpAccessError("MpUserInfo: No nested items");
    }


    //---------------------------------------------------------------------------------------
    std::mstring & MpUserInfo::val(const char * name)
    {
        if(strcmp(name, mpnUser) == 0)   return mp_User;
        if(strcmp(name, mpnPasswd) == 0) return mp_Passwd;
        if(strcmp(name, mpnISub) == 0)   return mp_ISub;
        if(strcmp(name, mpnPostD) == 0)  return mp_PostD;
        throw MpAccessError(std::mstring("MpUserInfo: Illegal Parameter: ") + name);
    }


    
    //---------------------------------------------------------------------------------------
    void MpUserInfo::get(unsigned i, std::mstring *name, std::mstring *value) const
    {
        switch(i)
        {
            case 0: if(name) *name = mpnUser;   if(value) *value = mp_User;   return;
            case 1: if(name) *name = mpnPasswd; if(value) *value = mp_Passwd; return;
            case 2: if(name) *name = mpnISub;   if(value) *value = mp_ISub;   return;
            case 3: if(name) *name = mpnPostD;  if(value) *value = mp_PostD;  return;
        }
        throw MpAccessError("MpUserInfo: Out of index");
    }



    
    //=======================================================================================
    //MpParm Implementation

    //---------------------------------------------------------------------------------------
    std::mstring MpParm::encode(bool chk_syntax_flag) const
    {
        if(!empty())
        {
            if(chk_syntax_flag) checkSyntax();
            return mp_Array.encode();
        }
        return std::mstring("");
    }

    //---------------------------------------------------------------------------------------
    void MpParm::decode(const std::mstring & str, bool chk_syntax_flag)
    {
        mp_Array.decode(str);
        if(chk_syntax_flag) checkSyntax();
    }


    //---------------------------------------------------------------------------------------
    void MpParm::checkSyntax() const
    {
        unsigned i;
        std::mstring parm;
        std::mstring value;
        for(i = 0; i < valCount(); i++)
        {
            get(i, &parm, &value);
            ValAssistant::check(mp_ItemName, parm.c_str(), value);
        }
    }



    //---------------------------------------------------------------------------------------
    void MpParm::erase()
    {
        mp_Array.erase();
    }


    //---------------------------------------------------------------------------------------
    MpParseItem & MpParm::operator [] (const char * name)
    {
        throw MpAccessError("MpParm: No nested items");
    }


    //---------------------------------------------------------------------------------------
    std::mstring & MpParm::val(const char * name)
    {
        return mp_Array[name].val();
    }


    
    //---------------------------------------------------------------------------------------
    void MpParm::get(unsigned i, std::mstring *name, std::mstring *value) const
    {
        if(i >= mp_Array.count()) throw MpAccessError("MpParm: Out of index");
        if(name)  *name  = mp_Array[i].parm();
        if(value) *value = mp_Array[i].val();
    }



    //=======================================================================================
    //MpUrl Implementation


    //---------------------------------------------------------------------------------------
    void MpUrl::set_allowed_prefixes(const char * prefixes)
    { 
        mp_AllowedPrefixes = prefixes; 
        if(prefixes)
        {
            std::mstring ts = prefixes;
            ts.token(&mp_CurPrefix, 0, "|", "", 0);
        }
        else
        {
            mp_CurPrefix = "";
        }
    }

    //---------------------------------------------------------------------------------------
    std::mstring MpUrl::encode(bool chk_syntax_flag) const
    {
        std::mstring ret;
        if(!empty())
        {
            if(!mp_CurPrefix.empty())
            {
                ret += mp_CurPrefix + ':';
            }
            ret += mp_UserInfo.encode(chk_syntax_flag);
            ret += mp_HostPort.encode(chk_syntax_flag);
            ret += mp_Parm.encode(chk_syntax_flag);
            ret += mp_Hdr.encode(chk_syntax_flag);
        }
        return ret;
    }


    //---------------------------------------------------------------------------------------
    void MpUrl::decode(const std::mstring & str, bool chk_syntax_flag)
    {
        std::mstring user_addr_parm;
        std::mstring user_addr;
        std::mstring user;
        std::mstring addr;
        std::mstring parm;
        std::mstring header;
        std::string::size_type start = 0;

        erase();

        mp_CurPrefix = "";
        if(mp_AllowedPrefixes)
        {
            std::string::size_type s = 0;
            std::mstring tmp;
            std::mstring name = mp_AllowedPrefixes;
            bool prefix_allowed = false;

            while((s = name.token(&tmp, s, "|", "", 0)) != std::string::npos)
            {
                tmp += ':';
                unsigned len = tmp.length();
                if(str.comparei(tmp, len) == 0)
                {
                    mp_CurPrefix.assign(str, 0, len - 1);
                    prefix_allowed = true;
                    start = len;
                    break;
                }
            }
            if(!prefix_allowed)
            {
                throw MpSyntaxError(std::string("Invalid URL-Prefix: '") + str + "' Allowed: " + mp_AllowedPrefixes);
            }
        }


        //First part name@addr;params
        start = toktrim(str, &user_addr_parm, start, "?");

        //Second part ?headers
        start = toktrim(str, &header, start, "?");

        //Params part
        start = user_addr_parm.find('@'); 
        if(start == std::string::npos) start = 0;
        start = user_addr_parm.find(';', start);
        if(start != std::string::npos) 
        {
            parm.assign(user_addr_parm, start + 1, std::string::npos);
        }
        //UserInfo and HostPort parts
        user_addr.assign(user_addr_parm, 0, start);

        //UserInfo
        start = toktrim(user_addr, &user, 0, "@");

        //HostPort
        start = toktrim(user_addr, &addr, start, "@");

        //URL can be without user info
        if(addr.empty())
        {
            addr = user;
            user = "";
        }

        mp_UserInfo.decode(user, chk_syntax_flag);
        mp_HostPort.decode(addr, chk_syntax_flag);
        mp_Parm.decode(parm, chk_syntax_flag);
        mp_Hdr.decode(header, chk_syntax_flag);
    }


    //---------------------------------------------------------------------------------------
    void MpUrl::checkSyntax() const
    {
        mp_UserInfo.checkSyntax();
        mp_HostPort.checkSyntax();
        mp_Parm.checkSyntax();
        mp_Hdr.checkSyntax();
    }


    //---------------------------------------------------------------------------------------
    void MpUrl::erase()
    {
        mp_UserInfo.erase();
        mp_HostPort.erase();
        mp_Parm.erase();
        mp_Hdr.erase();
    }


    //---------------------------------------------------------------------------------------
    MpParseItem & MpUrl::operator [] (const char * name)
    {
        if(strcmp(name, mpiHostPort) == 0) return mp_HostPort; 
        if(strcmp(name, mpiUserInfo) == 0) return mp_UserInfo;
        if(strcmp(name, mpiUrlParm)  == 0) return mp_Parm;
        if(strcmp(name, mpiUrlHdr)   == 0) return mp_Hdr;
        throw MpAccessError(std::mstring("MpUrl: Illegal nested name: ") + name);
    }


    //---------------------------------------------------------------------------------------
    const MpParseItem & MpUrl::operator [] (const char * name) const
    {
        if(strcmp(name, mpiHostPort) == 0) return mp_HostPort; 
        if(strcmp(name, mpiUserInfo) == 0) return mp_UserInfo;
        if(strcmp(name, mpiUrlParm)  == 0) return mp_Parm;
        if(strcmp(name, mpiUrlHdr)   == 0) return mp_Hdr;
        throw MpAccessError(std::mstring("MpUrl: Illegal nested name: ") + name);
    }


    //---------------------------------------------------------------------------------------
    std::mstring & MpUrl::val(const char * name)
    {
        throw MpAccessError("MpUrl: No parameters");
    }

    //---------------------------------------------------------------------------------------
    void MpUrl::get(unsigned i, std::mstring *name, std::mstring *value) const
    {
        throw MpAccessError("MpUrl: No parameters");
    }


    //---------------------------------------------------------------------------------------
    MpParseItem & MpUrl::item(unsigned i, std::mstring *name)
    {
        switch(i)
        {
            case 0: if(name) *name = mpiHostPort; return mp_HostPort; 
            case 1: if(name) *name = mpiUserInfo; return mp_UserInfo; 
            case 2: if(name) *name = mpiUrlParm;  return mp_Parm;     
            case 3: if(name) *name = mpiUrlHdr;   return mp_Hdr;      
        }
        throw MpAccessError("MpUrl: Out of item index");
    }



    //=======================================================================================
    //MpStartLine Implementation

    //---------------------------------------------------------------------------------------
    const MpStartLine::MethodString MpStartLine::mp_MethodString[] = 
    {
        { mtreqINVITE,   mtdINVITE },
        { mtreqOPTIONS,  mtdOPTIONS },
        { mtreqREGISTER, mtdREGISTER },
        { mtreqACK,      mtdACK },
        { mtreqCANCEL,   mtdCANCEL },
        { mtreqBYE,      mtdBYE },
        { mtreqSIGNAL,   mtdSIGNAL },
        { mtreqUNKNOWN,  0 }
    };


    //---------------------------------------------------------------------------------------
    const MpStartLine::ReasonText MpStartLine::mp_ReasonText[] = 
    {
        { respTrying,                            "Trying" },
        { respRinging,                           "Ringing" },
        { respCallIsBeingForwarded,              "Call Is Being Forwarded" },
        { respQueued,                            "Queued" },
        { respOK,                                "OK" },
        { respMultipleChoices,                   "Multiple Choices" },
        { respMovedPermanently,                  "Moved Permanently" },
        { respMovedTemporarily,                  "Moved Temporarily" },
        { respSeeOther,                          "See Other" },
        { respUseProxy,                          "Use Proxy" },
        { respAlternativeService,                "Alternative Service" },
        { respBadRequest,                        "Bad Request" },
        { respUnauthorized,                      "Unauthorized" },
        { respPaymentRequired,                   "Payment Required" },
        { respForbidden,                         "Forbidden" },
        { respNotFound,                          "Not Found" },
        { respMethodNotAllowed,                  "Method Not Allowed" },
        { respNotAcceptable,                     "Not Acceptable" },
        { respProxyAuthenticationRequired,       "Proxy Authentication Required" },
        { respRequestTimeout,                    "Request Timeout" },
        { respConflict,                          "Conflict" },
        { respGone,                              "Gone" },
        { respLengthRequired,                    "Length Required" },
        { respRequestEntityTooLarge,             "Request Entity Too Large" },
        { respRequestURITooLarge,                "Request-URI Too Large" },
        { respUnsupportedMediaType,              "Unsupported Media Type" },
        { respBadExtension,                      "Bad Extension" },
        { respTemporarilyNotAvailable,           "Temporarily not available" },
        { respCallLegOrTransactionDoesNotExist,  "Call Leg/Transaction Does Not Exist" },
        { respLoopDetected,                      "Loop Detected" },
        { respTooManyHops,                       "Too Many Hops" },
        { respAddressIncomplete,                 "Address Incomplete" },
        { respAmbiguous,                         "Ambiguous" },
        { respBusyHere,                          "Busy Here" },
        { respInternalServerError,               "Internal Server Error" },
        { respNotImplemented,                    "Not Implemented" },
        { respBadGateway,                        "Bad Gateway" },
        { respServiceUnavailable,                "Service Unavailable" },
        { respGatewayTimeout,                    "Gateway Time-out" },
        { respSIPVersionNotSupported,            "SIP Version not supported" },
        { respBusyEverywhere,                    "Busy Everywhere" },
        { respDecline,                           "Decline" },
        { respDoesNotExistAnywhere,              "Does not exist anywhere" },
        { respNotAcceptable,                     "Not Acceptable" },
        { respNullCode,  0 }
    };