<?php
/* *****************************************************************************
 *
 * @author Ira Tonert <ira.tonert@e-vendo.de>
 * @copyright e-vendo AG &copy; 2005 - 2020, Ira Tonert
 *
 * @package e-vendo Online-Shop
 * @subpackage Katalogdarstellung
 * @category e-vendo.php, Hauptmodul fuer die neue Shop-Generation
 *
 * @version 1.0
 *
 Historie:
  12.06.20, Ira Tonert: - Variablenpruefung (wegen PHP 7.4)
  03.04.20, Ira Tonert: - aeltere Kommentare entfernt
  04.03.19, Ira Tonert: - in postgetinput2php bei Fehlerausgabe wegen 0-Zeichen im Parameter kleine Textverbesserung
                        - in checkverdaechtig... kleine Verbesserung (rein intern)
  25.01.19, Ira Tonert: - CatNr nicht mehr auslesen

  aeltere Kommentare in _comments/e-vendo.php.txt

 ******************************************************************************/

  # Eintritt in das Script merken
  $f_evshop_starttime = microtime(true);

  # Konstanten
  define ('SRCDIR',             '_src');                # Unterverzeichnis mit den einzubindenden Shop-Modulen der neuen Shop-Generation
  define ('LIBDIR',             SRCDIR.'/lib');         # Unterverzeichnis mit den Bibliotheken

  $dSTARTSCRIPT = 'e-vendo.php';		# Zentrales Start-Modul fuer die neue Shop-Generation

  # die allgemeinen Charsets hier schon mal festlegen
  define('CHARSET_ISO8859_1', 0);
  define('CHARSET_UTF_8', 1);
  define('CHARSET_SHOP', CHARSET_ISO8859_1); # und das hier verwendet der Shop intern derzeit

  # die PHP-Big-Version (Zahl vor dem Punkt einmal abspeichern
  $phpbigversion = substr(phpversion(), 0, 1);

  # ggf. FirePHP aktivieren, an der Stelle von Hand einkommentieren, wenn vor Einlesen
  # der reg-Datei benoetigt
  # Nutzung am Besten ueber $GLOBALS['firephp']->log($varname, 'varname'); usw.
  /*
  #$bDebugFirePHP = true;
  if (isset($bDebugFirePHP) && $bDebugFirePHP) {
    require_once SRCDIR.'/_int/FIREPHPCORE/FirePHP.class.'.(($phpbigversion >= '5') ? '' : 'php4.').'php';
    if ($phpbigversion >= '5') {
      ob_start();
      $firephp = FirePHP::getInstance(true);
      # separate Behandlung fuer PHP4
    } else {
      require_once SRCDIR.'/_int/FIREPHPCORE/FirePHP.class.fb.php4.php';
      ob_start();
      $firephp = & FirePHP::getInstance(true);
      $fb($var, 'FirePHP_*');
    }
  }
  */

  # falls REQUEST_URI nicht da ist, dann dieses belegen (z.B. bei Nutzung durch IIS)
  if (!isset($_SERVER['REQUEST_URI'])) {
    $arr = explode("/", $_SERVER['PHP_SELF']);
    $_SERVER['REQUEST_URI'] = "/" . $arr[count($arr)-1];
    # da bei register_argc_argv auf Off die Werte nicht in argv drin stehen, diese aus QUERY_STRING nehmen
    if (!empty($_SERVER['QUERY_STRING']))
      # da bei register_argc_argv auf Off die Werte nicht in argv drin stehen, diese aus QUERY_STRING nehmen
      $_SERVER['REQUEST_URI'] .= "?".$_SERVER['QUERY_STRING'];
  }

# ------------------------------------------------------------------------------
  function checkcreatedir(
          $_dir
          , $bFilename = false # true, wenn statt einem Verzeichnis ein Dateiname mit Pfad uebergeben wurde und dann halt erst mal der Pfad separiert werden muss
          )
# ------------------------------------------------------------------------------
{
  global $shop;

  # das Verzeichnis nun erst mal vorbereiten, denn ggf. ist uns ja das ganze mit Dateinamen uebergeben worden
  $dir = $bFilename ? dirname($_dir) : $_dir;

  $exists = is_dir($dir);
  if (!$exists) {
    # ggf. handelt es sich aber um ein mehrstufiges Verzeichnis
    # existiert das Verzeichnis aus mehreren Teilen?
    $partsSlash = explode('/', $dir);

    if ($partsSlash && count($partsSlash)) {
      # der Pfad besteht aus mehreren Teilen
      $actDir = '';
      foreach ($partsSlash as $key => $partSlash) {
        # aktuell verlaengerten Pfad vorbereiten
        $actDir .= ($actDir ? '/' : '').$partSlash;
        # falls das oberste Verzeichnis das Shop-Verzeichnis ist, dann weigern wir uns, es zu erstellen, d.h. wir gehen gleich eine Ebene weiter
        if (!$key && ($shop == $partSlash))
          continue;
        # existiert dieser Pfad schon?
        if (!file_exists($actDir)) {
          # existiert nicht, also versuchen wir, ihn zu erstellen
          $bDir = mkdir($actDir);
          if (!$bDir) {
            # das hat nicht geklappt, also koennen wir hier aussteigen
            break;
          }
        }
      }
    } else {
      # der Pfad besteht nur aus einem Teil
      # das eigentliche Shop-Verzeichnis jedoch weigern wir uns zu erstellen
      if ($shop != $dir)
        $bDir = mkdir($dir);
    }
    $exists = is_dir($dir);
  }
  return $exists;
}

