aschwarz/Leitgedanken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Alexander Schwarz
2022-11-21 09:47:28 +01:00
commit 76cec83d26
11652 changed files with 1980467 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2979
#pma/doc/html/_sources/config.txt Normal file
View File

File diff suppressed because it is too large Load Diff

49
#pma/doc/html/_sources/copyright.txt Normal file
View File

@ -0,0 +1,49 @@
.. _copyright:
Copyright
=========
.. code-block:: none
Copyright (C) 1998-2000 Tobias Ratschiller <tobias_at_ratschiller.com>
Copyright (C) 2001-2014 Marc Delisle <marc_at_infomarc.info>
Olivier Müller <om_at_omnis.ch>
Robin Johnson <robbat2_at_users.sourceforge.net>
Alexander M. Turek <me_at_derrabus.de>
Michal Čihař <michal_at_cihar.com>
Garvin Hicking <me_at_supergarv.de>
Michael Keck <mkkeck_at_users.sourceforge.net>
Sebastian Mendel <cybot_tm_at_users.sourceforge.net>
[check credits for more details]
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License version 2, as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
Third party licenses
++++++++++++++++++++
phpMyAdmin includes several third party libraries which come under their
respective licenses.
jQuery's license, which is where we got the files under js/jquery/ is
(MIT|GPL), a copy of each license is available in this repository (GPL
is available as LICENSE, MIT as js/jquery/MIT-LICENSE.txt).
TCPDF which is located under libraries/tcpdf is released under GPL
version 3 and the license is available as libraries/tcpdf/LICENSE.TXT.
DejaVu fonts which are located under libraries/tcpdf/fonts/ and their
license is documented in
libraries/tcpdf/fonts/dejavu-fonts-ttf-2.33/LICENSE.
PHP-gettext which is located under libraries/php-gettext/ is released
under GPL version 2 license which is available in the LICENSE file.

1111
#pma/doc/html/_sources/credits.txt Normal file
View File

File diff suppressed because it is too large Load Diff

12
#pma/doc/html/_sources/developers.txt Normal file
View File

@ -0,0 +1,12 @@
.. _developers:
Developers Information
======================
phpMyAdmin is Open Source, so you're invited to contribute to it. Many
great features have been written by other people and you too can help
to make phpMyAdmin a useful tool.
You can check out all the possibilities to contribute in the
`contribute section on our website
<https://www.phpmyadmin.net/contribute/>`_.

2220
#pma/doc/html/_sources/faq.txt Normal file
View File

File diff suppressed because it is too large Load Diff

401
#pma/doc/html/_sources/glossary.txt Normal file
View File

