Assumes the input is an RFC-3261 SIP "Date" header value, parses it accordingly and returns the equivalent UNIX timestamp.

@]

{s.date2unix} 🔗

Assumes the input is an RFC-1123 SIP "Date" header value, parses it accordingly and returns the equivalent UNIX timestamp.

[@ $var(date) = "Thu, 13 Jun 2024 12:48:00 GMT"; $(var(date){s.date2unix}) => "1718282880";

Each transformation supports an optional 'index'. This can be used when passing a list of nameaddr specs, and represents the spec index that should be considered when extracting the value. Indexes start with 0 (the default value when missing), and can accept negative values (-1 represents the last nameaddr spec).

Example:

'"first" <first@opensips.org>, "second" <second@opensips.org>' {nameaddr.0.name} = "first"
'"first" <first@opensips.org>, "second" <second@opensips.org>' {nameaddr.1.name} = "second"
'"first" <first@opensips.org>, "second" <second@opensips.org>' {nameaddr.-1.name} = "second"

{s.sha1} 🔗

Returns the SHA1 hash of the given input.

xlog("SHA1 over From username: $(fU{s.sha1})\n");

{s.sha224} 🔗

Returns the SHA224 hash of the given input.

xlog("SHA224 over From username: $(fU{s.sha224})\n");

{s.sha256} 🔗

Returns the SHA256 hash of the given input.

xlog("SHA256 over From username: $(fU{s.sha256})\n");

{s.sha384} 🔗

Returns the SHA384 hash of the given input.

xlog("SHA384 over From username: $(fU{s.sha384})\n");

{s.sha512} 🔗

Returns the SHA512 hash of the given input.

xlog("SHA512 over From username: $(fU{s.sha512})\n");

{s.sha1_hmac,key} 🔗

Returns the SHA1 HMAC hash of the given input using key.

xlog("SHA1 HMAC over From username using key 'secret': $(fU{s.sha1_hmac,secret})\n");

{s.sha224_hmac,key} 🔗

Returns the SHA224 HMAC hash of the given input using key.

xlog("SHA224 HMAC over From username using key 'secret': $(fU{s.sha224_hmac,secret})\n");

{s.sha256_hmac,key} 🔗

Returns the SHA256 HMAC hash of the given input using key.

xlog("SHA256 HMAC over From username using key 'secret': $(fU{s.sha256_hmac,secret})\n");

{s.sha384_hmac,key} 🔗

Returns the SHA384 HMAC hash of the given input using key.

xlog("SHA384 HMAC over From username using key 'secret': $(fU{s.sha384_hmac,secret})\n");

{s.sha512_hmac,key} 🔗

Returns the SHA512 HMAC hash of the given input using key.

xlog("SHA512 HMAC over From username using key 'secret': $(fU{s.sha512_hmac,secret})\n");

Return the substring starting at offset having size of length. If offset is negative, then it is counted from the end of the value, -1 being the last char. In case of a positive value, 0 is the first char. The length must be positive and in case of both 0 and greater-than-string-length values, the substring to the end of the input string is returned. Both offset and length may be specified using variables.

Return the substring starting at offset having size of length. If offset is negative, then it is counted from the end of the value, -1 being the last char. In case of a positive value, 0 is the first char. The length must be positive and in case of both 0 and greater-than-string-length values, the substring to the end of the input string is returned. Both offset and length may be specified using variables.

@]

{s.eval} 🔗

Interprets the string as a variable formatted string, evaluating all the variables declared in it.