# ------------------------------------------------------------------------------
  function ev_fopen($filename, $mode)
# ------------------------------------------------------------------------------
{
  $fd = fopen($filename, $mode);
  if (!$fd) {
    # prueft, ob eines der Flags drin sind, die ein Schreiben erforderlich machen

    if (strpbrk($mode, 'waxc')) {
      # ja, da soll was geschrieben werden.
      # Dann kann es ja durchaus sein, dass das Verzeichnis evtl. noch gar nicht existiert hat, dann sollten wir das
      # mal versuchen anzulegen
      if (checkcreatedir($filename, true)) {
        # und dann versuchen wir nun noch einmal, die Datei anzulegen
        $fd = fopen($filename, $mode);
      }
    }
  }
  return $fd;
}

# ------------------------------------------------------------------------------
  function EvendoWarning($module, $msg)
# ------------------------------------------------------------------------------
# Diese Funktion protokolliert Fehler unter shopname/shop.err
{
  global $shop;

  # wenn shop leer ist, dann schreiben wir halt auch kein Logfile
  if ($shop) {
    # Dateiname mit Jahr und Monat versehen und erst mal in eine separate Variable schreiben
    $filename = $shop.'/log/shop_'.date('y_m').'.err';
    $fp = ev_fopen($filename, 'a');

    $rs = isOSWin() ? "\r\n" : "\n";

    $str = date('d.m.y'."\t".'H:i:s', time()).
          "\t".$module.
          "\t".$msg.
          "\t".$_SERVER['SCRIPT_NAME'].
          "\t".(isset($_SERVER['QUERY_STRING']) ? $_SERVER['QUERY_STRING'] : '').
          "\t".(count($_POST) ? '_POST:'.serialize($_POST) : '').
          $rs;

    if ($fp) {
      fputs ($fp, $str);
      fclose ($fp);
    }
  }
}

# ------------------------------------------------------------------------------
  function isHTTPS()
# ------------------------------------------------------------------------------
{
  return isset($_SERVER['HTTPS']) && ($_SERVER['HTTPS'] == 'on');
}

/*
$blogIra = false;
$logShop = '';
# ------------------------------------------------------------------------------
  function logIra ($wo, $was)
# ------------------------------------------------------------------------------
# Diese Funktion protokolliert Fehler unter shopname/shop.err
{
  global $shop, $logShop, $blogIra;

  if (!$blogIra)
    return;

  if (!isset($shop))
    $shop = 'e-vendo_ag';

  $filename = (isset($shop) ? $shop : $logShop).'/log/debug.txt';

  $fp = ev_fopen ($filename, 'a');

  $str = date('d.m.y H:i:s', time()).
    # *** 7.8.08, Ira Tonert: neue Funktion zum Pruefen auf SSL nutzen
    "\t".(isHTTPS() ? 'https' : 'http').
    "\t".$_SERVER['QUERY_STRING'].
    "\t".$wo.
    "\t".$was.
    "\r\n";
  if (!$fp) {
    echo "Fehler: $filename kann nicht geoeffnet werden (write)! ";
    echo $str;
    return;
  }
  fputs ($fp,$str);
  fclose ($fp);
}
*/

# falls die Funktion schon existiert, dann nicht noch einmal
if (!function_exists('ev_get_magic_quotes_gpc'))
{
  # ----------------------------------------------------------------------------
    function ev_get_magic_quotes_gpc()
  # ----------------------------------------------------------------------------
  {
    global $bMagicQuotesGPC;

    if (!isset($bMagicQuotesGPC))
      # ab PHP 5.4 gibt es die ganze Funktion nicht mehr
      $bMagicQuotesGPC = ((phpversion() <= '5.4') && function_exists('get_magic_quotes_gpc')) ? get_magic_quotes_gpc() : false;

    return $bMagicQuotesGPC;
  }
}

# ------------------------------------------------------------------------------
  function sendHeader_404($bWithContent = true
          , $bSaveSendHeader = true # false, wenn die Information ueber den gesendeten Header nicht gespeichert werden soll
          )
# ------------------------------------------------------------------------------
# sendet den 404-Header usw.
{
  global $bHasSend404Header;

  # das Protokoll nutzen, was aufgerufen worden ist
  header($_SERVER['SERVER_PROTOCOL'].' 404 Not Found');
  header('Status: 404 Not Found');
  if ($bWithContent) {
    header('Content-Type: text/plain');
    print("not found\n");
  }

  # merken, dass ein 404-Header gesendet worden ist
  # nur merken, wenn dieses Merken nicht abgeschaltet worden ist
  if ($bSaveSendHeader)
    $bHasSend404Header = true;
}

# ------------------------------------------------------------------------------
  function checkVerdaechtigParam($paramname, $paramvalue, $verdaechtig)
