Empowering you with the knowledge to master Linux web hosting, DevOps and Cloud

 Linux Web Hosting, DevOps, and Cloud Solutions

Category: Linux server

How dns works

A DNS client “resolves” an IP address by sending a specially formatted request to a DNS server. The client has to know the address of one or more DNS servers in advance. The reply from the server may be a direct reply with the IP address associated with the hostname, a referral to another DNS server, or a response indicating the requested name can’t be found in DNS.

Typically, the request will ask the server to “recursive“, i.e. if it cannot answer the question from its own local memory, it should go ask other servers on behalf of the client. This behavior helps the local server build up its own cache of addresses frequently looked up.

Another form of query is called iterative query, where a client machine sends the request to a known DNS server , if that DNS server fail to resolve the domain name into a IP, then the client sends the request to another DNS and this process goes on and on until it get the required IP resolution by sending address resolution request to all its known DNS.If every known DNS fail to give the IP, then client goes to the root domain.

When you type a URL into your browser, it uses the following steps to locate the correct website:

A DNS client uses a resolver to request resolution of a host name to an IP address. The resolver is really just a special-purpose application that’s sole function is to act as an intermediary between name servers and various applications that need name resolution, such as Web browsers, e-mail applications, and so on. Here’s an example: Assume you fire up your browser and direct it to connect to www.mysite.com.

1. Your browser checks it’s cache (memory) to see if it knows which IP address the domain name resolves to. If it knows, it will resolve it and display the web page.
2. If the domain name is unable to be resolved, the browser will check your hosts file for a DNS entry.
3. If there’s no entry in the hosts file, the browser will check the default DNS server (specified via your computer’s network settings, /etc/resolv.conf). This is usually your ISP’s DNS server or your employer’s. If the default DNS server has an entry for that domain name, the browser will display the applicable website.
4. If the default name server has no cached results, it sends a DNS query to the root server for the .com domain.
5. The root server responds with the addresses of the name servers that are authoritative for the mysite.com domain.
6. Your ISP’s name server then builds another request for www.mysite.com and submits it to mysite.com’s name server, which responds with the IP address of www.mysite.com.
7. That information is passed back to your resolver, which passes it to your application.

How to install an SSL certificate on Ubuntu for Nginx

Introduction

SSL (Secure Sockets Layer) is a protocol that provides secure communication over the internet. It uses cryptographic algorithms to encrypt data between the web server and the client’s browser. SSL is now deprecated, and TLS (Transport Layer Security) is the newer version that’s used widely.

In this tutorial, we’ll walk you through the steps to install and secure your website with SSL on Ubuntu 22.04 using Nginx. By the end of this guide, you’ll have a secure, encrypted connection between your web server and your users’ browsers, helping to ensure their safety and privacy.

Note: Originally, this blog was written for an old versions of Nginx and Ubuntu, I have updated to match the latest Ubuntu and Nginx recently.

Section 1: Installing Nginxon Ubuntu 22.04

Apache2 is a popular open-source web server software that plays a crucial role in hosting websites on the internet. In this section, we will walk through the process of installing Apache2 on Ubuntu 22.04.

Step 1: Update the Package List
Before installing any new software, it’s always a good idea to update the package list to ensure you are installing the latest version of the software. To update the package list, open the terminal on Ubuntu 22.04 and run the following command:

sudo apt update

Step 2: Install Nginx
Once the package list is updated, you can proceed with installing Nginx by running the following command:

sudo apt install nginx

This command will download and install Nginx along with all its dependencies. During the installation process, you will be prompted to confirm the installation by typing y and pressing Enter.

Enable and Start the Apache2 service

sudo systemctl enable nginx
sudo systemctl start nginx

Step 3: Verify NginxInstallation
To test if Nginx is working correctly, open a web browser and enter your server’s IP address or domain name in the address bar. You should receive the default Nginx landing page:

Congratulations, you have successfully installed Nginx on Ubuntu 22.04! In the next section, we will proceed with securing the web server by enabling SSL.

If you encounter any issues like Connection timeout or Unable to reach the website during the verification process, one possible cause could be that the Ubuntu firewall is blocking nginx traffic.