[@ $var(in) = "client"; $var(format) = "Hello, $var(in)!"; $(var(format){s.eval}) => "Hello, client!"

Intuitively, a Transformation is a function that is applied to a variable(script variable, pseudo-variable, AVP, static string) to get a special value from it. The input value is not altered.

Examples of using different kinds of variables in OpenSIPS script:

{ip.isip4} 🔗

Returns 1 if the string provided is a valid IPv4, otherwise 0. Example:

"193.668.3.634" {ip.isip4} = 1

{ip.isip6} 🔗

Returns 1 if the string provided is a valid IPv6, otherwise 0. Example:

"193.668.3.634" {ip.isip6} = 0
"2001:0db8:85a3:0000:0000:8a2e:0370:7334" {ip.isip6} = 1

{s.int} 🔗

{s.md5} 🔗

{s.reverse} 🔗

{s.substr,offset,length} 🔗

{s.select,index,separator} 🔗

{s.encode.hexa} 🔗

{s.decode.hexa} 🔗

{s.escape.common} 🔗

{s.unescape.common} 🔗

{s.escape.user} 🔗

{s.unescape.user} 🔗

{s.escape.param} 🔗

{s.unescape.param} 🔗

{s.tolower} 🔗

{s.toupper} 🔗

{s.index} 🔗

{s.rindex} 🔗

{s.fill.left, tok, len} 🔗

{s.fill.right, tok, len} 🔗

{s.width, len} 🔗

{s.trim} 🔗

{s.trimr} 🔗

{s.triml} 🔗

{s.dec2hex} 🔗

{s.hex2dec} 🔗

{s.b64encode} 🔗

{s.b64decode} 🔗

{s.xor,secret} 🔗

{uri.user} 🔗

{uri.host} 🔗

{uri.passwd} 🔗

{uri.port} 🔗

{uri.params} 🔗

{uri.param,name} 🔗

{uri.headers} 🔗

{uri.transport} 🔗

{uri.ttl} 🔗

{uri.uparam} 🔗

{uri.maddr} 🔗

{uri.method} 🔗

{uri.lr} 🔗

{uri.r2} 🔗

{uri.schema} 🔗

{via.name} 🔗

{via.version} 🔗

{via.transport} 🔗

{via.host} 🔗

{via.port} 🔗

{via.comment} 🔗

{via.params} 🔗

{via.param,name} 🔗

{via.branch} 🔗

{via.received} 🔗

{via.rport} 🔗

{param.value,name} 🔗

{param.exist,name} 🔗

{param.valueat,index} 🔗

{param.name,index} 🔗

{param.count} 🔗

{nameaddr.name} 🔗

{nameaddr.uri} 🔗

{nameaddr.len} 🔗

{nameaddr.param,param_name} 🔗

{nameaddr.params} 🔗

{ip.pton} 🔗

{ip.ntop} 🔗

{ip.isip} 🔗

{ip.family} 🔗

{ip.resolve} 🔗

{ip.matches} 🔗

{ip.isprivate} 🔗

{csv.count} 🔗

{csv.value} 🔗

{sdp.line} 🔗

{sdp.stream} 🔗

{sdp.stream-delete} 🔗

{re.subst,reg_exp} 🔗

@]

{s.len} 🔗

{ip.isprivate}

Checks if the input IP address is an IPv4 private IP, according to RFC 1918 and RFC 6598. It returns 1 if the IP is private, 0 if not. Example:

if ( $(si{ip.isprivate})==1 )
	xlog("source ip is private\n");
else
	xlog("source ip is not private\n");

if ($fU == $tU) {

1. Request-URI username based processing

switch ($rU) {

1. assign an integer value to an variable

$var(gw_count) = 1;

1. assign a string value to an AVP

$avp(server) = "opensips";

1. store the Request-URI in a variable

$var(ru_backup) = $ru;

$var(x) = "sip:" + $fU + "@" + $td;

Returns 1 if the string provided is a valid IPv4 or IPv6 address, otherwise 0.

Returns the resolved IP address corresponding to the string domain provided. Transformation has no effect if a string IP is provided.

{ip.matches}

Checks if the input IP address matches a net mask given as IP/masklen (short format). It returns 1 if matches, 0 if not. NULL is returned on error (invalid input, invalid parameter, AF mismatch). Variables are supported for the parameter. Example:

if ( $(si{ip.matches,10.10.0.1/24})==1 )
	xlog("It DOES match \n");
else
	xlog("It DOES NOT match \n");

{s.reverse}

Returns the input string in revers order.

$var(forward) = "onetwothree";
$var(reverse) = $(var(forward){s.reverse}); //Contains "eerhtowteno";

   }

@]

{sdp.stream}

Returns a specific stream (starting with the m= line) from an SDP body. The stream to be returned can be specified using its index within the body, or using on its media type. If specified as index, it starts at 0, but it can also be negative, with -1 being the last stream. If specified as media type, only the first stream of its type will be returned. If the media type or index does not exist, NULL is returned.

Example: [@ if (is_method("INVITE"))

   {
      $var(first_stream) = $(rb{sdp.stream,0});
      xlog("First stream is $var(first_stream)\n");
   }

if (is_method("INVITE"))

   {
      $var(audio_stream) = $(rb{sdp.stream,audio});
      xlog("Audio stream is $var(audio_stream)\n");

   }

@]

{sdp.stream-delete}

Returns the specified SDP body with some of its streams deleted. The stream to be deleted can be specified using its index, or using on its media type. If specified as index, it starts at 0, but it can also be negative, with -1 being the last stream. If specified as media type, all streams matching will be deleted! If the media type or index does not exist, NULL is returned.