# ------------------------------------------------------------------------------
{
  if ($paramvalue) {
    $icount = strlen($verdaechtig);
    for ($i = 0; $i < $icount; ++$i) {
      $pos = strpos($paramvalue, $verdaechtig[$i]);
      if ($pos === false)
        continue;
      # wenn es der shop-Parameter ist, dann muessen wir uns nun was einfallen lassen, denn
      # da koennen wir ja nichts protokollieren
      if ($paramname == 'shop') {
        # wir koennen es ja vielleicht in das Logfile eintragen, was unser Default-Shop ist
        include('shopstart.reg');
        # *** 04.03.19, Ira Tonert: auf !empty pruefen
        if (!empty($shop)) {
        #if ($shop) {
          # also, dieser Shop ist auf jeden Fall der Standard-Shop des Verzeichnisses
          $GLOBALS['shop'] = $shop;
          EvendoWarning('Parameter verdaechtig --> beende Scriptlauf', $paramname.':'.$paramvalue.':');
        } else {
          # wenn wir noch keinen shop-Parameter haben, dann koennen wir dies nun halt auch nicht protokollieren
        }
      } else {
        EvendoWarning('Parameter verdaechtig --> beende Scriptlauf', $paramname.':'.$paramvalue.':');
      }
      sendHeader_404();
      exit();
    }
  }
}

# ------------------------------------------------------------------------------
  function matchParam($paramname, $paramvalue, $pattern)
# ------------------------------------------------------------------------------
# prueft, ob paramvalue einem match entspricht. Wenn nein, dann wird eine
# Fehlermeldung ausgegeben und der Scriptlauf direkt beendet
{
  if ($paramvalue) {
    if (!preg_match($pattern, $paramvalue)) {
      EvendoWarning('Parameter verdaechtig --> beende Scriptlauf', $paramname.':'.$paramvalue.':');
      sendHeader_404();
      exit();
    }
  }
}

# ------------------------------------------------------------------------------
  function shop2site($str)
# ------------------------------------------------------------------------------
# wandelt einen String vom Shop-Charset in das Seiten-Charset um
{
  global $charsetSites;

  if (CHARSET_SHOP == $charsetSites) {
    return $str;
  } else {
    switch (CHARSET_SHOP) {
      case CHARSET_ISO8859_1:
        switch ($charsetSites) {
          case CHARSET_UTF_8:
            return utf8_encode($str);
        }
        break;
      case CHARSET_UTF_8:
        switch ($charsetSites) {
          case CHARSET_ISO8859_1:
            return utf8_decode($str);
        }
        break;
    }
  }
  return $str;
}

# ------------------------------------------------------------------------------
  function site2shop($str)
# ------------------------------------------------------------------------------
# wandelt einen String vom Seiten-Charset in das Shop-Charset um
{
  global $charsetSites;

  if (CHARSET_SHOP == $charsetSites) {
    return $str;
  } else {
    switch ($charsetSites) {
      case CHARSET_ISO8859_1:
        switch (CHARSET_SHOP) {
          case CHARSET_UTF_8:
            return utf8_encode($str);
        }
        break;
      case CHARSET_UTF_8:
        switch (CHARSET_SHOP) {
          case CHARSET_ISO8859_1:
            return utf8_decode($str);
        }
        break;
    }
  }
  return $str;
}

# ------------------------------------------------------------------------------
  function postinput2php($varname, $defaultvalue = ''
      , $bTrim = true,	# Parameter zum Deaktivieren des Trim
      $maxlength = 0, # maximale Laenge des Parameters, genereller Abbruch, wenn laenger
      $bLookInGlobalsToo = true # false, wenn nicht in den $GLOBALS geschaut werden soll
      , $pattern = '' # Pruef-Pattern
  )
# ------------------------------------------------------------------------------
# wandelt einen String aus einem POST-Input-Feld fuer die weitere Verarbeitung in PHP um
{
  $retstr = $defaultvalue;
  # falls globale Variable schon vorhanden, dann bleibt sie auch erhalten
  # Daten erst mal aus post holen
  if (isset($_POST[$varname])) {
    $retstr = $bTrim ? trim($_POST[$varname]) : $_POST[$varname];
    # evtl. muss noch was wegen dem Charset konvertiert werden
    $retstr = site2shop($retstr);
    # ggf. soll aber in den Globals nicht geschaut werden
  } elseif ($bLookInGlobalsToo && isset($GLOBALS[$varname])) {
    $retstr = $bTrim ? trim($GLOBALS[$varname]) : $GLOBALS[$varname];
  }
  # nur, wenn magic_quotes_gpc auf on steht, das stripslashes durchfuehren
  if (ev_get_magic_quotes_gpc())
    $retstr = stripslashes($retstr);

  # 0-Bytes in Parametern erkennen
  if (strpos($retstr, "\0") !== false) {
    EvendoWarning('Parameter mit inkl. Nullbyte --> beende Scriptlauf', $varname.':'.str_replace("\0", '%00', $retstr.':'));
    $retstr = substr($retstr, 0, $pos);
    # aber eigentlich muesste hier abgebrochen werden, denn das geht ja gar nicht
    sendHeader_404();
    exit();
  }

  # Pruefen des Parameters auf Laenge
  if ($maxlength && ($maxlength < strlen($retstr))) {
    EvendoWarning('Parameter zu lang --> beende Scriptlauf', $varname.':'.$retstr.':');
    sendHeader_404();
    exit();
  }
  # falls ein Pruefpattern vorhanden, dann hier auch gleich pruefen
  if ($pattern && $retstr) {
    if (!preg_match($pattern, $retstr)) {
      EvendoWarning('Parameter scheint manipuliert --> beende Scriptlauf', $varname.':'.$retstr.': pattern='.$pattern);
      sendHeader_404();
      exit();
    }
  }
  return $retstr;
}

