Commit ab4fc7b4 authored by Yann Garcia's avatar Yann Garcia
Browse files

Revert "Create TITAN architecture" 

This reverts commit f7426fc7
parent c41dfa8e

Makefile

deleted100644 → 0
+0 −129
Original line number Diff line number Diff line 
-include config.mk



ifeq (,$(ATS))

 $(error ATS shall be defined)

endif



ifeq (,$(TOPDIR))

 TOPDIR := .

endif



ifeq (,$(TTCN3_DIR))

 $(error TTCN3_DIR shall be defined in config.mk)

endif



first: all



define IncludeModule

undefine sources

undefine modules

undefine includes

include $(1)/module.mk

$$(foreach S, $$(sources),  $$(eval all_sources +=  $$(if $$(filter /%, $$(S)), $$(TOPDIR)$$(S), $(1)/$$(S))))

$$(foreach I, $$(includes), $$(eval all_includes += $$(if $$(filter /%, $$(I)), $$(TOPDIR)$$(I), $(1)/$$(I))))

$$(foreach M, $$(modules),  $$(eval $$(call IncludeModule, $$(if $$(filter /%, $$(M)), $$(TOPDIR)$$(M), $(1)/$$(M)))))

endef



all_includes := $(TTCN3_DIR)/include $(TTCN3_DIR)/src /usr/include/jsoncpp /usr/include/libxml2

defines  += TITAN_RUNTIME_2 _NO_SOFTLINKS_ $(ATS) AS_USE_SSL _GNU_SOURCE

libs     += $(TTCN3_DIR)/lib/libttcn3-rt2-parallel.a -lstdc++fs



ifeq (Windows_NT,$(OS))

# Silence linker warnings.

LDFLAGS += -Wl,--enable-auto-import,--enable-runtime-pseudo-reloc

defines += WIN32

libs += $(patsubst %, -L%/lib, $(OPENSSL_DIR))

all_includes += $(addsuffix /include, $(OPENSSL_DIR))

libs += $(WPCAP_DLL_PATH)

else

defines += LINUX

libs += -lpcap -lrt -lpthread

endif



libs += -lssl -lcrypto -lxml2 -ljsoncpp



$(eval $(call IncludeModule, $(TOPDIR)/ttcn/$(ATS)))



outdir := $(TOPDIR)/build/$(ATS)

bindir := $(TOPDIR)/bin



sources     := $(all_sources)

includes    := $(outdir) $(outdir)/.. $(all_includes) $(NPCAP_INCLUDE)



ifeq (Windows_NT,$(OS))

  EXE=.exe

endif



ttcn_sources  := $(filter %.ttcn , $(sources))

ttcn3_sources := $(filter %.ttcn3, $(sources))



tt_sources    := $(ttcn_sources) $(ttcn3_sources)

cc_sources    := $(filter %.cc,    $(sources))



gen_ttcn_sources  := $(addprefix $(outdir)/, $(notdir $(patsubst %.ttcn,  %.cc, $(ttcn_sources))))

gen_ttcn_headers  := $(addprefix $(outdir)/, $(notdir $(patsubst %.ttcn,  %.hh, $(ttcn_sources))))

gen_ttcn3_sources := $(addprefix $(outdir)/, $(notdir $(patsubst %.ttcn3, %.cc, $(ttcn3_sources))))

gen_ttcn3_headers := $(addprefix $(outdir)/, $(notdir $(patsubst %.ttcn3, %.hh, $(ttcn3_sources))))



gen_sources := $(gen_ttcn_sources) $(gen_ttcn3_sources)

gen_headers := $(gen_ttcn_headers) $(gen_ttcn3_headers)



gen_objects := $(patsubst %.cc, %.o, $(gen_sources))

cc_objects  := $(patsubst  %.cc, $(outdir)/%.o, $(cc_sources))



.PHONY: all FORCE echo



all: $(bindir) $(outdir) $(bindir)/$(ATS)$(EXE)



echo_sources:

	@echo -e "$(addsuffix \n,$(all_sources))"



