PC-Contact-Sync/sidecar.php

#!/usr/bin/php -q
<?php

$PROVISION_DIR = '/tftpboot';

$bootstrap_settings['freepbx_auth'] = false;
require_once '/etc/freepbx.conf';

$DB = FreePBX::Database();

$CONFIG_PATH = './config.json';
$CONFIG = read_config_json_file($CONFIG_PATH);

$TARGET_EXTENSIONS = read_config_json('target_extensions');
$LIST_FILTER_TYPE = read_config_json_string('list_filter_type');
$EXTENSION_FILTER_LIST = read_config_json('extension_filter_list');
$BLACKLISTED_TERMS = read_config_json('blacklisted_terms');
$PREPEND_EXTENSIONS = read_config_json_object_list('prepend_extensions');

function main(): void
{
    global $TARGET_EXTENSIONS;
    global $PROVISION_DIR;

    $argv = $_SERVER['argv'] ?? [];
    $do_notify = in_array('--notify', $argv, true);

    $pbdb = pull_db();

    blacklist_terms($pbdb);
    filter_extensions($pbdb);
    prepend_contact_list($pbdb);

    $mac_list = pull_mac_list();

    foreach ($TARGET_EXTENSIONS as $ext) {
        $mac = strtolower($mac_list[$ext]) ?? null;

        if (!$mac) {
            echo "Mac for $ext not found\n";
            continue;
        }

        $file = $PROVISION_DIR . '/' . $mac . '-features.cfg';

        $xml = pull_xml_file($file);
        $attendants = remove_attendants($xml);
        write_attendants($attendants, $pbdb);
        write_to_file($file, $xml);
    }

    if ($do_notify) {
        notify($pbdb);
    }
}