# ------------------------------------------------------------------------------
  function is_postget($varname)
# ------------------------------------------------------------------------------
# prueft, ob dieser Parameter per POST oder GET uebergeben wurde
{
  $retval = false;
  if (isset($_POST[$varname])) {
    $retval = true;
  } elseif (isset($_GET[$varname])) {
    $retval = true;
  }
  return $retval;
}

# ------------------------------------------------------------------------------
  function is_post($varname)
# ------------------------------------------------------------------------------
# prueft, ob dieser Parameter per POST uebergeben wurde
{
  return isset($_POST[$varname]);
}

if (!function_exists('postgetinput2php'))
{
  # ----------------------------------------------------------------------------
    function postgetinput2php($varname, $defaultvalue = ''
      , $maxlength = 0 # maximale Laenge des Parameters, genereller Abbruch, wenn laenger
      , $pattern = '' # Pruef-Pattern
    )
  # ----------------------------------------------------------------------------
  # wandelt einen String aus einem POST-Input-Feld oder, falls dort
  # nicht vorhanden aus dem GET-Bereich, fuer die weitere Verarbeitung in PHP um
  {
    $retstr = $defaultvalue;
    # erst in Post, dann in get und dann global schauen
    if (isset($_POST[$varname])) {
      $retstr = trim($_POST[$varname]);
      # evtl. muss noch was wegen dem Charset konvertiert werden
      $retstr = site2shop($retstr);
      # nur, wenn magic_quotes_gpc auf on steht, das stripslashes durchfuehren
      if (ev_get_magic_quotes_gpc())
        $retstr = stripslashes($retstr);
    } elseif (isset($_GET[$varname])) {
      $retstr = trim($_GET[$varname]);
      # evtl. muss noch was wegen dem Charset konvertiert werden
      $retstr = site2shop($retstr);
      # nur, wenn magic_quotes_gpc auf on steht, das stripslashes durchfuehren
      if (ev_get_magic_quotes_gpc())
        $retstr = stripslashes($retstr);
    } elseif (isset($GLOBALS[$varname])) {
      $retstr = $GLOBALS[$varname];
    }
    # 0-Bytes in Parametern erkennen
    if (strpos($retstr, "\0") !== false) {
      EvendoWarning('Parameter mit inkl. Nullbyte --> beende Scriptlauf', $varname.':'.str_replace("\0", '%00', $retstr.':'));
      # *** 04.03.19, Ira Tonert: statt $pos das strpos hier noch einmal durchfuehren
      $retstr = substr($retstr, 0, strpos($retstr, "\0"));
      #$retstr = substr($retstr, 0, $pos);
      # aber eigentlich muesste hier abgebrochen werden, denn das geht ja gar nicht
      sendHeader_404();
      exit();
    }
    # Pruefen des Parameters auf Laenge
    if ($maxlength && ($maxlength < strlen($retstr))) {
      EvendoWarning('Parameter zu lang --> beende Scriptlauf', $varname.':'.$retstr.':');
      sendHeader_404();
      exit();
    }
    # falls ein Pruefpattern vorhanden, dann hier auch gleich pruefen
    # Pruefung nur, wenn auch ein Inhalt vorliegt
    if ($pattern && $retstr) {
      if (!preg_match($pattern, $retstr)) {
        EvendoWarning('Parameter scheint manipuliert --> beende Scriptlauf', $varname.':'.$retstr.': pattern='.$pattern);
        sendHeader_404();
        exit();
      }
    }

    return $retstr;
  }
}

  # shop schon als erstes auslesen, sonst koennen wir ja nichts in Protokoll schreiben
  # Begrenzung auf 30 Zeichen
  $shop = isset($shop) ? $shop : postgetinput2php('shop', '', 30);
  # abfangen, falls verdaechtige Zeichen enthalten sind
  checkVerdaechtigParam('shop', $shop, '/\'%" =&.!:|�`?,;${}+'."\\");

  # SessionId darf nur Buchstaben, Ziffern und Minus-Zeichen enthalten
  $SessionId = isset($SessionId) ? $SessionId : postgetinput2php('SessionId', '', 40, '/^[0-9a-zA-Z\-]*$/');
  # falls eine unwirkliche, dann dies korrekt eintragen
  if ((strlen($SessionId) >= 4) && ($SessionId[strlen($SessionId)-1] == '-')) {
    $SessionIdNoReally = $SessionId;
    $SessionId = '';
  }
  # wenn wir eine SessionId in der URL drin haben, dann geben wir auf jeden Fall ein noindex
  # und bei einigen anderen Dingen auch erst mal
  if ((!empty($_GET['SessionId']))
      || isset($_GET['Back'])
      || isset($_GET['print'])
      # wenn wir die PartnerId im GET haben, dann gibt es auch ein X-Robots-Tag fuer noindex
      || isset($_GET['PartnerId'])
     )
    header('X-Robots-Tag: noindex', true);

  # wenn a leer, dann auch mit open belegen
  # Begrenzung auf 40 Zeichen
  $a = isset($a) ? $a : postgetinput2php('a', 'open', 40);
  # abfangen, falls verdaechtige Zeichen enthalten sind
  if ($a) {
    checkVerdaechtigParam('a', $a, '/\'" =!?,;'."\\");
  } else {
    $a = 'open';
  }
  # evendo_doorway hier schon bekannt machen
  $evendo_doorway = postgetinput2php('evendo_doorway');
  # die PartnerId hier mit auslesen
  $PartnerId    = postgetinput2php('PartnerId');
  # ggf. ist eine Filiale uebergeben
  $FilialeNr = postgetinput2php('F', '', 6);