Example: [@ if (is_method("INVITE"))

   {
      $var(new_body) = $(rb{sdp.stream-delete,0});
      xlog("SDP body without first stream is $var(new_body)\n");
   }

if (is_method("INVITE"))

   {
      $var(new_body) = $(rb{sdp.stream-delete,video});
      xlog("SDP body without video stream is $var(new_body)\n");

xlog("MD5 over From username: $(fU{s.md5})\n");

    xlog("found $var(sstr) in $var(strtosearch)\n");

    xlog("This is a de-registration\n");

Returns the MD5 hash of the given input.

xlog("MD5 over From username: $(fU{s.md5})");

Intuitively, a Transformation is a function that is applied to a variable(script variable, pseudo-variables, AVPS, static strings) to get a special value from it. The value of the original variable is not altered.

Multiple transformations can be applied to a variable at the same time.

All transformations, unless otherwise specified, will return NULL in case of error or unsuccessful operation (e.g looking for an nonexistent parameter in an URI with the "{uri.param,name}" transformation). Also, NULL is accepted as input for transformations in order to support chaining with a previous one that would return NULL.

Return a field from the value of a variable. The field is selected based on separator and index. The separator must be a character used to identify the fields. Index must be a integer value or a variable. If index is negative, the count of fields starts from end of value, -1 being last field. If index is positive, 0 is the first field. Note that if a field is empty, an empty string will be returned and not NULL.

Searches for one string within another starting at the beginning of the first string. Returns starting index of the string found or NULL if not found.

if ($(var(strtosearch){s.index, $var(str)}) != NULL)

Searches for one string within another starting at the end of the first string. Returns starting index of the string found or NULL if not found.

$(var(in){s.b64encode}) => "AgMEBSFAIyVeJio="

$(var(in){s.b64decode}) => "\x2\x3\x4\x5!@#%^&*"

{s.b64encode}

{s.b64decode}

$var(dur) = "2868.12 sec"; if ($(var(dur){s.int}) < 3600) {

Converts the initial part of the given string to an integer value. Returns 0 if there were no digits at all.

@]

{s.xor,secret}

Performs one or more logical XOR operations with (a part of) the "secret" string parameter and the input string, depending on the lengths of the two strings.

[@ $var(in) = "aaaaaabbbbbb"; $(var(in){s.xor,x}) => "!/>^P!/>^P!^U2^Q!^U2^Q"

@]

{s.dec2hex}

Converts a decimal(base 10) number to hexadecimal (in base 16), represented as string.

{s.hex2dec}

Converts a hexadecimal number (base 16) represented as string to decimal (base 10).

{s.base64encode}

Represents binary input data in an ASCII string format.

$var(in) = "\x2\x3\x4\x5!@#%^&*";
$(var(in){s.base64encode})   => "AgMEBSFAIyVeJio="

{s.base64decode}

Assumes input is a Base64 string and decodes as many characters as possible.

[@ $var(in) = "AgMEBSFAIyVeJio="; $(var(in){s.base64encode}) => "\x2\x3\x4\x5!@#%^&*"

@]

{s.trim}

Strips any leading or trailing whitespace from the input string. Trimmed characters are " " (space), \t (tab), \n (newline) and \r (carriage return).

$var(in) = "\t \n input string  \r  ";

$(var(in){s.trim})   => "input string"

{s.trimr}

Strips any trailing whitespace from the input string. Trimmed characters are " " (space), \t (tab), \n (newline) and \r (carriage return).

$var(in) = "\t \n input string  \r  ";

$(var(in){s.trimr})   => "\t \n input string"

{s.triml}

Strips any leading whitespace from the input string. Trimmed characters are " " (space), \t (tab), \n (newline) and \r (carriage return).

[@ $var(in) = "\t \n input string \r ";

$(var(in){s.triml}) => "input string \r "

$(var(in){s.width, 14}) => "transformation"

{s.fill.left, tok, len}

{s.fill.right, tok, len}

{s.width, len}

Truncates or expands the input to the given len. Expanding is done to the right with the space character ' '. Truncating is done in a similar manner, from the right. Examples:

Fills a string to the right with a char/string until the given final length is reached. The initial string is returned if its length is greater or equal to the given final length. If used on pseudo-variables containing integers, it will convert them to strings.

$var(in) = "transformation";

$(var(in){s.width, 0})   => "transformation"
$(var(in){s.width, 16})  => "transformation  "
$(var(in){s.width, 9})   => "transform"

{uri.schema}

Returns the schema part of the given URI.

(:title Script Transformations - 3.6:)

• The length of the value of parameter at position 1 (remember 0 is first position, 1 is second position)

    xlog("This is an un-registration");

(:allVersions Script-Tran 3.6:)

Note: currently optimized for speed. Does not support pseudo-variable parameters or successive "s.fill" cascading.

Note: currently optimized for speed. Does not support pseudo-variable parameters or successive "s.fill" cascading.

Note: currently optimized for speed. Does not support pseudo-variable parameters or successive "s.fill" cascading.

Note: currently optimized for speed. Does not support pseudo-variable parameters or successive "s.fill" cascading.

@]

{s.fill.left}

Fills a string to the left with a char/string until the given final length is reached. The initial string is returned if its length is greater or equal to the given final length.

$var(in) = "485"; (also works for integer PVs)

$(var(in){s.fill.left, 0, 3})    => 485    
$(var(in){s.fill.left, 0, 6})    => 000485
$(var(in){s.fill.left, abc, 8})  => bcabc485

{s.fill.right}

Fills a string to the right with a char/string until the given final length is reached. The initial string is returned if its length is greater or equal to the given final length.

[@ $var(in) = 485; (also works for string PVs)

$(var(in){s.fill.right, 0, 3}) => 485 $(var(in){s.fill.right, 0, 6}) => 485000 $(var(in){s.fill.right, abc, 8}) => 485abcab