function pull_db(): array
{
    global $DB;
    $pbdb = [];

    try {
        $stmt = $DB->prepare("
          SELECT name, extension
          FROM users
          WHERE extension REGEXP '^[0-9]+$'
          ORDER BY CAST(extension AS UNSIGNED)
      ");
        $stmt->execute();
        $pbdb = $stmt->fetchAll(PDO::FETCH_ASSOC);
    } catch (Exception $e) {
    }

    if (!$pbdb) {
        fwrite(STDERR, "No extensions found (users/ps_endpoints returned no pbdb).\n");
        exit(1);
    }

    usort($pbdb, function ($a, $b) {
        return strcasecmp($a['name'], $b['name']);
    });
    return $pbdb;
}

function filter_extensions(array &$pbdb)
{
    global $LIST_FILTER_TYPE;

    if ($LIST_FILTER_TYPE == 'whitelist') {
        whitelist_extension_filter($pbdb);
    } elseif ($LIST_FILTER_TYPE == 'blacklist') {
        blacklist_extension_filter($pbdb);
    } else {
        fwrite(STDERR, "Filter type invalid: $LIST_FILTER_TYPE");
        fwrite(STDERR, 'Use either whitelist or blacklist');
    }
}

function blacklist_terms(array &$pbdb)
{
    global $BLACKLISTED_TERMS;

    $pbdb = array_values(array_filter($pbdb, function ($item) use ($BLACKLISTED_TERMS) {
        if (!is_array($item) || !isset($item['name'])) {
            return true;
        }

        $name = ltrim($item['name']);

        foreach ($BLACKLISTED_TERMS as $term) {
            if (stripos($name, $term) === 0) {
                return false;
            }
        }
        return true;
    }));
}

function whitelist_extension_filter(array &$pbdb)
{
    global $EXTENSION_FILTER_LIST;

    $allowed = array_fill_keys(array_map('trim', array_map('strval', $EXTENSION_FILTER_LIST)), true);

    $pbdb = array_values(array_filter($pbdb, function ($item) use ($allowed) {
        if (!is_array($item) || !isset($item['extension'])) {
            return false;
        }

        $ext = trim((string) $item['extension']);
        return isset($allowed[$ext]);
    }));
}

function blacklist_extension_filter(array &$pbdb)
{
    global $EXTENSION_FILTER_LIST;

    $blocked = array_fill_keys(array_map('trim', array_map('strval', $EXTENSION_FILTER_LIST)), true);

    $pbdb = array_values(array_filter($pbdb, function ($item) use ($blocked) {
        if (!is_array($item) || !isset($item['extension'])) {
            return true;
        }

        $ext = trim((string) $item['extension']);
        return !isset($blocked[$ext]);
    }));
}

function prepend_contact_list(array &$pbdb)
{
    global $PREPEND_EXTENSIONS;
    array_unshift($pbdb, ...$PREPEND_EXTENSIONS);
}

function pull_mac_list(): array
{
    global $DB;
    $mac_db = [];

    try {
        $stmt = $DB->prepare("
          SELECT mac, SUBSTRING_INDEX(ext, '-', 1) AS ext
          FROM endpoint_extensions
          ORDER BY CAST(ext AS UNSIGNED)
      ");
        $stmt->execute();
        $mac_db = $stmt->fetchAll(PDO::FETCH_ASSOC);
    } catch (Exception $e) {
        echo $e;
    }
    return array_column($mac_db, 'mac', 'ext');
}

function read_config_json_file(string $path): array
{
    $json = file_get_contents($path);
    $data = json_decode($json, true);

    if ($data === null && json_last_error() !== JSON_ERROR_NONE) {
        throw new RuntimeException('JSON decode error: ' . json_last_error_msg());
    }
    return $data;
}

function read_config_json(string $key): array
{
    global $CONFIG;
    $value = $CONFIG[$key] ?? [];

    if (is_string($value)) {
        $items = preg_split('/\s*,\s*/', $value, -1, PREG_SPLIT_NO_EMPTY);
    } elseif (is_array($value)) {
        $items = $value;
    } else {
        $items = [];
    }

    $items = array_values(array_filter($items, fn($v) => is_scalar($v)));

    $items = array_map(fn($v) => strtolower(trim((string) $v)), $items);

    return array_values(array_filter($items, fn($v) => $v !== ''));
}

function read_config_json_string(string $key): string
{
    global $CONFIG;
    $value = $CONFIG[$key] ?? '';
    return strtolower(trim((string) $value));
}

function read_config_json_object_list(string $key): array
{
    global $CONFIG;
    $value = $CONFIG[$key] ?? [];

    if (!is_array($value))
        return [];

    $out = [];
    foreach ($value as $row) {
        if (is_array($row) && isset($row['name'], $row['extension'])) {
            $out[] = [
                'name' => (string) $row['name'],
                'extension' => (string) $row['extension'],
            ];
        }
    }
    return $out;
}

function pull_xml_file(string $file): DOMDocument
{
    if (!file_exists($file)) {
        $file = '/tftpboot/000000000000-features.cfg';
    }
    $xmlString = file_get_contents($file);
    if ($xmlString === false) {
        throw new RuntimeException("Unable to read file: {$file}");
    }

    $xmlString = preg_replace('/^\xEF\xBB\xBF/', '', $xmlString); // BOM
    $xmlString = ltrim($xmlString);

    $firstAngle = strpos($xmlString, '<');
    if ($firstAngle !== false && $firstAngle > 0) {
        $xmlString = substr($xmlString, $firstAngle);
    }

    $xml = new DOMDocument('1.0', 'UTF-8');
    $xml->preserveWhiteSpace = true;
    $xml->formatOutput = true;
    $xml->xmlStandalone = true;

    if (!$xml->loadXML($xmlString)) {
        $errs = libxml_get_errors();
        libxml_clear_errors();
        $msg = "Failed to parse XML.\n";
        foreach ($errs as $e) {
            $msg .= "[level {$e->level}] {$e->message} at line {$e->line}\n";
        }
        throw new RuntimeException($msg);
    }

    return $xml;
}

function remove_attendants(DOMDocument $xml): DOMElement
{
    $xpath = new DOMXPath($xml);
    $attendantNodes = $xpath->query('/polycomConfig/attendant');
    if ($attendantNodes->length === 0) {
        throw new RuntimeException('No <attendant> element found at /polycomConfig/attendant');
    }
    $attendant = $attendantNodes->item(0);

    $toRemove = [];
    foreach ($attendant->attributes as $attr) {
        if (strpos($attr->nodeName, 'attendant.resourceList.') === 0) {
            $toRemove[] = $attr->nodeName;
        }
    }
    foreach ($toRemove as $name) {
        $attendant->removeAttribute($name);
    }

    return $attendant;
}

function write_attendants(DOMElement $attendant, array $pbdb): void
{
    $index = 1;
    foreach ($pbdb as $r) {
        $label = trim((string) ($r['name'] ?? ''));
        $address = trim((string) ($r['extension'] ?? ''));
        $type = trim((string) 'normal');

        $attendant->setAttribute("attendant.resourceList.{$index}.address", $address);
        $attendant->setAttribute("attendant.resourceList.{$index}.label", $label);
        $attendant->setAttribute("attendant.resourceList.{$index}.type", $type);

        $index++;
    }
}

function write_to_file(string $file, DOMDocument $xml): void
{
    global $PROVISION_DIR;
    if (!is_dir($PROVISION_DIR)) {
        fwrite(STDERR, "Provisioning directory not found: $PROVISION_DIR\n");
        exit(2);
    }

    $tmpfile = $file . '.tmp';
    if ($xml->save($tmpfile) === false) {
        fwrite(STDERR, "Failed to write temporary file $tmpfile\n");
        exit(3);
    }
    if (!@rename($tmpfile, $file)) {
        @unlink($tmpfile);
        fwrite(STDERR, "Failed to move $tmpfile to $file (permissions?)\n");
        exit(4);
    }

    if (!chown($file, 'asterisk')) {
        error_log("chown failed for $file");
    }
    if (!chgrp($file, 'asterisk')) {
        error_log("chgrp failed for $file");
    }

    echo "Wrote $file \n";
}

function notify(array $pbdb): void
{
    $notified = 0;
    foreach ($pbdb as $r) {
        $ext = trim((string) $r['extension']);
        if ($ext === '')
            continue;
        $cmd = 'asterisk -rx "pjsip send notify polycom-check-cfg endpoint ' . escapeshellarg($ext) . '"';
        exec($cmd, $o, $rc);
        if ($rc === 0)
            $notified++;
    }
    echo "Sent check-sync to $notified endpoints\n";
}

main();