package           : tis-linphone
version           : 5.2.5-10
architecture      : x64
section           : base
priority          : optional
name              : Linphone
categories        : Messaging
maintainer        : WAPT Team,Tranquil IT,Alexandre Gauvrit,Jimmy PELÉ
description       : Linphone is an open source softphone for voice and video over IP calling and instant messaging. It is fully SIP-based, for all calling, presence and IM features
depends           : 
conflicts         : 
maturity          : PROD
locale            : all
target_os         : windows
min_wapt_version  : 2.3
sources           : https://www.linphone.org/technical-corner/linphone
installed_size    : 317656975
impacted_process  : linphone
description_fr    : Linphone est un softphone open source pour les appels vocaux et vidéo sur IP et la messagerie instantanée. Il est entièrement basé sur le protocole SIP, pour toutes les fonctions d'appel, de présence et de messagerie instantanée
description_pl    : Linphone to softphone o otwartym kodzie źródłowym do połączeń głosowych i wideo przez IP oraz komunikatorów internetowych. Jest w pełni oparty na protokole SIP dla wszystkich funkcji połączeń, obecności i wiadomości błyskawicznych
description_de    : Linphone ist ein Open-Source-Softphone für Sprach- und Videoanrufe über IP und Instant Messaging. Es ist vollständig SIP-basiert, für alle Anruf-, Präsenz- und IM-Funktionen
description_es    : Linphone es un softphone de código abierto para llamadas de voz y vídeo sobre IP y mensajería instantánea. Está totalmente basado en SIP, para todas las funciones de llamada, presencia y mensajería instantánea
description_pt    : O Linphone é um softphone de código aberto para chamadas de voz e vídeo sobre IP e mensagens instantâneas. É totalmente baseado em SIP, para todas as funcionalidades de chamada, presença e IM
description_it    : Linphone è un softphone open source per chiamate vocali e video su IP e messaggistica istantanea. È completamente basato su SIP, per tutte le funzioni di chiamata, presenza e messaggistica istantanea
description_nl    : Linphone is een open source softphone voor spraak en video over IP bellen en instant messaging. Het is volledig gebaseerd op SIP, voor alle functies voor bellen, aanwezigheid en IM
description_ru    : Linphone - это программный телефон с открытым исходным кодом для голосовых и видеовызовов по IP и обмена мгновенными сообщениями. Он полностью основан на протоколе SIP и обеспечивает все функции звонков, присутствия и обмена мгновенными сообщениями
audit_schedule    : 
editor            : Belledonne Communications
keywords          : 
licence           : opensource_free,cpe:/a:gnu:gpl_v3,wapt_private
homepage          : https://www.linphone.org/
package_uuid      : 198f76bf-cd5d-4cca-96d7-c0ba96333818
valid_from        : 
valid_until       : 
forced_install_on : 
changelog         : 
min_os_version    : 
max_os_version    : 
icon_sha256sum    : 73897b6f03daf2d4bbe00c4d1e75819b9b9f69415cae467997665ddcba080ea5
signer            : Tranquil IT
signer_fingerprint: 8c5127a75392be9cc9afd0dbae1222a673072c308c14d88ab246e23832e8c6bb
signature         : sAeSD+bfSQywGtc33pSw302prVPQOfsAm2eTQc+uj1F9H1TP8SzKHawr9DPMxuEabP5efEWcMFN7AFHyaK5QhEOPvxXOw5lJYnnyyKlM+KgVRo0ZSFOxWeE8Spuog2Nq/czeXHen5kFLl5SqiaVf5Lj7ob2mmmvIp2PMQlV5nr0W2dsb7B7LYs+/j4FcqfyIPY824gDcNzk/vOIl/qv289bBW1+aTRmlKeYsTkxmLFynvhX/Q4riDJ3BO6gb5xixzOIPn8uehWz3N5Wmd53nmXPPK+Jzb4R6vc9Qb7/Di5eQn6Kxr23o27FqxcFjgD5EkRnomJJv8GdioQsLBLnLvA==
signature_date    : 2024-07-22T16:01:56.810652
signed_attributes : package,version,architecture,section,priority,name,categories,maintainer,description,depends,conflicts,maturity,locale,target_os,min_wapt_version,sources,installed_size,impacted_process,description_fr,description_pl,description_de,description_es,description_pt,description_it,description_nl,description_ru,audit_schedule,editor,keywords,licence,homepage,package_uuid,valid_from,valid_until,forced_install_on,changelog,min_os_version,max_os_version,icon_sha256sum,signer,signer_fingerprint,signature_date,signed_attributes