# ------------------------------------------------------------------------------
  function readyURL($url)
# ------------------------------------------------------------------------------
{
  global $useSessionId;

  return str_replace('{SessionId}', $useSessionId, $url);
}

# ------------------------------------------------------------------------------
  function setUseSessionId($id)
# ------------------------------------------------------------------------------
{
  global $useSessionId, $startscript, $shop, $dSTARTSCRIPT, $bNoParam_shop, $bNoParam_SessionId;

  $useSessionId = $id;
  $startscript = readyURL($dSTARTSCRIPT.'?'.(empty($bNoParam_shop) ? "shop=$shop".ARG_SEPARATOR : '').($bNoParam_SessionId ? '' : 'SessionId={SessionId}'.ARG_SEPARATOR).'a=');
}

# ------------------------------------------------------------------------------
  function getHomeURL(
          $bForCanonical = false # true, wenn wir die Start-URL fuer das Canonical-Tag benoetigen
          )
# ------------------------------------------------------------------------------
# holt die URL auf die Startseite
{
  global $useSessionId, $shop, $dSTARTSCRIPT, $bNoParam_shop, $bShopIsInStartReg, $bNoParam_SessionId;

  $params = '';
  # bei der Startseite sparen wir uns den shop-Parameter auch, wenn es der Start-Shop im Verzeichnis ist
  if (empty($bNoParam_shop) && !$bShopIsInStartReg) $params .= ($params ? ARG_SEPARATOR : '').'shop='.$shop;
  # SessionId kommt dann mit ran, wenn wir nicht fuer das Canonical arbeiten und wenn der Parameter in den URLs nicht abgeschaltet ist
  if (!$bForCanonical && !$bNoParam_SessionId)
    $params .= ($params ? ARG_SEPARATOR : '').'SessionId='.$useSessionId;

  # wenn es die URL fuer das Canonical Tag ist, dann sparen wir uns das Startskript
  return ($params ? ($bForCanonical ? '' : $dSTARTSCRIPT).'?' : '').$params;
}

# wird oft gebraucht und deshalb als globale Variable
$textforurl_search  = array(' ', '_', '�',  '�',  '�',  '�',  '�',  '�',  '�',  '�', '�', '�', '�',  '�', '�', '�', '�', '�', '�', '�', '�', '�', '�', '�', '�', '�', '�', '�', '�', '�', '�', '�'); #'?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
$textforurl_replace = array('-', '-', 'ae', 'oe', 'ue', 'Ae', 'Oe', 'Ue', 'ss', 'a', 'a', 'a', 'ae', 'o', 'o', 'o', 'o', 'u', 'u', 'e', 'e', 'e', 'e', 'i', 'y', 's', 'S', 'z', 'Z', 'c', 'a', 'o'); #'c', 'C', 'd', 'D', 'n', 'N', 'r', 'R', 't', 'T',
# ------------------------------------------------------------------------------
  function prepareTextForUrl($text)
# ------------------------------------------------------------------------------
# wandelt einen Text so um, dass er in einer URL verwendet werden kann
{
  global $textforurl_search, $textforurl_replace;

  return preg_replace('/-{2,}/', '-',
         preg_replace('#[^/0-9a-zA-Z_-]#', '-',
         str_replace($textforurl_search, $textforurl_replace, $text
          )));
}

# ------------------------------------------------------------------------------
  function text2modrewritetext($text)
# ------------------------------------------------------------------------------
{
  return urlencode(preg_replace('/-{2,}/', '-', prepareTextForUrl(str_replace(array('_', '/') , array('-', '-'), $text))));
}

# ------------------------------------------------------------------------------
  function text2modrewritefilename($text
    , $bTextConverted = false	# true, wenn der Text bereits konvertiert ist
    , $arrPath = 0	# Path, der vor den Dateinamen gesetzt werden soll
    , $countPath = -1	# Anzahl der Path-Eintraege, die aus dem Path-Array
  			# verwendet werden sollen, bei -1 sollen alle Eintraege genutzt werden
    , $seo_filename = '' # wenn ein vom Pfad unabhaengiger Dateipfad mit -namen verwendet werden soll
                         # Dieser seo_filename ist dann schon konvertiert
    )