@ -0,0 +1,401 @@
.. _glossary:
Glossary
========
From Wikipedia, the free encyclopedia
.. glossary::
.htaccess
the default name of Apache's directory-level configuration file.
.. seealso:: <https://www.wikipedia.org/wiki/.htaccess>
ACL
Access Contol List
Blowfish
a keyed, symmetric block cipher, designed in 1993 by Bruce Schneier.
.. seealso:: <https://www.wikipedia.org/wiki/Blowfish_(cipher)>
Browser
a software application that enables a user to display and interact with text, images, and other information typically located on a web page at a website on the World Wide Web.
.. seealso:: <https://en.wikipedia.org/wiki/Web_browser>
bzip2
a free software/open source data compression algorithm and program developed by Julian Seward.
.. seealso:: <https://www.wikipedia.org/wiki/Bzip2>
CGI
Common Gateway Interface is an important World Wide Web technology that
enables a client web browser to request data from a program executed on
the Web server.
.. seealso:: <https://www.wikipedia.org/wiki/CGI>
Changelog
a log or record of changes made to a project.
.. seealso:: <https://www.wikipedia.org/wiki/Changelog>
Client
a computer system that accesses a (remote) service on another computer by some kind of network.
.. seealso:: <https://www.wikipedia.org/wiki/Client_(computing)>
column
a set of data values of a particular simple type, one for each row of the table.
.. seealso:: <https://www.wikipedia.org/wiki/Column_(database)>
Cookie
a packet of information sent by a server to a World Wide Web browser and then sent back by the browser each time it accesses that server.
.. seealso:: <https://www.wikipedia.org/wiki/HTTP_cookie>
CSV
Comma- separated values
.. seealso:: <https://www.wikipedia.org/wiki/Comma-separated_values>
DB
look at :term:`database`
database
an organized collection of data.
.. seealso:: <https://www.wikipedia.org/wiki/Database>
Engine
look at :term:`storage engines`
extension
a PHP module that extends PHP with additional functionality.
.. seealso:: <https://www.wikipedia.org/wiki/extension>
FAQ
Frequently Asked Questions is a list of commonly asked question and there
answers.
.. seealso:: <https://www.wikipedia.org/wiki/FAQ>
Field
one part of divided data/columns.
.. seealso:: <https://www.wikipedia.org/wiki/Field_(computer_science)>
foreign key
a column or group of columns in a database row that point to a key column
or group of columns forming a key of another database row in some
(usually different) table.
.. seealso:: <https://www.wikipedia.org/wiki/Foreign_key>
FPDF
the free :term:`PDF` library
.. seealso:: <http://www.fpdf.org/>
GD
Graphics Library by Thomas Boutell and others for dynamically manipulating images.
.. seealso:: <https://www.wikipedia.org/wiki/GD_Graphics_Library>
GD2
look at :term:`gd`
gzip
gzip is short for GNU zip, a GNU free software file compression program.
.. seealso:: <https://www.wikipedia.org/wiki/Gzip>
host
any machine connected to a computer network, a node that has a hostname.
.. seealso:: <https://www.wikipedia.org/wiki/Host>
hostname
the unique name by which a network attached device is known on a network.
.. seealso:: <https://www.wikipedia.org/wiki/Hostname>
HTTP
HyperText Transfer Protocol is the primary method used to transfer or
convey information on the World Wide Web.
.. seealso:: <https://www.wikipedia.org/wiki/HyperText_Transfer_Protocol>
https
a :term:`HTTP`-connection with additional security measures.
.. seealso:: <https://www.wikipedia.org/wiki/Https:_URI_scheme>
IEC
International Electrotechnical Commission
IIS
Internet Information Services is a set of Internet-based services for
servers using Microsoft Windows.
.. seealso:: <https://www.wikipedia.org/wiki/Internet_Information_Services>
Index
a feature that allows quick access to the rows in a table.
.. seealso:: <https://www.wikipedia.org/wiki/Index_(database)>
IP
Internet Protocol is a data-oriented protocol used by source and
destination hosts for communicating data across a packet-switched
internetwork.
.. seealso:: <https://www.wikipedia.org/wiki/Internet_Protocol>
IP Address
a unique number that devices use in order to identify and communicate with each other on a network utilizing the Internet Protocol standard.
.. seealso:: <https://www.wikipedia.org/wiki/IP_Address>
IPv6
IPv6 (Internet Protocol version 6) is the latest revision of the
Internet Protocol (:term:`IP`), designed to deal with the
long-anticipated problem of its precedessor IPv4 running out of addresses.
.. seealso:: <https://www.wikipedia.org/wiki/IPv6>
ISAPI
Internet Server Application Programming Interface is the API of Internet Information Services (IIS).
.. seealso:: <https://www.wikipedia.org/wiki/ISAPI>
ISP
Internet service provider is a business or organization that offers users
access to the Internet and related services.
.. seealso:: <https://www.wikipedia.org/wiki/ISP>
ISO
International Standards Organisation
JPEG
a most commonly used standard method of lossy compression for photographic images.
.. seealso:: <https://www.wikipedia.org/wiki/JPEG>
JPG
look at :term:`jpeg`
Key
look at :term:`index`
LATEX
a document preparation system for the TEX typesetting program.
.. seealso:: <https://www.wikipedia.org/wiki/LaTeX>
Mac
Apple Macintosh is line of personal computers is designed, developed, manufactured, and marketed by Apple Computer.
.. seealso:: <https://www.wikipedia.org/wiki/Mac>
Mac OS X
the operating system which is included with all currently shipping Apple Macintosh computers in the consumer and professional markets.
.. seealso:: <https://www.wikipedia.org/wiki/Mac_OS_X>
MCrypt
a cryptographic library.
.. seealso:: <https://www.wikipedia.org/wiki/MCrypt>
mcrypt
the MCrypt PHP extension.
.. seealso:: <https://php.net/mcrypt>
MIME
Multipurpose Internet Mail Extensions is
an Internet Standard for the format of e-mail.
.. seealso:: <https://www.wikipedia.org/wiki/MIME>
module
some sort of extension for the Apache Webserver.
.. seealso:: <https://www.wikipedia.org/wiki/module>
mod_proxy_fcgi
an Apache module implmenting a Fast CGI interface; PHP can be run as a CGI module, FastCGI, or
directly as an Apache module.
MySQL
a multithreaded, multi-user, SQL (Structured Query Language) Database Management System (DBMS).
.. seealso:: <https://www.wikipedia.org/wiki/MySQL>
mysqli
the improved MySQL client PHP extension.
.. seealso:: <https://php.net/mysqli>
mysql
the MySQL client PHP extension.
.. seealso:: <https://php.net/mysql>
OpenDocument
open standard for office documents.
.. seealso:: <https://www.wikipedia.org/wiki/OpenDocument>
OS X
look at :term:`Mac OS X`.
.. seealso:: <https://www.wikipedia.org/wiki/OS_X>
PDF
Portable Document Format is a file format developed by Adobe Systems for
representing two dimensional documents in a device independent and
resolution independent format.
.. seealso:: <https://www.wikipedia.org/wiki/Portable_Document_Format>
PEAR
the PHP Extension and Application Repository.
.. seealso:: <https://pear.php.net/>
PCRE
Perl Compatible Regular Expressions is the perl-compatible regular
expression functions for PHP
.. seealso:: <https://php.net/pcre>
PHP
short for "PHP: Hypertext Preprocessor", is an open-source, reflective
programming language used mainly for developing server-side applications
and dynamic web content, and more recently, a broader range of software
applications.
.. seealso:: <https://www.wikipedia.org/wiki/PHP>
port
a connection through which data is sent and received.
.. seealso:: <https://www.wikipedia.org/wiki/Port_(computing)>
RFC
Request for Comments (RFC) documents are a series of memoranda
encompassing new research, innovations, and methodologies applicable to
Internet technologies.
.. seealso:: <https://www.wikipedia.org/wiki/Request_for_Comments>
RFC 1952
GZIP file format specification version 4.3
.. seealso:: :rfc:`1952`
Row (record, tuple)
represents a single, implicitly structured data item in a table.
.. seealso:: <https://www.wikipedia.org/wiki/Row_(database)>
Server
a computer system that provides services to other computing systems over a network.
.. seealso:: <https://www.wikipedia.org/wiki/Server_(computing)>
Storage Engines
handlers for different table types
.. seealso:: <https://dev.mysql.com/doc/en/storage-engines.html>
socket
a form of inter-process communication.
.. seealso:: <https://www.wikipedia.org/wiki/Socket#Computer_sockets>
SSL
Secure Sockets Layer is a cryptographic protocol which provides secure
communication on the Internet.
.. seealso:: <https://www.wikipedia.org/wiki/Secure_Sockets_Layer>
Stored procedure
a subroutine available to applications accessing a relational database system
.. seealso:: <https://en.wikipedia.org/wiki/Stored_procedure>
SQL
Structured Query Language
.. seealso:: <https://www.wikipedia.org/wiki/SQL>
table
a set of data elements (cells) that is organized, defined and stored as
horizontal rows and vertical columns where each item can be uniquely
identified by a label or key or by it?s position in relation to other
items.
.. seealso:: <https://www.wikipedia.org/wiki/Table_(database)>
tar
a type of archive file format: the Tape ARchive format.
.. seealso:: <https://www.wikipedia.org/wiki/Tar_(file_format)>
TCP
Transmission Control Protocol is one of the core protocols of the
Internet protocol suite.
.. seealso:: <https://www.wikipedia.org/wiki/TCP>
TCPDF
Rewrite of :term:`UFPDF` with various improvements.
.. seealso:: <https://tcpdf.org/>
trigger
a procedural code that is automatically executed in response to certain events on a particular table or view in a database
.. seealso:: <https://en.wikipedia.org/wiki/Database_trigger>
UFPDF
Unicode/UTF-8 extension for :term:`FPDF`
URL
Uniform Resource Locator is a sequence of characters, conforming to a
standardized format, that is used for referring to resources, such as
documents and images on the Internet, by their location.
.. seealso:: <https://www.wikipedia.org/wiki/URL>
Webserver
A computer (program) that is responsible for accepting HTTP requests from clients and serving them Web pages.
.. seealso:: <https://www.wikipedia.org/wiki/Webserver>
XML
Extensible Markup Language is a W3C-recommended general- purpose markup
language for creating special-purpose markup languages, capable of
describing many different kinds of data.
.. seealso:: <https://www.wikipedia.org/wiki/XML>
ZIP
a popular data compression and archival format.
.. seealso:: <https://www.wikipedia.org/wiki/ZIP_(file_format)>
zlib
an open-source, cross- platform data compression library by Jean-loup Gailly and Mark Adler.
.. seealso:: <https://www.wikipedia.org/wiki/Zlib>

27
#pma/doc/html/_sources/import_export.txt Normal file
View File

@ -0,0 +1,27 @@
Import and export
=================
In addition to the standard Import and Export tab, you can also import an SQL file directly by dragging and dropping
it from your local file manager to the phpMyAdmin interface in your web browser.
Open Document Spreadsheet
-------------------------
When importing an ODS speadsheet, the spreadsheet must be named in a specific way in order to make the
import as simple as possible.
Table name
~~~~~~~~~~
During import, phpMyAdmin uses the sheet name as the table name; you should rename the
sheet in your spreadsheet program in order to match your existing table name (or the table you wish to create,
though this is less of a concern since you could quickly rename the new table from the Operations tab).
Column names
~~~~~~~~~~~~
You should also make the first row of your spreadsheet a header with the names of the columns (this can be
accomplished by inserting a new row at the top of your spreadsheet). When on the Import screen, select the
checkbox for "The first line of the file contains the table column names;" this way your newly imported
data will go to the proper columns.