echo: echo_sources

	@echo -e "sources:\n $(addsuffix \n, $(sources))"

	@echo -e "gen_sources:\n $(addsuffix \n, $(gen_sources))"

	@echo -e "gen_objects:\n $(addsuffix \n, $(gen_objects))"

	@echo -e "cc_objects:\n $(addsuffix \n, $(cc_objects))"

	@echo -e "includes:\n $(addsuffix \n, $(includes))"

	@echo -e "defines: $(addsuffix \n, $(defines))"



clean:

	rm -f $(outdir)/$(ATS)$(EXE) $(gen_objects) $(gen_sources) $(gen_headers) $(cc_objects) $(outdir)/.generate



regen: force_regen $(outdir)/.generate

force_regen:

	rm -f $(outdir)/.generate



t3q: all

	@echo -e "Code checking in progress..."

	@java -Xmx3g -Xss512m -jar $(T3Q_PATH)/t3q.jar --config $(T3Q_PATH)/$(T3Q_CONFIG) $(tt_sources) > $(outdir)/t3q.out 2>&1 ; cd -

	@echo -e "Code checking in done..."

	@echo -e "Output file is located here: $(outdir)/t3q.out"



t3d: all

	@echo -e "TTCN-3 doc generation in progress..."

	@java -Xmx3g -Xss512m -jar $(T3D_PATH)/t3d.jar --config $(T3D_PATH)/$(T3D_CONFIG) $(tt_sources) > $(outdir)/t3d.out 2>&1 ; cd -

	@echo -e "TTCN-3 doc generation done..."

	@echo -e "Output file is located here: $(outdir)/t3d.out"



$(bindir)/$(ATS)$(EXE): $(gen_objects) $(cc_objects) 

	g++ -g -O0 -std=c++17 -o $@ $(LDFLAGS) $(gen_objects) $(cc_objects) $(libs)



$(gen_objects) :%.o :%.cc

	g++ -g -O0 -std=c++17 -c $(addprefix -D, $(defines)) $(addprefix -I, $(includes)) -o $@ $<



$(cc_objects) : $(outdir)/%.o : %.cc

	mkdir -p $(dir $@)

	g++ -g -O0 -std=c++17 -c $(addprefix -D, $(defines)) $(addprefix -I, $(includes)) -o $@ $<



#$(gen_sources):

#	$(TTCN3_DIR)/bin/compiler -n -e -L -R -U none -o $(outdir) $(tt_sources)



$(gen_sources): $(outdir)/.generate



$(outdir)/.generate: Makefile $(tt_sources)

	$(TTCN3_DIR)/bin/compiler $(TTCN3_COMPILER_OPTIONS) -o  $(outdir) $(tt_sources)

	touch $@



$(foreach S, $(ttcn_sources),  $(eval $(outdir)/$(notdir $(patsubst %.ttcn, %.cc,  $(S))): $(S)))

$(foreach S, $(ttcn3_sources), $(eval $(outdir)/$(notdir $(patsubst %.ttcn3, %.cc, $(S))): $(S)))

TTF_T010_emergency_iop.code-workspace

deleted100644 → 0
+0 −8
Original line number Diff line number Diff line 
{

	"folders": [

		{

			"path": "."

		}

	],

	"settings": {}

}
 
 No newline at end of file

ccsrc/EncDec/LibSip/LibSip_Encdec.cc

deleted100644 → 0
+0 −372
Original line number Diff line number Diff line 


#include "LibSip_EncdecDeclarations.hh"

#include "LibSip_XMLTypes.hh"



#include "sip_codec_register_request.hh"

#include "sip_codec_invite_request.hh"

#include "sip_codec_options_request.hh"

#include "sip_codec_bye_request.hh"

#include "sip_codec_ack_request.hh"

#include "sip_codec_subscribe_request.hh"

#include "sip_codec_notify_request.hh"

#include "sip_codec_info_request.hh"

#include "sip_codec_message_request.hh"

#include "sip_codec_message_body.hh"

#include "sip_codec_response.hh"



#include "loggers.hh"



namespace LibSip__EncdecDeclarations {