# ------------------------------------------------------------------------------
{
  global $arrModRewritePath;

  $path = '';
  if ($seo_filename) {
    $path = '';
    # den seofilename erst mal nach text holen
    $text = $seo_filename;
    # Textersetzungen muessen ggf. trotzdem vorgenommen werden
    $text = prepareTextForUrl($text);
    # falls voreweg ein / ist, dann diesen wegnehmen
    if ($text[0] == '/') $text = substr($text, 1);
    $bTextConverted = true;
  } elseif ($arrPath) {
    $iEnde = ((-1) == $countPath) ? count($arrPath) : $countPath;
    # je nach Konfiguration Start der Namensbildung bei einer hoeheren Ebene
    $i = isset($arrModRewritePath['start_e']) ? (integer)($arrModRewritePath['start_e']) : 0;
    # wenn der Dateiname bei einer hoeheren Ebene gestartet werden soll, als ueberhaupt zur Verfuegung steht,
    # dann gehen wir auf die hoechste Ebene, die wir im Pfad ueberhaupt haben
    while ($i > $iEnde)
      --$i;
    # merken, wenn wir noch den ersten Eintrag auslesen
    $bFirst = true;
    for (; $i < $iEnde; ++$i) {
      $item = $arrPath[$i];
      # wenn es der erste Eintrag ist und wir ggf. ein Thema haben, das dort nicht im Pfad erscheinen soll,
      # dann dieses noch ueberpringen, falls es noch weitere Themen im Pfad gibt
      if ($bFirst && isset($arrModRewritePath['nostart_id']) &&
          ($arrModRewritePath['nostart_id'] == $item['p']) &&
          (($i + 1) <= $iEnde)) {
        # okay, wir nehmen diesen Eintrag nicht in den Pfad mit auf
      } else {
        $bezeichnung = empty($item['mr_bez']) ? text2modrewritetext($item['bez']) : $item['mr_bez'] ;
        # nur in den Pfad aufnehmen, wenn hier auch was entstanden ist
        if ($bezeichnung)
          $path .= $bezeichnung.'/';
      }
      # erster Eintrag ist auf jeden Fall vorbei
      if ($bFirst)
        $bFirst = false;
    }
  }

  # falls der Text bereits konvertiert ist, dann braucht er dies nicht ein zweites mal
  $filename = $bTextConverted ? $text : text2modrewritetext($text);
  # wenn leer, dann kein .htm anhaengen
  return $path.$filename.($filename ? '.htm' : '');
}

# ------------------------------------------------------------------------------
  function getURL(
    $tofilename = ''	# als Dateiname zu verwenden (noch nicht url-vorbereitet)
    , $bConverted = false # true, wenn bereits mod_rewrite vorbereitet
    , $argSeparator = '' # falls als argSeparator was spezielles verwendet werden soll
  )
# ------------------------------------------------------------------------------
{
  global $startscript;

  # Dateiname mit dem uebergebenen Text vorbereiten
  if ($tofilename) {
    # nur dann noch mal konvertieren, wenn dies noch nicht erfolgt ist
    $url = ($bConverted ? $tofilename : text2modrewritefilename($tofilename)).substr($startscript, strpos($startscript, '?'));
  } else {
    $url = $startscript;
  }

  # falls evtl. hier nun ein anderer argSeparator als im Standard verwendet werden soll
  if ($argSeparator && ($argSeparator != ARG_SEPARATOR)) {
    $url = str_replace(ARG_SEPARATOR, $argSeparator, $url);
  }

  return $url;
}

# ------------------------------------------------------------------------------
  function Initialisation(
    $bToShopInside = false,		# Parameter zur Anzeige,
                             		# ob man mit diesem Aufruf in den Shop geht
    $bNoCheckSessionTimeout = false,	# true, wenn keine Pruefung auf Session-Timeout erfolgen soll
    $bNoExitIfTimeout = false		# true, wenn kein Exit bei Sessionablauf erfolgen soll
    , $bCreateSession = false		# true, wenn wir hier die Session erstellen sollen, falls diese noch nicht da ist
    , $bNoCheckReferrer = false		# keine Pruefung auf den Referrer ggf.
    )
# ------------------------------------------------------------------------------
{
  global $bSideEntry, $SessionData, $SessionId, $useSessionId, $t, $p; # *** 25.01.19, Ira Tonert: auskommentiert: $CatNr,

  if (!$bSideEntry) {
    # *** 25.01.19, Ira Tonert: auskommentiert
    ## Katalogparameter auslesen, fuer die Navigation
    #$CatNr = intval(postgetinput2php('CatNr', 0));
    $t = intval(postgetinput2php('t', -1, 6));
    $p = intval(postgetinput2php('p', 0, 6));
    # wenn p noch 0, aber t gefuellt, dann p auf t setzen
    if (!$p && ($t > 0))
      $p = $t;

    # wir sind im Shop
    $SessionData = GetSessionData($bToShopInside, $bNoCheckSessionTimeout, false, $bCreateSession, $bNoCheckReferrer);
    # Absprung, falls Session bereits abgelaufen
    if (!$SessionData)
      if (!$bNoExitIfTimeout)
        exit();

    # kein Cache, also ist die wirkliche SessionId zu nutzen
    # ausser, wenn es ein Cookie gibt
    $useSessionId = isSessionCookie() ? '' : $SessionId;
  }
}

$act_basehref = '-1';
# ------------------------------------------------------------------------------
  function getBaseHRef()
# ------------------------------------------------------------------------------
/* ermittelt die Base-HRef
*/
{
  global $act_basehref, $T_www, $T_ssl;

  # base-Verzeichnis liefern
  if ('-1' == $act_basehref) {
    # basehref gibt es immer und dann abhaengig vom Protokoll
    $act_basehref = isHTTPS() ? $T_ssl : $T_www;
  }
  return $act_basehref;
}