32
#pma/doc/html/_sources/index.txt Normal file
View File

@ -0,0 +1,32 @@
.. phpMyAdmin documentation master file, created by
sphinx-quickstart on Wed Sep 26 14:04:48 2012.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
Welcome to phpMyAdmin's documentation!
======================================
Contents:
.. toctree::
:maxdepth: 2
intro
require
setup
config
user
faq
developers
vendors
copyright
credits
glossary
Indices and tables
==================
* :ref:`genindex`
* :ref:`search`
* :ref:`glossary`

68
#pma/doc/html/_sources/intro.txt Normal file
View File

@ -0,0 +1,68 @@
.. _intro:
Introduction
============
phpMyAdmin can manage a whole MySQL server (needs a super-user) as
well as a single database. To accomplish the latter you'll need a
properly set up MySQL user who can read/write only the desired
database. It's up to you to look up the appropriate part in the MySQL
manual.
Supported features
------------------
Currently phpMyAdmin can:
* browse and drop databases, tables, views, columns and indexes
* display multiple results sets through stored procedures or queries
* create, copy, drop, rename and alter databases, tables, columns and
indexes
* maintenance server, databases and tables, with proposals on server
configuration
* execute, edit and bookmark any :term:`SQL`-statement, even batch-queries
* load text files into tables
* create [#f1]_ and read dumps of tables
* export [#f1]_ data to various formats: :term:`CSV`, :term:`XML`, :term:`PDF`,
:term:`ISO`/:term:`IEC` 26300 - :term:`OpenDocument` Text and Spreadsheet, Microsoft
Word 2000, and LATEX formats
* import data and :term:`MySQL` structures from :term:`OpenDocument` spreadsheets, as
well as :term:`XML`, :term:`CSV`, and :term:`SQL` files
* administer multiple servers
* manage MySQL users and privileges
* check referential integrity in MyISAM tables
* using Query-by-example (QBE), create complex queries automatically
connecting required tables
* create :term:`PDF` graphics of your
database layout
* search globally in a database or a subset of it
* transform stored data into any format using a set of predefined
functions, like displaying BLOB-data as image or download-link
* track changes on databases, tables and views
* support InnoDB tables and foreign keys
* support mysqli, the improved MySQL extension see :ref:`faq1_17`
* create, edit, call, export and drop stored procedures and functions
* create, edit, export and drop events and triggers
* communicate in `80 different languages
<https://www.phpmyadmin.net/translations/>`_
A word about users
------------------
Many people have difficulty understanding the concept of user
management with regards to phpMyAdmin. When a user logs in to
phpMyAdmin, that username and password are passed directly to MySQL.
phpMyAdmin does no account management on its own (other than allowing
one to manipulate the MySQL user account information); all users must
be valid MySQL users.
.. rubric:: Footnotes
.. [#f1]
phpMyAdmin can compress (:term:`Zip`, :term:`GZip` or :term:`RFC 1952`
formats) dumps and :term:`CSV` exports if you use PHP with
:term:`Zlib` support (``--with-zlib``).
Proper support may also need changes in :file:`php.ini`.

18
#pma/doc/html/_sources/other.txt Normal file
View File

@ -0,0 +1,18 @@
Other sources of information
============================
Printed Book
------------
The definitive guide to using phpMyAdmin is the book Mastering phpMyAdmin for
Effective MySQL Management by Marc Delisle. You can get information on that
book and other officially endorsed `books at the phpMyAdmin site`_.
.. _books at the phpMyAdmin site: https://www.phpmyadmin.net/docs/
Tutorials
---------
Third party tutorials and articles are listed on our `wiki page`_.
.. _wiki page: https://wiki.phpmyadmin.net/pma/Articles

74
#pma/doc/html/_sources/privileges.txt Normal file
View File

@ -0,0 +1,74 @@
User management
===============
User management is the process of controlling which users are allowed to
connect to the MySQL server and what permissions they have on each database.
phpMyAdmin does not handle user management, rather it passes the username and
password on to MySQL, which then determines whether a user is permitted to
perform a particular action. Within phpMyAdmin, administrators have full
control over creating users, viewing and editing privileges for existing users,
and removing users.
Within phpMyAdmin, user management is controlled via the :guilabel:`Users` link
from the main page. Users can be created, edited, and removed.
Creating a new user
-------------------
To create a new user, click the :guilabel:`Add a new user` link near the bottom
of the :guilabel:`Users` page (you must be a "superuser", e.g., user "root").
Use the textboxes and drop-downs to configure the user to your particular
needs. You can then select whether to create a database for that user and grant
specific global privileges. Once you've created the user (by clicking Go), you
can define that user's permissions on a specific database (don't grant global
privileges in that case). In general, users do not need any global privileges
(other than USAGE), only permissions for their specific database.
Editing an existing user
------------------------
To edit an existing user, simply click the pencil icon to the right of that
user in the :guilabel:`Users` page. You can then edit their global- and
database-specific privileges, change their password, or even copy those
privileges to a new user.
Deleting a user
---------------
From the :guilabel:`Users` page, check the checkbox for the user you wish to
remove, select whether or not to also remove any databases of the same name (if
they exist), and click Go.
Assigning privileges to user for a specific database
----------------------------------------------------
Users are assigned to databases by editing the user record (from the
:guilabel:`Users` link on the home page) not from within the :guilabel:`Users`
link under the table. If you are creating a user specifically for a given table
you will have to create the user first (with no global privileges) and then go
back and edit that user to add the table and privileges for the individual
table.
.. _configurablemenus:
Configurable menus and user groups
----------------------------------
By enabling :config:option:`$cfg['Servers'][$i]['usergroups']` and
:config:option:`$cfg['Servers'][$i]['usergroups']` you can customize what users
will see in the phpMyAdmin navigation.
.. warning::
This feature only limits what a user sees, he is still able to use all the
functions. So this can not be considered as a security limitation. Should
you want to limit what users can do, use MySQL privileges to achieve that.
With this feature enabled, the :guilabel:`User accounts` management interface gains
a second tab for managing :guilabel:`User groups`, where you can define what each
group will view (see image below) and you can then assign each user to one of
these groups. Users will be presented with a simplified user interface, which might be
useful for inexperienced users who could be overwhelmed by all the features
phpMyAdmin provides.
.. image:: images/usergroups.png

59
#pma/doc/html/_sources/require.txt Normal file
View File

@ -0,0 +1,59 @@
.. _require:
Requirements
============
Web server
----------
Since phpMyAdmin's interface is based entirely in your browser, you'll need a
web server (such as Apache, nginx, :term:`IIS`) to install phpMyAdmin's files into.
PHP
---
* You need PHP 5.5.0 or newer, with ``session`` support, the Standard PHP Library
(SPL) extension, JSON support, and the ``mbstring`` extension.
* To support uploading of ZIP files, you need the PHP ``zip`` extension.
* You need GD2 support in PHP to display inline thumbnails of JPEGs
("image/jpeg: inline") with their original aspect ratio.
* When using the cookie authentication (the default), the `openssl
<https://www.php.net/openssl>`_ extension is strongly suggested.
* To support upload progress bars, see :ref:`faq2_9`.
* To support XML and Open Document Spreadsheet importing, you need the
`libxml <https://www.php.net/libxml>`_ extension.
* To support reCAPTCHA on the login page, you need the
`openssl <https://www.php.net/openssl>`_ extension.
* To support displaying phpMyAdmin's latest version, you need to enable
``allow_url_open`` in your :file:`php.ini` or to have the
`curl <https://www.php.net/curl>`_ extension.
* Performance suggestion: install the ``ctype`` extension.
.. seealso:: :ref:`faq1_31`, :ref:`authentication_modes`
Database
--------
phpMyAdmin supports MySQL-compatible databases.
* MySQL 5.5 or newer
* MariaDB 5.5 or newer
.. seealso:: :ref:`faq1_17`
Web browser
-----------
To access phpMyAdmin you need a web browser with cookies and JavaScript
enabled.
You need browser which is supported by jQuery 2.0, see
<https://jquery.com/browser-support/>.

819
#pma/doc/html/_sources/setup.txt Normal file
View File

@ -0,0 +1,819 @@
.. _setup:
Installation
============
phpMyAdmin does not apply any special security methods to the MySQL
database server. It is still the system administrator's job to grant
permissions on the MySQL databases properly. phpMyAdmin's :guilabel:`Users`
page can be used for this.
.. warning::
:term:`Mac` users should note that if you are on a version before
:term:`Mac OS X`, StuffIt unstuffs with :term:`Mac` formats. So you'll have
to resave as in BBEdit to Unix style ALL phpMyAdmin scripts before
uploading them to your server, as PHP seems not to like :term:`Mac`-style
end of lines character ("``\r``").
Linux distributions
+++++++++++++++++++
phpMyAdmin is included in most Linux distributions. It is recommended to use
distribution packages when possible - they usually provide integration to your
distribution and you will automatically get security updates from your distribution.
Debian
------
Debian's package repositories include a phpMyAdmin package, but be aware that
the configuration file is maintained in ``/etc/phpmyadmin`` and may differ in
some ways from the official phpMyAdmin documentation.
OpenSUSE
--------
OpenSUSE already comes with phpMyAdmin package, just install packages from
the `openSUSE Build Service <https://software.opensuse.org/package/phpMyAdmin>`_.
Ubuntu
------
Ubuntu ships phpMyAdmin package, however if you want to use recent version, you
can use packages from
`PPA for Michal Čihař <https://launchpad.net/~nijel/+archive/phpmyadmin>`_.
Gentoo
------
Gentoo ships the phpMyAdmin package, both in a near stock configuration as well
as in a ``webapp-config`` configuration. Use ``emerge dev-db/phpmyadmin`` to
install.
Mandriva
--------
Mandriva ships the phpMyAdmin package in their ``contrib`` branch and can be
installed via the usual Control Center.
Fedora
------
Fedora ships the phpMyAdmin package, but be aware that the configuration file
is maintained in ``/etc/phpMyAdmin/`` and may differ in some ways from the
official phpMyAdmin documentation.
Red Hat Enterprise Linux
------------------------
Red Hat Enterprise Linux itself and thus derivatives like CentOS don't
ship phpMyAdmin, but the Fedora-driven repository
`Extra Packages for Enterprise Linux (EPEL) <https://fedoraproject.org/wiki/EPEL>`_
is doing so, if it's
`enabled <https://fedoraproject.org/wiki/EPEL/FAQ#howtouse>`_.
But be aware that the configuration file is maintained in
``/etc/phpMyAdmin/`` and may differ in some ways from the
official phpMyAdmin documentation.
Installing on Windows
+++++++++++++++++++++
The easiest way to get phpMyAdmin on Windows is using third party products
which include phpMyAdmin together with a database and web server such as
`XAMPP <https://www.apachefriends.org/>`_.
You can find more of such options at `Wikipedia <https://en.wikipedia.org/wiki/List_of_AMP_packages>`_.
Installing using Composer
+++++++++++++++++++++++++
You can install phpMyAdmin using `Composer <https://getcomposer.org/>`_,
however it's currently not available in the default
`Packagist <https://packagist.org/>`_ repository due to its technical
limitations.
The installation is possible by adding our own repository
<https://www.phpmyadmin.net/packages.json>:
.. code-block:: sh
composer create-project phpmyadmin/phpmyadmin --repository-url=https://www.phpmyadmin.net/packages.json --no-dev
Installing using Docker
+++++++++++++++++++++++
phpMyAdmin comes with a Docker image, which you can easily deploy. You can
download it using:
.. code-block:: sh
docker pull phpmyadmin/phpmyadmin
The phpMyAdmin server will be executed on port 80. It supports several ways of
configuring the link to the database server, which you can manage using
environment variables:
.. envvar:: PMA_ARBITRARY
Allows you to enter database server hostname on login form (see
:config:option:`$cfg['AllowArbitraryServer']`).
.. envvar:: PMA_HOST
Host name or IP address of the database server to use.
.. envvar:: PMA_HOSTS
Comma separated host names or IP addresses of the database servers to use.
.. envvar:: PMA_USER
User name to use for :ref:`auth_config`.
.. envvar:: PMA_PASSWORD
Password to use for :ref:`auth_config`.
.. envvar:: PMA_PORT
Port of the databse server to use.
.. envvar:: PMA_ABSOLUTE_URI
The fully-qualified path (``https://pma.example.net/``) where the reverse
proxy makes phpMyAdmin available.
By default, :ref:`cookie` is used, but if :envvar:`PMA_USER` and
:envvar:`PMA_PASSWORD` are set, it is switched to :ref:`auth_config`.
.. note::
The credentials you need to login are stored in the MySQL server, in case
of Docker image there are various ways to set it (for example
:envvar:`MYSQL_ROOT_PASSWORD` when starting MySQL container). Please check
documentation for `MariaDB container <https://hub.docker.com/r/_/mariadb/>`_
or `MySQL container <https://hub.docker.com/r/_/mysql/>`_.
Additionally configuration can be tweaked by :file:`/www/config.user.inc.php`. If
this file exists, it will be loaded after configuration generated from above
environment variables, so you can override any configuration variable. This
configuraiton can be added as a volume when invoking docker using
`-v /some/local/directory/config.user.inc.php:/www/config.user.inc.php` parameters.
.. seealso::
See :ref:`config` for detailed description of configuration options.
Docker Volumes
--------------
You can use following volumes to customise image behavior:
:file:`/www/config.user.inc.php`
Can be used for additional settings, see previous chapter for more details.
:file:`/sessions/`
Directory where PHP sessions are stored. You might want to share this
for example when uswing :ref:`auth_signon`.
Docker Examples
---------------
To connect phpMyAdmin to given server use:
.. code-block:: sh
docker run --name myadmin -d -e PMA_HOST=dbhost -p 8080:80 phpmyadmin/phpmyadmin
To connect phpMyAdmin to more servers use:
.. code-block:: sh
docker run --name myadmin -d -e PMA_HOSTS=dbhost1,dbhost2,dbhost3 -p 8080:80 phpmyadmin/phpmyadmin
To use arbitrary server option:
.. code-block:: sh
docker run --name myadmin -d --link mysql_db_server:db -p 8080:80 -e PMA_ARBITRARY=1 phpmyadmin/phpmyadmin
You can also link the database container using Docker:
.. code-block:: sh
docker run --name phpmyadmin -d --link mysql_db_server:db -p 8080:80 phpmyadmin/phpmyadmin
Running with additional configration:
.. code-block:: sh
docker run --name phpmyadmin -d --link mysql_db_server:db -p 8080:80 -v /some/local/directory/config.user.inc.php:/config.user.inc.php phpmyadmin/phpmyadmin
Using docker-compose
--------------------
Alternatively you can also use docker-compose with the docker-compose.yml from
<https://github.com/phpmyadmin/docker>. This will run phpMyAdmin with
arbitrary server - allowing you to specify MySQL/MariaDB server on login page.
.. code-block:: sh
docker-compose up -d
.. _quick_install:
Quick Install
+++++++++++++
#. Choose an appropriate distribution kit from the phpmyadmin.net
Downloads page. Some kits contain only the English messages, others
contain all languages. We'll assume you chose a kit whose name
looks like ``phpMyAdmin-x.x.x -all-languages.tar.gz``.
#. Ensure you have downloaded a genuine archive, see :ref:`verify`.
#. Untar or unzip the distribution (be sure to unzip the subdirectories):
``tar -xzvf phpMyAdmin_x.x.x-all-languages.tar.gz`` in your
webserver's document root. If you don't have direct access to your
document root, put the files in a directory on your local machine,
and, after step 4, transfer the directory on your web server using,
for example, ftp.
#. Ensure that all the scripts have the appropriate owner (if PHP is
running in safe mode, having some scripts with an owner different from
the owner of other scripts will be a problem). See :ref:`faq4_2` and
:ref:`faq1_26` for suggestions.
#. Now you must configure your installation. There are two methods that
can be used. Traditionally, users have hand-edited a copy of
:file:`config.inc.php`, but now a wizard-style setup script is provided
for those who prefer a graphical installation. Creating a
:file:`config.inc.php` is still a quick way to get started and needed for
some advanced features.
Manually creating the file
--------------------------
To manually create the file, simply use your text editor to create the
file :file:`config.inc.php` (you can copy :file:`config.sample.inc.php` to get
a minimal configuration file) in the main (top-level) phpMyAdmin
directory (the one that contains :file:`index.php`). phpMyAdmin first
loads :file:`libraries/config.default.php` and then overrides those values
with anything found in :file:`config.inc.php`. If the default value is
okay for a particular setting, there is no need to include it in
:file:`config.inc.php`. You'll probably need only a few directives to get going; a
simple configuration may look like this:
.. code-block:: xml+php
<?php
// use here a value of your choice at least 32 chars long
$cfg['blowfish_secret'] = '1{dd0`<Q),5XP_:R9UK%%8\"EEcyH#{o';
$i=0;
$i++;
$cfg['Servers'][$i]['auth_type'] = 'cookie';
?>
Or, if you prefer to not be prompted every time you log in:
.. code-block:: xml+php
<?php
$i=0;
$i++;
$cfg['Servers'][$i]['user'] = 'root';
$cfg['Servers'][$i]['password'] = 'cbb74bc'; // use here your password
$cfg['Servers'][$i]['auth_type'] = 'config';
?>
For a full explanation of possible configuration values, see the
:ref:`config` of this document.
.. index:: Setup script
.. _setup_script:
Using Setup script
------------------
Instead of manually editing :file:`config.inc.php`, you can use phpMyAdmin's
setup feature. First you must manually create a folder ``config``
in the phpMyAdmin directory. This is a security measure. On a
Linux/Unix system you can use the following commands:
.. code-block:: sh
cd phpMyAdmin
mkdir config # create directory for saving
chmod o+rw config # give it world writable permissions
And to edit an existing configuration, copy it over first:
.. code-block:: sh
cp config.inc.php config/ # copy current configuration for editing
chmod o+w config/config.inc.php # give it world writable permissions
.. note::
Debian and Ubuntu have simplified this setup and all you need to do is to
execute :program:`/usr/sbin/pma-configure`.
On other platforms, simply create the folder and ensure that your web
server has read and write access to it. :ref:`faq1_26` can help with
this.
Next, open your browser and visit the location where you installed phpMyAdmin, with the ``/setup`` suffix. If you have an existing configuration,
use the ``Load`` button to bring its content inside the setup panel.
Note that **changes are not saved to disk until you explicitly choose ``Save``**
from the *Configuration* area of the screen. Normally the script saves the new
:file:`config.inc.php` to the ``config/`` directory, but if the webserver does
not have the proper permissions you may see the error "Cannot load or
save configuration." Ensure that the ``config/`` directory exists and
has the proper permissions - or use the ``Download`` link to save the
config file locally and upload it (via FTP or some similar means) to the
proper location.
Once the file has been saved, it must be moved out of the ``config/``
directory and the permissions must be reset, again as a security
measure:
.. code-block:: sh
mv config/config.inc.php . # move file to current directory
chmod o-rw config.inc.php # remove world read and write permissions
rm -rf config # remove not needed directory
.. note::
Debian and Ubuntu have simplified this setup and all you need to do is to
execute :program:`/usr/sbin/pma-secure`.
Now the file is ready to be used. You can choose to review or edit the
file with your favorite editor, if you prefer to set some advanced
options which the setup script does not provide.
#. If you are using the ``auth_type`` "config", it is suggested that you
protect the phpMyAdmin installation directory because using config
does not require a user to enter a password to access the phpMyAdmin
installation. Use of an alternate authentication method is
recommended, for example with HTTP–AUTH in a :term:`.htaccess` file or switch to using
``auth_type`` cookie or http. See the :ref:`faqmultiuser`
for additional information, especially :ref:`faq4_4`.
#. Open the `main phpMyAdmin directory <index.php>`_ in your browser.
phpMyAdmin should now display a welcome screen and your databases, or
a login dialog if using :term:`HTTP` or
cookie authentication mode.
#. You should deny access to the ``./libraries`` and ``./setup/lib``
subfolders in your webserver configuration.
Such configuration prevents from possible
path exposure and cross side scripting vulnerabilities that might
happen to be found in that code. For the Apache webserver, this is
often accomplished with a :term:`.htaccess` file in those directories.
#. It is generally a good idea to protect a public phpMyAdmin installation
against access by robots as they usually can not do anything good
there. You can do this using ``robots.txt`` file in root of your
webserver or limit access by web server configuration, see
:ref:`faq1_42`.
.. _verify:
Verifying phpMyAdmin releases
+++++++++++++++++++++++++++++
Since July 2015 all phpMyAdmin releases are cryptographically signed by the
releasing developer, who through January 2016 was Marc Delisle. His key id is
0xFEFC65D181AF644A, his PGP fingerprint is:
.. code-block:: console
436F F188 4B1A 0C3F DCBF 0D79 FEFC 65D1 81AF 644A
and you can get more identification information from <https://keybase.io/lem9>.
Beginning in January 2016, the release manager is Isaac Bennetch. His key id is
0xCE752F178259BD92, and his PGP fingerprint is:
.. code-block:: console
3D06 A59E CE73 0EB7 1B51 1C17 CE75 2F17 8259 BD92
and you can get more identification information from <https://keybase.io/ibennetch>.
Some additional downloads (for example themes) might be signed by Michal Čihař. His key id is
0x9C27B31342B7511D, and his PGP fingerprint is:
.. code-block:: console
63CB 1DF1 EF12 CF2A C0EE 5A32 9C27 B313 42B7 511D
and you can get more identification information from <https://keybase.io/nijel>.
You should verify that the signature matches
the archive you have downloaded. This way you can be sure that you are using
the same code that was released.
Each archive is accompanied with ``.asc`` files which contains the PGP signature
for it. Once you have both of them in the same folder, you can verify the signature:
.. code-block:: console
$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: Can't check signature: public key not found
As you can see gpg complains that it does not know the public key. At this
point you should do one of the following steps:
* Download the keyring from `our download server <https://files.phpmyadmin.net/phpmyadmin.keyring>`_, then import it with:
.. code-block:: console
$ gpg --import phpmyadmin.keyring
* Download and import the key from one of the key servers:
.. code-block:: console
$ gpg --keyserver hkp://pgp.mit.edu --recv-keys 3D06A59ECE730EB71B511C17CE752F178259BD92
gpg: requesting key 8259BD92 from hkp server pgp.mit.edu
gpg: key 8259BD92: public key "Isaac Bennetch <bennetch@gmail.com>" imported
gpg: no ultimately trusted keys found
gpg: Total number processed: 1
gpg: imported: 1 (RSA: 1)
This will improve the situation a bit - at this point you can verify that the
signature from the given key is correct but you still can not trust the name used
in the key:
.. code-block:: console
$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: Good signature from "Isaac Bennetch <bennetch@gmail.com>"
gpg: aka "Isaac Bennetch <isaac@bennetch.org>"
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: 3D06 A59E CE73 0EB7 1B51 1C17 CE75 2F17 8259 BD92
The problem here is that anybody could issue the key with this name. You need to
ensure that the key is actually owned by the mentioned person. The GNU Privacy
Handbook covers this topic in the chapter `Validating other keys on your public
keyring`_. The most reliable method is to meet the developer in person and
exchange key fingerprints, however you can also rely on the web of trust. This way
you can trust the key transitively though signatures of others, who have met
the developer in person. For example you can see how `Isaac's key links to
Linus's key`_.
Once the key is trusted, the warning will not occur:
.. code-block:: console
$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: Good signature from "Isaac Bennetch <bennetch@gmail.com>" [full]
Should the signature be invalid (the archive has been changed), you would get a
clear error regardless of the fact that the key is trusted or not:
.. code-block:: console
$ gpg --verify phpMyAdmin-4.5.4.1-all-languages.zip.asc
gpg: Signature made Fri 29 Jan 2016 08:59:37 AM EST using RSA key ID 8259BD92
gpg: BAD signature from "Isaac Bennetch <bennetch@gmail.com>" [unknown]
.. _Validating other keys on your public keyring: https://www.gnupg.org/gph/en/manual.html#AEN335
.. _Isaac's key links to Linus's key: https://pgp.cs.uu.nl/mk_path.cgi?FROM=ABAF11C65A2970B130ABE3C479BE3E4300411886&TO=3D06A59ECE730EB71B511C17CE752F178259BD92
.. index::
single: Configuration storage
single: phpMyAdmin configuration storage
single: pmadb
.. _linked-tables:
phpMyAdmin configuration storage
++++++++++++++++++++++++++++++++
For a whole set of additional features (bookmarks, comments, :term:`SQL`-history,
tracking mechanism, :term:`PDF`-generation, column contents transformation,
etc.) you need to create a set of special tables. Those tables can be located
in your own database, or in a central database for a multi-user installation
(this database would then be accessed by the controluser, so no other user
should have rights to it).
Zero configuration
------------------
In many cases, this database structure can be automatically created and
configured. This is called “Zero Configuration” mode and can be particularly
useful in shared hosting situations. “Zeroconf” mode is on by default, to
disable set :config:option:`$cfg['ZeroConf']` to false.
The following three scenarios are covered by the Zero Configuration mode:
* When entering a database where the configuration storage tables are not
present, phpMyAdmin offers to create them from the Operations tab.
* When entering a database where the tables do already exist, the software
automatically detects this and begins using them. This is the most common
situation; after the tables are initially created automatically they are
continually used without disturbing the user; this is also most useful on
shared hosting where the user is not able to edit :file:`config.inc.php` and
usually the user only has access to one database.
* When having access to multiple databases, if the user first enters the
database containing the configuration storage tables then switches to
another database,
phpMyAdmin continues to use the tables from the first database; the user is
not prompted to create more tables in the new database.
Manual configuration
--------------------
Please look at your ``./sql/`` directory, where you should find a
file called *create\_tables.sql*. (If you are using a Windows server,
pay special attention to :ref:`faq1_23`).
If you already had this infrastructure and:
* upgraded to MySQL 4.1.2 or newer, please use
:file:`sql/upgrade_tables_mysql_4_1_2+.sql`.
* upgraded to phpMyAdmin 4.3.0 or newer from 2.5.0 or newer (<= 4.2.x),
please use :file:`sql/upgrade_column_info_4_3_0+.sql`.
and then create new tables by importing :file:`sql/create_tables.sql`.
You can use your phpMyAdmin to create the tables for you. Please be
aware that you may need special (administrator) privileges to create
the database and tables, and that the script may need some tuning,
depending on the database name.
After having imported the :file:`sql/create_tables.sql` file, you
should specify the table names in your :file:`config.inc.php` file. The
directives used for that can be found in the :ref:`config`.
You will also need to have a controluser
(:config:option:`$cfg['Servers'][$i]['controluser']` and
:config:option:`$cfg['Servers'][$i]['controlpass']` settings)
with the proper rights to those tables. For example you can create it
using following statement:
.. code-block:: mysql
GRANT SELECT, INSERT, UPDATE, DELETE ON <pma_db>.* TO 'pma'@'localhost' IDENTIFIED BY 'pmapass';
.. _upgrading:
Upgrading from an older version
+++++++++++++++++++++++++++++++
.. warning::
**Never** extract the new version over an existing installation of
phpMyAdmin, always first remove the old files keeping just the
configuration.
This way you will not leave old no longer working code in the directory,
which can have severe security implications or can cause various breakages.
Simply copy :file:`config.inc.php` from your previous installation into
the newly unpacked one. Configuration files from old versions may
require some tweaking as some options have been changed or removed.
For compatibility with PHP 5.3 and later, remove a
``set_magic_quotes_runtime(0);`` statement that you might find near
the end of your configuration file.
You should **not** copy :file:`libraries/config.default.php` over
:file:`config.inc.php` because the default configuration file is version-
specific.
If you have upgraded your MySQL server from a version previous to 4.1.2 to
version 5.x or newer and if you use the phpMyAdmin configuration storage, you
should run the :term:`SQL` script found in
:file:`sql/upgrade_tables_mysql_4_1_2+.sql`.
If you have upgraded your phpMyAdmin to 4.3.0 or newer from 2.5.0 or
newer (<= 4.2.x) and if you use the phpMyAdmin configuration storage, you
should run the :term:`SQL` script found in
:file:`sql/upgrade_column_info_4_3_0+.sql`.
Do not forget to clear the browser cache and to empty the old session by
logging out and logging in again.
.. index:: Authentication mode
.. _authentication_modes:
Using authentication modes
++++++++++++++++++++++++++
:term:`HTTP` and cookie authentication modes are recommended in a **multi-user
environment** where you want to give users access to their own database and
don't want them to play around with others. Nevertheless be aware that MS
Internet Explorer seems to be really buggy about cookies, at least till version
6. Even in a **single-user environment**, you might prefer to use :term:`HTTP`
or cookie mode so that your user/password pair are not in clear in the
configuration file.
:term:`HTTP` and cookie authentication
modes are more secure: the MySQL login information does not need to be
set in the phpMyAdmin configuration file (except possibly for the
:config:option:`$cfg['Servers'][$i]['controluser']`).
However, keep in mind that the password travels in plain text, unless
you are using the HTTPS protocol. In cookie mode, the password is
stored, encrypted with the AES algorithm, in a temporary cookie.
Then each of the *true* users should be granted a set of privileges
on a set of particular databases. Normally you shouldn't give global
privileges to an ordinary user, unless you understand the impact of those
privileges (for example, you are creating a superuser).
For example, to grant the user *real_user* with all privileges on
the database *user_base*:
.. code-block:: mysql
GRANT ALL PRIVILEGES ON user_base.* TO 'real_user'@localhost IDENTIFIED BY 'real_password';
What the user may now do is controlled entirely by the MySQL user management
system. With HTTP or cookie authentication mode, you don't need to fill the
user/password fields inside the :config:option:`$cfg['Servers']`.
.. index:: pair: HTTP; Authentication mode
HTTP authentication mode
------------------------
* Uses :term:`HTTP` Basic authentication
method and allows you to log in as any valid MySQL user.
* Is supported with most PHP configurations. For :term:`IIS` (:term:`ISAPI`)
support using :term:`CGI` PHP see :ref:`faq1_32`, for using with Apache
:term:`CGI` see :ref:`faq1_35`.
* When PHP is running under Apache's :term:`mod_proxy_fcgi` (e.g. with PHP-FPM),
``Authorization`` headers are not passed to the underlying FCGI application,
such that your credentials will not reach the application. In this case, you can
add the following configuration directive:
.. code-block:: apache
SetEnvIf Authorization "(.*)" HTTP_AUTHORIZATION=$1
* See also :ref:`faq4_4` about not using the :term:`.htaccess` mechanism along with
':term:`HTTP`' authentication mode.
.. index:: pair: Cookie; Authentication mode
.. _cookie:
Cookie authentication mode
--------------------------
* Username and password are stored in cookies during the session and password
is deleted when it ends.
* With this mode, the user can truly log out of phpMyAdmin and log
back in with the same username.
* If you want to allow users to enter any hostname to connect (rather than only
servers that are configured in :file:`config.inc.php`),
see the :config:option:`$cfg['AllowArbitraryServer']` directive.
* As mentioned in the :ref:`require` section, having the ``mcrypt`` extension will
speed up access considerably, but is not required.
.. index:: pair: Signon; Authentication mode
.. _auth_signon:
Signon authentication mode
--------------------------
* This mode is a convenient way of using credentials from another
application to authenticate to phpMyAdmin to implement single signon
solution.
* The other application has to store login information into session
data (see :config:option:`$cfg['Servers'][$i]['SignonSession']`) or you
need to implement script to return the credentials (see
:config:option:`$cfg['Servers'][$i]['SignonScript']`).
* When no credentials are available, the user is being redirected to
:config:option:`$cfg['Servers'][$i]['SignonURL']`, where you should handle
the login process.
The very basic example of saving credentials in a session is available as
:file:`examples/signon.php`:
.. literalinclude:: ../examples/signon.php
:language: php
Alternatively you can also use this way to integrate with OpenID as shown
in :file:`examples/openid.php`:
.. literalinclude:: ../examples/openid.php
:language: php
If you intend to pass the credentials using some other means than, you have to
implement wrapper in PHP to get that data and set it to
:config:option:`$cfg['Servers'][$i]['SignonScript']`. There is very minimal example
in :file:`examples/signon-script.php`:
.. literalinclude:: ../examples/signon-script.php
:language: php
.. seealso::
:config:option:`$cfg['Servers'][$i]['auth_type']`,
:config:option:`$cfg['Servers'][$i]['SignonSession']`,
:config:option:`$cfg['Servers'][$i]['SignonScript']`,
:config:option:`$cfg['Servers'][$i]['SignonURL']`
.. index:: pair: Config; Authentication mode
.. _auth_config:
Config authentication mode
--------------------------
* This mode is sometimes the less secure one because it requires you to fill the
:config:option:`$cfg['Servers'][$i]['user']` and
:config:option:`$cfg['Servers'][$i]['password']`
fields (and as a result, anyone who can read your :file:`config.inc.php`
can discover your username and password).
* In the :ref:`faqmultiuser` section, there is an entry explaining how
to protect your configuration file.
* For additional security in this mode, you may wish to consider the
Host authentication :config:option:`$cfg['Servers'][$i]['AllowDeny']['order']`
and :config:option:`$cfg['Servers'][$i]['AllowDeny']['rules']` configuration directives.
* Unlike cookie and http, does not require a user to log in when first
loading the phpMyAdmin site. This is by design but could allow any
user to access your installation. Use of some restriction method is
suggested, perhaps a :term:`.htaccess` file with the HTTP-AUTH directive or disallowing
incoming HTTP requests at one’s router or firewall will suffice (both
of which are beyond the scope of this manual but easily searchable
with Google).
Securing your phpMyAdmin installation
+++++++++++++++++++++++++++++++++++++
The phpMyAdmin team tries hard to make the application secure, however there
are always ways to make your installation more secure:
* Serve phpMyAdmin on HTTPS only. Preferably, you should use HSTS as well, so that
you're protected from protocol downgrade attacks.
* Remove the ``test`` directory from phpMyAdmin, unless you are developing and need test suite.
* Remove the ``setup`` directory from phpMyAdmin, you will probably not
use it after the initial setup.
* Properly choose an authentication method - :ref:`cookie`
is probably the best choice for shared hosting.
* In case you don't want all MySQL users to be able to access
phpMyAdmin, you can use :config:option:`$cfg['Servers'][$i]['AllowDeny']['rules']` to limit them.
* Consider hiding phpMyAdmin behind an authentication proxy, so that
users need to authenticate prior to providing MySQL credentials
to phpMyAdmin. You can achieve this by configuring your web server to request
HTTP authentication. For example in Apache this can be done with:
.. code-block:: apache
AuthType Basic
AuthName "Restricted Access"
AuthUserFile /usr/share/phpmyadmin/passwd
Require valid-user
Once you have changed the configuration, you need to create a list of users which
can authenticate. This can be done using the :program:`htpasswd` utility:
.. code-block:: sh
htpasswd -c /usr/share/phpmyadmin/passwd username
* If you are afraid of automated attacks, enabling Captcha by
:config:option:`$cfg['CaptchaLoginPublicKey']` and
:config:option:`$cfg['CaptchaLoginPrivateKey']` might be an option.
Known issues
++++++++++++
Users with column-specific privileges are unable to "Browse"
------------------------------------------------------------
If a user has only column-specific privileges on some (but not all) columns in a table, "Browse"
will fail with an error message.
As a workaround, a bookmarked query with the same name as the table can be created, this will
run when using the "Browse" link instead. `Issue 11922 <https://github.com/phpmyadmin/phpmyadmin/issues/11922>`_.
Trouble logging back in after logging out using 'http' authentication
----------------------------------------------------------------------
When using the 'http' ``auth_type``, it can be impossible to log back in (when the logout comes
manually or after a period of inactivity). `Issue 11898 <https://github.com/phpmyadmin/phpmyadmin/issues/11898>`_.

138
#pma/doc/html/_sources/transformations.txt Normal file
View File

@ -0,0 +1,138 @@
.. _transformations:
Transformations
===============
.. _transformationsintro:
Introduction
++++++++++++
To enable transformations, you have to setup the ``column_info``
table and the proper directives. Please see the :ref:`config` on how to do so.
You can apply different transformations to the contents of each
column. The transformation will take the content of each column and
transform it with certain rules defined in the selected
transformation.
Say you have a column 'filename' which contains a filename. Normally
you would see in phpMyAdmin only this filename. Using transformations
you can transform that filename into a HTML link, so you can click
inside of the phpMyAdmin structure on the column's link and will see
the file displayed in a new browser window. Using transformation
options you can also specify strings to append/prepend to a string or
the format you want the output stored in.
For a general overview of all available transformations and their
options, you can consult your *<www.your-host.com>/<your-install-
dir>/transformation\_overview.php* installation.
For a tutorial on how to effectively use transformations, see our
`Link section <https://www.phpmyadmin.net/home_page/docs.php>`_ on the
official phpMyAdmin homepage.
.. _transformationshowto:
Usage
+++++
Go to your *tbl\_structure.php* page (i.e. reached through clicking on
the 'Structure' link for a table). There click on "Change" (or change
icon) and there you will see three new fields at the end of the line.
They are called 'MIME-type', 'Browser transformation' and
'Transformation options'.
* The field 'MIME-type' is a drop-down field. Select the MIME-type that
corresponds to the column's contents. Please note that transformations
are inactive as long as no MIME-type is selected.
* The field 'Browser transformation' is a drop-down field. You can
choose from a hopefully growing amount of pre-defined transformations.
See below for information on how to build your own transformation.
There are global transformations and mimetype-bound transformations.
Global transformations can be used for any mimetype. They will take
the mimetype, if necessary, into regard. Mimetype-bound
transformations usually only operate on a certain mimetype. There are
transformations which operate on the main mimetype (like 'image'),
which will most likely take the subtype into regard, and those who
only operate on a specific subtype (like 'image/jpeg'). You can use
transformations on mimetypes for which the function was not defined
for. There is no security check for you selected the right
transformation, so take care of what the output will be like.
* The field 'Transformation options' is a free-type textfield. You have
to enter transform-function specific options here. Usually the
transforms can operate with default options, but it is generally a
good idea to look up the overview to see which options are necessary.
Much like the ENUM/SET-Fields, you have to split up several options
using the format 'a','b','c',...(NOTE THE MISSING BLANKS). This is
because internally the options will be parsed as an array, leaving the
first value the first element in the array, and so forth. If you want
to specify a MIME character set you can define it in the
transformation\_options. You have to put that outside of the pre-
defined options of the specific mime-transform, as the last value of
the set. Use the format "'; charset=XXX'". If you use a transform, for
which you can specify 2 options and you want to append a character
set, enter "'first parameter','second parameter','charset=us-ascii'".
You can, however use the defaults for the parameters: "'','','charset
=us-ascii'".
.. _transformationsfiles:
File structure
++++++++++++++
All specific transformations for mimetypes are defined through class
files in the directory 'libraries/plugins/transformations/'. Each of
them extends a certain transformation abstract class declared in
libraries/plugins/transformations/abstract.
They are stored in files to ease up customization and easy adding of
new transformations.
Because the user cannot enter own mimetypes, it is kept sure that
transformations always work. It makes no sense to apply a
transformation to a mimetype the transform-function doesn't know to
handle.
There is a file called '*transformations.lib.php*' that provides some
basic functions which can be included by any other transform function.
The file name convention is ``[Mimetype]_[Subtype]_[Transformation
Name].class.php``, while the abtract class that it extends has the
name ``[Transformation Name]TransformationsPlugin``. All of the
methods that have to be implemented by a transformations plug-in are:
#. getMIMEType() and getMIMESubtype() in the main class;
#. getName(), getInfo() and applyTransformation() in the abstract class
it extends.
The getMIMEType(), getMIMESubtype() and getName() methods return the
name of the MIME type, MIME Subtype and transformation accordingly.
getInfo() returns the transformation's description and possible
options it may receive and applyTransformation() is the method that
does the actual work of the transformation plug-in.
Please see the libraries/plugins/transformations/TEMPLATE and
libraries/plugins/transformations/TEMPLATE\_ABSTRACT files for adding
your own transformation plug-in. You can also generate a new
transformation plug-in (with or without the abstract transformation
class), by using
:file:`scripts/transformations_generator_plugin.sh` or
:file:`scripts/transformations_generator_main_class.sh`.
The applyTransformation() method always gets passed three variables:
#. **$buffer** - Contains the text inside of the column. This is the
text, you want to transform.
#. **$options** - Contains any user-passed options to a transform
function as an array.
#. **$meta** - Contains an object with information about your column. The
data is drawn from the output of the `mysql\_fetch\_field()
<https://www.php.net/mysql_fetch_field>`_ function. This means, all
object properties described on the `manual page
<https://www.php.net/mysql_fetch_field>`_ are available in this
variable and can be used to transform a column accordingly to
unsigned/zerofill/not\_null/... properties. The $meta->mimetype
variable contains the original MIME-type of the column (i.e.
'text/plain', 'image/jpeg' etc.)

10
#pma/doc/html/_sources/user.txt Normal file
View File

@ -0,0 +1,10 @@
User Guide
==========
.. toctree::
:maxdepth: 2
transformations
privileges
other
import_export

35
#pma/doc/html/_sources/vendors.txt Normal file
View File

@ -0,0 +1,35 @@
Distributing and packaging phpMyAdmin
=====================================
This document is intended to give advices to people who want to
redistribute phpMyAdmin inside other software package such as Linux
distribution or some all in one package including web server and MySQL
server.
Generally you can customize some basic aspects (paths to some files and
behavior) in :file:`libraries/vendor_config.php`.
For example if you want setup script to generate config file in var, change
``SETUP_CONFIG_FILE`` to :file:`/var/lib/phpmyadmin/config.inc.php` and you
will also probably want to skip directory writable check, so set
``SETUP_DIR_WRITABLE`` to false.
External libraries
------------------
phpMyAdmin includes several external libraries, you might want to
replace them with system ones if they are available, but please note
that you should test whether version you provide is compatible with the
one we ship.
Currently known list of external libraries:
js/jquery
jQuery js framework and various jQuery based libraries.
libraries/php-gettext
php-gettext library
libraries/tcpdf
tcpdf library, stripped down of not needed files
libraries/phpseclib
portions of phpseclib library