To check if Nginx is currently enabled in the firewall, you can use the Nginx is not listed as an allowed service, you can add it by running the following command:

sudo ufw allow 'Nginx Full'

This will allow both HTTP (port 80) and HTTPS (port 443) traffic to pass through the firewall, ensuring that your website is accessible to visitors.

Section 2: Installing SSL Certificate on Ubuntu 22.04 with Nginx

There are different types of SSL certificates, including domain validated, organization validated, and extended validation certificates. Each type has different features and provides varying levels of trust and security.

To install an SSL certificate on Ubuntu 22.04 with Nginx, you’ll need to follow these steps:

  • Obtain an SSL certificate: You can purchase an SSL certificate from a certificate authority (CA) or obtain a free SSL certificate from Let’s Encrypt. If you already have an SSL certificate, make sure it is valid and up-to-date.
  • Configure Apache2 to use the SSL certificate: Apache2 needs to be configured to use the SSL certificate for secure communication. This involves creating a virtual host for the SSL-enabled website, specifying the SSL certificate and key files, and enabling SSL encryption.

    You can read more about different SSL certificate types, the process to create a Certificate signing request(CSR), etc in the below blog post:

    SSL Certificates: What They Are and Why Your Website Needs Them

    Here are the steps for creating and configuring virtual hosts for Apache on Ubuntu 22.04:

    1. Create a new virtual host configuration file:

    sudo nano /etc/nginx/sites-available/linuxwebhostingsupport.in

    Add the following configuration to the file, replacing linuxwebhostingsupport.in with your own domain name:

    server {
        listen 80;
        listen [::]:80;
    
        server_name linuxwebhostingsupport.in;
    
        root /var/www/html/linuxwebhostingsupport.in/html;
        index index.html;
    
        location / {
            try_files $uri $uri/ =404;
        }
    }
    
    server {
        listen 443 ssl http2;
        listen [::]:443 ssl http2;
    
        server_name linuxwebhostingsupport.in;
    
        root /var/www/html/linuxwebhostingsupport.in/html;
        index index.html;
    
        ssl_certificate /etc/ssl/certs/linuxwebhostingsupport.in.crt;
        ssl_certificate_key /etc/ssl/certs/linuxwebhostingsupport.in.key;
        ssl_trusted_certificate /etc/ssl/certs/linuxwebhostingsupport.in_cabundle.crt;
    
        location / {
            try_files $uri $uri/ =404;
        }
    }
    

    Note: replace the paths to SSL certificate files with your own paths.

    2. Create the documentroot
    Run the following command to create the directory:

    sudo mkdir -p /var/www/html/linuxwebhostingsupport.in/html

    3. Test the Nginx configuration:

    sudo nginx -t

    If there are any issues, this check will show

    4. Enable the virtual host configuration file:

    If the configuration test is successful, enable the server block by creating a symbolic link in the /etc/nginx/sites-enabled directory:

    sudo ln -s /etc/nginx/sites-available/linuxwebhostingsupport.in /etc/nginx/sites-enabled/

    5. Create an HTML file named index.html in the new directory by running the following command:

    sudo nano /var/www/html/linuxwebhostingsupport.in/html/index.html

    This will open a text editor. Add the following code to the file:

    <html>
        <head>
            <title>Hello, world!</title>
        </head>
        <body>
            <h1>Hello, world!</h1>
            <p>Welcome to my website!</p>
        </body>
    </html>
    

    5. Reload Nginx for the changes to take effect:

    sudo systemctl reload Nginx

    Section 3: Testing SSL on Ubuntu 22.04 with Nginx

    Test your SSL configuration by visiting your domain in a web browser and verifying that the SSL certificate is valid and the website loads correctly over HTTPS. The browser should display a padlock icon and the connection should be secure

    You can also use the online tools like https://www.sslshopper.com/ssl-checker.html to check the configuration further. It can show if there any issues with certificate chain or trust.

    Section 4. Troubleshooting SSL on Ubuntu 22.04 with Apache2

    1. Certificate errors: If you encounter a certificate error, such as a warning that the certificate is not trusted or has expired, check the certificate’s validity and ensure it’s installed correctly. You can check the certificate’s details using your web browser, and make sure it matches the domain name and other relevant details.

    2. Mixed content warnings: If you see mixed content warnings, which indicate that some parts of the site are not secure, check for any resources that are still being loaded over HTTP instead of HTTPS. This can include images, scripts, and other files.

    3. SSL handshake errors: If you see an SSL handshake error, this usually means there’s an issue with the SSL configuration. Check your Apache configuration files and make sure the SSL directives are properly set up. You can also check for any issues with the SSL certificate, such as an invalid or mismatched domain name.

    4. Server configuration errors: If the SSL certificate is working properly, but the site is still not loading over HTTPS, check your server configuration files to make sure the VirtualHost configuration is correct. Make sure the correct SSL certificate and key files are specified and that the SSL directives are set up correctly.

    5. Browser-specific issues: If you’re only experiencing SSL issues in a specific web browser, make sure the browser is up to date and try clearing the cache and cookies. You can also try disabling any browser extensions that may be interfering with the SSL connection.

    Remember, troubleshooting SSL issues can be complex and may require some technical expertise. If you’re not comfortable with these steps or need additional help, it’s always a good idea to consult with a professional. You can contact me at admin @ linuxwebhostingsupport.in

    Section 5: Best Practices for SSL Configuration on Ubuntu 22.04 with Apache2

    Here are some tips and best practices for configuring SSL on Ubuntu 22.04 with Apache2:

    1. Keep SSL certificates up to date: Make sure to renew your SSL certificates before they expire. This can be done through the certificate authority where you purchased the certificate. Keeping your SSL certificates up to date will ensure that your website visitors are not presented with security warnings or errors.

    2. Configure Nginx for HTTPS-only access: To ensure that your website visitors are accessing your site securely, configure your Nginx server to only serve HTTPS traffic. This can be done by redirecting all HTTP traffic to HTTPS. To do this, add the red colored line to your server block of Nginx virtual host configuration file:

    server {
        listen 80;
        server_name linuxwebhostingsupport.in;
        return 301 https://$server_name$request_uri;
    }
    

    3. Use secure ciphers and protocols: To protect the confidentiality and integrity of your website traffic, use secure ciphers and protocols. Disable weak ciphers and protocols such as SSLv2 and SSLv3. Use TLSv1.2 or higher, and prefer the use of forward secrecy. You can configure this in your Nginx virtual host configuration file by adding the following lines:

    ssl_protocols TLSv1.2;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA;
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_stapling on;
    ssl_stapling_verify on;
    

    Make sure to adjust the file paths and other configuration options to match your specific setup.

    You can find more detailed instruction on making your SSL configuration strong and best practices in the below post:

    Strong TLS/SSL Security on your server

    By following these best practices, you can ensure that your SSL configuration is secure and up to date.

    Section 6. Summary

    In this tutorial, we discussed how to install and configure SSL certificates on Ubuntu 22.04 with Nginx. We covered the different types of SSL certificates, the steps for obtaining and installing an SSL certificate, and how to configure Nginx to use the SSL certificate. We also discussed how to create virtual hosts for both SSL and non-SSL sites and how to troubleshoot SSL issues.
    It’s important to emphasize the importance of SSL for website security and user trust. SSL encryption helps protect sensitive information, such as passwords and credit card numbers, from being intercepted by attackers. Additionally, having a valid SSL certificate gives users confidence that they are interacting with a legitimate website and not an imposter.

    To follow best practices for SSL configuration, it’s recommended to keep SSL certificates up to date, configure Nginx for HTTPS-only access, and use secure ciphers and protocols. By following these best practices, website owners can help ensure the security and trustworthiness of their website.

  • Case insensitive url Aapche Webserver

    How to enable Case-Insensitive url’s ?

    Webserver: Apache

    OS: Linux

    One of our customer had opened ticket. He has a very interesting need. He wants his site urls  to be Case-insensitive . I will explain with examples:- He needs the following urls to work currently he is getting 404 errors for each request.

    http://yourdomain.com/Yourpage.html

    http://yourdomain.com/YourPage.html

    We were unable to add rewrite rules in his htaccess files as we need to write rule for every single file that has a mixture of upper and lower case.

    http://yourdomain.com/yourpage.html => This is the correct url

    He needs this url http://yourdomain.com/Yourpage.html to load even if they have one spelling mistake or there is one capitalization error. This was found very strange. We have managed to fix the issue by adding an apache module server wide, which neutralise all the the upper case and lower case characters to a single format.

    Solution: If you want requested URLs to be valid whether uppercase or lowercase letters are used and with one spelling mistake, “mod_speling” module needs to be enabled in apache.

    The mod_speling module is part of the standard Apache distribution but is not enabled by default, so you need to explicitly enable it. When mod_speling is installed, it may be turned on for a particular scope (such as a directory, virtual host, or the entire server) by setting the CheckSpelling directive to On.

    For making URL case-insensitive in cPanel:

    First run belwow on Cpanel based server : /scripts/easyapache And select ‘Spelling’ from the available module list for apache. Once apache/php are recompiled with this option and easyapache finishes, you can put below code in the .htaccess or in the virtual host entry of the particular domain to apply it to any directory/directories :

    < IfModule mod_speling.c > CheckCaseOnly On CheckSpelling On < / IfModule > This helped to fix this particular issue

    Verify PHP/cURL is working correctly

    Simply, cURL is a command line tool for getting or sending files using URL syntax. It supports a range of common Internet protocols, including HTTP, FTP, SCP, SFTP, TFTP, TELNET, FILE, IMAP, POP3, SMTP and RTSP, etc. The command is designed to work without user interaction.

    Usage:-

    Basic use of cURL involves simply typing curl at the command line, followed by the URL of the output to retrieve.
    To retrieve the google.com homepage, type:
    curl www.google.com
    What is PHP/CURL?
    The module for PHP that makes it possible for PHP programs to access curl-functions from within PHP.

    How to verify cURL is working correctly?.

    cURL does have very powerfull functions which inturn not used properly may leads to complete breakdown of your server. Because of this most of the hosting companies disable some of these dangerous functions. But for a PHP Programmer cURL is an essential tool and must requires basic functionality atleast. It is very easy to check the PHP/cURL is working normal.

    Steps:-

    1. Create a php file “check_cURL.php” with following content using any of your favourite editor.

    <?php
    /**
    * Initialize the cURL session
    */
    $ch = curl_init();
    /**
    * Set the URL of the page or file to download.
    */
    curl_setopt($ch, CURLOPT_URL,
    ‘http://news.google.com/news?hl=en&topic=t&output=rss’);
    /**
    * Create a new file
    */
    $fp = fopen(‘rss.xml’, ‘w’);
    /**
    * Ask cURL to write the contents to a file
    */
    curl_setopt($ch, CURLOPT_FILE, $fp);
    /**
    * Execute the cURL session
    */
    curl_exec ($ch);
    /**
    * Close cURL session and file
    */
    curl_close ($ch);
    fclose($fp);
    ?>


    2.  Execute the “check_cURL.php” script (I just run “php -q   check_cURL.php” from the terminal)

    3.  Check the output file “rss.xml”. If the file contains data, we can conclude curl is working fine.

    How does this script works:-

    The check_cURL.php is simple php script which when called connects to the url specified(Google in our example) and download its source code. The script then writes its output to downloaded content to the output file(rss.xml in our example).

    IPTABLES complete cheatlist

    Please note that the iptables rules are stored in the /etc/sysconfig/iptables file. If you view this file, you’ll see all the default rules.

    1. Delete Existing Rules

    Before you start building new set of rules, you might want to clean-up all the default rules, and existing rules. Use the iptables flush command as shown below to do this.

    iptables -F
    (or)
    iptables –flush
    service iptables save

    2. Set Default Chain Policies

    The default chain policy is ACCEPT. Change this to DROP for all INPUT, FORWARD, and OUTPUT chains as shown below.

    iptables -P INPUT DROP
    iptables -P FORWARD DROP
    iptables -P OUTPUT DROP

    When you make both INPUT, and OUTPUT chain’s default policy as DROP, for every firewall rule requirement you have, you should define two rules. i.e one for incoming andone for outgoing.
    Change default policy for INPUT/OUTPUT/FORWARD to ACCEPT. All inbound connections will be allowed

    iptables -P INPUT ACCEPT
    iptables -P OUTPUT ACCEPT
    iptables -P FORWARD ACCEPT

    3.Block an IP for inbound connection

    iptables -A INPUT -s 192.168.1.5 -j DROP
    iptables -A INPUT -i eth0 -p tcp -s “$BLOCK_THIS_IP” -j DROP
    4.Allow an IP for inbound connection

    iptables -A INPUT -s 192.168.1.5 -j ACCEPT

    5.Block outbound IP address

    iptables -A OUTPUT -d <IP> -j DROP

    6.Block outbound PORT

    iptables -A OUTPUT -p tcp –dport <PORT> -j DROP

    7.Block outbound IP:PORT

    iptables -A OUTPUT -p tcp -d <IP> –dport <PORT> -j DROP

    8.Allow port 2222 for inbound tcp connections

    iptables -A INPUT -p tcp –dport 2222 -j ACCEPT

    9.White list an IP

    iptables -A INPUT -i eth0 -s <IP> -j ACCEPT

    10.Open port 5666

    iptables -I INPUT -p tcp -m tcp –dport 5666 -j ACCEPT
    11.Allow ALL Incoming SSH

    The following rules allow ALL incoming ssh connections on eth0 interface.

    iptables -A INPUT -i eth0 -p tcp –dport 22 -m state –state NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth0 -p tcp –sport 22 -m state –state ESTABLISHED -j ACCEPT

    12.Allow Incoming SSH only from a Sepcific Network

    The following rules allow incoming ssh connections only from 192.168.100.X network.

    iptables -A INPUT -i eth0 -p tcp -s 192.168.100.0/24 –dport 22 -m state –state NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth0 -p tcp –sport 22 -m state –state ESTABLISHED -j ACCEPT

    In the above example, instead of /24, you can also use the full subnet mask. i.e “192.168.100.0/255.255.255.0″.

    13. Allow Incoming HTTP and HTTPS

    The following rules allow all incoming web traffic. i.e HTTP traffic to port 80.

    iptables -A INPUT -i eth0 -p tcp –dport 80 -m state –state NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth0 -p tcp –sport 80 -m state –state ESTABLISHED -j ACCEPT

    The following rules allow all incoming secure web traffic. i.e HTTPS traffic to port 443.

    iptables -A INPUT -i eth0 -p tcp –dport 443 -m state –state NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth0 -p tcp –sport 443 -m state –state ESTABLISHED -j ACCEPT

    14.Combine Multiple Rules Together using MultiPorts

    When you are allowing incoming connections from outside world to multiple ports, instead of writing individual rules for each and every port, you can combine them together using the multiport extension as shown below.

    The following example allows all incoming SSH, HTTP and HTTPS traffic.

    iptables -A INPUT -i eth0 -p tcp -m multiport –dports 22,80,443 -m state –state NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth0 -p tcp -m multiport –sports 22,80,443 -m state –state ESTABLISHED -j ACCEPT

    15.Allow Outgoing SSH

    The following rules allow outgoing ssh connection. i.e When you ssh from inside to an outside server.

    iptables -A OUTPUT -o eth0 -p tcp –dport 22 -m state –state NEW,ESTABLISHED -j ACCEPT
    iptables -A INPUT -i eth0 -p tcp –sport 22 -m state –state ESTABLISHED -j ACCEPT

    Please note that this is slightly different than the incoming rule. i.e We allow both the NEW and ESTABLISHED state on the OUTPUT chain, and only ESTABLISHED state on  the INPUT chain. For the incoming rule, it is vice versa.

    16.Allow Outgoing SSH only to a Specific Network

    The following rules allow outgoing ssh connection only to a specific network. i.e You an ssh only to 192.168.100.0/24 network from the inside.

    iptables -A OUTPUT -o eth0 -p tcp -d 192.168.100.0/24 –dport 22 -m state –state NEW,ESTABLISHED -j ACCEPT
    iptables -A INPUT -i eth0 -p tcp –sport 22 -m state –state ESTABLISHED -j ACCEPT

    17.Allow Ping from Outside to Inside

    The following rules allow outside users to be able to ping your servers.
    iptables -A OUTPUT -p icmp –icmp-type echo-request -j ACCEPT
    iptables -A INPUT -p icmp –icmp-type echo-reply -j ACCEPT
    19.Allow Loopback Access

    You should allow full loopback access on your servers. i.e access using 127.0.0.1

    iptables -A INPUT -i lo -j ACCEPT
    iptables -A OUTPUT -o lo -j ACCEPT

    20. Allow MySQL connection only from a specific network

    iptables -A INPUT -i eth0 -p tcp -s 192.168.100.0/24 –dport 3306 -m state –state NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth0 -p tcp –sport 3306 -m state –state ESTABLISHED -j ACCEPT

    21.Prevent DoS Attack

    The following iptables rule will help you prevent the Denial of Service (DoS) attack on your webserver.

    iptables -A INPUT -p tcp –dport 80 -m limit –limit 25/minute –limit-burst 1000 -j ACCEPT
    In the above example:
    -m limit: This uses the limit iptables extension

    –limit 25/minute: This limits only maximum of 25 connection per minute. Change this value based on your specific requirement
    –limit-burst 1000: This value indicates that the limit/minute will be enforced only after the total number of connection have reached the limit-burst level.

    22.Port forwarding using IPTables

    Forward port 80 from IP address to another IP

    iptables -t nat -A PREROUTING -i eth0 -p tcp –dport 80 -j DNAT –to <DESTIP>:80
    iptables -t nat -A POSTROUTING -p tcp –dst <DESTIP> –dport 80 -j SNAT –to <SRCIP>
    iptables -t nat -A OUTPUT –dst <SRC> -p tcp –dport 80 -j DNAT –to <DESTIP>:80

    Removing the above rules
    iptables -t nat -D PREROUTING -i eth0 -p tcp –dport 80 -j DNAT –to <DESTIP>:80
    iptables -t nat -D POSTROUTING -p tcp –dst <DESTIP> –dport 80 -j SNAT –to <SRCIP>
    iptables -t nat -d OUTPUT –dst <SRC> -p tcp –dport 80 -j DNAT –to <DESTIP>:80

    23.List all the rules in the iptables

    iptables  -L

    24.Check an IP in the rule

    iptables -nL | grep <IP>

    25.Save the current iptables rules

    iptables-save >  File_name

    26.Restore iptable rules from the file

    iptables-restore <  File_name

    MSSQL support to PHP in cpanel server

    To use the MSSQL extension on Unix/Linux, you first need to build and install the FreeTDS library. FreeTDS is a set of libraries for Unix and Linux that allows your programs to natively talk to Microsoft SQL Server and Sybase databases.

    You can refer to the following url to get informations about mssql extension and  the functions supported with it.
    http://www.php.net/manual/en/book.mssql.php

    To get these functions to work, you have to compile PHP with –with-mssql[=DIR] , where DIR is the FreeTDS install prefix. And FreeTDS should be compiled using
    –enable-msdblib

    Installation instruction:-

    (This is not specific to cpanel servers, you can recompile php directly without easyapache in any normal linux servers with ‘–with-mssql=/usr/local/freetds’)

    1-. Download freetds source -> www.freetds.org
    2-. tar -zxvf freetds-stable-tgz
    3-. cd freetds-*
    4-. ./configure –prefix=/usr/local/freetds –with-tdsver=8.0 –enable-msdblib  –with-gnu-ld

    Note: If you use SQL 2000, 2005, 2008 then tds version = 8.0
    if you use SQL 7.0 then tds version = 7.0

    5-. make
    6-. make install
    7-. To check freetds working, run from terminal
    7.1 /usr/local/freetds/bin/tsql -S <ip of the server> -U <User SQL>
    7.2 If the connection parameters are correct you will be connected to a prompt.
    8-. Add the following text in freetds.conf ( /usr/local/freetds/etc )
    [TDS]
    host = <ip of the Server with Sql>
    port = 1433
    tds version = 8.0

    9-. Add the following line in the file /etc/ld.so.conf and run ldconfig -v:
    include /usr/local/freetds/lib

    10-. Recompile PHP with –with-mssql=/usr/local/freetds flag.
    Create a file called all_php4 or all_php5 in:

    ‘/var/cpanel/easy/apache/rawopts/’

    The file doesnt exist by default, just create it and add this line to the file:
    –with-mssql=/usr/local/freetds
    Easy apache will check this file ‘/var/cpanel/easy/apache/rawopts/all_php5’ for any additional php configuration option during recompilation.

    11-. Run ‘/scripts/easyapache’

    Notes:-

    1-. If you are running a 64bit OS and get an error about configure: error: ‘Could not find /usr/local/freetds/lib64/libsybdb.a|so’
    then you need to do the following:
    1.1 Make sure libsybdb.so is available on the server,then
    1.2 ln -s /usr/local/freetds/lib/libsybdb.so.5 /usr/lib64/libsybdb.so.5
    1.3 ln -s /usr/local/freetds/lib/libsybdb.so.5 /usr/local/freetds/lib64/libsybdb.so
    1.4 Run   ldconfig -v

    2-. If you are getting an error about configure:’ error: Directory /usr/local/freetds is not a FreeTDS installation directory’
    2.1 cp [tds source]/include/tds.h /usr/local/freetds/include
    2.2 cp [tds source]src/tds/.libs/libtds.a /usr/local/freetds/lib
    2.3 Recompile again.

    Reference:-

    http://www.freetds.org/userguide/
    http://www.php.net/manual/en/book.mssql.php
    http://forums.cpanel.net

    Flex2gateway 404 error with railo

    Railo 3.x comes with BlazeDS 3.2, the Adobe open source amf engine to communicate from a Flex application to a Java backend. But we may need to modify some tomcat configurations files to get it work.  You need to verify that tomcat configurations files are properly configured for flex or not. The following are the settings needed for Flex  services:-

    #1. Updating the web.xml file

    /opt/railo/tomcat/conf/web.xml

    Uncomment the following settings in the web.xml if present or add the following details.

    <!– Load the MessageBrokerServlet  –>
    <servlet>
    <servlet-name>MessageBrokerServlet</servlet-name>
    <servlet-class>flex.messaging.MessageBrokerServlet</servlet-class>
    <init-param>
    <param-name>services.configuration.file</param-name>
    <param-value>/WEB-INF/flex/services-config.xml</param-value>
    </init-param>
    <init-param>
    <param-name>messageBrokerId</param-name>
    <param-value>MessageBroker</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    </servlet>

    <!– The mappings for the Flex servlet –>
    <servlet-mapping>
    <servlet-name>MessageBrokerServlet</servlet-name>
    /flex2gateway/*
    </servlet-mapping>
    <servlet-mapping>
    <servlet-name>MessageBrokerServlet</servlet-name>
    /flashservices/gateway/*
    </servlet-mapping>
    <servlet-mapping>
    <servlet-name>MessageBrokerServlet</servlet-name>
    /messagebroker/*
    </servlet-mapping>

    #2. Updating the uriworkermap.properties file

    /opt/railo/tomcat/conf/uriworkermap.properties

    Add the following details.

    /*.cfm=ajp13
    /*.cfc=ajp13
    /*.cfml=ajp13
    /*.cfres=ajp13
    /*.cfchart=ajp13
    /*.cfm/*=ajp13
    /*.cfml/*=ajp13
    /*.cfc/*=ajp13
    /*.jsp=ajp13
    /*.do=ajp13
    /=ajp13
    /flex2gateway/*=ajp13
    /flashservices/gateway/*=ajp13
    /messagebroker/*=ajp13
    /=ajp13

    Once you’ve updated Tomcat configuration files, restart Tomcat/Railo.

    Verify the Flex

    Browse to  http:///flex2gateway/  you should get a white page, if you get an error message, this would mean that either you server is not running, the MessageBroker Servlet is not running or there are some configuration mistakes.

    Troubleshooting 404 error

    Apache 404 error

    1.Please understand that if the URL you’re using is this: http://mydomain/flex2gateway , then all your mappings should look like
    /flex2gateway*=ajp13
    There must no trailing slash on either of them.

    2.Also verify the server.xml is updated correctly and hence the domain is  pointing to its  webroot.

    3. Most importantly, the mod_jk module needed to be loaded in to apache, then only the connection between tomcat and apache works. So please verify the apache configurations files and verify the mod_jk is enabled. If not add the following details to the apache configuration file.

    <IfModule !mod_jk.c>
    LoadModule jk_module [modules directory]/mod_jk.so
    <!–IfModule>

    <IfModule mod_jk.c>
    JkMount /*.cfm ajp13
    JkMount /*.cfc ajp13
    JkMount /*.do ajp13
    JkMount /*.jsp ajp13
    JkMount /*.cfchart ajp13
    JkMount /*.cfm/* ajp13
    JkMount /*.cfml/* ajp13
    Flex Gateway Mappings
    # JkMount /flex2gateway/* ajp13
    JkMount /flashservices/gateway/* ajp13
    JkMount /messagebroker/* ajp13
    JkMountCopy all
    JkLogFile [log directory]/mod_jk.log
    </IfModule>

    ps: Please restart the httpd service.

    Tomcat 404 error

    The reason mostly is Tomcat servlet “MessageBrokerServlet” is unavailable or not loaded. In that case please verify the tomcat configuration files are updated correctly as mentioned above, ie web.xml and uriworkermap.properties files. Also verify tomcat log files to find out why “MessageBrokerServlet” is not loaded. Sometimes you may need to comment “MessageBrokerServlet” in other web.xml files.

    Tomcat log file location:- /opt/railo/tomcat/logs/

    ps: You need to restart railo/tomcat if you made any changes to tomcat configuration files.

    Joomla jos_session table crashed

    You may come across the following error sometime if you are working joomla site.
    jtablesession::Store Failed
    DB function failed with error number 145
    Table ‘./eilmccco_cmsicdc/jos_session’ is marked as crashed and should be repaired SQL=INSERT INTO jos_session ( `session_id`,`time`,`username`,`gid`,`guest`,`clie nt_id` ) VALUES ( ‘ca7331cb8a008d79e24df425257229ea’,’1227636484′,” ,’0′,’1′,’0′ )

    This is a very common error. The problem with this error is that you cannot access your site nor the admin page.
    The error messages means that the table “jos_session” is crashed or damaged. This table stores your session information.

    This issue can be easily fixed by repairing the session table. For doing this the first thing you should do is find out your joomla database. This can be done by checking your joomla configuration.php file.
    Now we can try  repairing the table in following ways.

    Cpanel
    If you are using the Cpanel, then you can repair you joomla database by clicking the “Repair DB” option in the Mysql section of the Cpanel.

    phpMyAdmin

    If you can access your database though phpMyAdmin, then on the phpMyAdmin interface, select the joomla database and look for the table “jos_session”. Once you selected the “jos_session” (tick the checkbox) and choose “Repair table” from the drop-down you find at the bottom of the list of tables.

    SSH access

    If you have shell access of your server, the database can be repaired within the Mysql.
    Login to the mysql with necessary privileges
    #mysql -u <dbuser> -p
    mysql> use joomla1;                              [Assume your joomla database name is joomla1]
    mysql> REPAIR TABLE jos_session;

    If all the above tricks failed, then you must recreate the “jos_session” table

    First of all, please take a complete backup of the joomla database.

    phpMyAdmin

    1 – Go to MySQL phpMyadmin Control Panel

    2 – Go and click on “SQL” near the top left corner of the page, and paste the following lines (below) into the empty text area :

    DROP TABLE IF EXISTS `jos_session`;
    CREATE TABLE `jos_session` (
    `username` varchar(150) default ”,
    `time` varchar(14) default ”,
    `session_id` varchar(200) NOT NULL default ‘0’,
    `guest` tinyint(4) default ‘1’,
    `userid` int(11) default ‘0’,
    `usertype` varchar(50) default ”,
    `gid` tinyint(3) unsigned NOT NULL default ‘0’,
    `client_id` tinyint(3) unsigned NOT NULL default ‘0’,
    `data` longtext,
    PRIMARY KEY (`session_id`(64)),
    KEY `whosonline` (`guest`,`usertype`),
    KEY `userid` (`userid`),
    KEY `time` (`time`)
    ) ENGINE=MyISAM DEFAULT CHARSET=utf8;

    3 – Click on “Execute” or “Go” to execute the command.

    Thats it. This must fix your concern…

    Please let me know your feedback and also if you have any other easy workaround

    Page 4 of 4

    Powered by WordPress & Theme by Anders Norén