# -*- coding: utf-8 -*-
from setuphelpers import *

r"""
{
    "key": "Linphone",
    "name": "Linphone",
    "version": "5.1.2",
    "install_date": "",
    "install_location": "",
    "uninstall_string": "C:\\Program Files\\Linphone\\Uninstall.exe",
    "publisher": "Belledonne Communications",
    "system_component": 0,
    "win64": false,
}

Name,Group,Profile,Enabled,Action,Override,Program,Local Address,Remote Address,Protocol,Local Port,Remote Port,Authorized Users,Authorized Computers,Authorized Local Principals,Local User Owner,PolicyAppId,Application Package,
Linphone - A libre SIP client,,Domain,Yes,Allow,No,C:\program files\linphone\bin\linphone.exe,Any,Any,UDP,Any,Any,Any,Any,Any,Any,None,Any,
Linphone - A libre SIP client,,Domain,Yes,Allow,No,C:\program files\linphone\bin\linphone.exe,Any,Any,TCP,Any,Any,Any,Any,Any,Any,None,Any,

"""


def install():
    # Declaring local variables
    bin_name = glob.glob("Linphone-*-win64.exe")[0]

    # Uninstall the older versions of the software  # it seems necessary for Linphone
    for to_uninstall in installed_softwares(uninstallkey="Linphone"):
        if Version(to_uninstall["version"]) < Version(control.get_software_version()) or force:
            print("Removing: %s (%s)" % (to_uninstall["name"], to_uninstall["version"]))
            killalltasks(ensure_list(control.impacted_process))
            run(uninstall_cmd(to_uninstall["key"]))
            wait_uninstallkey_absent(to_uninstall["key"])
            # if isdir(to_uninstall["install_location"]):
            #     remove_tree(to_uninstall["install_location"])

    # Installing the software
    install_exe_if_needed(
        bin_name,
        "/S",
        key="Linphone",
        min_version=control.get_software_version(),
        timeout=600,
    )

    # Adding Firewall Rules
    app_path = makepath(os.path.dirname(installed_softwares(uninstallkey="Linphone")[0]["uninstall_string"]), "bin", "linphone.exe")
    remove_netfirewallrule("Linphone - A libre SIP client")
    add_netfirewallrule("Linphone - A libre SIP client", app_path, profile="Domain,Private", protocol="UDP")
    add_netfirewallrule("Linphone - A libre SIP client", app_path, profile="Domain,Private", protocol="TCP")


def uninstall():
    # Removing Firewall Rules
    remove_netfirewallrule("Linphone - A libre SIP client")