  BITSTRING fx__enc__Request(const LibSip__SIPTypesAndValues::Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__Request: ", p);



    float duration;

    std::string tag("fx__enc__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__Request -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);

    

    return oct2bit(os);

  }

  

  BITSTRING fx__enc__REGISTER__Request(const LibSip__SIPTypesAndValues::REGISTER__Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__REGISTER__Request: ", p);



    float duration;

    std::string tag("fx__enc__REGISTER__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_register_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__REGISTER__Request: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);

    

    return oct2bit(os);

  }

  

  BITSTRING fx__enc__INVITE__Request(const LibSip__SIPTypesAndValues::INVITE__Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__INVITE__Request: ", p);



    float duration;

    std::string tag("fx__enc__INVITE__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_invite_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__INVITE__Request: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);

    

    return oct2bit(os);

  }

  

  BITSTRING fx__enc__OPTIONS__Request(const LibSip__SIPTypesAndValues::OPTIONS__Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__OPTIONS__Request: ", p);



    float duration;

    std::string tag("fx__enc__OPTIONS__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_options_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__OPTIONS__Request: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);

    

    return oct2bit(os);

  }



  BITSTRING fx__enc__BYE__Request(const LibSip__SIPTypesAndValues::BYE__Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__BYE__Request: ", p);



    float duration;

    std::string tag("fx__enc__BYE__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_bye_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__BYE__Request: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);



    return oct2bit(os);

  }



  BITSTRING fx__enc__ACK__Request(const LibSip__SIPTypesAndValues::ACK__Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__ACK__Request: ", p);



    float duration;

    std::string tag("fx__enc__ACK__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_ack_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__ACK__Request: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);



    return oct2bit(os);

  }



  BITSTRING fx__enc__CANCEL__Request(const LibSip__SIPTypesAndValues::CANCEL__Request& p) { return BITSTRING(); }

  BITSTRING fx__enc__PRACK__Request(const LibSip__SIPTypesAndValues::PRACK__Request& p) { return BITSTRING(); }

  BITSTRING fx__enc__NOTIFY__Request(const LibSip__SIPTypesAndValues::NOTIFY__Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__NOTIFY__Request: ", p);



    float duration;

    std::string tag("fx__enc__NOTIFY__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_notify_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__NOTIFY__Request: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);



    return oct2bit(os);

  }



  BITSTRING fx__enc__SUBSCRIBE__Request(const LibSip__SIPTypesAndValues::SUBSCRIBE__Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__SUBSCRIBE__Request: ", p);



    float duration;

    std::string tag("fx__enc__SUBSCRIBE__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_subscribe_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__SUBSCRIBE__Request: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);



    return oct2bit(os);

  }



  BITSTRING fx__enc__MESSAGE__Request(const LibSip__SIPTypesAndValues::MESSAGE__Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__MESSAGE__Request: ", p);



    float duration;

    std::string tag("fx__enc__MESSAGE__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_message_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__MESSAGE__Request: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);



    return oct2bit(os);

  }



  BITSTRING fx__enc__PUBLISH__Request(const LibSip__SIPTypesAndValues::PUBLISH__Request& p) { return BITSTRING(); }

  BITSTRING fx__enc__UPDATE__Request(const LibSip__SIPTypesAndValues::UPDATE__Request& p) { return BITSTRING(); }

  BITSTRING fx__enc__REFER__Request(const LibSip__SIPTypesAndValues::REFER__Request& p) { return BITSTRING(); }

  BITSTRING fx__enc__INFO__Request(const LibSip__SIPTypesAndValues::INFO__Request& p) {

    loggers::get_instance().log_msg(">>> fx__enc__INFO__Request: ", p);



    float duration;

    std::string tag("fx__enc__INFO__Request");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_info_request codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__INFO__Request: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);



    return oct2bit(os);

  }



  

  BITSTRING fx__enc__Response(const LibSip__SIPTypesAndValues::Response& p) {

    loggers::get_instance().log_msg(">>> fx__enc__Response: ", p);



    float duration;

    std::string tag("fx__enc__Response");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_response codec;

    if (codec.encode(p, os) == -1) {

      loggers::get_instance().warning("fx__enc__Response: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);

    

    return oct2bit(os);

  }

  

  BITSTRING fx__enc__Raw(const CHARSTRING& p) { return BITSTRING(); }

  BITSTRING fx__enc__SMS(const LibSip__SimpleMsgSummaryTypes::SimpleMsgSummary& pdu) { return BITSTRING(); }



  BITSTRING fx__enc__MessageBody(const LibSip__MessageBodyTypes::MessageBody& pdu) {

    loggers::get_instance().log_msg(">>> fx__enc__MessageBody: ", pdu);



    float duration;

    std::string tag("fx__enc__MessageBody");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_message_body codec;

    if (codec.encode(pdu, os) == -1) {

      loggers::get_instance().warning("fx__enc__MessageBody: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);



    return oct2bit(os);

  }

  

  INTEGER fx__dec__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__REGISTER__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::REGISTER__Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__REGISTER__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_register_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__INVITE__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::INVITE__Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__INVITE__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_invite_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__OPTIONS__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::OPTIONS__Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__OPTIONS__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_options_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__BYE__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::BYE__Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__BYE__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_bye_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__ACK__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::ACK__Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__ACK__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_ack_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__CANCEL__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::CANCEL__Request& p) { return INTEGER(0); }

  INTEGER fx__dec__PRACK__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::PRACK__Request& p) { return INTEGER(0); }

  INTEGER fx__dec__NOTIFY__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::NOTIFY__Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__NOTIFY__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_notify_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__SUBSCRIBE__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::SUBSCRIBE__Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__SUBSCRIBE__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_subscribe_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__MESSAGE__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::MESSAGE__Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__MESSAGE__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_message_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__PUBLISH__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::PUBLISH__Request& p) { return INTEGER(0); }

  INTEGER fx__dec__UPDATE__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::UPDATE__Request& p) { return INTEGER(0); }

  INTEGER fx__dec__REFER__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::REFER__Request& p) { return INTEGER(0); }

  INTEGER fx__dec__INFO__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::INFO__Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__INFO__Request: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_info_request codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__Response(BITSTRING& pdu, LibSip__SIPTypesAndValues::Response& p) {

    loggers::get_instance().log_msg(">>> fx__dec__Response: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_response codec;

    codec.decode(os, p);



    return 0;

  }



  INTEGER fx__dec__SMS(BITSTRING& pdu, LibSip__SimpleMsgSummaryTypes::SimpleMsgSummary& p) { return INTEGER(0); }



  INTEGER fx__dec__MessageBody(BITSTRING& pdu, LibSip__MessageBodyTypes::MessageBody& p) {

    loggers::get_instance().log_msg(">>> fx__dec__MessageBody: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_message_body codec;

    codec.decode(os, p);



    return 0;

  }

} // End of namespace LibSip__EncdecDeclarations

ccsrc/EncDec/LibSip/LibSip_SMSFunctions_Encdec.cc

deleted100644 → 0
+0 −9
Original line number Diff line number Diff line 
#include "LibSip_SMSFunctions.hh"



#include "loggers.hh"



namespace LibSip__SMSFunctions {



  HEXSTRING fx__GetSC__TimeStamp(const INTEGER& p__TimeZone) { return int2hex(0, 14); };



} // End of namespace LibSip__SMSFunctions

ccsrc/EncDec/LibSip/LibSip_Steps_Encdec.cc

deleted100644 → 0
+0 −109
Original line number Diff line number Diff line 
#include <algorithm>

#include <string>

#include <regex>



#include <openssl/md5.h>



#include "LibSip_Steps.hh"



#include "loggers.hh"



#include "converter.hh"



namespace LibSip__Steps {



  int calculate_md5(const std::string& p_data, std::string& p_md5)

  {

    loggers::get_instance().log(">>> calculate_md5: %s", p_data.c_str());



    MD5_CTX md5_context;

    ::MD5_Init(&md5_context);

    

    loggers::get_instance().log("calculate_md5: length=%d", p_data.length());

    ::MD5_Update(&md5_context, p_data.c_str(), p_data.length()); // TODO Add support of block size > 512

    

    const size_t digestlen = 16;

    unsigned char digest[digestlen];

    ::MD5_Final(digest, &md5_context);

    p_md5 = converter::get_instance().bytes_to_hexa(std::vector<unsigned char>(digest, digest + digestlen));

    

    loggers::get_instance().log("<<< calculate_md5: %s", p_md5.c_str());

    return 0;

  }

  

  CHARSTRING fx__rndStr() {

    static const char alphanum[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

    static int length = 10;

    char s[length] = { 0 };

    for (int i = 0; i < length - 1; ++i) {

      s[i] = alphanum[rand() % (sizeof(alphanum) - 1)];

    } // End of 'for' statement

    return CHARSTRING(s);

  };



  CHARSTRING fx__putInLowercase(const CHARSTRING& p__string) {

    std::string s(static_cast<const char*>(p__string));

    std::transform(s.begin(), s.end(), s.begin(), ::tolower);

    return CHARSTRING(s.c_str());

  };

  

  CHARSTRING fx__getIpAddr(const CHARSTRING& p__host__name) { return CHARSTRING(""); };

  

  CHARSTRING fx__calculateDigestResponse(const CHARSTRING& p__nonce, const CHARSTRING& p__cnonce, const CHARSTRING& p__user, const CHARSTRING& p__realm, const CHARSTRING& p__passwd, const CHARSTRING& p__alg, const CHARSTRING& p__nonceCount, const CHARSTRING& p__method, const CHARSTRING& p__qop, const CHARSTRING& p__URI, const CHARSTRING& p__HEntity) {

    loggers::get_instance().log(">>> fx__calculateDigestResponse");



    // Buid a1=USERNAME:REALM:PASSWORD

    std::string a1(static_cast<const char*>(p__user));

    a1 += ":";

    a1 += static_cast<const char*>(p__realm);

    a1 += ":";

    a1 += static_cast<const char*>(p__passwd);

    if (a1.find("\"") != std::string::npos) {

      a1 = std::regex_replace(a1, std::regex("\""), "");

    }

    loggers::get_instance().log("fx__calculateDigestResponse: a1='%s'", a1.c_str());

    std::string md5_a1;

    calculate_md5(a1, md5_a1);

    

    // Buid a2=METHOD:DIGESTURI

    std::string a2(static_cast<const char*>(p__method));

    a2 += ":";

    a2 += static_cast<const char*>(p__URI);

    if (a2.find("\"") != std::string::npos) {

      a2 = std::regex_replace(a2, std::regex("\""), ""); // TODO Move to converter

    }

    loggers::get_instance().log("fx__calculateDigestResponse: a2='%s'", a2.c_str());

    std::string md5_a2;

    calculate_md5(a2, md5_a2);

    

    // Buid resp=HA1:NONCE:HA2

    std::string resp(md5_a1);

    resp += ":";

    resp += static_cast<const char*>(p__nonce);

    resp += ":";

    resp += md5_a2;

    loggers::get_instance().log("fx__calculateDigestResponse: resp='%s'", resp.c_str());

    std::string md5_resp;

    calculate_md5(resp, md5_resp);



    // Convert into Base64

    std::vector<unsigned char> u = converter::get_instance().string_to_bytes(md5_resp);

    md5_resp = converter::get_instance().bytes_to_string(converter::get_instance().buffer_to_base64(u));

    

    loggers::get_instance().log("<<< fx__calculateDigestResponse: '%s'", md5_resp.c_str());

    return CHARSTRING(md5_resp.c_str());

  };

  

  CHARSTRING fx__encodeBase64(const CHARSTRING& p__value) {

    std::vector<unsigned char> s(static_cast<const char*>(p__value), static_cast<const char*>(p__value) + p__value.lengthof());

    std::vector<unsigned char> o = converter::get_instance().buffer_to_base64(s);

    return CHARSTRING(o.size(), (const char*)o.data());

  };

  

  CHARSTRING fx__decodeBase64(const CHARSTRING& p__value) {

    std::vector<unsigned char> s(static_cast<const char*>(p__value), static_cast<const char*>(p__value) + p__value.lengthof());

    std::vector<unsigned char> o = converter::get_instance().base64_to_buffer(s);

    return CHARSTRING(o.size(), (const char*)o.data());

  };

  

} // End of namespace LibSip__Steps