phpMyAdmin is an open source tool written in PHP intended to handle the administration of MySQL over the World Wide Web. It can do various tasks such as creating, modifying or deleting databases, tables, fields or rows; executing SQL statements; or managing users and permissions.
The installation on the NAS-Device requires a working lighttpd with php and the MySQL-Database server. Please follow the respective tutorials for the installation of these.
Download and unpacking
Check the homepage of phpMyAdmin for the current version and download it. As of 13-Dec-2010, this latest non-beta version is 3.3.8.1:
Now you have a directory called phpmyadmin in the webroot of your lighttpd.
Configuring
Now we need to add a configuration-file for phpmyadmin. We use nano for this:
cd/srv/pages/phpmyadmin/nano config.inc.php
Simply copy the content below to this file:
<?/* Servers configuration */$i=0;/* Server localhost */$i++;$cfg['Servers'][$i]['host']='localhost';$cfg['Servers'][$i]['extension']='mysql';$cfg['Servers'][$i]['connect_type']='tcp';$cfg['Servers'][$i]['compress']=false;$cfg['Servers'][$i]['auth_type']='http';?>
Errors and Remarks
The auth_type “http” was chosen as cookie is extremely slow without the php-extension mcrypt which is not compiled into the current php-versions
If you get an error with the code #2002, you have to change the host to “127.0.0.1” and add a comment in the file my.cnf of mysql on the line skip-networking
If you get the error The mbstring PHP extension was not found and you seem to be using a multibyte charset. Without the mbstring extension phpMyAdmin is unable to split strings correctly and it may result in unexpected results, you have to enable the mbstring-extension in the php.ini of your NAS.
Finally
Now you should see phpmyadmin under http://CH3SNAS/phpmyadmin (substitute CH3SNAS with the network-name of your NAS-Device).
For further information consider reading the documentation online.
An RDBMS is a software tool to store, access and update (often large) amounts of data structured as interrelated tables. Originally, databases were typically used for adminstrative purposes such as storing employee- or inventory information. Nowadays, databases are also widely used to store the raw content from which dynamic web sites are generated. This allows the same information to be presented in different ways. Because SQL is a standardized language to update or access an RDBMS, it also avoids relying on proprietary storage formats with associated risks of obsolescence or lock-in to particular software.
Although there are various other open source and commercial RDBMS systems available, MySQL is commonly used in web development in conjunction withLinux, Apache (or lighttpd), and php. Wikipedia, for example, runs on MediaWiki software written in PHP and uses a MySQL database.
Uli kindly provided a packaged version of MySQL for the NAS in his repository.
MySQL is not installed as part of fun_plug by default, but you should already have downloaded a copy as part of the general tutorial on how to download, install and upgrade packages. Let’s first make sure you still have the latest version (as Uli upgrades his repository regularly).
Note that the installation command below could take a while:
funpkg -i/ffp/pkg/additional/*/mysql-*.tgz
If you have a version of mysql installed that is outdated, you will need to run in upgrade mode instead (see here for help):
funpkg -u/ffp/pkg/additional/*/mysql-*.tgz
Configuration
MySQL can be configured with a file called my.cnf. After installation you can configure several MySQL settings by copying an example-file from /ffp/etc/examples/mysql/ to /ffp/etc/:
MySQL stores the data of its databases in files which are in turn stored in a directory named /srv/mysql/. Instead of creating the directory at that location, you may prefer to create a symbolic link from /srv/ to the target-directory of your choice.
First we create it:
This link will be lost after rebooting the device, so you have to add the following two lines to the end of the file /ffp/etc/fun_plug.init to recreate the link every time the NAS boots. You can edit this file using an editor like nano:
# create custom link to the server-folderln-s/ffp/opt/srv//srv
Initialization
MySQL needs some internal databases for the initial startup which can be installed by issuing the mysql_install_db command:
cd/srv/ls-al/ffp/bin/mysql_install_db
ls-al
This results in several warnings (which you can ignore) about adjusted sizes system- and help tables. Typical partial output:
081116 22:05:32[Warning] option 'max_join_size': unsigned value 18446744073709551615 adjusted to 4294967295
081116 22:05:32[Warning] option 'max_join_size': unsigned value 18446744073709551615 adjusted to 4294967295
081116 22:05:32[Warning] option 'myisam_max_extra_sort_file_size': unsigned value 2147483648 adjusted to 2147483647
081116 22:05:32[Warning] option 'thread_stack': unsigned value 65536 adjusted to 131072
Now we manually start the MySQL server for further configuration:
sh /ffp/start/mysqld.sh start
Note that you will have to press Enter to get your prompt back (unlike other daemons).
After the first start, we have to secure the installation:
/ffp/bin/mysql_secure_installation
You will be asked several questions (shown below in abridged form) and can answer Y(es) for each of them.
For "Enter current password for root (enter for none):" you press enter because the default root password is empty.
For the new root password, it is best to use a different password than the user root of the system: this is just for owning the administration rights to the database and is unrelated to overall control over the machine.
Enter current password for root (enter for none):
OK, successfully used password, moving on...
Set root password? [Y/n] Y
New password:
Re-enter new password:
Password updated successfully!
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y
All done!
After MySQL has started, you can test your installation using the following ways:
Command-line
Enter the following command on the command-line:
mysql -p
This will open a special mysql-command-line, where you can enter regular SQL-Commands. Now change to the database “mysql”:
USE mysql;
Then select the Host, User and Passwort from the Database:
SELECT Host, User, Password FROM user;
Finally exit the mysql-command-line:
exit;
A sample output will look like this:
root@CH3SNAS:/srv/mysql# mysql -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 1
Server version: 5.0.67 Source distribution
Type 'help;' or '\h'for help. Type '\c' to clear the buffer.
mysql> USE mysql;
Database changed
mysql> SELECT Host, User, Password FROM user;
+-----------+------+-------------------------------------------+
| Host | User | Password |
+-----------+------+-------------------------------------------+
| localhost | root |*8D2414F01991E3B0B86E14D2469EACA0B6D78B99 || CH3SNAS | root |*8D2414F01991E3B0B86E14D2469EACA0B6D78B99 || 127.0.0.1 | root |*8D2414F01991E3B0B86E14D2469EACA0B6D78B99 |
+-----------+------+-------------------------------------------+
3 rows inset(0.01 sec)
mysql>exit;
Bye
By the way: As you can see, passwords are crypted (in this case it was “nas-tweaks.net“).
PHP
For the following, you need to install lighttpd and php in case you haven’t already done so.
You also need to enable the mysql module of lighttpd by editing the /ffp/etc/php.ini file:
; Linux extensions
extension=calendar.so
;extension=ctype.so
;extension=ftp.so
;extension=gd.so
;extension=mbstring.so
extension=mysql.so
;etc
Make sure you define the folder which contains all the above modules in line 536 of the php.ini file. Usually it should be:
You will need to restart the web server if you enabled the my-sql extension, or changed the extension_dir using:
sh/ffp/start/lighttpd.sh restart
Then place a file called testmysql.php in the document-root (as configured here e.g. /srv/www/pages) with the following content (replace YOURROOTPASS with the password of mysql user root):
<?php// Connect to the databasemysql_connect("localhost","root","YOURROOTPASS");// Select the database "mysql"mysql_select_db("mysql");// Query the database for the Users:$result=mysql_query("SELECT Host, User, Password FROM user;");// Print the resultswhile($row=mysql_fetch_object($result)){echo$row->User."@".$row->Host." has the encrypted password: ".$row->Password;}// Close the connection to the databasemysql_close();?>
If opening this page in your browser doesn’t give the expected results, check the password, and if needed close and open the browser again.
When you are done, you may want remove the root password (or delete this .php file) to avoid exposing the mysql password in the line mysql_connect("localhost", "root","YOURROOTPASS");.
Users and privileges
Adding additional Users
As you should never use the root-password of your database, you can add additional users in the mysql-command-line (enter “mysql -uroot -p” on the command-line).
Please consult the mysql-manual for more examples.
A User with all privileges, who can only connect from localhost:
After you send add or alter the rights, please make sure, that these get loaded by executing the following command in the mysql-command-line:
FLUSH PRIVILEGES;
Allowing external access
Per default external access is not allowed as this is a security risk. But many tools like HeidiSQL or other external administrator-programs rely on access from the outside of your NAS.
Caution: You should explicitly check the rights of your users! All MySQL-users should have passwords!
Edit /ffp/etc/my.cnf and add a comment to the line skip-networking, so that it looks like this:
#skip-networking
Edit /ffp/start/mysqld.sh and find the line beginning with mysqld_flags and remove “--skip-networking” between the two quotation marks. Save the file afterwards.
Running mysql under a user with limited rights
Per default the MySQL gets started with root-rights. This means, that if the MySQL-server is breached by a intruder, the system probably can be corrupted. Be advised to use the mysql-server only in secure areas (e.g. your local LAN without internet access) and to disable external access (default).
If you want to secure your installation please follow the following steps:
Stop the mysql-server:
sh/ffp/start/mysqld.sh stop
Add a new user with limited rights:
useradd -U-s/bin/false mysql
store-passwd.sh
This will create a user mysql who is in the group mysql (-U add a new group) and who cannot log in. It will probably show up in the Webinterface, but cannot be used!
This user needs access to the directories of MySQL:
cd/srv
chown-R mysql:mysql mysql
cd/ffp/var/run/chown mysql:mysql mysql
Edit /ffp/start/mysqld.sh and find the line beginning with mysqld_flags and remove “--user=root” between the two quotation marks. Save the file afterwards.
Then start MySQL again:
sh /ffp/start/mysqld.sh start
With these changes, MySQL is started under the user mysql.
Removing MySQL
If you want to remove MySQL and its databases, you proceed like described in the general tutorial on packages.
First, stop mysql:
sh/ffp/start/mysqld.sh stop
Then remove the package with funpkg:
funpkg -r/ffp/pkg/additional/*/mysql*.tgz
Afterwards you have to remove the databases (careful!). Change to the folder /srv/ and delete the folder mysql:
cd/srv/rm-R mysql
Furthermore, you should undo the change in /ffp/etc/fun_plug.init, possibly remove the (harmless) symbolic link /srv/, but especially disable execution of the startup script:
This tutorial is deprecated and should only be used with fonz fun_plug 0.5! Please check the tutorial page for updated tutorials on this topic!
PHP is a server-side scripting language that is widely used for developing dynamic web sites. PHP allows custom software to run on the server (in our case the NAS) hosting the web site.
PHP scripts are typically embedded in HTML pages. When a browser requests such a HTML page, the scripts are executed by the PHP add-in module of the HTTP server (here: lighttpd). Usually the PHP code inserts some additional HTML content into the version of the HTML page that gets sent to the browser. The browser (“client”) itself thus doesn’t see the scripts which were executed on the server.
In this tutorial we assume that the lighttpd HTTP server is already installed on the NAS (see tutorial on installing lighttpd On bigger systems, PHP is sometimes used in combination with an Apache server (instead of the leaner lighttpd) and an SQL database. This widely-used bundle of software tools is sometimes known as LAMP: Linux, Apache, MySQL, PHP. The installation of MySQL on the NAS is covered in another tutorial.
With regular HTML pages, your web server can only provide static content: all users see the same set of pages and the pages don’t change until someone (e.g. manually) updates the stored HTML pages. A server-side scripting language like PHP helps if you need to add dynamic content, such as a visitor counter (see example code below) or maybe news-of-the-day.
Public domain as well as proprietary PHP software is available for various applications including:
public domain
personal photo galleries (e.g. Gallery (Gallery 2 also requires mySQL) or Dalbum)
Uli kindly provided a packaged version of php for the NAS in his repository.
PHP is not installed as part of fun_plug by default, but you should already have downloaded a copy as part of the general tutorial on how to download, install and upgrade packages. Let’s make sure you still have the latest version (as Uli upgrades his repository regularly). Note that the rsync command could take a while because it can download multiple packages depending on what is already in your /ffp/pkg/packages directory. Also note that you have to install curl additionally! As of PHP 5.2.17 you also have to install libiconv which is in fonz repository.
If you have a version of php installed that is outdated, you will need to run in upgrade mode instead (see here for help). Still, make sure you have curl and libiconv installed!
PHP is configured with a file called php.ini. You thus need to copy one of the example-files from /ffp/etc/examples/ to /ffp/etc/ while renaming it to php.ini:
Restart lighttpd to load the new configuration – including the PHP module. This can be done by rebooting the entire NAS or using
cd/ffp/start
sh lighttpd.sh restart
Testing PHP
You can test your installation of PHP by placing a file called index.php in the server.document-root directory (e.g. /mnt/HD_a2/www/pages) with the following content:
<H1>This is normal HTML</H1>
But the <U>following table</U> is generated by PHP:
<?phpphpinfo();?>
Now go to the website on your NAS using the configured address and e.g. http://CH3SNAS:80. You should see a long page with configuration information for the PHP server as shown in the picture). This output is generated by the function call “phpinfo()“.
Using PHP
Let us now go back to a somewhat less intimidating and possibly even boring example: the standard “Hello World” in PHP. Copy and paste the following text to a file named helloworld.php and store it in the server.document-root:
<?phpecho"Hello World";?>
Then go to the website on your NAS using the configured address and port and add /helloworld.php (the address may look like this: http://CH3SNAS/helloworld.php).
The following example shows a more complete web page (adapted from the lighttpd tutorial). It adds 3 features:
visitors are greeted using their IP address (using the $_SERVER['REMOTE_ADDR'])
any viewing of the web page triggers updates to a file (counter.txt) stored on the NAS
the web site uses counter.txt to show how often the page has been viewed
This requires three fragments of PHP code, each enclosed between and ?> tokens:
<?php$fname="counter.txt";// The file where the number of hits gets storedif(!file_exists($fname)){// If file doesn't exist..$countfile=fopen($fname,"a");// .. create it$counter=0;// .. and initialize hit counter to zero}else{$countfile=fopen($fname,"r+");// Open for read and write$counter=fgets($countfile,100);// Load number of hits by reading first 100 bytesrewind($countfile);// Reset the file pointer to overwrite old counter value}$counter++;// Increment counter by onefputs($countfile,$counter);// Write the new value to the filefclose($countfile);// Close the File?>
<html>
<head>
<title>Hello PHP World!</title>
<style type="text/css">
<!--
h1 {text-align:center; font-family:Arial, Helvetica, Sans-Serif;}
h2 {text-align:center;}
p {text-indent:20px;}
-->
</style>
</head>
<body bgcolor = "#ffffcc" text = "#0000ff">
<h1>Welcome, <?phpecho$_SERVER['REMOTE_ADDR'];?>, <BR>to the PHP world</h1>
<h2>This page was viewed <?phpecho$counter;?> times</h2>
<p><A HREF="page1.html">Link to page1</A></p>
<p><A HREF="page2.html">Link to page2</A></p>
<p><A HREF="https://nas-tweaks.net/">external link</A></p>
</body>
</html>
The first and by far the longest PHP section looks to see if a file name counter.txt exists in the server.document-root If it doesn't exist, it creates it and decides there have been zero hits so far ($counter=0). Note that variables in PHP do not need to be declared and start with a $ and that no clear distinctions are made between numeric and string variables: conversions are done on demand.
If the file already exists, the first 100 bytes (should be enough for a decent number) are copied into $counter. Then $counter is incremented, written to the counter.txt file and the file is closed.
The remaining HTML code is similar to the code in the lighttpd tutorial. In the level one header (H1), a string is generated by a PHP echo command which prints the IP address of the remote client. In the level two header the value of $counter that was previously computed is used.
Optional: Using shared extensions
PHP allows the use of additional modules, so called "shared extensions". E.g. there is calendar for calendar-related functions. The modules are stored in /ffp/lib/php/extensions/no-debug-non-zts-20060613/.
Available modules
You can list the available modules using:
ls -al /ffp/lib/php/extensions/no-debug-non-zts-20060613/*.so
As of version php-5.2.6-3 the following modules are available:
And add below the extension you want. E.g. to enable the calendar extension, you add:
; Linux extensions
extension=calendar.so
;extension=ctype.so
;extension=ftp.so
Afterwards you have to restart lighttpd to load the changes.
Demo of calendar extension
To see whether or not calendar was indeed loaded, you could run the PHPinfo.php script shown above.
Or run a script calendar.php containing:
<?phpfor($year=2000;$year<2011;$year++){$days=cal_days_in_month(CAL_GREGORIAN,2,$year);echo"February in $year has $days days <BR>";}?>
Notes
PHP and HTML
A page with PHP code is generally stored on disk as HTML code with one or more fragments of embedded PHP. When the HTTP sends delivers the actual page to the browser ("client") the PHP sections have been interpreted and removed. In general they have been replaced by additional HTML code (see the counter example above). The receiving client thus does not see the PHP code and cannot even directly know whether PHP has been used to generate the served page.
Short open tag
If you want to use "<?" instead of "<?php" to mark the start of PHP code fragments, you need to change change the value of "short_open_tag" (line 131) in /ffp/etc/php.ini file to On:
short_open_tag = On
This is a matter of taste and convenience. When you distribute PHP code for use in other servers, you need to keep in mind that they may be set to short_open_tag = Off.
File extensions and default file names
HTML pages containing PHP code should have a .php extension. This tells the lighttpd server to pass the code via the PHP preprocessor before sending it across the network.
When you access the lighttpd server without providing a specific file name, it successively checks for files in the server.document-root directory(typically /srv/www/pages/) named
index.php
index.html
index.htm
default.htm
This is defined in a parameter called index-file.names in the lighttpd.conf file. As the list suggests, if you have both an index.php file and an index.html file in the same directory, the index.php file has precedence. If you explicitly ask for index.html, however, you will get that file instead of index.php.
Stateless
Note that after a page has been processed, when a new request for the same page is made by the same or another client, all computation starts from scratch: PHP is "stateless" in the sense that variables such as $counter are all lost after the page request has been completed. So the only way to track state in a PHP server is to store information in a file (as in counter.txt above), to store information in a database (another tutorial), or to assume the client maintains any relevant information between one page request and the next one.
Learning the PHP language
There are numerous books (printed and online) on PHP. See for example php.net.
Dealing with PHP errors
PHP syntax errors messages are appended to the Lighttpd error.log file. So if you are experimenting with- or developing PHP code, it can help to keep an eye on that file.
This tutorial is deprecated and should only be used with fonz fun_plug 0.5! Please check the tutorial page for updated tutorials on this topic!
The lighttpd daemon is a lightweight web server. Its main task is to respond to HTTP requests. In other words, it allows HTTP clients (such as Internet Explorer and Firefox) to retrieve hyperlinked HTML pages stored on a web site stored on the CH3SNAS.
The lighttpd server allows you to build a web site which is accessible via your local area network (LAN). If you configure your router’s firewall properly, you can also let others access the website via the Internet. Opening your firewall to give access to outside HTTP requests obviously requires paying some attention to security.
A basic web site consists of a collection of HTML pages which provide text, links, images, documents, etc. HTML pages can be written with an ASCII editor. There are numerous books and online tutorials on how to create basic and advanced web pages directly in HTML. This can be worth trying if you want to understand how the World Wide Web works: HTML is the main technology behind WWW.
In recent years, however, the average web page has gotten increasingly sophisticated in terms of its technical and visual design. Furthermore, the content of many web sites has become dynamic: what you see in your browser often changes daily (the weather, the news, a blog, photos). Such dynamic HTML pages are generated (by running programs or scripts) whenever the set of HTML pages needs to be updated, or are created on the fly whenever the server receives a page request.
Some examples of what you can do with a web site consisting of basic, static HTML served via lighttpd:
a basic home page telling who you are
a set of pages about your hobby, your recipes, or reporting on your holiday trip (all with embedded pictures)
Using this approach you “program” your page using the HTML language.
Examples of ways to generate ”’fancier static HTML”’ pages using software:
Microsoft Word can generate a HTML version of a document (including formatting, links and pictures)
professional photographers may use Photoshop Lightroom to generate an online gallery of sample pictures
Using this approach you use software to generate the HTML pages. This means you don’t need to learn (much) HTML, but instead need to learn how to use the (often fancy) software. All-in-all this can save you some typing and helps generate a uniform look for the web site.
Examples of applications involving generating dynamic HTML pages:
a Blog or Forum contains HTML forms that allow users to type in text that is appended to certain pages. Example: NAS-Tweaks uses a PHP server and software by WordPress for its Blog. Often this approach uses a database like MySQL to store and manage the raw data used to generate the HTML.
many well-known Web 2.0 sites that provide a service for you (WikiPedia, Google Maps, YouTube, Flickr)
Using using this approach, software generates HTML pages on demand, keeps the pages updated, and allows interaction with the user. If you go overboard on this, and manage to get the users of your website to provide content which keeps you web site interesting, you can call this Web 2.0 and tell your friends you may become rich – someday.
This kind of software is often known as Content Management Systems and includes engines like Drupal, Joomla, Mediawiki (as used by Wikipedia) and WordPress (as used for blogs).
Setting up Lighttpd
Installation
By default a lighttpd is already installed with the fun_plug packages. But there is an update available. Before you can install it, be sure to synchronize my repository. Then update using the following command:
funpkg -u/ffp/pkg/additional/*/lighttpd-*.tgz
If you didn’t install all packages from the “packages”-directory (why not?), you should execute at least the installation of the OpenSSL-package:
funpkg -i/ffp/pkg/packages/openssl-*.tgz
Directories
The default lighttpd configuration needs a small directory tree where it can store logfiles and retrieve the data to display to the users. Instead of creating the directory at that location, you may prefer to create a symbolic link from /srv/ to the target-directory of your choice.
mkdir-p/ffp/opt/srv/mysql
ln-s/ffp/opt/srv//srv
This link will be lost after rebooting the device, so you have to add the following two lines to the end of the file /ffp/etc/fun_plug.init to recreate the link every time the NAS boots. You can edit this file using an editor like nano. Use the following for all NAS other than the DNS-320 or DNS-325:
# create custom link to the server-folderln-s/ffp/opt/srv//srv
The folder /srv/www/pages is the default location for the web site itself. The location is set via a parameter called server.document-root in the /ffp/etc/lighttpd.conf file. This means that any directories below server.document-root are visible via the HTTP server (careful), while any other directories are not visible.
The folder /srv/www/logs is for log files in which lighttpd can record what happened.
HTML test pages
Within the www folder, you should create a home page named index.html containing the following ASCII text. Note that the indentation is only for readability and can be (and often is) omitted. You don’t need to worry about using Linux or Windows end-of-line conventions here (both work). You may have to adapt the line CH3SNAS:81 to reflect the network name of your NAS or use its IP address instead (e.g. 192.168.0.20:81).
<html>
<head>
<title>Hello world</title>
<style type="text/css">
<!--
h1 {text-align:center;
font-family:Arial, Helvetica, Sans-Serif;}
p {text-indent:20px;}
-->
</style>
</head>
<body bgcolor="#ffffcc" text="#0000ff">
<h1>Hello, CH3SNAS Tweak'n World!</h1><p>
<A HREF="page1.html">Link to local page1</A><p>
<A HREF="page2.html">Link to local page2</A><p>
<A HREF="http://CH3SNAS:81">Configure the CH3SNAS</A><p>
<A HREF="https://nas-tweaks.net/CH3SNAS:Tutorials/lighttpd">external link to the Lighttpd tutorial</A>
</body>
</html>
The HTML code consists of a head and a body section. The head contains the title (shown at the top of the browser window) and, in this case, defines formatting styles for Header1 and new paragraph (<p>).
The body starts with a header, followed by four links (“<A>nchors”) to other pages, to the original HTML configuration page for the CH3SNAS (on port 81 instead of the default 80) and a link to a remote web site.
Then create page1.html in the same directory containing:
This tutorial assumes that fun_plug is installed and that you have installed the additional packages (these include lighttpd). You can test whether lighttpd is installed using
which lighttpd
on the ssh command line. If it is installed, it will respond with the location of the lighttpd script file: /ffp/sbin/lighttpd.
Waking up daemons
Next we need to enable the lighttpd server from the command line (see the packages tutorial for a detailed explanation):
chmod a+x /ffp/start/lighttpd.sh
and enable a script which disables the standard HTML server called webs (if you are running a DNS-320 / DNS-325 please skip this step and go to the following section):
chmod a+x /ffp/start/kickwebs.sh
The standard “webs” server then restarts automatically within a few minutes, but moves to port 81 because the standard HTTP port (80) is already occupied by the lighttpd server.
If you are running a DNS-320 or a DNS-325, you need to enable “kickwebs_dns320.sh” for kicking the internal lighttpd (which is used for the Webinterface of the Device) from Port 80:
chmod a+x /ffp/start/kickwebs_dns320.sh
Note that the chmod commands only take effect on the next reboot. If you would reboot now, however, nothing changes. If you want to try, you can see test this manually using:
sh/ffp/start/kickwebs.sh start # When you run a Device other than DNS-320 / DNS-325sh/ffp/start/kickwebs_dns320.sh start # When you run a DNS-320 / DNS-325sh/ffp/start/lighttpd.sh start
Unless you have installed the server before, you will get the error message /ffp/etc/lighttpd.conf: Required file not found or not readable. Which, by Linux standards is an unusually clear error message: a file with configuration settings for lighttpd is missing in the /ffp/etc directory (see the packages tutorial for more explanation).
lighttpd.conf
We can resolve the missing /ffp/etc/lighttpd.conf file by copying the file from the directory /ffp/etc/examples/. If you are not on a DNS-320 or a DNS-325 and you don’t need PHP, then run the following command:
cp/ffp/etc/examples/lighttpd.conf /ffp/etc/
This copies one of the two supplied configuration files from the /ffp/etc/examples subdirectory to the /ffp/etc directory.
if you want to run PHP and you are not on a DNS-320 or a DNS-325, then run the following:
If you are on the DNS-320 or DNS-325, you have no choice but to run the Webserver with PHP (Please configure PHP before you try starting lighttpd again!):
Next we can try starting lighttpd manually again to see how we are doing:
sh/ffp/start/kickwebs.sh start # When you run a Device other than DNS-320/DNS-325sh/ffp/start/kickwebs_dns320.sh start # When you run a DNS-320 / DNS-325sh/ffp/start/lighttpd.sh start
sh/ffp/start/lighttpd.sh status
As, this suggests that lighttpd is now happily running, we try typing http://CH3SNAS:81 in the address bar of your Web browser. Note that if your network name for the device differs from “CH3SNAS“, use that name or its IP address instead. You should now get the standard configuration screen. Please remember the :81 port number in case you need to access it in the future (it is one more than the standard port 80 used for HTTP servers – which you can look up on the internet). You can close that screen – it was only to demonstrate that kickwebs.sh did its job.
We now try entering http://CH3SNAS in the address bar of the Web browser. If all goes well, you will see the expected web page.
To boot or not to boot
Remember that you now have a lighttpd running on port 80 each time you boot the NAS. If you want to connect to the Webinterface of the NAS, connect to Port 81.
Testing Lighttpd
At this point, you can enter any of the following into your browser’s address bar (assuming CH3SNAS is the correct network name of your NAS):
http://CH3SNAS:80/index.html
http://CH3SNAS:80 – index.html is a default for browsers
http://CH3SNAS – port 80 is default for HTTP
CH3SNAS – http is the default protocol for web browsers
Notes
The log files
The directory /srv/www/logs contain log files which respectively record the access to the server and any errors (including starting and stopping) reported by the server.
-rw-r--r--1 root root 0 Oct 1917:06 access.log
-rw-r--r--1 root root 48 Oct 1917:06 error.log
If you want to clear the log files, one quick-and-dirty way to do so is to delete them and restart the CH3SNAS. The lighttpd server will regenerate the log files when it is started. A quicker approach is to restart the lighttpd server using:
rm/srv/logs/access.log
cd/ffp/start
sh lighttpd.sh restart
Now What?
You should now install PHP if not already installed and try using MySQL. Have fun 🙂
The CH3SNAS uses the Linux ext2 file system, and thus cannot preserve data which was written to the hard disks (e.g. using Microsoft Windows) before these are inserted into the CH3SNAS: reformatting will normally be necessary for both a new and a used hard disk. Lets assume the drives have storage capacities of respectively C1 and, if a 2nd drive is present, C2 Gigabytes. The CH3SNAS supports a number of different ways in which to format individual hard disk partitions using the built-in web interface:
Standard – each drive can be accessed as a different volume (results in a volume of size C1 and, if present, C2)
JBOD – Just-a-Bunch of Disks, allowing both drives to be accessed as a single large volume (of size C1+C2)
RAID 0 – files are “striped” over both drives, thus potentially giving higher performance (resulting in a single volume of size 2*min(C1,C2))
RAID 1 – files are automatically mirrored at the sector level on both drives, thus allowing data recovery if either drive fails. RAID 1 results in a single volume of size min(C1,C2). Note that this occupies 2*min(C1,C2) of total disk space.
Configurations 2, 3, and 4 require a dual-drive system. A RAID 0 or 1 volume can be no larger than the smallest of the two drives, but can optionally be configured to be smaller than min(C1,C2). Any remaining space on both drives becomes accessible as a single JBOD volume.
Consequently, a dual-drive system can support up to 6 alternative configuration options:
Two Standard volumes
A single large JBOD volume
A single RAID 0 volume (if both drives have the same size, and no JBOD volume is needed)
A single smaller RAID 1 volume (if both drives have the same size, and no JBOD volume is needed)
A RAID 0 volume and a JBOD volume
A RAID 1 volume and a JBOD volume (see screen shot)
It may be possible to create other working configurations (such as RAID 0 + RAID 1 + JBOD), but these cannot be created using the built-in configuration interface and will probably not have been tested.
Under Windows, volumes can be assigned user-selectable drive letters (such as R: for a RAID).
We use cookies on our website to give you the most relevant experience by remembering your preferences and repeat visits. By clicking “Accept All”, you consent to the use of ALL the cookies. However, you may visit "Cookie Settings" to provide a controlled consent.
This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary cookies are absolutely essential for the website to function properly. These cookies ensure basic functionalities and security features of the website, anonymously.
Cookie
Duration
Description
cookielawinfo-checkbox-analytics
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checkbox-functional
11 months
The cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checkbox-necessary
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-others
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-performance
11 months
This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy
11 months
The cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.
Functional cookies help to perform certain functionalities like sharing the content of the website on social media platforms, collect feedbacks, and other third-party features.
Performance cookies are used to understand and analyze the key performance indexes of the website which helps in delivering a better user experience for the visitors.
Analytical cookies are used to understand how visitors interact with the website. These cookies help provide information on metrics the number of visitors, bounce rate, traffic source, etc.
Advertisement cookies are used to provide visitors with relevant ads and marketing campaigns. These cookies track visitors across websites and collect information to provide customized ads.