# ------------------------------------------------------------------------------
  function assignFirsts(
    $bWithCustomerdates = false	# true, wenn auch die Kundendaten mit geliefert werden sollen
    , $bCustomerdatesInputfield = false	# true, wenn Kundendaten fuer Eingabefeld
    					# vorformatiert sein sollen
  )
# ------------------------------------------------------------------------------
{
  global $tpl, $useSessionId, $configarray, $shop, $T_ssl, $T_www, $custnr, $custinfo, $mwst_texts,
         $Languagefields, $DBVersion, $SessionId, $SessionIdNoReally, $URL_HTTP, $URL_HTTPS,
         $arrSpecialStandardFirstVariables, $charsetSites, $shop_language;

  # Base-href erst mal als @@@basehref@@@ retten, SessionIdnc auch setzen
  if ('@@@SessionId@@@' != $useSessionId) {
    $base = getBaseHRef();
    $tpl->assign('basehref', $base);
    # falls eine nicht wirkliche SessionId vorliegt, dann diese verwenden
    $tpl->assign('SessionIdnc', $SessionId ? $SessionId : (isset($SessionIdNoReally) ? $SessionIdNoReally : ''));
  } else {
    $tpl->assign('basehref', '@@@basehref@@@');
    $tpl->assign('SessionIdnc', '@@@SessionIdnc@@@');
  }

  # ggf. muss noch was individuelles zugewiesen werden
  if (isset($arrSpecialStandardFirstVariables))
    foreach ($arrSpecialStandardFirstVariables as $key => $item)
      $tpl->assign($key, $item);

  # Charset zuweisen
  $tpl->assign('site_charset', ($charsetSites == CHARSET_UTF_8) ? 'UTF-8' : 'ISO-8859-1');

  # das Sprachkuerzel des Shops zuweisen
  $tpl->assign('shoplanguage', $shop_language);

  $tpl->assign('SessionId', $useSessionId);
  $tpl->assign('shop', $shop);
  $tpl->assign('shop_titel', isset($configarray['SHOP_TITEL1']['PARAM_STRING']) ? evendo_db2html($configarray['SHOP_TITEL1']['PARAM_STRING']) : '');
  $tpl->assign('shoptitel', isset($configarray['SHOP_TITEL1']['PARAM_STRING']) ? evendo_db2html($configarray['SHOP_TITEL1']['PARAM_STRING']) : '');
  $tpl->assign('URL_SSL', $T_ssl);
  $tpl->assign('URL_WWW', $T_www);
  # je nachdem, ob wir per HTTP oder HTTPS dies aufrufen, liefern wir die URL auf das Shopverzeichnis
  $tpl->assign('URL_SHOPDIR', urlencode((isHTTPS() ? $T_ssl : $T_www)));
  $tpl->assign('URL_HTTP', $URL_HTTP);
  $tpl->assign('URL_HTTPS', $URL_HTTPS);
  $tpl->assign('URL', getURL());
  # Templatevariable fuer die Startseiten-URL
  $tpl->assign('URL_HOME', getHomeURL());
  $tpl->assign('EVENDO_SHOP_VERSION', $configarray['_SHOP_VERSION']['PARAM_STRING']);
  if (isset($custinfo['DEBKALKARTNETTO'])) {
    $tpl->assign('mwsttext', evendo_db2html(('J' == $custinfo['DEBKALKARTNETTO'])
      ? (isset($mwst_texts['netto']) ? $mwst_texts['netto'] : 'zzgl.')
      : (isset($mwst_texts['brutto']) ? $mwst_texts['brutto'] : 'inkl.')));
    # mit ausgeben, ob die Preise in Brutto oder in Netto anzuzeigen sind
    $tpl->assign('brutto_netto', ('J' == $custinfo['DEBKALKARTNETTO']) ? 'netto' : 'brutto');
  }

  # *** 12.06.20, Ira Tonert: Variablenpruefung
  $tpl->assign('wkz', empty($custinfo['WKZ']) ? '' : $custinfo['WKZ']);
  #$tpl->assign('wkz', $custinfo['WKZ']);

  if ($custnr && $bWithCustomerdates) {
    $query = 'select adressen.name, adressen.ort, adressen.strasse'.
             ', adressen.plz, adressen.hausnr, adressen.anrede, adressen.namezwei'.
             ', adressen.personanschrift, land.landesname'.
             # sprachabhaengigen Landestext ermitteln
             ($Languagefields ? ', landesname_'.$Languagefields : '').
        ' from adressen '.
        ' join land on land.landnr = adressen.landherkunft '.
        "where adressen.adrnr = $custnr";
    $custdates = DoSQL_simple_one($query, TRANSMODE_SENSITIVE);

    # sprachabhaengigen Landestext vorbereiten
    if ($Languagefields) {
      if ($custdates['LANDESNAME_'.$Languagefields]) {
        $custdates['LANDESNAME'] = $custdates['LANDESNAME_'.$Languagefields];
        unset($custdates['LANDESNAME_'.$Languagefields]);
      }
    }

    # Auslesen der Ansprechpartnerinformationen
    $perinfo = (isset($custdates['PERSONANSCHRIFT']) && ($custdates['PERSONANSCHRIFT'] == 'N')) ?
      getAnsprechpartner($custnr, 4, 'default_adrre') : 0;

    # ueberall den Inhalt erst mal in separater Variable vorbereiten,
    # dann je nach Flag fuer ein Eingabefeld oder fuer die Anzeige in HTML vorbereiten
    $sal_company = ($perinfo && $perinfo['NAME']) ? $custdates['NAME'] : '';
    $tpl->assign('SAL_COMPANY', $bCustomerdatesInputfield ? evendo_db2input($sal_company) : evendo_db2html($sal_company));

    # zweiter Firmenname
    $sal_company2 = (isset($custdates['PERSONANSCHRIFT']) && ($custdates['PERSONANSCHRIFT'] == 'N')) ? $custdates['NAMEZWEI'] : '';
    $tpl->assign('SAL_COMPANY2', $bCustomerdatesInputfield ? evendo_db2input($sal_company2) : evendo_db2html($sal_company2));

    $sal_vorname = ($perinfo && $perinfo['NAME'])
      ? $perinfo['NAMEZWEI']
      # wenn Kundenadresse eine Personenadresse ist, dann Name und Vorname vertauschen
      : (($custdates['PERSONANSCHRIFT'] == 'J') ? $custdates['NAMEZWEI'] : $custdates['NAME']);
    $tpl->assign('SAL_VORNAME', $bCustomerdatesInputfield ? evendo_db2input($sal_vorname) : evendo_db2html($sal_vorname));

    $sal_name = ($perinfo && $perinfo['NAME'])
      ? $perinfo['NAME']
      # wenn Kundenadresse eine Personenadresse ist, dann Name und Vorname vertauschen
      : (($custdates['PERSONANSCHRIFT'] == 'J') ? $custdates['NAME'] : $custdates['NAMEZWEI']);
    $tpl->assign('SAL_NAME', $bCustomerdatesInputfield ? evendo_db2input($sal_name) : evendo_db2html($sal_name));

    $sal_anrede = ($perinfo && $perinfo['NAME']) ? $perinfo['ANREDE'] : $custdates['ANREDE'];
    $tpl->assign('SAL_ANREDE', $bCustomerdatesInputfield ? evendo_db2input($sal_anrede) : evendo_db2html($sal_anrede));

    $sal_mail = getCustomerMailAddr();
    $tpl->assign('SAL_MAIL', $bCustomerdatesInputfield ? evendo_db2input($sal_mail) : evendo_db2html($sal_mail));

    $sal_ort = $custdates['ORT'];
    $tpl->assign('SAL_ORT', $bCustomerdatesInputfield ? evendo_db2input($sal_ort) : evendo_db2html($sal_ort));

    $sal_strasse = $custdates['STRASSE'];
    $tpl->assign('SAL_STRASSE', $bCustomerdatesInputfield ? evendo_db2input($sal_strasse) : evendo_db2html($sal_strasse));

    $sal_hausnr = $custdates['HAUSNR'];
    $tpl->assign('SAL_HAUSNR', $bCustomerdatesInputfield ? evendo_db2input($sal_hausnr) : evendo_db2html($sal_hausnr));

    $sal_plz = $custdates['PLZ'];
    $tpl->assign('SAL_PLZ', $bCustomerdatesInputfield ? evendo_db2input($sal_plz) : evendo_db2html($sal_plz));

    $sal_land = $custdates['LANDESNAME'];
    $tpl->assign('SAL_LAND', $bCustomerdatesInputfield ? evendo_db2input($sal_land) : evendo_db2html($sal_land));
  }

}