def add_netfirewallrule(
    rule_name,
    app_path,
    group=None,
    direction="Inbound",
    profile=None,
    enabled=True,
    action="Allow",
    protocol=None,
):
    """
    Add a Windows Firewall rule using New-NetFirewallRule cmdlet in PowerShell for Windows 10 and newer,
    or netsh advfirewall for older Windows versions.

    https://learn.microsoft.com/troubleshoot/windows-server/networking/netsh-advfirewall-firewall-control-firewall-behavior
    https://learn.microsoft.com/powershell/module/netsecurity/new-netfirewallrule

    Args:
        rule_name (str): Display name for the firewall rule.
        app_path (str): Path to the program for which the rule is being created.
        group (str, optional): Group name for the firewall rule (only works with PowerShell).
        direction (str): Direction of the rule (Inbound or Outbound). Default: Inbound.
        profile (str or list, optional): Profile(s) to which the rule should apply (e.g., "Domain,Private"). Default: Any.
        enabled (bool): Specify if the created rule's state is Enabled (True) or not (False). Default: True.
        action (str): Action for the rule (Allow or Block). Default: Allow.
        protocol (str, optional): Protocol by name or number (e.g., "TCP", "UDP", "ICMPv4", or "ICMPv6"). Default: Any.

    Returns:
        waptutils.RunOutput: The result of the command execution.

    .. versionadded:: 2.5

    """
    if not isinstance(profile, list):
        profile = ensure_list(profile)
    profile = ",".join(profile)

    message = f"Adding Firewall Rule: {rule_name}"
    if direction:
        message += f" ({direction})"
    if protocol:
        message += f" ({protocol})"
    if action:
        message += f" ({action})"
    print(message)
    if windows_version() < WindowsVersions.Windows10:
        direction = "out" if direction.lower() == "Outbound".lower() else "in"
        enabled = "no" if not enabled else "yes"
        cmd_command = f'netsh advfirewall firewall add rule name="{rule_name}" dir={direction} action={action} program="{app_path}" enable={enabled}'
        if profile:  # any and all are working
            cmd_command += f' profile="{profile}"'
        if protocol:
            cmd_command += f' protocol="{protocol}"'
        result = run_notfatal(cmd_command)
    else:
        pwsh_command = (
            f'New-NetFirewallRule -DisplayName "{rule_name}" -Direction {direction} -Action {action} -Program "{app_path}" -Enabled {str(enabled)}'
        )
        if group:
            pwsh_command += f' -Group "{group}"'
        if profile:
            pwsh_command += f' -Profile "{profile}"'
        if protocol:
            pwsh_command += f' -Protocol "{protocol}"'
        result = run_powershell(pwsh_command, output_format="text")

    return result


def remove_netfirewallrule(rule_name):
    """
    Remove Windows Firewall rule using New-NetFirewallRule cmdlet in PowerShell for Windows 10 and newer,
    or netsh advfirewall for older Windows versions.

    Args:
        rule_name (str): Display name of the firewall rule to remove.

    Returns:
        waptutils.RunOutput: The result of the command execution.

    .. versionadded:: 2.5

    """
    print(f"Removing Firewall Rule: {rule_name}")
    if windows_version() < WindowsVersions.Windows10:
        result = run_notfatal(f'netsh advfirewall firewall delete rule name="{rule_name}"')
    else:
        result = run_powershell(
            f'Remove-NetFirewallRule -DisplayName "{rule_name}" -ErrorAction SilentlyContinue', output_format="text", accept_returncodes=[0, 1, 3010]
        )

    return result

# -*- coding: utf-8 -*-
from setuphelpers import *
from setupdevhelpers import *
import bs4 as BeautifulSoup
from urllib.parse import urlparse, urljoin


def update_package():
    # Declaring local variables
    package_updated = False
    proxies = get_proxies()
    if not proxies:
        proxies = get_proxies_from_wapt_console()
    download_dict = {
        "windows": "https://download.linphone.org/releases/windows/app/",
        "mac": "https://download.linphone.org/releases/macosx/app/",
        "linux": "https://download.linphone.org/releases/linux/app/",
    }
    url = download_dict[control.target_os]

    # Getting latest version information from official sources
    print("URL used is: %s" % url)
    binaries_dict = bs_index_of_to_dict(url, proxies=proxies)
    newer_version = "0"
    for to_download in binaries_dict.keys():
        filename = to_download
        try:
            checked_version = filename.split("-")[1]
            checked_version = checked_version if is_version(checked_version) else "0"
        except:
            checked_version = "0"
        if Version(checked_version, 4) > Version(newer_version, 4):
            newer_version = checked_version
            download_url = binaries_dict[to_download]
            latest_bin = filename
    version = newer_version

    # Downloading latest binaries
    print("Latest %s version is: %s" % (control.name, version))
    print("Download URL is: %s" % download_url)
    if not isfile(latest_bin):
        print("Downloading: %s" % latest_bin)
        wget(download_url, latest_bin, proxies=proxies)
    else:
        print("Binary is present: %s" % latest_bin)

    # Deleting outdated binaries
    remove_outdated_binaries(latest_bin)
    # arch_list = ensure_list(control.architecture)
    # remove_outdated_binaries(version, filename_contains=("x64" if "x64" in arch_list else "x86" if "x86" in arch_list else []))

    # # Checking version from file
    # if get_os_name() == "Windows" and "windows" in control.target_os.lower():
    #     version_from_file = get_version_from_binary(latest_bin)
    #     if Version(version_from_file, 4) == Version(version, 4):
    #         print(f"INFO: Binary file version ({version_from_file}) corresponds to online version ({version})")
    #     else:
    #         error(f"ERROR: Binary file version ({version_from_file}) do NOT corresponds to online version ({version})")

    # Changing version of the package
    if Version(version, 4) > Version(control.get_software_version(), 4):
        print("Software version updated (from: %s to: %s)" % (control.get_software_version(), Version(version)))
        package_updated = True
    else:
        print("Software version up-to-date (%s)" % Version(version))
    control.set_software_version(version)
    control.save_control_to_wapt()

    # Validating or not update-package-sources
    return package_updated

    # # Changing version of the package and validating update-package-sources
    # return complete_control_version(control, version)


