libraries/blobstreaming.lib.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * @author          Raj Kissu Rajandran
   5  * @version     1.0
   6  * @package     BLOBStreaming
   7  */
   8
   9 /**
  10  * checks whether the necessary plugins for BLOBStreaming exist
  11  *
  12  * @access  public
  13  * @uses    PMA_Config::get()
  14  * @uses    PMA_Config::settings()
  15  * @uses    PMA_Config::set()
  16  * @uses    PMA_PluginsExist()
  17  * @uses    PMA_BS_SetVariables()
  18  * @uses    PMA_BS_GetVariables()
  19  * @uses    PMA_BS_SetFieldReferences()
  20  * @return  boolean
  21 */
  22 function checkBLOBStreamingPlugins()
  23 {
  24     // load PMA configuration
  25     $PMA_Config = $_SESSION['PMA_Config'];
  26
  27     // return if unable to load PMA configuration
  28     if (empty($PMA_Config))
  29         return FALSE;
  30
  31     // retrieve current server configuration
  32     $serverCfg = $PMA_Config->get('Servers');
  33
  34     if (isset($serverCfg[$GLOBALS['server']]))
  35         $serverCfg = $serverCfg[$GLOBALS['server']];
  36     else
  37         $serverCfg = null;
  38
  39     // return if unable to retrieve current server configuration
  40     if (!isset($serverCfg))
  41         return FALSE;
  42
  43     // if PHP extension in use is 'mysql', specify element 'PersistentConnections'
  44     if (isset($serverCfg['extension']) && "mysql" == $serverCfg['extension'])
  45         $serverCfg['PersistentConnections'] = $PMA_Config->settings['PersistentConnections'];
  46
  47     // if connection type is TCP, unload socket variable
  48     if (isset($serverCfg['connect_type']) && "tcp" == strtolower($serverCfg['connect_type']))
  49         $serverCfg['socket'] = "";
  50
  51     // define BS Plugin variables
  52     $allPluginsExist = TRUE;
  53
  54     $PMA_Config->set('PBXT_NAME', 'pbxt');
  55     $PMA_Config->set('PBMS_NAME', 'pbms');
  56
  57     $plugins[$PMA_Config->get('PBXT_NAME')]['Library'] = 'libpbxt.so';
  58     $plugins[$PMA_Config->get('PBXT_NAME')]['Exists'] = FALSE;
  59
  60     $plugins[$PMA_Config->get('PBMS_NAME')]['Library'] = 'libpbms.so';
  61     $plugins[$PMA_Config->get('PBMS_NAME')]['Exists'] = FALSE;
  62
  63     // retrieve state of BS plugins
  64     PMA_PluginsExist($plugins);
  65
  66     foreach ($plugins as $plugin_key=>$plugin)
  67         if (!$plugin['Exists'])
  68         {
  69             $allPluginsExist = FALSE;
  70             break;
  71         } // end if (!$plugin['Exists'])
  72
  73     // set variable indicating BS plugin existance
  74     $PMA_Config->set('BLOBSTREAMING_PLUGINS_EXIST', $allPluginsExist);
  75
  76     // do the plugins exist?
  77     if ($allPluginsExist)
  78     {
  79         // retrieve BS variables from PMA configuration
  80         $bs_set_variables = array();
  81
  82         $bs_set_variables[$PMA_Config->get('PBMS_NAME') . '_garbage_threshold'] = (isset($serverCfg['bs_garbage_threshold'])) ? $serverCfg['bs_garbage_threshold'] : NULL;
  83         $bs_set_variables[$PMA_Config->get('PBMS_NAME') . '_repository_threshold'] = (isset($serverCfg['bs_repository_threshold'])) ? $serverCfg['bs_repository_threshold'] : NULL;
  84         $bs_set_variables[$PMA_Config->get('PBMS_NAME') . '_temp_blob_timeout'] = (isset($serverCfg['bs_temp_blob_timeout'])) ? $serverCfg['bs_temp_blob_timeout'] : NULL;
  85         $bs_set_variables[$PMA_Config->get('PBMS_NAME') . '_temp_log_threshold'] = (isset($serverCfg['bs_temp_log_threshold'])) ? $serverCfg['bs_temp_log_threshold'] : NULL;
  86
  87         // set BS variables to PMA configuration defaults
  88         PMA_BS_SetVariables($bs_set_variables);
  89
  90         // retrieve updated BS variables (configurable and unconfigurable)
  91         $bs_variables = PMA_BS_GetVariables();
  92
  93         // if no BS variables exist, set plugin existance to false and return
  94         if (count($bs_variables) <= 0)
  95         {
  96             $PMA_Config->set('BLOBSTREAMING_PLUGINS_EXIST', FALSE);
  97             return FALSE;
  98         } // end if (count($bs_variables) <= 0)
  99
 100         // switch on BS field references
 101         if (strtolower($bs_variables[$PMA_Config->get('PBMS_NAME') . '_field_references']) == "off")
 102             if(!PMA_BS_SetFieldReferences('ON'))
 103                     return FALSE;
 104
 105         // get BS server port
 106         $BS_PORT = $bs_variables[$PMA_Config->get('PBMS_NAME') . '_port'];
 107
 108         // if no BS server port exists, set plugin existance to false and return
 109         if (!$BS_PORT)
 110         {
 111             $PMA_Config->set('BLOBSTREAMING_PLUGINS_EXIST', FALSE);
 112             return FALSE;
 113         } // end if (!$BS_PORT)
 114
 115         // add selected BS, CURL and fileinfo library variables to PMA configuration
 116         $PMA_Config->set('BLOBSTREAMING_PORT', $BS_PORT);
 117         $PMA_Config->set('BLOBSTREAMING_HOST', $serverCfg['host']);
 118         $PMA_Config->set('BLOBSTREAMING_SERVER', $serverCfg['host'] . ':' . $BS_PORT);
 119         $PMA_Config->set('CURL_EXISTS', FALSE);
 120         $PMA_Config->set('FILEINFO_EXISTS', FALSE);
 121
 122         // check if CURL exists
 123         if (function_exists("curl_init"))
 124         {
 125             // initialize curl handler
 126             $curlHnd = curl_init();
 127
 128             // CURL exists, set necessary variable and close resource
 129             if (!empty($curlHnd))
 130             {
 131                 $PMA_Config->set('CURL_EXISTS', TRUE);
 132                 curl_close($curlHnd);
 133             } // end if (!empty($curlHnd))
 134         } // end if (function_exists("curl_init"))
 135
 136         // check if PECL's fileinfo library exist
 137         $finfo = NULL;
 138
 139         if (function_exists("finfo_open"))
 140             $finfo = finfo_open(FILEINFO_MIME);
 141
 142         // fileinfo library exists, set necessary variable and close resource
 143         if (!empty($finfo))
 144         {
 145             $PMA_Config->set('FILEINFO_EXISTS', TRUE);
 146             finfo_close($finfo);
 147         } // end if (!empty($finfo))
 148     } // end if ($allPluginsExist)
 149     else
 150         return FALSE;
 151
 152     $bs_tables = array();
 153
 154     // specify table structure for BS reference table
 155     $bs_tables[$PMA_Config->get('PBMS_NAME') . '_reference'] = array();
 156     $bs_tables[$PMA_Config->get('PBMS_NAME') . '_reference']['struct'] = <<<EOD
 157         CREATE TABLE {$PMA_Config->get('PBMS_NAME')}_reference
 158         (
 159          Table_name        CHAR(64) COMMENT 'The name of the referencing table',
 160          Blob_id           BIGINT COMMENT 'The BLOB reference number - part of the BLOB URL',
 161          Column_name       CHAR(64) COMMENT 'The column name of the referencing field',
 162          Row_condition     VARCHAR(255) COMMENT 'This condition identifies the row in the table',
 163          Blob_url          VARCHAR(200) COMMENT 'The BLOB URL for HTTP GET access',
 164          Repository_id     INT COMMENT 'The repository file number of the BLOB',
 165          Repo_blob_offset  BIGINT COMMENT 'The offset in the repository file',
 166          Blob_size         BIGINT COMMENT 'The size of the BLOB in bytes',
 167          Deletion_time     TIMESTAMP COMMENT 'The time the BLOB was deleted',
 168          Remove_in         INT COMMENT 'The number of seconds before the reference/BLOB is removed perminently',
 169          Temp_log_id       INT COMMENT 'Temporary log number of the referencing deletion entry',
 170          Temp_log_offset   BIGINT COMMENT 'Temporary log offset of the referencing deletion entry'
 171         ) ENGINE=PBMS;
 172 EOD;
 173
 174     // specify table structure for BS repository table
 175     $bs_tables[$PMA_Config->get('PBMS_NAME') . '_repository'] = array();
 176     $bs_tables[$PMA_Config->get('PBMS_NAME') . '_repository']['struct'] = <<<EOD
 177         CREATE TABLE {$PMA_Config->get('PBMS_NAME')}_repository
 178         (
 179          Repository_id     INT COMMENT 'The repository file number',
 180          Repo_blob_offset  BIGINT COMMENT 'The offset of the BLOB in the repository file',
 181          Blob_size         BIGINT COMMENT 'The size of the BLOB in bytes',
 182          Head_size         SMALLINT UNSIGNED COMMENT 'The size of the BLOB header - proceeds the BLOB data',
 183          Access_code       INT COMMENT 'The 4-byte authorisation code required to access the BLOB - part of the BLOB URL',
 184          Creation_time     TIMESTAMP COMMENT 'The time the BLOB was created',
 185          Last_ref_time     TIMESTAMP COMMENT 'The last time the BLOB was referenced',
 186          Last_access_time  TIMESTAMP COMMENT 'The last time the BLOB was accessed (read)',
 187          Content_type      CHAR(128) COMMENT 'The content type of the BLOB - returned by HTTP GET calls',
 188          Blob_data         LONGBLOB COMMENT 'The data of this BLOB'
 189         ) ENGINE=PBMS;
 190 EOD;
 191
 192     // specify table structure for BS custom content type table
 193     $bs_tables[$PMA_Config->get('PBMS_NAME') . '_custom_content_type'] = array();
 194     $bs_tables[$PMA_Config->get('PBMS_NAME') . '_custom_content_type']['struct'] = <<<EOD
 195         CREATE TABLE {$PMA_Config->get('PBMS_NAME')}_custom_content_type
 196         (
 197          Blob_url           VARCHAR(200) COMMENT 'The BLOB URL for HTTP GET access',
 198          Content_type       VARCHAR(255) COMMENT 'The custom MIME type for a given BLOB reference as specified by the user',
 199
 200          PRIMARY KEY(Blob_url)
 201         );
 202 EOD;
 203
 204     // add BS tables to PMA configuration
 205     $PMA_Config->set('BLOBSTREAMING_TABLES', $bs_tables);
 206
 207     return TRUE;
 208 }
 209
 210 /**
 211  * checks for databases that support BLOBStreaming
 212  *
 213  * @access  public
 214  * @uses    PMA_GetDatabases()
 215  * @uses    PMA_TablesExist()
 216  * @uses    PMA_Config::set()
 217 */
 218 function checkBLOBStreamableDatabases()
 219 {
 220     // load PMA configuration
 221     $PMA_Config = $_SESSION['PMA_Config'];
 222
 223     // return if unable to load PMA configuration
 224     if (empty($PMA_Config))
 225         return;
 226
 227     // retrieve BS tables from PMA configuration
 228     $session_bs_tables = $PMA_Config->get('BLOBSTREAMING_TABLES');
 229
 230     $bs_databases = array();
 231     $bs_tables = array();
 232
 233     // return if BS tables do not exist
 234     if (!$session_bs_tables)
 235         return;
 236
 237     foreach ($session_bs_tables as $table_key=>$table)
 238     {
 239         $bs_tables[$table_key] = array();
 240         $bs_tables[$table_key]['Exists'] = FALSE;
 241     }
 242
 243     // retrieve MySQL databases
 244     $databases = PMA_GetDatabases();
 245
 246     // check if BS tables exist for each database
 247     foreach ($databases as $db_key=>$db_name)
 248     {
 249         $bs_databases[$db_name] = $bs_tables;
 250
 251         PMA_TablesExist($bs_databases[$db_name], $db_name);
 252     }
 253
 254     // set BS databases in PMA configuration
 255     $PMA_Config->set('BLOBSTREAMABLE_DATABASES', $bs_databases);
 256 }
 257
 258 /**
 259  * checks whether a set of plugins exist
 260  *
 261  * @access  public
 262  * @param   array - a list of plugin names and accompanying library filenames to check for
 263  * @uses    PMA_DBI_query()
 264  * @uses    PMA_DBI_fetch_assoc()
 265 */
 266 function PMA_PluginsExist(&$plugins)
 267 {
 268     if (PMA_MYSQL_INT_VERSION < 50109) {
 269         return;
 270     }
 271     // run query to retrieve MySQL plugins
 272     $query = "SHOW PLUGINS";
 273     $result = PMA_DBI_query($query);
 274
 275     // while there are records to parse
 276         while ($data = @PMA_DBI_fetch_assoc($result))
 277         {
 278         // reset plugin state
 279         $state = TRUE;
 280
 281         // check if required plugins exist
 282                 foreach ($plugins as $plugin_key=>$plugin)
 283                         if (!$plugin['Exists'])
 284                                 if (
 285                                         strtolower($data['Library']) == strtolower($plugin['Library']) &&
 286                                         $data['Status'] == "ACTIVE"
 287                                    )
 288                                         $plugins[$plugin_key]['Exists'] = TRUE;
 289                 else
 290                     if ($state)
 291                         $state = FALSE;
 292
 293         // break if all necessary plugins are found before all records are parsed
 294         if ($state)
 295             break;
 296     } // end while ($data = @PMA_DBI_fetch_assoc($result))
 297 }
 298
 299 /**
 300  * checks whether a given set of tables exist in a given database
 301  *
 302  * @access  public
 303  * @param   array - list of tables to look for
 304  * @param   string - name of database
 305  * @uses    PMA_DBI_select_db()
 306  * @uses    PMA_DBI_query()
 307  * @uses    PMA_DBI_fetch_assoc()
 308  */
 309 function PMA_TablesExist(&$tables, $db_name)
 310 {
 311     // select specified database
 312     PMA_DBI_select_db($db_name);
 313
 314     // run query to retrieve tables in specified database
 315     $query = "SHOW TABLES";
 316     $result = PMA_DBI_query($query);
 317
 318     // while there are records to parse
 319     while ($data = @PMA_DBI_fetch_assoc($result))
 320     {
 321         $state = TRUE;
 322
 323         // check if necessary tables exist
 324         foreach ($tables as $table_key=>$table)
 325             if (!$table['Exists'])
 326                 if ($data['Tables_in_' . $db_name] == $table_key)
 327                     $tables[$table_key]['Exists'] = TRUE;
 328                 else
 329                     if ($state)
 330                         $state = FALSE;
 331
 332         // break if necessary tables are found before all records are parsed
 333         if ($state)
 334             break;
 335     } // end while ($data = @PMA_DBI_fetch_assoc($result))
 336 }
 337
 338 /**
 339  * returns a list of databases
 340  *
 341  * @access  public
 342  * @uses    PMA_DBI_query()
 343  * @uses    PMA_DBI_fetch_assoc()
 344  * @return  array - list of databases acquired via MySQL
 345 */
 346 function PMA_GetDatabases()
 347 {
 348     // run query to retrieve databases
 349     $query = "SHOW DATABASES";
 350     $result = PMA_DBI_query($query);
 351
 352     $databases = array();
 353
 354     // while there are records to parse
 355     while ($data = @PMA_DBI_fetch_assoc($result))
 356         $databases[] = $data['Database'];
 357
 358     // return list of databases
 359     return $databases;
 360 }
 361
 362 /**
 363  * sets BLOBStreaming variables to a list of specified arguments
 364  * @access  public
 365  * @uses    PMA_DBI_query()
 366  * @returns boolean - success of variables setup
 367 */
 368
 369 function PMA_BS_SetVariables($bs_variables)
 370 {
 371     // if no variables exist in array, return false
 372     if (empty($bs_variables) || count($bs_variables) == 0)
 373         return FALSE;
 374
 375     // set BS variables to those specified in array
 376     foreach ($bs_variables as $key=>$val)
 377         if (!is_null($val) && strlen($val) > 0)
 378         {
 379             // set BS variable to specified value
 380             $query = "SET GLOBAL $key=" . PMA_sqlAddSlashes($val);
 381             $result = PMA_DBI_query($query);
 382
 383             // if query fails execution, return false
 384             if (!$result)
 385                 return FALSE;
 386         } // end if (!is_null($val) && strlen($val) > 0)
 387
 388     // return true on success
 389     return TRUE;
 390 }
 391
 392 /**
 393  * returns a list of BLOBStreaming variables used by MySQL
 394  *
 395  * @access  public
 396  * @uses    PMA_Config::get()
 397  * @uses    PMA_DBI_query()
 398  * @uses    PMA_DBI_fetch_assoc()
 399  * @return  array - list of BLOBStreaming variables
 400 */
 401 function PMA_BS_GetVariables()
 402 {
 403     // load PMA configuration
 404     $PMA_Config = $_SESSION['PMA_Config'];
 405
 406     // return if unable to load PMA configuration
 407     if (empty($PMA_Config))
 408         return NULL;
 409
 410     // run query to retrieve BS variables
 411     $query = "SHOW VARIABLES LIKE '%" . $PMA_Config->get('PBMS_NAME') . "%'";
 412     $result = PMA_DBI_query($query);
 413
 414     $BS_Variables = array();
 415
 416     // while there are records to retrieve
 417     while ($data = @PMA_DBI_fetch_assoc($result))
 418         $BS_Variables[$data['Variable_name']] = $data['Value'];
 419
 420     // return BS variables
 421     return $BS_Variables;
 422 }
 423
 424 /**
 425  * sets the BLOBStreaming global field references to ON/OFF
 426  *
 427  * @access  public
 428  * @param   string - ON or OFF
 429  * @uses    PMA_Config::get()
 430  * @uses    PMA_sqlAddslashes()
 431  * @uses    PMA_DBI_query()
 432  * @return  boolean - success/failure of query execution
 433 */
 434 function PMA_BS_SetFieldReferences($val)
 435 {
 436     // load PMA configuration
 437     $PMA_Config = $_SESSION['PMA_Config'];
 438
 439     // return if unable to load PMA configuration
 440     if (empty($PMA_Config))
 441         return FALSE;
 442
 443     // set field references to value specified
 444     $query = "SET GLOBAL " . $PMA_Config->get('PBMS_NAME') . "_field_references=" . PMA_sqlAddslashes($val);
 445     $result = PMA_DBI_try_query($query, null, 0);
 446
 447     // get last known error (if applicable)
 448     PMA_DBI_getError();
 449
 450     // return success of query execution
 451     if ($result && 0 == $GLOBALS['errno'])
 452         return TRUE;
 453     else
 454         return FALSE;
 455 }
 456
 457 /**
 458  * gets the SQL table definition for a given BLOBStreaming table
 459  *
 460  * @access  public
 461  * @param   string - table name
 462  * @uses    PMA_Config::get()
 463  * @return  string - SQL table definition
 464 */
 465 function PMA_BS_GetTableStruct($tbl_name)
 466 {
 467     // retrieve table structures for BS tables
 468     $bs_tables = $_SESSION['PMA_Config']->get('BLOBSTREAMING_TABLES');
 469
 470     // return if tables don't exist
 471     if (!$bs_tables)
 472         return;
 473
 474     // return if specified table doesn't exist in collection of BS tables
 475     if (!isset($bs_tables[$tbl_name]))
 476         return;
 477
 478     // return specified table's structure
 479     return $bs_tables[$tbl_name]['struct'];
 480 }
 481
 482 /**
 483  * creates the BLOBStreaming tables for a given database
 484  *
 485  * @access  public
 486  * @param   string - database name
 487  * @uses    PMA_Config::get()
 488  * @uses    PMA_DBI_select_db()
 489  * @uses    PMA_DBI_query()
 490  * @uses    PMA_BS_GetTableStruct()
 491  * @return  boolean - success/failure of transactional query execution
 492 */
 493 function PMA_BS_CreateTables($db_name)
 494 {
 495     // retrieve BS tables
 496     $bs_tables = $_SESSION['PMA_Config']->get('BLOBSTREAMING_TABLES');
 497
 498     // select specified database
 499     PMA_DBI_select_db($db_name);
 500
 501     // create necessary BS tables for specified database
 502     foreach ($bs_tables as $table_key=>$table)
 503     {
 504         $result = PMA_DBI_query(PMA_BS_GetTableStruct($table_key));
 505
 506         // return false if query execution fails
 507         if (!$result)
 508             return FALSE;
 509     }
 510
 511     // return true on success
 512     return TRUE;
 513 }
 514
 515 /**
 516  * drops BLOBStreaming tables for a given database
 517  *
 518  * @access  public
 519  * @param   string - database name
 520  * @uses    PMA_Config::get()
 521  * @uses    PMA_DBI_select_db()
 522  * @uses    PMA_backquote()
 523  * @uses    PMA_DBI_query()
 524  * @return  boolean - success/failure of transactional query execution
 525 */
 526 function PMA_BS_DropTables($db_name)
 527 {
 528     // load PMA configuration
 529     $PMA_Config = $_SESSION['PMA_Config'];
 530
 531     // return if unable to load PMA configuration
 532     if (empty($PMA_Config))
 533         return FALSE;
 534
 535     // retrieve BS tables
 536     $bs_tables = $PMA_Config->get('BLOBSTREAMING_TABLES');
 537
 538     // select specified database
 539     PMA_DBI_select_db($db_name);
 540
 541     // drop BS tables
 542     foreach ($bs_tables as $table_key=>$table)
 543     {
 544         $query = "DROP TABLE IF EXISTS " . PMA_backquote($table_key);
 545         $result = PMA_DBI_query($query);
 546
 547         // return false if query execution fails
 548         if (!$result)
 549             return FALSE;
 550     }
 551
 552     // return true on success
 553     return TRUE;
 554 }
 555
 556 /**
 557  * returns the field name for a primary key of a given table in a given database
 558  *
 559  * @access  public
 560  * @param   string - database name
 561  * @param   string - table name
 562  * @uses    PMA_DBI_select_db()
 563  * @uses    PMA_backquote()
 564  * @uses    PMA_DBI_query()
 565  * @uses    PMA_DBI_fetch_assoc()
 566  * @return  string - field name for primary key
 567 */
 568 function PMA_BS_GetPrimaryField($db_name, $tbl_name)
 569 {
 570     // load PMA configuration
 571     $PMA_Config = $_SESSION['PMA_Config'];
 572
 573     // return if unable to load PMA configuration
 574     if (empty($PMA_Config))
 575         return FALSE;
 576
 577     // select specified database
 578     PMA_DBI_select_db($db_name);
 579
 580     // retrieve table fields
 581     $query = "SHOW FULL FIELDS FROM " . PMA_backquote($tbl_name);
 582     $result = PMA_DBI_query($query);
 583
 584     // while there are records to parse
 585     while ($data = PMA_DBI_fetch_assoc($result))
 586         if ("PRI" == $data['Key'])
 587             return $data['Field'];
 588
 589     // return NULL on no primary key
 590     return NULL;
 591 }
 592
 593 /**
 594  * checks whether a BLOB reference exists in the BLOB repository
 595  *
 596  * @access  public
 597  * @param   string - BLOB reference
 598  * @param   string - database name
 599  * @uses    PMA_DBI_select_db()
 600  * @uses    PMA_backquote()
 601  * @uses    PMA_Config::get()
 602  * @uses    PMA_sqlAddslashes()
 603  * @uses    PMA_DBI_query()
 604  * @return  boolean - existence of BLOB reference
 605 */
 606 function PMA_BS_ReferenceExists($bs_reference, $db_name)
 607 {
 608     $referenceExists = FALSE;
 609
 610     // return false on invalid BS reference
 611     if (strlen ($bs_reference) < strlen ("~*$db_name/~") || "~*$db_name/~" != substr ($bs_reference, 0, strlen ($db_name) + 4))
 612         return $referenceExists;
 613
 614     // load PMA configuration
 615     $PMA_Config = $_SESSION['PMA_Config'];
 616
 617     // return if unable to load PMA configuration
 618     if (empty($PMA_Config))
 619         return $referenceExists;
 620
 621     // select specified database
 622     PMA_DBI_select_db($db_name);
 623
 624     // run query on BS reference retrieval
 625     $query = "SELECT * FROM " . PMA_backquote($PMA_Config->get('PBMS_NAME') . "_reference") . " WHERE Blob_url='" . PMA_sqlAddslashes($bs_reference) . "'";
 626     $result = PMA_DBI_query($query);
 627
 628     // if record exists
 629     if ($data = @PMA_DBI_fetch_assoc($result))
 630         $referenceExists = TRUE;
 631
 632     // return reference existance
 633     return $referenceExists;
 634 }
 635
 636 /**
 637  * creates a HTTP link to a given blob reference for a given database
 638  *
 639  * @access  public
 640  * @param   string - BLOB reference
 641  * @param   string - database name
 642  * @uses    PMA_Config::get()
 643  * @uses    PMA_DBI_select_db()
 644  * @uses    PMA_backquote()
 645  * @uses    PMA_sqlAddslashes()
 646  * @uses    PMA_DBI_query()
 647  * @uses    PMA_DBI_fetch_assoc()
 648  * @return  string - HTTP link or Error
 649 */
 650 function PMA_BS_CreateReferenceLink($bs_reference, $db_name)
 651 {
 652     // load PMA configuration
 653     $PMA_Config = $_SESSION['PMA_Config'];
 654
 655     // return if unable to load PMA configuration
 656     if (empty($PMA_Config))
 657         return '';
 658
 659     // generate bs reference link
 660     $bs_ref_link = 'http://' . $PMA_Config->get('BLOBSTREAMING_SERVER') . '/' . $bs_reference;
 661
 662     // select specified database
 663     PMA_DBI_select_db($db_name);
 664
 665     $pbms_repo_bq = PMA_backquote($PMA_Config->get('PBMS_NAME') . "_repository");
 666     $pbms_ref_bq = PMA_backquote($PMA_Config->get('PBMS_NAME') . "_reference");
 667     $pbms_cust_content_bq = PMA_backquote($PMA_Config->get('PBMS_NAME') . "_custom_content_type");
 668
 669     // run query on determining specified BS reference
 670     $query = "SELECT $pbms_repo_bq.Content_type, $pbms_cust_content_bq.Content_type AS Custom_type";
 671     $query .= " FROM $pbms_repo_bq LEFT JOIN $pbms_ref_bq ON";
 672     $query .= "$pbms_repo_bq.Repository_id=$pbms_ref_bq.Repository_id";
 673     $query .= " AND $pbms_repo_bq.Blob_size=$pbms_ref_bq.Blob_size";
 674     $query .= " AND $pbms_repo_bq.Repo_blob_offset=$pbms_ref_bq.Repo_blob_offset";
 675     $query .= " LEFT JOIN $pbms_cust_content_bq ON $pbms_cust_content_bq.Blob_url=$pbms_ref_bq.Blob_url";
 676     $query .= " WHERE $pbms_ref_bq.Blob_url='" . PMA_sqlAddslashes($bs_reference) . "'";
 677
 678     $result = PMA_DBI_query($query);
 679
 680     // if record exists
 681     if ($data = @PMA_DBI_fetch_assoc($result))
 682     {
 683         // determine content-type for BS repository file (original or custom)
 684         $is_custom_type = false;
 685
 686         if (isset($data['Custom_type']))
 687         {
 688                 $content_type = $data['Custom_type'];
 689                 $is_custom_type = true;
 690         }
 691         else
 692                 $content_type = $data['Content_type'];
 693
 694         if (!$content_type)
 695             $content_type = NULL;
 696
 697         $output = "<a href=\"#\" onclick=\"requestMIMETypeChange('" . urlencode($db_name) . "', '" . urlencode($GLOBALS['table']) . "', '" . urlencode($bs_reference) . "', '" . urlencode($content_type) . "')\">$content_type</a>";
 698
 699         // specify custom HTML for various content types
 700         switch ($content_type)
 701         {
 702             // no content specified
 703             case NULL:
 704                 $output = "NULL";
 705                 break;
 706             // image content
 707             case 'image/jpeg':
 708             case 'image/png':
 709                 $output .= ' (<a href="' . $bs_ref_link . '" target="new">' . $GLOBALS['strViewImage'] . '</a>)';
 710                 break;
 711             // audio content
 712             case 'audio/mpeg':
 713                 $output .= ' (<a href="#" onclick="popupBSMedia(\'' . PMA_generate_common_url() . '\',\'' . urlencode($bs_reference) . '\', \'' . urlencode($content_type) . '\',' . ($is_custom_type ? 1 : 0) . ', 640, 120)">' . $GLOBALS['strPlayAudio']. '</a>)';
 714                 break;
 715             // video content
 716             case 'application/x-flash-video':
 717             case 'video/mpeg':
 718                 $output .= ' (<a href="#" onclick="popupBSMedia(\'' . PMA_generate_common_url() . '\',\'' . urlencode($bs_reference) . '\', \'' . urlencode($content_type) . '\',' . ($is_custom_type ? 1 : 0) . ', 640, 480)">' . $GLOBALS['strViewVideo'] . '</a>)';
 719                 break;
 720             // unsupported content. specify download
 721             default:
 722                 $output .= ' (<a href="' . $bs_ref_link . '" target="new">' . $GLOBALS['strDownloadFile']. '</a>)';
 723         }
 724
 725         // return HTML
 726         return $output;
 727     } // end if ($data = @PMA_DBI_fetch_assoc($result))
 728
 729     // return on error
 730     return 'Error';
 731 }
 732
 733 ?>