# ------------------------------------------------------------------------------
  function isOSWin()
# ------------------------------------------------------------------------------
{
  global $bOSWin;

  if (!isset($bOSWin)) {
    $bOSWin = false;
    # alles $_ENV durch getenv ersetzt
    if ((getenv('OSTYPE') && stristr(getenv('OSTYPE'), 'win')) ||
        (getenv('OS') && stristr(getenv('OS'), 'win')) ||
        # fuer Windows XP und Apache noch WINDIR abfragen
        stristr(getenv('OS'),'win') || (getenv('windir') && getenv('windir')))
      $bOSWin = true;
  }
  return $bOSWin;
}

# ------------------------------------------------------------------------------
  function ev_command($command)
# ------------------------------------------------------------------------------
# fuehrt ein Kommando aus
{
  global $shop;

  if (isOSWin()) {
    # Windows-Kommando
    $retdata = exec($command, $returns, $result);
    $retArray = array('sys' => 'win', 'returnstring' => implode("\n", $returns), 'result' => $result);
  } else {
    # Linux-Kommando
    # das 2>&1 ist wichtig, damit wir wirklich alle Ausgaben zurueck erhalten
    $fp = popen($command.' 2>&1', 'r');

    if ($fp) {
      $retdata = '';
      while (!feof($fp))
        $retdata .= fgets($fp, 4096);
      pclose($fp);

      $retArray = array('sys' => 'linux', 'returnstring' => $retdata, 'result' => 0);
    }
  }

  return isset($retArray) ? $retArray : 0;
}

  include LIBDIR.'/main.inc.php';

  if (!empty($bStartAgain)) {
    $bStartAgain = false;
    include LIBDIR.'/main.inc.php';
  }