def bs_index_of_to_dict(url, **kwargs):
    r"""Parse html "Index of" web page with BeautifulSoup and get a dict of the result

    Args:
        url (str): url of the web page to parse

    Return:
        result: a dict of the index URLs

    """
    result = {}
    for elem in bs_find_all(url, "a", "href"):
        if not "://" in elem["href"]:
            # absolute_link = urljoin(url, url + "/" + elem.get("title", elem["href"]) if not url.endswith("/") else url + elem.get("title", elem["href"]))
            absolute_link = url + "/" + elem.get("title", elem["href"]) if not url.endswith("/") else url + elem.get("title", elem["href"])
            if len(absolute_link.rsplit("//")) > 2:
                absolute_link = absolute_link.rsplit("//", 1)[0]  # fix for Parent Dir, to test if it break any other link
                if "parent" in elem.text.lower():
                    absolute_link = absolute_link.rsplit("/", 1)[0]  # Parent Dir is uplevel
        else:
            absolute_link = elem["href"]
        key = elem.text
        if key.endswith("..>"):  # if key.endswith("..>"):
            key = elem["href"]
        result[key] = absolute_link
    return result


def is_version(version_str, max_members=4):
    parts = version_str.split(".")
    if len(parts) > max_members:
        error(f'"{version_str} contains more members than the specified maximum: ({max_members})')
    for part in parts:
        if not part.isdigit():
            return False
    return True


def is_url(x):
    try:
        result = urlparse(x)
        return all([result.scheme, result.netloc])
    except:
        return False


def bs_find_all(url, element, attribute=None, value=None, user_agent=None, proxies=None, features="html.parser", **kwargs):
    """
    Parse an HTML or XML web page with BeautifulSoup and retrieve a list of all matching results.

    Args:
        url (str): URL of the web page or string to parse.
        element (str): Searched element.
        attribute (str): Selected attribute of the element.
        value (str): Value of the selected attribute.
        user_agent (str): Specify a user-agent if needed.
        proxies (dict): Specify proxies if needed.
        features (str): BeautifulSoup feature to use.
        **kwargs: Additional parameters for the requests library.

    Returns:
        list: List of bs4.element.Tag objects representing the matching elements.

    Examples:
        >>> bs_find_all('https://www.w3.org/', 'a', 'title', 'Open Web Platform testing')[0]['href']
        'https://web-platform-tests.org/'

        >>> bs_find_all('https://www.w3.org/', 'span', 'class', 'alt-logo')[0].string
        'W3C'

    .. versionadded:: 2.0

    .. versionchanged:: 2.5
        Function can now parse string content of a page or reparse a "bs_result". It is now possible to parse a specific attribute.

    """
    url = str(url)
    if is_url(url):
        if user_agent:
            page = requests.get(url, proxies=proxies, headers={"User-Agent": user_agent}, **kwargs).text
        else:
            page = requests.get(url, proxies=proxies, **kwargs).text
    else:
        page = url
    soup = BeautifulSoup.BeautifulSoup(page, features=features)
    if value:
        return soup.find_all(element, {attribute: value})
    elif attribute:
        return soup.find_all(element, attrs={attribute: True})
    else:
        return soup.find_all(element)