mirror of
https://github.com/processone/ejabberd.git
synced 2024-11-24 16:23:40 +01:00
5209 lines
208 KiB
TeX
5209 lines
208 KiB
TeX
\documentclass[a4paper,10pt]{book}
|
|
|
|
%% Packages
|
|
\usepackage{float}
|
|
\usepackage{graphics}
|
|
\usepackage{hevea}
|
|
\usepackage[pdftex,colorlinks,unicode,urlcolor=blue,linkcolor=blue,
|
|
pdftitle=Ejabberd\ Installation\ and\ Operation\ Guide,pdfauthor=ProcessOne,pdfsubject=ejabberd,pdfkeywords=ejabberd,
|
|
pdfpagelabels=false]{hyperref}
|
|
\usepackage{makeidx}
|
|
%\usepackage{showidx} % Only for verifying the index entries.
|
|
\usepackage{verbatim}
|
|
\usepackage{geometry}
|
|
\usepackage{fancyhdr}
|
|
|
|
\pagestyle{fancy} %Forces the page to use the fancy template
|
|
\renewcommand{\chaptermark}[1]{\markboth{\textbf{\thechapter}.\ \emph{#1}}{}}
|
|
\renewcommand{\sectionmark}[1]{\markright{\thesection\ \boldmath\textbf{#1}\unboldmath}}
|
|
\fancyhf{}
|
|
\fancyhead[LE,RO]{\textbf{\thepage}} %Displays the page number in bold in the header,
|
|
% to the left on even pages and to the right on odd pages.
|
|
\fancyhead[RE]{\nouppercase{\leftmark}} %Displays the upper-level (chapter) information---
|
|
% as determined above---in non-upper case in the header, to the right on even pages.
|
|
\fancyhead[LO]{\rightmark} %Displays the lower-level (section) information---as
|
|
% determined above---in the header, to the left on odd pages.
|
|
\renewcommand{\headrulewidth}{0.5pt} %Underlines the header. (Set to 0pt if not required).
|
|
\renewcommand{\footrulewidth}{0.5pt} %Underlines the footer. (Set to 0pt if not required).
|
|
|
|
%% Index
|
|
\makeindex
|
|
% Remove the index anchors from the HTML version to save size and bandwith.
|
|
\newcommand{\ind}[1]{\begin{latexonly}\index{#1}\end{latexonly}}
|
|
\newcommand{\makechapter}[2]{ \aname{#1}{} \chapter{\ahrefloc{#1}{#2}} \label{#1} }
|
|
\newcommand{\makesection}[2]{ \aname{#1}{} \section{\ahrefloc{#1}{#2}} \label{#1} }
|
|
\newcommand{\makesubsection}[2]{ \aname{#1}{} \subsection{\ahrefloc{#1}{#2}} \label{#1} }
|
|
\newcommand{\makesubsubsection}[2]{ \aname{#1}{} \subsubsection{\ahrefloc{#1}{#2}} \label{#1} }
|
|
\newcommand{\makeparagraph}[2]{ \aname{#1}{} \paragraph{\ahrefloc{#1}{#2}} \label{#1} }
|
|
|
|
%% Images
|
|
\newcommand{\logoscale}{0.7}
|
|
\newcommand{\imgscale}{0.58}
|
|
\newcommand{\insimg}[1]{\insscaleimg{\imgscale}{#1}}
|
|
\newcommand{\insscaleimg}[2]{
|
|
\imgsrc{#2}{}
|
|
\begin{latexonly}
|
|
\scalebox{#1}{\includegraphics{#2}}
|
|
\end{latexonly}
|
|
}
|
|
|
|
%% Various
|
|
\newcommand{\bracehack}{\def\{{\char"7B}\def\}{\char"7D}}
|
|
\newcommand{\titem}[1]{\item[\bracehack\texttt{#1}]}
|
|
\newcommand{\ns}[1]{\texttt{#1}}
|
|
\newcommand{\jid}[1]{\texttt{#1}}
|
|
\newcommand{\option}[1]{\texttt{#1}}
|
|
\newcommand{\poption}[1]{{\bracehack\texttt{#1}}}
|
|
\newcommand{\node}[1]{\texttt{#1}}
|
|
\newcommand{\term}[1]{\texttt{#1}}
|
|
\newcommand{\shell}[1]{\texttt{#1}}
|
|
\newcommand{\ejabberd}{\texttt{ejabberd}}
|
|
\newcommand{\Jabber}{Jabber}
|
|
\newcommand{\esyntax}[1]{\begin{description}\titem{#1}\end{description}}
|
|
|
|
%% Modules
|
|
\newcommand{\module}[1]{\texttt{#1}}
|
|
\newcommand{\modadhoc}{\module{mod\_adhoc}}
|
|
\newcommand{\modannounce}{\module{mod\_announce}}
|
|
\newcommand{\modcaps}{\module{mod\_caps}}
|
|
\newcommand{\modconfigure}{\module{mod\_configure}}
|
|
\newcommand{\moddisco}{\module{mod\_disco}}
|
|
\newcommand{\modecho}{\module{mod\_echo}}
|
|
\newcommand{\modhttpbind}{\module{mod\_http\_bind}}
|
|
\newcommand{\modhttpfileserver}{\module{mod\_http\_fileserver}}
|
|
\newcommand{\modirc}{\module{mod\_irc}}
|
|
\newcommand{\modlast}{\module{mod\_last}}
|
|
\newcommand{\modlastodbc}{\module{mod\_last\_odbc}}
|
|
\newcommand{\modmuc}{\module{mod\_muc}}
|
|
\newcommand{\modmuclog}{\module{mod\_muc\_log}}
|
|
\newcommand{\modoffline}{\module{mod\_offline}}
|
|
\newcommand{\modofflineodbc}{\module{mod\_offline\_odbc}}
|
|
\newcommand{\modping}{\module{mod\_ping}}
|
|
\newcommand{\modprivacy}{\module{mod\_privacy}}
|
|
\newcommand{\modprivacyodbc}{\module{mod\_privacy\_odbc}}
|
|
\newcommand{\modprivate}{\module{mod\_private}}
|
|
\newcommand{\modprivateodbc}{\module{mod\_private\_odbc}}
|
|
\newcommand{\modproxy}{\module{mod\_proxy65}}
|
|
\newcommand{\modpubsub}{\module{mod\_pubsub}}
|
|
\newcommand{\modpubsubodbc}{\module{mod\_pubsub\_odbc}}
|
|
\newcommand{\modregister}{\module{mod\_register}}
|
|
\newcommand{\modroster}{\module{mod\_roster}}
|
|
\newcommand{\modrosterodbc}{\module{mod\_roster\_odbc}}
|
|
\newcommand{\modservicelog}{\module{mod\_service\_log}}
|
|
\newcommand{\modsharedroster}{\module{mod\_shared\_roster}}
|
|
\newcommand{\modstats}{\module{mod\_stats}}
|
|
\newcommand{\modtime}{\module{mod\_time}}
|
|
\newcommand{\modvcard}{\module{mod\_vcard}}
|
|
\newcommand{\modvcardldap}{\module{mod\_vcard\_ldap}}
|
|
\newcommand{\modvcardodbc}{\module{mod\_vcard\_odbc}}
|
|
\newcommand{\modversion}{\module{mod\_version}}
|
|
|
|
%% Contributed modules
|
|
%\usepackage{ifthen}
|
|
%\newboolean{modhttpbind}
|
|
%\newcommand{\modhttpbind}{\module{mod\_http\_bind}}
|
|
%\include{contributed_modules}
|
|
%
|
|
% Then in the document you can input the partial tex file with:
|
|
%\ifthenelse{\boolean{modhttpbind}}{\input{mod_http_bind.tex}}{}
|
|
|
|
%% Common options
|
|
\newcommand{\iqdiscitem}[1]{\titem{\{iqdisc, Discipline\}} \ind{options!iqdisc}This specifies
|
|
the processing discipline for #1 IQ queries (see section~\ref{modiqdiscoption}).}
|
|
\newcommand{\hostitem}[1]{
|
|
\titem{\{host, HostName\}} \ind{options!host} This option defines the Jabber ID of the
|
|
service. If the \texttt{host} option is not specified, the Jabber ID will be the
|
|
hostname of the virtual host with the prefix `\jid{#1.}'. The keyword "@HOST@"
|
|
is replaced at start time with the real virtual host name.
|
|
}
|
|
|
|
%% Title page
|
|
\include{version}
|
|
\newlength{\larg}
|
|
\setlength{\larg}{14.5cm}
|
|
\title{
|
|
{\rule{\larg}{1mm}}\vspace{7mm}
|
|
\begin{tabular}{r}
|
|
{\huge {\bf ejabberd \version\ }} \\
|
|
\\
|
|
{\huge Installation and Operation Guide}
|
|
\end{tabular}\\
|
|
\vspace{2mm}
|
|
{\rule{\larg}{1mm}}
|
|
\begin{latexonly}
|
|
\vspace{2mm} \\
|
|
\vspace{5.5cm}
|
|
\end{latexonly}
|
|
}
|
|
\begin{latexonly}
|
|
\author{\begin{tabular}{p{13.7cm}}
|
|
ejabberd Development Team
|
|
\end{tabular}}
|
|
\date{}
|
|
\end{latexonly}
|
|
|
|
|
|
%% Options
|
|
\newcommand{\marking}[1]{#1} % Marking disabled
|
|
\newcommand{\quoting}[2][yozhik]{} % Quotes disabled
|
|
%\newcommand{\new}{\marginpar{\textsc{new}}} % Highlight new features
|
|
%\newcommand{\improved}{\marginpar{\textsc{improved}}} % Highlight improved features
|
|
|
|
%% To by-pass errors in the HTML version:
|
|
\newstyle{.SPAN}{width:20\%; float:right; text-align:left; margin-left:auto;}
|
|
\newstyle{H1.titlemain HR}{display:none;}
|
|
\newstyle{TABLE.title}{border-top:1px solid grey;border-bottom:1px solid grey; background: \#efefef}
|
|
\newstyle{H1.chapter A, H2.section A, H3.subsection A, H4.subsubsection A, H5.paragraph A}
|
|
{color:\#000000; text-decoration:none;}
|
|
\newstyle{H1.chapter, H2.section, H3.subsection, H4.subsubsection, H5.paragraph}
|
|
{border-top: 1px solid grey; background: \#efefef; padding: 0.5ex}
|
|
\newstyle{pre.verbatim}{margin:1ex 2ex;border:1px dashed lightgrey;background-color:\#f9f9f9;padding:0.5ex;}
|
|
\newstyle{.dt-description}{margin:0ex 2ex;}
|
|
\newstyle{table[border="1"]}{border-collapse:collapse;margin-bottom:1em;}
|
|
\newstyle{table[border="1"] td}{border:1px solid \#aaa;padding:2px}
|
|
% Don't display <hr> before and after tables or images:
|
|
\newstyle{BLOCKQUOTE.table DIV.center DIV.center HR}{display:none;}
|
|
\newstyle{BLOCKQUOTE.figure DIV.center DIV.center HR}{display:none;}
|
|
|
|
%% Footnotes
|
|
\begin{latexonly}
|
|
\global\parskip=9pt plus 3pt minus 1pt
|
|
\global\parindent=0pt
|
|
\gdef\ahrefurl#1{\href{#1}{\texttt{#1}}}
|
|
\gdef\footahref#1#2{#2\footnote{\href{#1}{\texttt{#1}}}}
|
|
\end{latexonly}
|
|
\newcommand{\txepref}[2]{\footahref{http://xmpp.org/extensions/xep-#1.html}{#2}}
|
|
\newcommand{\xepref}[1]{\txepref{#1}{XEP-#1}}
|
|
|
|
\begin{document}
|
|
|
|
\label{titlepage}
|
|
\begin{titlepage}
|
|
\maketitle{}
|
|
|
|
%% Commenting. Breaking clean layout for now:
|
|
%% \begin{center}
|
|
%% {\insscaleimg{\logoscale}{logo.png}
|
|
%% \par
|
|
%% }
|
|
%% \end{center}
|
|
|
|
%% \begin{quotation}\textit{I can thoroughly recommend ejabberd for ease of setup ---
|
|
%% Kevin Smith, Current maintainer of the Psi project}\end{quotation}
|
|
|
|
\end{titlepage}
|
|
|
|
% Set the page counter to 2 so that the titlepage and the second page do not
|
|
% have the same page number. This fixes the PDFLaTeX warning "destination with
|
|
% the same identifier".
|
|
\begin{latexonly}
|
|
\setcounter{page}{2}
|
|
\end{latexonly}
|
|
|
|
\label{toc}
|
|
\tableofcontents{}
|
|
|
|
% Input introduction.tex
|
|
\input{introduction}
|
|
|
|
\makechapter{installing}{Installing \ejabberd{}}
|
|
|
|
\makesection{install.binary}{Installing \ejabberd{} with Binary Installer}
|
|
|
|
Probably the easiest way to install an \ejabberd{} instant messaging server
|
|
is using the binary installer published by ProcessOne.
|
|
The binary installers of released \ejabberd{} versions
|
|
are available in the ProcessOne \ejabberd{} downloads page:
|
|
\ahrefurl{http://www.process-one.net/en/ejabberd/downloads}
|
|
|
|
The installer will deploy and configure a full featured \ejabberd{}
|
|
server and does not require any extra dependencies.
|
|
|
|
In *nix systems, remember to set executable the binary installer before starting it. For example:
|
|
\begin{verbatim}
|
|
chmod +x ejabberd-2.0.0_1-linux-x86-installer.bin
|
|
./ejabberd-2.0.0_1-linux-x86-installer.bin
|
|
\end{verbatim}
|
|
|
|
\ejabberd{} can be started manually at any time,
|
|
or automatically by the operating system at system boot time.
|
|
|
|
To start and stop \ejabberd{} manually,
|
|
use the desktop shortcuts created by the installer.
|
|
If the machine doesn't have a graphical system, use the scripts 'start'
|
|
and 'stop' in the 'bin' directory where \ejabberd{} is installed.
|
|
|
|
The Windows installer also adds ejabberd as a system service,
|
|
and a shortcut to a debug console for experienced administrators.
|
|
If you want ejabberd to be started automatically at boot time,
|
|
go to the Windows service settings and set ejabberd to be automatically started.
|
|
Note that the Windows service is a feature still in development,
|
|
and for example it doesn't read the file ejabberdctl.cfg.
|
|
|
|
On a *nix system, if you want ejabberd to be started as daemon at boot time,
|
|
copy \term{ejabberd.init} from the 'bin' directory to something like \term{/etc/init.d/ejabberd}
|
|
(depending on your distribution).
|
|
Create a system user called \term{ejabberd};
|
|
it will be used by the script to start the server.
|
|
Then you can call \term{/etc/inid.d/ejabberd start} as root to start the server.
|
|
|
|
If \term{ejabberd} doesn't start correctly in Windows,
|
|
try to start it using the shortcut in desktop or start menu.
|
|
If the window shows error 14001, the solution is to install:
|
|
"Microsoft Visual C++ 2005 SP1 Redistributable Package".
|
|
You can download it from
|
|
\footahref{http://www.microsoft.com/}{www.microsoft.com}.
|
|
Then uninstall \ejabberd{} and install it again.
|
|
|
|
If \term{ejabberd} doesn't start correctly and a crash dump is generated,
|
|
there was a severe problem.
|
|
You can try starting \term{ejabberd} with
|
|
the script \term{bin/live.bat} in Windows,
|
|
or with the command \term{bin/ejabberdctl live} in other Operating Systems.
|
|
This way you see the error message provided by Erlang
|
|
and can identify what is exactly the problem.
|
|
|
|
The \term{ejabberdctl} administration script is included in the \term{bin} directory.
|
|
Please refer to the section~\ref{ejabberdctl} for details about \term{ejabberdctl},
|
|
and configurable options to fine tune the Erlang runtime system.
|
|
|
|
\makesection{install.os}{Installing \ejabberd{} with Operating System Specific Packages}
|
|
|
|
Some Operating Systems provide a specific \ejabberd{} package adapted to
|
|
the system architecture and libraries.
|
|
It usually also checks dependencies
|
|
and performs basic configuration tasks like creating the initial
|
|
administrator account. Some examples are Debian and Gentoo. Consult the
|
|
resources provided by your Operating System for more information.
|
|
|
|
Usually those packages create a script like \term{/etc/init.d/ejabberd}
|
|
to start and stop \ejabberd{} as a service at boot time.
|
|
|
|
\makesection{install.cean}{Installing \ejabberd{} with CEAN}
|
|
|
|
\footahref{http://cean.process-one.net/}{CEAN}
|
|
(Comprehensive Erlang Archive Network) is a repository that hosts binary
|
|
packages from many Erlang programs, including \ejabberd{} and all its dependencies.
|
|
The binaries are available for many different system architectures, so this is an
|
|
alternative to the binary installer and Operating System's \ejabberd{} packages.
|
|
|
|
You will have to create your own \ejabberd{} start
|
|
script depending of how you handle your CEAN installation.
|
|
The default \term{ejabberdctl} script is located
|
|
into \ejabberd{}'s priv directory and can be used as an example.
|
|
|
|
\makesection{installation}{Installing \ejabberd{} from Source Code}
|
|
\ind{install}
|
|
|
|
The canonical form for distribution of \ejabberd{} stable releases is the source code package.
|
|
Compiling \ejabberd{} from source code is quite easy in *nix systems,
|
|
as long as your system have all the dependencies.
|
|
|
|
\makesubsection{installreq}{Requirements}
|
|
\ind{installation!requirements}
|
|
|
|
To compile \ejabberd{} on a `Unix-like' operating system, you need:
|
|
\begin{itemize}
|
|
\item GNU Make
|
|
\item GCC
|
|
\item Libexpat 1.95 or higher
|
|
\item Erlang/OTP R10B-9 or higher. The recommended version is R12B-5. Support for R13 is experimental.
|
|
\item OpenSSL 0.9.6 or higher, for STARTTLS, SASL and SSL encryption. Optional, highly recommended.
|
|
\item Zlib 1.2.3 or higher, for Stream Compression support (\xepref{0138}). Optional.
|
|
\item Erlang mysql library. Optional. For MySQL authentication or storage. See section \ref{compilemysql}.
|
|
\item Erlang pgsql library. Optional. For PostgreSQL authentication or storage. See section \ref{compilepgsql}.
|
|
\item PAM library. Optional. For Pluggable Authentication Modules (PAM). See section \ref{pam}.
|
|
\item GNU Iconv 1.8 or higher, for the IRC Transport (mod\_irc). Optional. Not needed on systems with GNU Libc. See section \ref{modirc}.
|
|
\item ImageMagick's Convert program. Optional. For CAPTCHA challenges. See section \ref{captcha}.
|
|
\item exmpp 0.9.1 or higher. Optional. For import/export user data with \xepref{0227} XML files.
|
|
\end{itemize}
|
|
|
|
\makesubsection{download}{Download Source Code}
|
|
\ind{install!download}
|
|
|
|
Released versions of \ejabberd{} are available in the ProcessOne \ejabberd{} downloads page:
|
|
\ahrefurl{http://www.process-one.net/en/ejabberd/downloads}
|
|
|
|
\ind{Subversion repository}
|
|
Alternatively, the latest development version can be retrieved from the Subversion repository using this command:
|
|
\begin{verbatim}
|
|
svn co http://svn.process-one.net/ejabberd/trunk ejabberd
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsection{compile}{Compile}
|
|
\ind{install!compile}
|
|
|
|
To compile \ejabberd{} execute the commands:
|
|
\begin{verbatim}
|
|
./configure
|
|
make
|
|
\end{verbatim}
|
|
|
|
The build configuration script allows several options.
|
|
To get the full list run the command:
|
|
\begin{verbatim}
|
|
./configure --help
|
|
\end{verbatim}
|
|
|
|
Some options that you may be interested in modifying:
|
|
\begin{description}
|
|
\titem{--prefix=/}
|
|
Specify the path prefix where the files will be copied when running
|
|
the \term{make install} command.
|
|
|
|
\titem{--enable-user[=USER]}
|
|
Allow this normal system user to execute the ejabberdctl script
|
|
(see section~\ref{ejabberdctl}),
|
|
read the configuration files,
|
|
read and write in the spool directory,
|
|
read and write in the log directory.
|
|
The account user and group must exist in the machine
|
|
before running \term{make install}.
|
|
This account doesn't need an explicit HOME directory, because
|
|
\term{/var/lib/ejabberd/} will be used by default.
|
|
|
|
\titem{--enable-pam}
|
|
Enable the PAM authentication method (see section \ref{pam}).
|
|
|
|
\titem{--enable-odbc or --enable-mssql}
|
|
Required if you want to use an external database.
|
|
See section~\ref{database} for more information.
|
|
|
|
\titem{--enable-full-xml}
|
|
Enable the use of XML based optimisations.
|
|
It will for example use CDATA to escape characters in the XMPP stream.
|
|
Use this option only if you are sure your Jabber clients include a fully compliant XML parser.
|
|
|
|
\titem{--disable-transient-supervisors}
|
|
Disable the use of Erlang/OTP supervision for transient processes.
|
|
\end{description}
|
|
|
|
|
|
\makesubsection{install}{Install}
|
|
\ind{install!install}
|
|
|
|
To install \ejabberd{} in the destination directories, run the command:
|
|
\begin{verbatim}
|
|
make install
|
|
\end{verbatim}
|
|
Note that you probably need administrative privileges in the system
|
|
to install \term{ejabberd}.
|
|
|
|
The files and directories created are, by default:
|
|
\begin{description}
|
|
\titem{/etc/ejabberd/} Configuration directory:
|
|
\begin{description}
|
|
\titem{ejabberd.cfg} ejabberd configuration file
|
|
\titem{ejabberdctl.cfg} Configuration file of the administration script
|
|
\titem{inetrc} Network DNS configuration file
|
|
\end{description}
|
|
\titem{/lib/ejabberd/}
|
|
\begin{description}
|
|
\titem{ebin/} Erlang binary files (*.beam)
|
|
\titem{include/} Erlang header files (*.hrl)
|
|
\titem{priv/} Additional files required at runtime
|
|
\begin{description}
|
|
\titem{bin/} Executable programs
|
|
\titem{lib/} Binary system libraries (*.so)
|
|
\titem{msgs/} Translation files (*.msgs)
|
|
\end{description}
|
|
\end{description}
|
|
\titem{/sbin/ejabberdctl} Administration script (see section~\ref{ejabberdctl})
|
|
\titem{/share/doc/ejabberd/} Documentation of ejabberd
|
|
\titem{/var/lib/ejabberd/} Spool directory:
|
|
\begin{description}
|
|
\titem{.erlang.cookie} Erlang cookie file (see section \ref{cookie})
|
|
\titem{acl.DCD, ...} Mnesia database spool files (*.DCD, *.DCL, *.DAT)
|
|
\end{description}
|
|
\titem{/var/log/ejabberd/} Log directory (see section~\ref{logfiles}):
|
|
\begin{description}
|
|
\titem{ejabberd.log} ejabberd service log
|
|
\titem{erlang.log} Erlang/OTP system log
|
|
\end{description}
|
|
\end{description}
|
|
|
|
|
|
\makesubsection{start}{Start}
|
|
\ind{install!start}
|
|
|
|
You can use the \term{ejabberdctl} command line administration script to start and stop \ejabberd{}.
|
|
If you provided the configure option \term{--enable-user=USER} (see \ref{compile}),
|
|
you can execute \term{ejabberdctl} with either that system account or root.
|
|
|
|
Usage example:
|
|
\begin{verbatim}
|
|
ejabberdctl start
|
|
|
|
ejabberdctl status
|
|
The node ejabberd@localhost is started with status: started
|
|
ejabberd is running in that node
|
|
|
|
ejabberdctl stop
|
|
\end{verbatim}
|
|
|
|
If \term{ejabberd} doesn't start correctly and a crash dump is generated,
|
|
there was a severe problem.
|
|
You can try starting \term{ejabberd} with
|
|
the command \term{ejabberdctl live}
|
|
to see the error message provided by Erlang
|
|
and can identify what is exactly the problem.
|
|
|
|
Please refer to the section~\ref{ejabberdctl} for details about \term{ejabberdctl},
|
|
and configurable options to fine tune the Erlang runtime system.
|
|
|
|
If you want ejabberd to be started as daemon at boot time,
|
|
copy \term{ejabberd.init} to something like \term{/etc/init.d/ejabberd}
|
|
(depending on your distribution).
|
|
Create a system user called \term{ejabberd};
|
|
it will be used by the script to start the server.
|
|
Then you can call \term{/etc/inid.d/ejabberd start} as root to start the server.
|
|
|
|
\makesubsection{bsd}{Specific Notes for BSD}
|
|
\ind{install!bsd}
|
|
|
|
The command to compile \ejabberd{} in BSD systems is:
|
|
\begin{verbatim}
|
|
gmake
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsection{solaris}{Specific Notes for Sun Solaris}
|
|
\ind{install!solaris}
|
|
|
|
You need to have \term{GNU install},
|
|
but it isn't included in Solaris.
|
|
It can be easily installed if your Solaris system
|
|
is set up for \footahref{http://www.blastwave.org/}{blastwave.org}
|
|
package repository.
|
|
Make sure \term{/opt/csw/bin} is in your \term{PATH} and run:
|
|
\begin{verbatim}
|
|
pkg-get -i fileutils
|
|
\end{verbatim}
|
|
|
|
If that program is called \term{ginstall},
|
|
modify the \ejabberd{} \term{Makefile} script to suit your system,
|
|
for example:
|
|
\begin{verbatim}
|
|
cat Makefile | sed s/install/ginstall/ > Makefile.gi
|
|
\end{verbatim}
|
|
And finally install \ejabberd{} with:
|
|
\begin{verbatim}
|
|
gmake -f Makefile.gi ginstall
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsection{windows}{Specific Notes for Microsoft Windows}
|
|
\ind{install!windows}
|
|
|
|
\makesubsubsection{windowsreq}{Requirements}
|
|
|
|
To compile \ejabberd{} on a Microsoft Windows system, you need:
|
|
\begin{itemize}
|
|
\item MS Visual C++ 6.0 Compiler
|
|
\item \footahref{http://www.erlang.org/download.html}{Erlang/OTP R11B-5}
|
|
\item \footahref{http://sourceforge.net/project/showfiles.php?group\_id=10127\&package\_id=11277}{Expat 2.0.0 or higher}
|
|
\item
|
|
\footahref{http://www.gnu.org/software/libiconv/}{GNU Iconv 1.9.2}
|
|
(optional)
|
|
\item \footahref{http://www.slproweb.com/products/Win32OpenSSL.html}{Shining Light OpenSSL 0.9.8d or higher}
|
|
(to enable SSL connections)
|
|
\item \footahref{http://www.zlib.net/}{Zlib 1.2.3 or higher}
|
|
\end{itemize}
|
|
|
|
|
|
\makesubsubsection{windowscom}{Compilation}
|
|
|
|
We assume that we will try to put as much library as possible into \verb|C:\sdk\| to make it easier to track what is install for \ejabberd{}.
|
|
|
|
\begin{enumerate}
|
|
\item Install Erlang emulator (for example, into \verb|C:\sdk\erl5.5.5|).
|
|
\item Install Expat library into \verb|C:\sdk\Expat-2.0.0|
|
|
directory.
|
|
|
|
Copy file \verb|C:\sdk\Expat-2.0.0\Libs\libexpat.dll|
|
|
to your Windows system directory (for example, \verb|C:\WINNT| or
|
|
\verb|C:\WINNT\System32|)
|
|
\item Build and install the Iconv library into the directory
|
|
\verb|C:\sdk\GnuWin32|.
|
|
|
|
Copy file \verb|C:\sdk\GnuWin32\bin\lib*.dll| to your
|
|
Windows system directory (more installation instructions can be found in the
|
|
file README.woe32 in the iconv distribution).
|
|
|
|
Note: instead of copying libexpat.dll and iconv.dll to the Windows
|
|
directory, you can add the directories
|
|
\verb|C:\sdk\Expat-2.0.0\Libs| and
|
|
\verb|C:\sdk\GnuWin32\bin| to the \verb|PATH| environment
|
|
variable.
|
|
\item Install OpenSSL in \verb|C:\sdk\OpenSSL| and add \verb|C:\sdk\OpenSSL\lib\VC| to your path or copy the binaries to your system directory.
|
|
\item Install ZLib in \verb|C:\sdk\gnuWin32|. Copy
|
|
\verb|C:\sdk\GnuWin32\bin\zlib1.dll| to your system directory. If you change your path it should already be set after libiconv install.
|
|
\item Make sure the you can access Erlang binaries from your path. For example: \verb|set PATH=%PATH%;"C:\sdk\erl5.6.5\bin"|
|
|
\item Depending on how you end up actually installing the library you might need to check and tweak the paths in the file configure.erl.
|
|
\item While in the directory \verb|ejabberd\src| run:
|
|
\begin{verbatim}
|
|
configure.bat
|
|
nmake -f Makefile.win32
|
|
\end{verbatim}
|
|
\item Edit the file \verb|ejabberd\src\ejabberd.cfg| and run
|
|
\begin{verbatim}
|
|
werl -s ejabberd -name ejabberd
|
|
\end{verbatim}
|
|
\end{enumerate}
|
|
|
|
%TODO: how to compile database support on windows?
|
|
|
|
|
|
\makesection{initialadmin}{Create a Jabber Account for Administration}
|
|
|
|
You need a Jabber account and grant him administrative privileges
|
|
to enter the \ejabberd{} Web Admin:
|
|
\begin{enumerate}
|
|
\item Register a Jabber account on your \ejabberd{} server, for example \term{admin1@example.org}.
|
|
There are two ways to register a Jabber account:
|
|
\begin{enumerate}
|
|
\item Using \term{ejabberdctl}\ind{ejabberdctl} (see section~\ref{ejabberdctl}):
|
|
\begin{verbatim}
|
|
ejabberdctl register admin1 example.org FgT5bk3
|
|
\end{verbatim}
|
|
\item Using a Jabber client and In-Band Registration (see section~\ref{modregister}).
|
|
\end{enumerate}
|
|
\item Edit the \ejabberd{} configuration file to give administration rights to the Jabber account you created:
|
|
\begin{verbatim}
|
|
{acl, admins, {user, "admin1", "example.org"}}.
|
|
{access, configure, [{allow, admins}]}.
|
|
\end{verbatim}
|
|
You can grant administrative privileges to many Jabber accounts,
|
|
and also to accounts in other Jabber servers.
|
|
\item Restart \ejabberd{} to load the new configuration.
|
|
\item Open the Web Admin (\verb|http://server:port/admin/|) in your
|
|
favourite browser. Make sure to enter the \emph{full} JID as username (in this
|
|
example: \jid{admin1@example.org}. The reason that you also need to enter the
|
|
suffix, is because \ejabberd{}'s virtual hosting support.
|
|
\end{enumerate}
|
|
|
|
\makesection{upgrade}{Upgrading \ejabberd{}}
|
|
|
|
To upgrade an ejabberd installation to a new version,
|
|
simply uninstall the old version, and then install the new one.
|
|
Of course, it is important that the configuration file
|
|
and Mnesia database spool directory are not removed.
|
|
|
|
\ejabberd{} automatically updates the Mnesia table definitions at startup when needed.
|
|
If you also use an external database for storage of some modules,
|
|
check if the release notes of the new ejabberd version
|
|
indicates you need to also update those tables.
|
|
|
|
|
|
\makechapter{configure}{Configuring \ejabberd{}}
|
|
\ind{configuration file}
|
|
|
|
\makesection{basicconfig}{Basic Configuration}
|
|
|
|
The configuration file will be loaded the first time you start \ejabberd{}. The
|
|
content from this file will be parsed and stored in the internal \ejabberd{} database. Subsequently the
|
|
configuration will be loaded from the database and any commands in the
|
|
configuration file are appended to the entries in the database.
|
|
|
|
Note that \ejabberd{} never edits the configuration file.
|
|
So, the configuration changes done using the Web Admin
|
|
are stored in the database, but are not reflected in the configuration file.
|
|
If you want those changes to be use after \ejabberd{} restart, you can either
|
|
edit the configuration file, or remove all its content.
|
|
|
|
The configuration file contains a sequence of Erlang terms. Lines beginning with a
|
|
\term{`\%'} sign are ignored. Each term is a tuple of which the first element is
|
|
the name of an option, and any further elements are that option's values. If the
|
|
configuration file do not contain for instance the `hosts' option, the old
|
|
host name(s) stored in the database will be used.
|
|
|
|
|
|
You can override the old values stored in the database by adding next lines to
|
|
the beginning of the configuration file:
|
|
\begin{verbatim}
|
|
override_global.
|
|
override_local.
|
|
override_acls.
|
|
\end{verbatim}
|
|
With these lines the old global options (shared between all \ejabberd{} nodes in a
|
|
cluster), local options (which are specific for this particular \ejabberd{} node)
|
|
and ACLs will be removed before new ones are added.
|
|
|
|
\makesubsection{hostnames}{Host Names}
|
|
\ind{options!hosts}\ind{host names}
|
|
|
|
The option \option{hosts} defines a list containing one or more domains that
|
|
\ejabberd{} will serve.
|
|
|
|
The syntax is:
|
|
\esyntax{\{hosts, [HostName, ...]\}.}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item Serving one domain:
|
|
\begin{verbatim}
|
|
{hosts, ["example.org"]}.
|
|
\end{verbatim}
|
|
\item Serving three domains:
|
|
\begin{verbatim}
|
|
{hosts, ["example.net", "example.com", "jabber.somesite.org"]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{virtualhost}{Virtual Hosting}
|
|
\ind{virtual hosting}\ind{virtual hosts}\ind{virtual domains}
|
|
|
|
Options can be defined separately for every virtual host using the
|
|
\term{host\_config} option.
|
|
|
|
The syntax is: \ind{options!host\_config}
|
|
\esyntax{\{host\_config, HostName, [Option, ...]\}}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item Domain \jid{example.net} is using the internal authentication method while
|
|
domain \jid{example.com} is using the \ind{LDAP}LDAP server running on the
|
|
domain \jid{localhost} to perform authentication:
|
|
\begin{verbatim}
|
|
{host_config, "example.net", [{auth_method, internal}]}.
|
|
|
|
{host_config, "example.com", [{auth_method, ldap},
|
|
{ldap_servers, ["localhost"]},
|
|
{ldap_uids, [{"uid"}]},
|
|
{ldap_rootdn, "dc=localdomain"},
|
|
{ldap_rootdn, "dc=example,dc=com"},
|
|
{ldap_password, ""}]}.
|
|
\end{verbatim}
|
|
\item Domain \jid{example.net} is using \ind{ODBC}ODBC to perform authentication
|
|
while domain \jid{example.com} is using the LDAP servers running on the domains
|
|
\jid{localhost} and \jid{otherhost}:
|
|
\begin{verbatim}
|
|
{host_config, "example.net", [{auth_method, odbc},
|
|
{odbc_server, "DSN=ejabberd;UID=ejabberd;PWD=ejabberd"}]}.
|
|
|
|
{host_config, "example.com", [{auth_method, ldap},
|
|
{ldap_servers, ["localhost", "otherhost"]},
|
|
{ldap_uids, [{"uid"}]},
|
|
{ldap_rootdn, "dc=localdomain"},
|
|
{ldap_rootdn, "dc=example,dc=com"},
|
|
{ldap_password, ""}]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
To define specific ejabberd modules in a virtual host,
|
|
you can define the global \term{modules} option with the common modules,
|
|
and later add specific modules to certain virtual hosts.
|
|
To accomplish that, instead of defining each option in \term{host\_config} with the general syntax
|
|
\esyntax{\{OptionName, OptionValue\}}
|
|
use this syntax:
|
|
\esyntax{\{\{add, OptionName\}, OptionValue\}}
|
|
|
|
In this example three virtual hosts have some similar modules, but there are also
|
|
other different modules for some specific virtual hosts:
|
|
\begin{verbatim}
|
|
%% This ejabberd server has three vhosts:
|
|
{hosts, ["one.example.org", "two.example.org", "three.example.org"]}.
|
|
|
|
%% Configuration of modules that are common to all vhosts
|
|
{modules,
|
|
[
|
|
{mod_roster, []},
|
|
{mod_configure, []},
|
|
{mod_disco, []},
|
|
{mod_private, []},
|
|
{mod_time, []},
|
|
{mod_last, []},
|
|
{mod_version, []}
|
|
]}.
|
|
|
|
%% Add some modules to vhost one:
|
|
{host_config, "one.example.org",
|
|
[{{add, modules}, [
|
|
{mod_echo, [{host, "echo-service.one.example.org"}]}
|
|
{mod_http_bind, []},
|
|
{mod_logxml, []}
|
|
]
|
|
}
|
|
]}.
|
|
|
|
%% Add a module just to vhost two:
|
|
{host_config, "two.example.org",
|
|
[{{add, modules}, [
|
|
{mod_echo, [{host, "mirror.two.example.org"}]}
|
|
]
|
|
}
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{listened}{Listening Ports}
|
|
\ind{options!listen}
|
|
|
|
The option \option{listen} defines for which ports, addresses and network protocols \ejabberd{}
|
|
will listen and what services will be run on them. Each element of the list is a
|
|
tuple with the following elements:
|
|
\begin{itemize}
|
|
\item Port number. Optionally also the IP address and/or a transport protocol.
|
|
\item Listening module that serves this port.
|
|
\item Options for the TCP socket and for the listening module.
|
|
\end{itemize}
|
|
|
|
The option syntax is:
|
|
\esyntax{\{listen, [Listener, ...]\}.}
|
|
|
|
To define a listener there are several syntax.
|
|
\esyntax{\{PortNumber, Module, [Option, ...]\}}
|
|
\esyntax{\{\{PortNumber, IPaddress\}, Module, [Option, ...]\}}
|
|
\esyntax{\{\{PortNumber, TransportProtocol\}, Module, [Option, ...]\}}
|
|
\esyntax{\{\{PortNumber, IPaddress, TransportProtocol\}, Module, [Option, ...]\}}
|
|
|
|
|
|
\makesubsubsection{listened-port}{Port Number, IP Address and Transport Protocol}
|
|
|
|
The port number defines which port to listen for incoming connections.
|
|
It can be a Jabber/XMPP standard port
|
|
(see section \ref{firewall}) or any other valid port number.
|
|
|
|
The IP address can be represented with a string
|
|
or an Erlang tuple with decimal or hexadecimal numbers.
|
|
The socket will listen only in that network interface.
|
|
It is possible to specify a generic address,
|
|
so \ejabberd{} will listen in all addresses.
|
|
Depending in the type of the IP address, IPv4 or IPv6 will be used.
|
|
When not specified the IP address, it will listen on all IPv4 network addresses.
|
|
|
|
Some example values for IP address:
|
|
\begin{itemize}
|
|
\item \verb|"0.0.0.0"| to listen in all IPv4 network interfaces. This is the default value when no IP is specified.
|
|
\item \verb|"::"| to listen in all IPv6 network interfaces
|
|
\item \verb|"10.11.12.13"| is the IPv4 address \verb|10.11.12.13|
|
|
\item \verb|"::FFFF:127.0.0.1"| is the IPv6 address \verb|::FFFF:127.0.0.1/128|
|
|
\item \verb|{10, 11, 12, 13}| is the IPv4 address \verb|10.11.12.13|
|
|
\item \verb|{0, 0, 0, 0, 0, 65535, 32512, 1}| is the IPv6 address \verb|::FFFF:127.0.0.1/128|
|
|
\item \verb|{16#fdca, 16#8ab6, 16#a243, 16#75ef, 0, 0, 0, 1}| is the IPv6 address \verb|FDCA:8AB6:A243:75EF::1/128|
|
|
\end{itemize}
|
|
|
|
The transport protocol can be \term{tcp} or \term{udp}.
|
|
Default is \term{tcp}.
|
|
|
|
|
|
\makesubsubsection{listened-module}{Listening Module}
|
|
|
|
\ind{modules!ejabberd\_c2s}\ind{modules!ejabberd\_s2s\_in}\ind{modules!ejabberd\_service}\ind{modules!ejabberd\_http}\ind{protocols!XEP-0114: Jabber Component Protocol}
|
|
The available modules, their purpose and the options allowed by each one are:
|
|
\begin{description}
|
|
\titem{\texttt{ejabberd\_c2s}}
|
|
Handles c2s connections.\\
|
|
Options: \texttt{access}, \texttt{certfile},
|
|
\texttt{max\_stanza\_size}, \texttt{shaper},
|
|
\texttt{starttls}, \texttt{starttls\_required}, \texttt{tls},
|
|
\texttt{zlib}
|
|
\titem{\texttt{ejabberd\_s2s\_in}}
|
|
Handles incoming s2s connections.\\
|
|
Options: \texttt{max\_stanza\_size}
|
|
\titem{\texttt{ejabberd\_service}}
|
|
Interacts with an \footahref{http://www.ejabberd.im/tutorials-transports}{external component}
|
|
(as defined in the Jabber Component Protocol (\xepref{0114}).\\
|
|
Options: \texttt{access}, \texttt{hosts},
|
|
\texttt{shaper}, \texttt{service\_check\_from}
|
|
\titem{\texttt{ejabberd\_stun}}
|
|
Handles STUN Binding requests as defined in
|
|
\footahref{http://tools.ietf.org/html/rfc5389}{RFC 5389}.\\
|
|
Options: \texttt{certfile}
|
|
\titem{\texttt{ejabberd\_http}}
|
|
Handles incoming HTTP connections.\\
|
|
Options: \texttt{captcha}, \texttt{certfile}, \texttt{http\_bind}, \texttt{http\_poll},
|
|
\texttt{request\_handlers}, \texttt{tls}, \texttt{web\_admin}\\
|
|
\end{description}
|
|
|
|
|
|
\makesubsubsection{listened-options}{Options}
|
|
|
|
This is a detailed description of each option allowed by the listening modules:
|
|
\begin{description}
|
|
\titem{\{access, AccessName\}} \ind{options!access}This option defines
|
|
access to the port. The default value is \term{all}.
|
|
\titem{\{certfile, Path\}} Full path to a file containing the default SSL certificate.
|
|
To define a certificate file specific for a given domain, use the global option \term{domain\_certfile}.
|
|
\titem{\{service\_check\_from, true|false\}} \ind{options!service\_check\_from}
|
|
This option can be used with \term{ejabberd\_service} only. It is
|
|
used to disable control on the from field on packets send by an
|
|
external components. The option can be either \term{true} or
|
|
\term{false}. The default value is \term{true} which conforms to \xepref{0114}.
|
|
\titem{\{hosts, [Hostname, ...], [HostOption, ...]\}} \ind{options!hosts}
|
|
The external Jabber component that connects to this \term{ejabberd\_service}
|
|
can serve one or more hostnames.
|
|
As \term{HostOption} you can define options for the component;
|
|
currently the only allowed option is the password required to the component
|
|
when attempt to connect to ejabberd: \poption{\{password, Secret\}}.
|
|
Note that you cannot define in a single \term{ejabberd\_service} components of
|
|
different services: add an \term{ejabberd\_service} for each service,
|
|
as seen in an example below.
|
|
\titem{captcha} \ind{options!http-captcha}
|
|
Simple web page that allows a user to fill a CAPTCHA challenge (see section \ref{captcha}).
|
|
\titem{http\_bind} \ind{options!http\_bind}\ind{protocols!XEP-0206: HTTP Binding}\ind{JWChat}\ind{web-based Jabber client}
|
|
This option enables HTTP Binding (\xepref{0124} and \xepref{0206}) support. HTTP Bind
|
|
enables access via HTTP requests to \ejabberd{} from behind firewalls which
|
|
do not allow outgoing sockets on port 5222.
|
|
|
|
Remember that you must also install and enable the module mod\_http\_bind.
|
|
|
|
If HTTP Bind is enabled, it will be available at
|
|
\verb|http://server:port/http-bind/|. Be aware that support for HTTP Bind
|
|
is also needed in the \Jabber{} client. Remark also that HTTP Bind can be
|
|
interesting to host a web-based \Jabber{} client such as
|
|
\footahref{http://jwchat.sourceforge.net/}{JWChat}
|
|
(check the tutorials to install JWChat with ejabberd and an
|
|
\footahref{http://www.ejabberd.im/jwchat-localserver}{embedded local web server}
|
|
or \footahref{http://www.ejabberd.im/jwchat-apache}{Apache}).
|
|
\titem{http\_poll} \ind{options!http\_poll}\ind{protocols!XEP-0025: HTTP Polling}\ind{JWChat}\ind{web-based Jabber client}
|
|
This option enables HTTP Polling (\xepref{0025}) support. HTTP Polling
|
|
enables access via HTTP requests to \ejabberd{} from behind firewalls which
|
|
do not allow outgoing sockets on port 5222.
|
|
|
|
If HTTP Polling is enabled, it will be available at
|
|
\verb|http://server:port/http-poll/|. Be aware that support for HTTP Polling
|
|
is also needed in the \Jabber{} client. Remark also that HTTP Polling can be
|
|
interesting to host a web-based \Jabber{} client such as
|
|
\footahref{http://jwchat.sourceforge.net/}{JWChat}.
|
|
|
|
The maximum period of time to keep a client session active without
|
|
an incoming POST request can be configured with the global option
|
|
\term{http\_poll\_timeout}. The default value is five minutes.
|
|
The option can be defined in \term{ejabberd.cfg}, expressing the time
|
|
in seconds: \verb|{http_poll_timeout, 300}.|
|
|
|
|
\titem{\{max\_stanza\_size, Size\}}
|
|
\ind{options!max\_stanza\_size}This option specifies an
|
|
approximate maximum size in bytes of XML stanzas. Approximate,
|
|
because it is calculated with the precision of one block of readed
|
|
data. For example \verb|{max_stanza_size, 65536}|. The default
|
|
value is \term{infinity}. Recommended values are 65536 for c2s
|
|
connections and 131072 for s2s connections. s2s max stanza size
|
|
must always much higher than c2s limit. Change this value with
|
|
extreme care as it can cause unwanted disconnect if set too low.
|
|
\titem{\{request\_handlers, [ \{Path, Module\}, ...]\}} To define one or several handlers that will serve HTTP requests.
|
|
The Path is a list of strings; so the URIs that start with that Path will be served by Module.
|
|
For example, if you want \term{mod\_foo} to serve the URIs that start with \term{/a/b/},
|
|
and you also want \term{mod\_http\_bind} to serve the URIs \term{/http-bind/},
|
|
use this option: \term{\{request\_handlers, [\{["a", "b"], mod\_foo\}, \{["http-bind"], mod\_http\_bind\}]\}}
|
|
\titem{\{service\_check\_from, true|false\}}
|
|
By enabling this option, \ejabberd{} allows the component to send packets with any arbitrary domain in the 'from' attribute.
|
|
Note that \xepref{0114} requires that the domain must match the hostname of the component.
|
|
Only enable this option if you are completely sure you need to enable it.
|
|
Default value: false.
|
|
\titem{\{shaper, none|ShaperName\}} \ind{options!shaper}This option defines a
|
|
shaper for the port (see section~\ref{shapers}). The default value
|
|
is \term{none}.
|
|
\titem{starttls} \ind{options!starttls}\ind{STARTTLS}This option
|
|
specifies that STARTTLS encryption is available on connections to the port.
|
|
You should also set the \option{certfile} option.
|
|
You can define a certificate file for a specific domain using the global option \option{domain\_certfile}.
|
|
\titem{starttls\_required} \ind{options!starttls\_required}This option
|
|
specifies that STARTTLS encryption is required on connections to the port.
|
|
No unencrypted connections will be allowed.
|
|
You should also set the \option{certfile} option.
|
|
You can define a certificate file for a specific domain using the global option \option{domain\_certfile}.
|
|
\titem{tls} \ind{options!tls}\ind{TLS}This option specifies that traffic on
|
|
the port will be encrypted using SSL immediately after connecting.
|
|
This was the traditional encryption method in the early Jabber software,
|
|
commonly on port 5223 for client-to-server communications.
|
|
But this method is nowadays deprecated and not recommended.
|
|
The preferable encryption method is STARTTLS on port 5222, as defined
|
|
\footahref{http://xmpp.org/specs/rfc3920.html\#tls}{RFC 3920: XMPP Core},
|
|
which can be enabled in \ejabberd{} with the option \term{starttls}.
|
|
If this option is set, you should also set the \option{certfile} option.
|
|
\titem{web\_admin} \ind{options!web\_admin}\ind{web admin}This option
|
|
enables the Web Admin for \ejabberd{} administration which is available
|
|
at \verb|http://server:port/admin/|. Login and password are the username and
|
|
password of one of the registered users who are granted access by the
|
|
`configure' access rule.
|
|
\titem{zlib} \ind{options!zlib}\ind{protocols!XEP-0138: Stream Compression}\ind{Zlib}This
|
|
option specifies that Zlib stream compression (as defined in \xepref{0138})
|
|
is available on connections to the port.
|
|
\end{description}
|
|
|
|
There are some additional global options that can be specified in the ejabberd configuration file (outside \term{listen}):
|
|
\begin{description}
|
|
\titem{\{s2s\_use\_starttls, true|false\}}
|
|
\ind{options!s2s\_use\_starttls}\ind{STARTTLS}This option defines whether to
|
|
use STARTTLS for s2s connections.
|
|
\titem{\{s2s\_certfile, Path\}} \ind{options!s2s\_certificate}Full path to a
|
|
file containing a SSL certificate.
|
|
\titem{\{domain\_certfile, Domain, Path\}} \ind{options!domain\_certfile}
|
|
Full path to the file containing the SSL certificate for a specific domain.
|
|
\titem{\{outgoing\_s2s\_options, Methods, Timeout\}} \ind{options!outgoing\_s2s\_options}
|
|
Specify which address families to try, in what order, and connect timeout in milliseconds.
|
|
By default it first tries connecting with IPv4, if that fails it tries using IPv6,
|
|
with a timeout of 10000 milliseconds.
|
|
\titem{\{s2s\_dns\_options, [ \{Property, Value\}, ...]\}}
|
|
\ind{options!s2s\_dns\_options}Define properties to use for DNS resolving.
|
|
Allowed Properties are: \term{timeout} in seconds which default value is \term{10}
|
|
and \term{retries} which default value is \term{2}.
|
|
\titem{\{s2s\_default\_policy, allow|deny\}}
|
|
The default policy for incoming and outgoing s2s connections to other Jabber servers.
|
|
The default value is \term{allow}.
|
|
\titem{\{\{s2s\_host, Host\}, allow|deny\}}
|
|
Defines if incoming and outgoing s2s connections with a specific remote host are allowed or denied.
|
|
This allows to restrict ejabberd to only establish s2s connections
|
|
with a small list of trusted servers, or to block some specific servers.
|
|
\titem{\{s2s\_max\_retry\_delay, Seconds\}} \ind{options!s2s\_max\_retry\_delay}
|
|
The maximum allowed delay for retry to connect after a failed connection attempt.
|
|
Specified in seconds. The default value is 300 seconds (5 minutes).
|
|
\end{description}
|
|
|
|
\makesubsubsection{listened-examples}{Examples}
|
|
|
|
For example, the following simple configuration defines:
|
|
\begin{itemize}
|
|
\item There are three domains. The default certificate file is \term{server.pem}.
|
|
However, the c2s and s2s connections to the domain \term{example.com} use the file \term{example\_com.pem}.
|
|
\item Port 5222 listens for c2s connections with STARTTLS,
|
|
and also allows plain connections for old clients.
|
|
\item Port 5223 listens for c2s connections with the old SSL.
|
|
\item Port 5269 listens for s2s connections with STARTTLS. The socket is set for IPv6 instead of IPv4.
|
|
\item Port 3478 listens for STUN requests over UDP.
|
|
\item Port 5280 listens for HTTP requests, and serves the HTTP Poll service.
|
|
\item Port 5281 listens for HTTP requests, and serves the Web Admin using HTTPS as explained in
|
|
section~\ref{webadmin}. The socket only listens connections to the IP address 127.0.0.1.
|
|
\end{itemize}
|
|
\begin{verbatim}
|
|
{hosts, ["example.com", "example.org", "example.net"]}.
|
|
{listen,
|
|
[
|
|
{5222, ejabberd_c2s, [
|
|
{access, c2s},
|
|
{shaper, c2s_shaper},
|
|
starttls, {certfile, "/etc/ejabberd/server.pem"},
|
|
{max_stanza_size, 65536}
|
|
]},
|
|
{5223, ejabberd_c2s, [
|
|
{access, c2s},
|
|
{shaper, c2s_shaper},
|
|
tls, {certfile, "/etc/ejabberd/server.pem"},
|
|
{max_stanza_size, 65536}
|
|
]},
|
|
{{5269, "::"}, ejabberd_s2s_in, [
|
|
{shaper, s2s_shaper},
|
|
{max_stanza_size, 131072}
|
|
]},
|
|
{{3478, udp}, ejabberd_stun, []},
|
|
{5280, ejabberd_http, [
|
|
http_poll
|
|
]},
|
|
{{5281, "127.0.0.1"}, ejabberd_http, [
|
|
web_admin,
|
|
tls, {certfile, "/etc/ejabberd/server.pem"},
|
|
]}
|
|
]
|
|
}.
|
|
{s2s_use_starttls, true}.
|
|
{s2s_certfile, "/etc/ejabberd/server.pem"}.
|
|
{domain_certfile, "example.com", "/etc/ejabberd/example_com.pem"}.
|
|
\end{verbatim}
|
|
|
|
In this example, the following configuration defines that:
|
|
\begin{itemize}
|
|
\item c2s connections are listened for on port 5222 (all IPv4 addresses) and
|
|
on port 5223 (SSL, IP 192.168.0.1 and fdca:8ab6:a243:75ef::1) and denied
|
|
for the user called `\term{bad}'.
|
|
\item s2s connections are listened for on port 5269 (all IPv4 addresses)
|
|
with STARTTLS for secured traffic enabled.
|
|
Incoming and outgoing connections of remote Jabber servers are denied,
|
|
only two servers can connect: "jabber.example.org" and "example.com".
|
|
\item Port 5280 is serving the Web Admin and the HTTP Polling service
|
|
in all the IPv4 addresses. Note
|
|
that it is also possible to serve them on different ports. The second
|
|
example in section~\ref{webadmin} shows how exactly this can be done.
|
|
\item All users except for the administrators have a traffic of limit
|
|
1,000\,Bytes/second
|
|
\item \ind{transports!AIM}The
|
|
\footahref{http://www.ejabberd.im/pyaimt}{AIM transport}
|
|
\jid{aim.example.org} is connected to port 5233 on localhost IP addresses
|
|
(127.0.0.1 and ::1) with password `\term{aimsecret}'.
|
|
\item \ind{transports!ICQ}The ICQ transport JIT (\jid{icq.example.org} and
|
|
\jid{sms.example.org}) is connected to port 5234 with password
|
|
`\term{jitsecret}'.
|
|
\item \ind{transports!MSN}The
|
|
\footahref{http://www.ejabberd.im/pymsnt}{MSN transport}
|
|
\jid{msn.example.org} is connected to port 5235 with password
|
|
`\term{msnsecret}'.
|
|
\item \ind{transports!Yahoo}The
|
|
\footahref{http://www.ejabberd.im/yahoo-transport-2}{Yahoo! transport}
|
|
\jid{yahoo.example.org} is connected to port 5236 with password
|
|
`\term{yahoosecret}'.
|
|
\item \ind{transports!Gadu-Gadu}The \footahref{http://www.ejabberd.im/jabber-gg-transport}{Gadu-Gadu transport} \jid{gg.example.org} is
|
|
connected to port 5237 with password `\term{ggsecret}'.
|
|
\item \ind{transports!email notifier}The
|
|
\footahref{http://www.ejabberd.im/jmc}{Jabber Mail Component}
|
|
\jid{jmc.example.org} is connected to port 5238 with password
|
|
`\term{jmcsecret}'.
|
|
\item The service custom has enabled the special option to avoiding checking the \term{from} attribute in the packets send by this component. The component can send packets in behalf of any users from the server, or even on behalf of any server.
|
|
\end{itemize}
|
|
\begin{verbatim}
|
|
{acl, blocked, {user, "bad"}}.
|
|
{access, c2s, [{deny, blocked},
|
|
{allow, all}]}.
|
|
{shaper, normal, {maxrate, 1000}}.
|
|
{access, c2s_shaper, [{none, admin},
|
|
{normal, all}]}.
|
|
{listen,
|
|
[{5222, ejabberd_c2s, [
|
|
{access, c2s},
|
|
{shaper, c2s_shaper}
|
|
]},
|
|
{{5223, {192, 168, 0, 1}}, ejabberd_c2s, [
|
|
{access, c2s},
|
|
ssl, {certfile, "/path/to/ssl.pem"}
|
|
]},
|
|
{{5223, {16#fdca, 16#8ab6, 16#a243, 16#75ef, 0, 0, 0, 1}},
|
|
ejabberd_c2s, [
|
|
{access, c2s},
|
|
ssl, {certfile, "/path/to/ssl.pem"}
|
|
]},
|
|
{5269, ejabberd_s2s_in, []},
|
|
{{5280, {0, 0, 0, 0}}, ejabberd_http, [
|
|
http_poll,
|
|
web_admin
|
|
]},
|
|
{{5233, {127, 0, 0, 1}}, ejabberd_service, [
|
|
{hosts, ["aim.example.org"],
|
|
[{password, "aimsecret"}]}
|
|
]},
|
|
{{5233, "::1"}, ejabberd_service, [
|
|
{hosts, ["aim.example.org"],
|
|
[{password, "aimsecret"}]}
|
|
]},
|
|
{5234, ejabberd_service, [{hosts, ["icq.example.org", "sms.example.org"],
|
|
[{password, "jitsecret"}]}]},
|
|
{5235, ejabberd_service, [{hosts, ["msn.example.org"],
|
|
[{password, "msnsecret"}]}]},
|
|
{5236, ejabberd_service, [{hosts, ["yahoo.example.org"],
|
|
[{password, "yahoosecret"}]}]},
|
|
{5237, ejabberd_service, [{hosts, ["gg.example.org"],
|
|
[{password, "ggsecret"}]}]},
|
|
{5238, ejabberd_service, [{hosts, ["jmc.example.org"],
|
|
[{password, "jmcsecret"}]}]},
|
|
{5239, ejabberd_service, [{hosts, ["custom.example.org"],
|
|
[{password, "customsecret"}]},
|
|
{service_check_from, false}]}
|
|
]
|
|
}.
|
|
{s2s_use_starttls, true}.
|
|
{s2s_certfile, "/path/to/ssl.pem"}.
|
|
{s2s_default_policy, deny}.
|
|
{{s2s_host,"jabber.example.org"}, allow}.
|
|
{{s2s_host,"example.com"}, allow}.
|
|
\end{verbatim}
|
|
Note, that for services based in \ind{jabberd14}jabberd14 or \ind{WPJabber}WPJabber
|
|
you have to make the transports log and do \ind{XDB}XDB by themselves:
|
|
\begin{verbatim}
|
|
<!--
|
|
You have to add elogger and rlogger entries here when using ejabberd.
|
|
In this case the transport will do the logging.
|
|
-->
|
|
|
|
<log id='logger'>
|
|
<host/>
|
|
<logtype/>
|
|
<format>%d: [%t] (%h): %s</format>
|
|
<file>/var/log/jabber/service.log</file>
|
|
</log>
|
|
|
|
<!--
|
|
Some Jabber server implementations do not provide
|
|
XDB services (for example, jabberd2 and ejabberd).
|
|
xdb_file.so is loaded in to handle all XDB requests.
|
|
-->
|
|
|
|
<xdb id="xdb">
|
|
<host/>
|
|
<load>
|
|
<!-- this is a lib of wpjabber or jabberd14 -->
|
|
<xdb_file>/usr/lib/jabber/xdb_file.so</xdb_file>
|
|
</load>
|
|
<xdb_file xmlns="jabber:config:xdb_file">
|
|
<spool><jabberd:cmdline flag='s'>/var/spool/jabber</jabberd:cmdline></spool>
|
|
</xdb_file>
|
|
</xdb>
|
|
\end{verbatim}
|
|
|
|
\makesubsection{auth}{Authentication}
|
|
\ind{authentication}\ind{options!auth\_method}
|
|
|
|
The option \option{auth\_method} defines the authentication methods that are used
|
|
for user authentication. The syntax is:
|
|
\esyntax{\{auth\_method, [Method, ...]\}.}
|
|
|
|
The following authentication methods are supported by \ejabberd{}:
|
|
\begin{itemize}
|
|
\item internal (default) --- See section~\ref{internalauth}.
|
|
\item external --- There are \footahref{http://www.ejabberd.im/extauth}{some
|
|
example authentication scripts}.
|
|
\item ldap --- See section~\ref{ldap}.
|
|
\item odbc --- See section~\ref{mysql}, \ref{pgsql},
|
|
\ref{mssql} and \ref{odbc}.
|
|
\item anonymous --- See section~\ref{saslanonymous}.
|
|
\item pam --- See section~\ref{pam}.
|
|
\end{itemize}
|
|
|
|
Account creation is only supported by internal and odbc methods.
|
|
|
|
\makesubsubsection{internalauth}{Internal}
|
|
\ind{internal authentication}\ind{Mnesia}
|
|
|
|
\ejabberd{} uses its internal Mnesia database as the default authentication method.
|
|
The value \term{internal} will enable the internal authentication method.
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item To use internal authentication on \jid{example.org} and LDAP
|
|
authentication on \jid{example.net}:
|
|
\begin{verbatim}
|
|
{host_config, "example.org", [{auth_method, [internal]}]}.
|
|
{host_config, "example.net", [{auth_method, [ldap]}]}.
|
|
\end{verbatim}
|
|
\item To use internal authentication on all virtual hosts:
|
|
\begin{verbatim}
|
|
{auth_method, internal}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsubsection{saslanonymous}{SASL Anonymous and Anonymous Login}
|
|
\ind{sasl anonymous}\ind{anonymous login}
|
|
|
|
The value \term{anonymous} will enable the internal authentication method.
|
|
|
|
%TODO: introduction; tell what people can do with this
|
|
The anonymous authentication method can be configured with the following
|
|
options. Remember that you can use the \term{host\_config} option to set virtual
|
|
host specific options (see section~\ref{virtualhost}). Note that there also
|
|
is a detailed tutorial regarding \footahref{http://support.process-one.net/doc/display/MESSENGER/Anonymous+users+support}{SASL
|
|
Anonymous and anonymous login configuration}.
|
|
|
|
\begin{description}
|
|
\titem{\{allow\_multiple\_connections, false|true\}} This option is only used
|
|
when the anonymous mode is
|
|
enabled. Setting it to \term{true} means that the same username can be taken
|
|
multiple times in anonymous login mode if different resource are used to
|
|
connect. This option is only useful in very special occasions. The default
|
|
value is \term{false}.
|
|
\titem{\{anonymous\_protocol, sasl\_anon | login\_anon | both\}}
|
|
\term{sasl\_anon} means
|
|
that the SASL Anonymous method will be used. \term{login\_anon} means that the
|
|
anonymous login method will be used. \term{both} means that SASL Anonymous and
|
|
login anonymous are both enabled.
|
|
\end{description}
|
|
|
|
Those options are defined for each virtual host with the \term{host\_config}
|
|
parameter (see section~\ref{virtualhost}).
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item To enable anonymous login on all virtual hosts:
|
|
\begin{verbatim}
|
|
{auth_method, [anonymous]}.
|
|
{anonymous_protocol, login_anon}.
|
|
\end{verbatim}
|
|
\item Similar as previous example, but limited to \jid{public.example.org}:
|
|
\begin{verbatim}
|
|
{host_config, "public.example.org", [{auth_method, [anonymous]},
|
|
{anonymous_protocol, login_anon}]}.
|
|
\end{verbatim}
|
|
\item To enable anonymous login and internal authentication on a virtual host:
|
|
\begin{verbatim}
|
|
{host_config, "public.example.org", [{auth_method, [internal,anonymous]},
|
|
{anonymous_protocol, login_anon}]}.
|
|
\end{verbatim}
|
|
\item To enable SASL Anonymous on a virtual host:
|
|
\begin{verbatim}
|
|
{host_config, "public.example.org", [{auth_method, [anonymous]},
|
|
{anonymous_protocol, sasl_anon}]}.
|
|
\end{verbatim}
|
|
\item To enable SASL Anonymous and anonymous login on a virtual host:
|
|
\begin{verbatim}
|
|
{host_config, "public.example.org", [{auth_method, [anonymous]},
|
|
{anonymous_protocol, both}]}.
|
|
\end{verbatim}
|
|
\item To enable SASL Anonymous, anonymous login, and internal authentication on
|
|
a virtual host:
|
|
\begin{verbatim}
|
|
{host_config, "public.example.org", [{auth_method, [internal,anonymous]},
|
|
{anonymous_protocol, both}]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsubsection{pam}{PAM Authentication}
|
|
\ind{PAM authentication}\ind{Pluggable Authentication Modules}
|
|
|
|
\ejabberd{} supports authentication via Pluggable Authentication Modules (PAM).
|
|
PAM is currently supported in AIX, FreeBSD, HP-UX, Linux, Mac OS X, NetBSD and Solaris.
|
|
PAM authentication is disabled by default, so you have to configure and compile
|
|
\ejabberd{} with PAM support enabled:
|
|
\begin{verbatim}
|
|
./configure --enable-pam && make install
|
|
\end{verbatim}
|
|
|
|
Options:
|
|
\begin{description}
|
|
\titem{\{pam\_service, Name\}}\ind{options!pam\_service}This option defines the PAM service name.
|
|
Default is \term{"ejabberd"}. Refer to the PAM documentation of your operation system
|
|
for more information.
|
|
\end{description}
|
|
|
|
Example:
|
|
\begin{verbatim}
|
|
{auth_method, [pam]}.
|
|
{pam_service, "ejabberd"}.
|
|
\end{verbatim}
|
|
|
|
Though it is quite easy to set up PAM support in \ejabberd{}, PAM itself introduces some
|
|
security issues:
|
|
|
|
\begin{itemize}
|
|
\item To perform PAM authentication \ejabberd{} uses external C-program called
|
|
\term{epam}. By default, it is located in \verb|/var/lib/ejabberd/priv/bin/|
|
|
directory. You have to set it root on execution in the case when your PAM module
|
|
requires root privileges (\term{pam\_unix.so} for example). Also you have to grant access
|
|
for \ejabberd{} to this file and remove all other permissions from it.
|
|
Execute with root privileges:
|
|
\begin{verbatim}
|
|
chown root:ejabberd /var/lib/ejabberd/priv/bin/epam
|
|
chmod 4750 /var/lib/ejabberd/priv/bin/epam
|
|
\end{verbatim}
|
|
\item Make sure you have the latest version of PAM installed on your system.
|
|
Some old versions of PAM modules cause memory leaks. If you are not able to use the latest
|
|
version, you can \term{kill(1)} \term{epam} process periodically to reduce its memory
|
|
consumption: \ejabberd{} will restart this process immediately.
|
|
\item \term{epam} program tries to turn off delays on authentication failures.
|
|
However, some PAM modules ignore this behavior and rely on their own configuration options.
|
|
You can create a configuration file \term{ejabberd.pam}.
|
|
This example shows how to turn off delays in \term{pam\_unix.so} module:
|
|
\begin{verbatim}
|
|
#%PAM-1.0
|
|
auth sufficient pam_unix.so likeauth nullok nodelay
|
|
account sufficient pam_unix.so
|
|
\end{verbatim}
|
|
That is not a ready to use configuration file: you must use it
|
|
as a hint when building your own PAM configuration instead. Note that if you want to disable
|
|
delays on authentication failures in the PAM configuration file, you have to restrict access
|
|
to this file, so a malicious user can't use your configuration to perform brute-force
|
|
attacks.
|
|
\item You may want to allow login access only for certain users. \term{pam\_listfile.so}
|
|
module provides such functionality.
|
|
\item If you use \term{pam\_winbind} to authorise against a Windows Active Directory,
|
|
then \term{/etc/nssswitch.conf} must be configured to use \term{winbind} as well.
|
|
\end{itemize}
|
|
|
|
\makesubsection{accessrules}{Access Rules}
|
|
\ind{access rules}\ind{ACL}\ind{Access Control List}
|
|
|
|
\makesubsubsection{ACLDefinition}{ACL Definition}
|
|
\ind{ACL}\ind{options!acl}\ind{ACL}\ind{Access Control List}
|
|
|
|
Access control in \ejabberd{} is performed via Access Control Lists (ACLs). The
|
|
declarations of ACLs in the configuration file have the following syntax:
|
|
\esyntax{\{acl, ACLName, ACLValue\}.}
|
|
|
|
\term{ACLValue} can be one of the following:
|
|
\begin{description}
|
|
\titem{all} Matches all JIDs. Example:
|
|
\begin{verbatim}
|
|
{acl, all, all}.
|
|
\end{verbatim}
|
|
\titem{\{user, Username\}} Matches the user with the name
|
|
\term{Username} at the first virtual host. Example:
|
|
\begin{verbatim}
|
|
{acl, admin, {user, "yozhik"}}.
|
|
\end{verbatim}
|
|
\titem{\{user, Username, Server\}} Matches the user with the JID
|
|
\term{Username@Server} and any resource. Example:
|
|
\begin{verbatim}
|
|
{acl, admin, {user, "yozhik", "example.org"}}.
|
|
\end{verbatim}
|
|
\titem{\{server, Server\}} Matches any JID from server
|
|
\term{Server}. Example:
|
|
\begin{verbatim}
|
|
{acl, exampleorg, {server, "example.org"}}.
|
|
\end{verbatim}
|
|
\titem{\{resource, Resource\}} Matches any JID with a resource
|
|
\term{Resource}. Example:
|
|
\begin{verbatim}
|
|
{acl, mucklres, {resource, "muckl"}}.
|
|
\end{verbatim}
|
|
\titem{\{shared\_group, Groupname\}} Matches any member of a Shared Roster Group with name \term{Groupname} in the virtual host. Example:
|
|
\begin{verbatim}
|
|
{acl, techgroupmembers, {shared_group, "techteam"}}.
|
|
\end{verbatim}
|
|
\titem{\{shared\_group, Groupname, Server\}} Matches any member of a Shared Roster Group with name \term{Groupname} in the virtual host \term{Server}. Example:
|
|
\begin{verbatim}
|
|
{acl, techgroupmembers, {shared_group, "techteam", "example.org"}}.
|
|
\end{verbatim}
|
|
\titem{\{user\_regexp, Regexp\}} Matches any local user with a name that
|
|
matches \term{Regexp} on local virtual hosts. Example:
|
|
\begin{verbatim}
|
|
{acl, tests, {user_regexp, "^test[0-9]*$"}}.
|
|
\end{verbatim}
|
|
%$
|
|
\titem{\{user\_regexp, UserRegexp, Server\}} Matches any user with a name
|
|
that matches \term{Regexp} at server \term{Server}. Example:
|
|
\begin{verbatim}
|
|
{acl, tests, {user_Userregexp, "^test", "example.org"}}.
|
|
\end{verbatim}
|
|
\titem{\{server\_regexp, Regexp\}} Matches any JID from the server that
|
|
matches \term{Regexp}. Example:
|
|
\begin{verbatim}
|
|
{acl, icq, {server_regexp, "^icq\\."}}.
|
|
\end{verbatim}
|
|
\titem{\{resource\_regexp, Regexp\}} Matches any JID with a resource that
|
|
matches \term{Regexp}. Example:
|
|
\begin{verbatim}
|
|
{acl, icq, {resource_regexp, "^laptop\\."}}.
|
|
\end{verbatim}
|
|
\titem{\{node\_regexp, UserRegexp, ServerRegexp\}} Matches any user
|
|
with a name that matches \term{UserRegexp} at any server that matches
|
|
\term{ServerRegexp}. Example:
|
|
\begin{verbatim}
|
|
{acl, yohzik, {node_regexp, "^yohzik$", "^example.(com|org)$"}}.
|
|
\end{verbatim}
|
|
\titem{\{user\_glob, Glob\}}
|
|
\titem{\{user\_glob, Glob, Server\}}
|
|
\titem{\{server\_glob, Glob\}}
|
|
\titem{\{resource\_glob, Glob\}}
|
|
\titem{\{node\_glob, UserGlob, ServerGlob\}} This is the same as
|
|
above. However, it uses shell glob patterns instead of regexp. These patterns
|
|
can have the following special characters:
|
|
\begin{description}
|
|
\titem{*} matches any string including the null string.
|
|
\titem{?} matches any single character.
|
|
\titem{[...]} matches any of the enclosed characters. Character
|
|
ranges are specified by a pair of characters separated by a \term{`-'}.
|
|
If the first character after \term{`['} is a \term{`!'}, any
|
|
character not enclosed is matched.
|
|
\end{description}
|
|
\end{description}
|
|
|
|
The following \term{ACLName} are pre-defined:
|
|
\begin{description}
|
|
\titem{all} Matches any JID.
|
|
\titem{none} Matches no JID.
|
|
\end{description}
|
|
|
|
\makesubsubsection{AccessRights}{Access Rights}
|
|
\ind{access}\ind{ACL}\ind{options!acl}\ind{ACL}\ind{Access Control List}
|
|
|
|
An entry allowing or denying access to different services.
|
|
The syntax is:
|
|
\esyntax{\{access, AccessName, [ \{allow|deny, ACLName\}, ...]\}.}
|
|
|
|
When a JID is checked to have access to \term{Accessname}, the server
|
|
sequentially checks if that JID matches any of the ACLs that are named in the
|
|
second elements of the tuples in the list. If it matches, the first element of
|
|
the first matched tuple is returned, otherwise the value `\term{deny}' is
|
|
returned.
|
|
|
|
Example:
|
|
\begin{verbatim}
|
|
{access, configure, [{allow, admin}]}.
|
|
{access, something, [{deny, badmans},
|
|
{allow, all}]}.
|
|
\end{verbatim}
|
|
|
|
The following \term{AccessName} are pre-defined:
|
|
\begin{description}
|
|
\titem{all} Always returns the value `\term{allow}'.
|
|
\titem{none} Always returns the value `\term{deny}'.
|
|
\end{description}
|
|
|
|
\makesubsubsection{configmaxsessions}{Limiting Opened Sessions with ACL}
|
|
\ind{options!max\_user\_sessions}
|
|
|
|
The special access \term{max\_user\_sessions} specifies the maximum
|
|
number of sessions (authenticated connections) per user. If a user
|
|
tries to open more sessions by using different resources, the first
|
|
opened session will be disconnected. The error \term{session replaced}
|
|
will be sent to the disconnected session. The value for this option
|
|
can be either a number, or \term{infinity}. The default value is
|
|
\term{infinity}.
|
|
|
|
The syntax is:
|
|
\esyntax{\{access, max\_user\_sessions, [ \{MaxNumber, ACLName\}, ...]\}.}
|
|
|
|
This example limits the number of sessions per user to 5 for all users, and to 10 for admins:
|
|
\begin{verbatim}
|
|
{access, max_user_sessions, [{10, admin}, {5, all}]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsubsection{configmaxs2sconns}{Several connections to a remote Jabber server with ACL}
|
|
\ind{options!max\_s2s\_connections}
|
|
|
|
The special access \term{max\_s2s\_connections} specifies how many
|
|
simultaneus S2S connections can be established to a specific remote Jabber server.
|
|
The default value is \term{1}.
|
|
There's also available the access \term{max\_s2s\_connections\_per\_node}.
|
|
|
|
The syntax is:
|
|
\esyntax{\{access, max\_s2s\_connections, [ \{MaxNumber, ACLName\}, ...]\}.}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item Allow up to 3 connections with each remote server:
|
|
\begin{verbatim}
|
|
{access, max_s2s_connections, [{3, all}]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{shapers}{Shapers}
|
|
\ind{options!shaper}\ind{options!maxrate}\ind{shapers}\ind{maxrate}\ind{traffic speed}
|
|
|
|
Shapers enable you to limit connection traffic.
|
|
The syntax is:
|
|
\esyntax{\{shaper, ShaperName, Kind\}.}
|
|
Currently only one kind of shaper called \term{maxrate} is available. It has the
|
|
following syntax:
|
|
\esyntax{\{maxrate, Rate\}}
|
|
where \term{Rate} stands for the maximum allowed incoming rate in bytes per
|
|
second.
|
|
When a connection exceeds this limit, \ejabberd{} stops reading from the socket
|
|
until the average rate is again below the allowed maximum.
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item To define a shaper named `\term{normal}' with traffic speed limited to
|
|
1,000\,bytes/second:
|
|
\begin{verbatim}
|
|
{shaper, normal, {maxrate, 1000}}.
|
|
\end{verbatim}
|
|
\item To define a shaper named `\term{fast}' with traffic speed limited to
|
|
50,000\,bytes/second:
|
|
\begin{verbatim}
|
|
{shaper, fast, {maxrate, 50000}}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{language}{Default Language}
|
|
\ind{options!language}\ind{language}
|
|
|
|
The option \option{language} defines the default language of server strings that
|
|
can be seen by \Jabber{} clients. If a \Jabber{} client does not support
|
|
\option{xml:lang}, the specified language is used.
|
|
|
|
The option syntax is:
|
|
\esyntax{\{language, Language\}.}
|
|
|
|
The default value is \term{en}.
|
|
In order to take effect there must be a translation file
|
|
\term{Language.msg} in \ejabberd{}'s \term{msgs} directory.
|
|
|
|
For example, to set Russian as default language:
|
|
\begin{verbatim}
|
|
{language, "ru"}.
|
|
\end{verbatim}
|
|
|
|
Appendix \ref{i18ni10n} provides more details about internationalization and localization.
|
|
|
|
|
|
\makesubsection{captcha}{CAPTCHA}
|
|
\ind{options!captcha}\ind{captcha}
|
|
|
|
Some \ejabberd{} modules can be configured to require a CAPTCHA challenge on certain actions.
|
|
If the client does not support CAPTCHA Forms (\xepref{0158}),
|
|
a web link is provided so the user can fill the challenge in a web browser.
|
|
|
|
An example script is provided that generates the image
|
|
using ImageMagick's Convert program.
|
|
|
|
The configurable options are:
|
|
\begin{description}
|
|
\titem{\{captcha\_cmd, Path\}}
|
|
Full path to a script that generates the image.
|
|
The default value is an empty string: \term{""}
|
|
\titem{\{captcha\_host, Host\}}
|
|
Host part of the URL sent to the user.
|
|
You can include the port number.
|
|
The URL sent to the user is formed by: \term{http://Host/captcha/}
|
|
The default value is the first hostname configured.
|
|
\end{description}
|
|
|
|
Additionally, an \term{ejabberd\_http} listener must be enabled with the \term{captcha} option.
|
|
See section \ref{listened-module}.
|
|
|
|
Example configuration:
|
|
\begin{verbatim}
|
|
{hosts, ["example.org"]}.
|
|
|
|
{captcha_cmd, "/lib/ejabberd/priv/bin/captcha.sh"}.
|
|
{captcha_host, "example.org:5280"}.
|
|
|
|
{listen,
|
|
[
|
|
...
|
|
{5280, ejabberd_http, [
|
|
captcha,
|
|
...
|
|
]
|
|
}
|
|
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{stun}{STUN}
|
|
\ind{options!stun}\ind{stun}
|
|
|
|
\ejabberd{} is able to act as a stand-alone STUN server
|
|
(\footahref{http://tools.ietf.org/html/rfc5389}{RFC 5389}). Currently only Binding usage
|
|
is supported. In that role \ejabberd{} helps clients with Jingle ICE (\xepref{0176}) support to discover their external addresses and ports.
|
|
|
|
You should configure \term{ejabberd\_stun} listening module as described in \ref{listened} section.
|
|
If \option{certfile} option is defined, \ejabberd{} multiplexes TCP and
|
|
TLS over TCP connections on the same port. Obviously, \option{certfile} option
|
|
is defined for \term{tcp} only. Note however that TCP or TLS over TCP
|
|
support is not required for Binding usage and is reserved for
|
|
\footahref{http://tools.ietf.org/html/draft-ietf-behave-turn-16}{TURN}
|
|
functionality. Feel free to configure \term{udp} transport only.
|
|
|
|
Example configuration:
|
|
\begin{verbatim}
|
|
{listen,
|
|
[
|
|
...
|
|
{{3478, udp}, ejabberd_stun, []},
|
|
{3478, ejabberd_stun, []},
|
|
{5349, ejabberd_stun, [{certfile, "/etc/ejabberd/server.pem"}]},
|
|
...
|
|
]
|
|
}.
|
|
\end{verbatim}
|
|
|
|
You also need to configure DNS SRV records properly so clients can easily discover a
|
|
STUN server serving your XMPP domain. Refer to section
|
|
\footahref{http://tools.ietf.org/html/rfc5389\#section-9}{DNS Discovery of a Server}
|
|
of \footahref{http://tools.ietf.org/html/rfc5389}{RFC 5389} for details.
|
|
|
|
Example DNS SRV configuration:
|
|
\begin{verbatim}
|
|
_stun._udp IN SRV 0 0 3478 stun.example.com.
|
|
_stun._tcp IN SRV 0 0 3478 stun.example.com.
|
|
_stuns._tcp IN SRV 0 0 5349 stun.example.com.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{includeconfigfile}{Include Additional Configuration Files}
|
|
\ind{options!includeconfigfile}\ind{includeconfigfile}
|
|
|
|
The option \option{include\_config\_file} in a configuration file instructs \ejabberd{} to include other configuration files immediately.
|
|
|
|
The basic syntax is:
|
|
\esyntax{\{include\_config\_file, Filename\}.}
|
|
It is possible to specify suboptions using the full syntax:
|
|
\esyntax{\{include\_config\_file, Filename, [Suboption, ...]\}.}
|
|
|
|
The filename can be indicated either as an absolute path,
|
|
or relative to the main \ejabberd{} configuration file.
|
|
It isn't possible to use wildcards.
|
|
The file must exist and be readable.
|
|
|
|
The allowed suboptions are:
|
|
\begin{description}
|
|
\titem{\{disallow, [Optionname, ...]\}} Disallows the usage of those options in the included configuration file.
|
|
The options that match this criteria are not accepted.
|
|
The default value is an empty list: \term{[]}
|
|
\titem{\{allow\_only, [Optionname, ...]\}} Allows only the usage of those options in the included configuration file.
|
|
The options that do not match this criteria are not accepted.
|
|
The default value is: \term{all}
|
|
\end{description}
|
|
|
|
This is a basic example:
|
|
\begin{verbatim}
|
|
{include_config_file, "/etc/ejabberd/additional.cfg"}.
|
|
\end{verbatim}
|
|
|
|
In this example, the included file is not allowed to contain a \term{listen} option.
|
|
If such an option is present, the option will not be accepted.
|
|
The file is in a subdirectory from where the main configuration file is.
|
|
\begin{verbatim}
|
|
{include_config_file, "./example.org/additional_not_listen.cfg", [{disallow, [listen]}]}.
|
|
\end{verbatim}
|
|
|
|
In this example, \term{ejabberd.cfg} defines some ACL and Access rules,
|
|
and later includes another file with additional rules:
|
|
\begin{verbatim}
|
|
{acl, admin, {user, "admin", "localhost"}}.
|
|
{access, announce, [{allow, admin}]}.
|
|
{include_config_file, "/etc/ejabberd/acl_and_access.cfg", [{allow_only, [acl, access]}]}.
|
|
\end{verbatim}
|
|
and content of the file \term{acl\_and\_access.cfg} can be, for example:
|
|
\begin{verbatim}
|
|
{acl, admin, {user, "bob", "localhost"}}.
|
|
{acl, admin, {user, "jan", "localhost"}}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsection{optionmacros}{Option Macros in Configuration File}
|
|
\ind{options!optionmacros}\ind{optionmacros}
|
|
|
|
In the \ejabberd{} configuration file,
|
|
it is possible to define a macro for a value
|
|
and later use this macro when defining an option.
|
|
|
|
A macro is defined with this syntax:
|
|
\esyntax{\{define\_macro, 'MACRO', Value\}.}
|
|
The \term{MACRO} must be surrounded by single quotation marks,
|
|
and all letters in uppercase; check the examples bellow.
|
|
The \term{value} can be any valid arbitrary Erlang term.
|
|
|
|
The first definition of a macro is preserved,
|
|
and additional definitions of the same macro are forgotten.
|
|
|
|
Macros are processed after
|
|
additional configuration files have been included,
|
|
so it is possible to use macros that
|
|
are defined in configuration files included before the usage.
|
|
|
|
It isn't possible to use a macro in the definition
|
|
of another macro.
|
|
|
|
There are two ways to use a macro:
|
|
\begin{description}
|
|
|
|
\titem{'MACRO'}
|
|
You can put this instead of a value in an \ejabberd{} option,
|
|
and will be replaced with the \term{value} previously defined.
|
|
If the macro is not defined previously,
|
|
the program will crash and report an error.
|
|
|
|
\titem{\{use\_macro, 'MACRO', Defaultvalue\}}
|
|
Use a macro even if it may not be defined.
|
|
If the macro is not defined previously,
|
|
the provided \term{defaultvalue} is used.
|
|
This usage behaves as if it were defined and used this way:
|
|
\begin{verbatim}
|
|
{define_macro, 'MACRO', Defaultvalue}.
|
|
'MACRO'
|
|
\end{verbatim}
|
|
|
|
\end{description}
|
|
|
|
This example shows the basic usage of a macro:
|
|
\begin{verbatim}
|
|
{define_macro, 'LOG_LEVEL_NUMBER', 5}.
|
|
{loglevel, 'LOG_LEVEL_NUMBER'}.
|
|
\end{verbatim}
|
|
The resulting option interpreted by \ejabberd{} is: \term{\{loglevel, 5\}}.
|
|
|
|
This example shows that values can be any arbitrary Erlang term:
|
|
\begin{verbatim}
|
|
{define_macro, 'USERBOB', {user, "bob", "localhost"}}.
|
|
{acl, admin, 'USERBOB'}.
|
|
\end{verbatim}
|
|
The resulting option interpreted by \ejabberd{} is: \term{\{acl, admin, \{user, "bob", "localhost"\}\}}.
|
|
|
|
This complex example:
|
|
\begin{verbatim}
|
|
{define_macro, 'NUMBER_PORT_C2S', 5222}.
|
|
{define_macro, 'PORT_S2S_IN', {5269, ejabberd_s2s_in, []}}.
|
|
{listen,
|
|
[
|
|
{'NUMBER_PORT_C2S', ejabberd_c2s, []},
|
|
'PORT_S2S_IN',
|
|
{{use_macro, 'NUMBER_PORT_HTTP', 5280}, ejabberd_http, []}
|
|
]
|
|
}.
|
|
\end{verbatim}
|
|
produces this result after being interpreted:
|
|
\begin{verbatim}
|
|
{listen,
|
|
[
|
|
{5222, ejabberd_c2s, []},
|
|
{5269, ejabberd_s2s_in, []},
|
|
{5280, ejabberd_http, []}
|
|
]
|
|
}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesection{database}{Database and LDAP Configuration}
|
|
\ind{database}
|
|
%TODO: this whole section is not yet 100% optimized
|
|
|
|
\ejabberd{} uses its internal Mnesia database by default. However, it is
|
|
possible to use a relational database or an LDAP server to store persistent,
|
|
long-living data. \ejabberd{} is very flexible: you can configure different
|
|
authentication methods for different virtual hosts, you can configure different
|
|
authentication mechanisms for the same virtual host (fallback), you can set
|
|
different storage systems for modules, and so forth.
|
|
|
|
The following databases are supported by \ejabberd{}:
|
|
\begin{itemize}
|
|
\item \footahref{http://www.microsoft.com/sql/}{Microsoft SQL Server}
|
|
\item \footahref{http://www.erlang.org/doc/apps/mnesia/index.html}{Mnesia}
|
|
\item \footahref{http://www.mysql.com/}{MySQL}
|
|
\item \footahref{http://en.wikipedia.org/wiki/Open\_Database\_Connectivity}{Any ODBC compatible database}
|
|
\item \footahref{http://www.postgresql.org/}{PostgreSQL}
|
|
\end{itemize}
|
|
|
|
The following LDAP servers are tested with \ejabberd{}:
|
|
\begin{itemize}
|
|
\item \footahref{http://www.microsoft.com/activedirectory/}{Active Directory}
|
|
(see section~\ref{ad})
|
|
\item \footahref{http://www.openldap.org/}{OpenLDAP}
|
|
\item Normally any LDAP compatible server should work; inform us about your
|
|
success with a not-listed server so that we can list it here.
|
|
\end{itemize}
|
|
|
|
Important note about virtual hosting:
|
|
if you define several domains in ejabberd.cfg (see section \ref{hostnames}),
|
|
you probably want that each virtual host uses a different configuration of database, authentication and storage,
|
|
so that usernames do not conflict and mix between different virtual hosts.
|
|
For that purpose, the options described in the next sections
|
|
must be set inside a \term{host\_config} for each vhost (see section \ref{virtualhost}).
|
|
For example:
|
|
\begin{verbatim}
|
|
{host_config, "public.example.org", [
|
|
{odbc_server, {pgsql, "localhost", "database-public-example-org", "ejabberd", "password"}},
|
|
{auth_method, [odbc]}
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsection{mysql}{MySQL}
|
|
\ind{MySQL}\ind{MySQL!schema}
|
|
|
|
Although this section will describe \ejabberd{}'s configuration when you want to
|
|
use the native MySQL driver, it does not describe MySQL's installation and
|
|
database creation. Check the MySQL documentation and the tutorial \footahref{http://support.process-one.net/doc/display/MESSENGER/Using+ejabberd+with+MySQL+native+driver}{Using ejabberd with MySQL native driver} for information regarding these topics.
|
|
Note that the tutorial contains information about \ejabberd{}'s configuration
|
|
which is duplicate to this section.
|
|
|
|
Moreover, the file mysql.sql in the directory src/odbc might be interesting for
|
|
you. This file contains the \ejabberd{} schema for MySQL. At the end of the file
|
|
you can find information to update your database schema.
|
|
|
|
|
|
\makesubsubsection{compilemysql}{Driver Compilation}
|
|
\ind{MySQL!Driver Compilation}
|
|
|
|
You can skip this step if you installed \ejabberd{} using a binary installer or
|
|
if the binary packages of \ejabberd{} you are using include support for MySQL.
|
|
|
|
\begin{enumerate}
|
|
\item First, install the \footahref{http://support.process-one.net/doc/display/CONTRIBS/Yxa}{Erlang
|
|
MySQL library}. Make sure the compiled files are in your Erlang path; you can
|
|
put them for example in the same directory as your \ejabberd{} .beam files.
|
|
\item Then, configure and install \ejabberd{} with ODBC support enabled (this is
|
|
also needed for native MySQL support!). This can be done, by using next
|
|
commands:
|
|
\begin{verbatim}
|
|
./configure --enable-odbc && make install
|
|
\end{verbatim}
|
|
\end{enumerate}
|
|
|
|
|
|
\makesubsubsection{configuremysql}{Database Connection}
|
|
\ind{MySQL!Database Connection}
|
|
|
|
The actual database access is defined in the option \term{odbc\_server}. Its
|
|
value is used to define if we want to use ODBC, or one of the two native
|
|
interface available, PostgreSQL or MySQL.
|
|
|
|
To use the native MySQL interface, you can pass a tuple of the following form as
|
|
parameter:
|
|
\esyntax{\{mysql, "Server", "Database", "Username", "Password"\}}
|
|
|
|
\term{mysql} is a keyword that should be kept as is. For example:
|
|
\esyntax{\{odbc\_server, \{mysql, "localhost", "test", "root", "password"\}\}.}
|
|
|
|
Optionally, it is possible to define the MySQL port to use. This
|
|
option is only useful, in very rare cases, when you are not running
|
|
MySQL with the default port setting. The \term{mysql} parameter
|
|
can thus take the following form:
|
|
\esyntax{\{mysql, "Server", Port, "Database", "Username", "Password"\}}
|
|
|
|
The \term{Port} value should be an integer, without quotes. For example:
|
|
\esyntax{\{odbc\_server, \{mysql, "localhost", Port, "test", "root", "password"\}\}.}
|
|
|
|
By default \ejabberd{} opens 10 connections to the database for each virtual host.
|
|
Use this option to modify the value:
|
|
\begin{verbatim}
|
|
{odbc_pool_size, 10}.
|
|
\end{verbatim}
|
|
|
|
You can configure an interval to make a dummy SQL request
|
|
to keep alive the connections to the database.
|
|
The default value is 'undefined', so no keepalive requests are made.
|
|
Specify in seconds: for example 28800 means 8 hours.
|
|
\begin{verbatim}
|
|
{odbc_keepalive_interval, undefined}.
|
|
\end{verbatim}
|
|
|
|
If the connection to the database fails, \ejabberd{} waits 30 seconds before retrying.
|
|
You can modify this interval with this option:
|
|
\begin{verbatim}
|
|
{odbc_start_interval, 30}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsubsection{mysqlauth}{Authentication}
|
|
\ind{MySQL!authentication}
|
|
|
|
The option value name may be misleading, as the \term{auth\_method} name is used
|
|
for access to a relational database through ODBC, as well as through the native
|
|
MySQL interface. Anyway, the first configuration step is to define the odbc
|
|
\term{auth\_method}. For example:
|
|
\begin{verbatim}
|
|
{auth_method, [odbc]}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsubsection{mysqlstorage}{Storage}
|
|
\ind{MySQL!storage}
|
|
|
|
MySQL also can be used to store information into from several \ejabberd{}
|
|
modules. See section~\ref{modoverview} to see which modules have a version
|
|
with the `\_odbc'. This suffix indicates that the module can be used with
|
|
relational databases like MySQL. To enable storage to your database, just make
|
|
sure that your database is running well (see previous sections), and replace the
|
|
suffix-less or ldap module variant with the odbc module variant. Keep in mind
|
|
that you cannot have several variants of the same module loaded!
|
|
|
|
\makesubsection{mssql}{Microsoft SQL Server}
|
|
\ind{Microsoft SQL Server}\ind{Microsoft SQL Server!schema}
|
|
|
|
Although this section will describe \ejabberd{}'s configuration when you want to
|
|
use Microsoft SQL Server, it does not describe Microsoft SQL Server's
|
|
installation and database creation. Check the MySQL documentation and the
|
|
tutorial \footahref{http://support.process-one.net/doc/display/MESSENGER/Using+ejabberd+with+MySQL+native+driver}{Using ejabberd with MySQL native driver} for information regarding these topics.
|
|
Note that the tutorial contains information about \ejabberd{}'s configuration
|
|
which is duplicate to this section.
|
|
|
|
Moreover, the file mssql.sql in the directory src/odbc might be interesting for
|
|
you. This file contains the \ejabberd{} schema for Microsoft SQL Server. At the end
|
|
of the file you can find information to update your database schema.
|
|
|
|
|
|
\makesubsubsection{compilemssql}{Driver Compilation}
|
|
\ind{Microsoft SQL Server!Driver Compilation}
|
|
|
|
You can skip this step if you installed \ejabberd{} using a binary installer or
|
|
if the binary packages of \ejabberd{} you are using include support for ODBC.
|
|
|
|
If you want to use Microsoft SQL Server with ODBC, you need to configure,
|
|
compile and install \ejabberd{} with support for ODBC and Microsoft SQL Server
|
|
enabled. This can be done, by using next commands:
|
|
\begin{verbatim}
|
|
./configure --enable-odbc --enable-mssql && make install
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsubsection{configuremssql}{Database Connection}
|
|
\ind{Microsoft SQL Server!Database Connection}
|
|
|
|
By default \ejabberd{} opens 10 connections to the database for each virtual host.
|
|
Use this option to modify the value:
|
|
\begin{verbatim}
|
|
{odbc_pool_size, 10}.
|
|
\end{verbatim}
|
|
|
|
You can configure an interval to make a dummy SQL request
|
|
to keep alive the connections to the database.
|
|
The default value is 'undefined', so no keepalive requests are made.
|
|
Specify in seconds: for example 28800 means 8 hours.
|
|
\begin{verbatim}
|
|
{odbc_keepalive_interval, undefined}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsubsection{mssqlauth}{Authentication}
|
|
\ind{Microsoft SQL Server!authentication}
|
|
|
|
%TODO: not sure if this section is right!!!!!!
|
|
|
|
The configuration of Microsoft SQL Server is the same as the configuration of
|
|
ODBC compatible servers (see section~\ref{odbcauth}).
|
|
|
|
\makesubsubsection{mssqlstorage}{Storage}
|
|
\ind{Microsoft SQL Server!storage}
|
|
|
|
Microsoft SQL Server also can be used to store information into from several
|
|
\ejabberd{} modules. See section~\ref{modoverview} to see which modules have
|
|
a version with the `\_odbc'. This suffix indicates that the module can be used
|
|
with relational databases like Microsoft SQL Server. To enable storage to your
|
|
database, just make sure that your database is running well (see previous
|
|
sections), and replace the suffix-less or ldap module variant with the odbc
|
|
module variant. Keep in mind that you cannot have several variants of the same
|
|
module loaded!
|
|
|
|
\makesubsection{pgsql}{PostgreSQL}
|
|
\ind{PostgreSQL}\ind{PostgreSQL!schema}
|
|
|
|
Although this section will describe \ejabberd{}'s configuration when you want to
|
|
use the native PostgreSQL driver, it does not describe PostgreSQL's installation
|
|
and database creation. Check the PostgreSQL documentation and the tutorial \footahref{http://support.process-one.net/doc/display/MESSENGER/Using+ejabberd+with+MySQL+native+driver}{Using ejabberd with MySQL native driver} for information regarding these topics.
|
|
Note that the tutorial contains information about \ejabberd{}'s configuration
|
|
which is duplicate to this section.
|
|
|
|
Also the file pg.sql in the directory src/odbc might be interesting for you.
|
|
This file contains the \ejabberd{} schema for PostgreSQL. At the end of the file
|
|
you can find information to update your database schema.
|
|
|
|
|
|
\makesubsubsection{compilepgsql}{Driver Compilation}
|
|
\ind{PostgreSQL!Driver Compilation}
|
|
|
|
You can skip this step if you installed \ejabberd{} using a binary installer or
|
|
if the binary packages of \ejabberd{} you are using include support for
|
|
PostgreSQL.
|
|
|
|
\begin{enumerate}
|
|
\item First, install the Erlang pgsql library from
|
|
\footahref{http://www.ejabberd.im/ejabberd-modules/}{ejabberd-modules SVN repository}.
|
|
Make sure the compiled
|
|
files are in your Erlang path; you can put them for example in the same
|
|
directory as your \ejabberd{} .beam files.
|
|
\item Then, configure, compile and install \ejabberd{} with ODBC support enabled
|
|
(this is also needed for native PostgreSQL support!). This can be done, by
|
|
using next commands:
|
|
\begin{verbatim}
|
|
./configure --enable-odbc && make install
|
|
\end{verbatim}
|
|
\end{enumerate}
|
|
|
|
|
|
\makesubsubsection{configurepgsql}{Database Connection}
|
|
\ind{PostgreSQL!Database Connection}
|
|
|
|
The actual database access is defined in the option \term{odbc\_server}. Its
|
|
value is used to define if we want to use ODBC, or one of the two native
|
|
interface available, PostgreSQL or MySQL.
|
|
|
|
To use the native PostgreSQL interface, you can pass a tuple of the following
|
|
form as parameter:
|
|
\esyntax{\{pgsql, "Server", "Database", "Username", "Password"\}}
|
|
|
|
\term{pgsql} is a keyword that should be kept as is. For example:
|
|
\esyntax{\{odbc\_server, \{pgsql, "localhost", "database", "ejabberd", "password"\}\}.}
|
|
|
|
Optionally, it is possible to define the PostgreSQL port to use. This
|
|
option is only useful, in very rare cases, when you are not running
|
|
PostgreSQL with the default port setting. The \term{pgsql} parameter
|
|
can thus take the following form:
|
|
\esyntax{\{pgsql, "Server", Port, "Database", "Username", "Password"\}}
|
|
|
|
The \term{Port} value should be an integer, without quotes. For example:
|
|
\esyntax{\{odbc\_server, \{pgsql, "localhost", 5432, "database", "ejabberd", "password"\}\}.}
|
|
|
|
By default \ejabberd{} opens 10 connections to the database for each virtual host.
|
|
Use this option to modify the value:
|
|
\begin{verbatim}
|
|
{odbc_pool_size, 10}.
|
|
\end{verbatim}
|
|
|
|
You can configure an interval to make a dummy SQL request
|
|
to keep alive the connections to the database.
|
|
The default value is 'undefined', so no keepalive requests are made.
|
|
Specify in seconds: for example 28800 means 8 hours.
|
|
\begin{verbatim}
|
|
{odbc_keepalive_interval, undefined}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsubsection{pgsqlauth}{Authentication}
|
|
\ind{PostgreSQL!authentication}
|
|
|
|
The option value name may be misleading, as the \term{auth\_method} name is used
|
|
for access to a relational database through ODBC, as well as through the native
|
|
PostgreSQL interface. Anyway, the first configuration step is to define the odbc
|
|
\term{auth\_method}. For example:
|
|
\begin{verbatim}
|
|
{auth_method, [odbc]}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsubsection{pgsqlstorage}{Storage}
|
|
\ind{PostgreSQL!storage}
|
|
|
|
PostgreSQL also can be used to store information into from several \ejabberd{}
|
|
modules. See section~\ref{modoverview} to see which modules have a version
|
|
with the `\_odbc'. This suffix indicates that the module can be used with
|
|
relational databases like PostgreSQL. To enable storage to your database, just
|
|
make sure that your database is running well (see previous sections), and
|
|
replace the suffix-less or ldap module variant with the odbc module variant.
|
|
Keep in mind that you cannot have several variants of the same module loaded!
|
|
|
|
\makesubsection{odbc}{ODBC Compatible}
|
|
\ind{databases!ODBC}
|
|
|
|
Although this section will describe \ejabberd{}'s configuration when you want to
|
|
use the ODBC driver, it does not describe the installation and database creation
|
|
of your database. Check the documentation of your database. The tutorial \footahref{http://support.process-one.net/doc/display/MESSENGER/Using+ejabberd+with+MySQL+native+driver}{Using ejabberd with MySQL native driver} also can help you. Note that the tutorial
|
|
contains information about \ejabberd{}'s configuration which is duplicate to
|
|
this section.
|
|
|
|
|
|
\makesubsubsection{compileodbc}{Driver Compilation}
|
|
|
|
You can skip this step if you installed \ejabberd{} using a binary installer or
|
|
if the binary packages of \ejabberd{} you are using include support for
|
|
ODBC.
|
|
|
|
\begin{enumerate}
|
|
\item First, install the \footahref{http://support.process-one.net/doc/display/CONTRIBS/Yxa}{Erlang
|
|
MySQL library}. Make sure the compiled files are in your Erlang path; you can
|
|
put them for example in the same directory as your \ejabberd{} .beam files.
|
|
\item Then, configure, compile and install \ejabberd{} with ODBC support
|
|
enabled. This can be done, by using next commands:
|
|
\begin{verbatim}
|
|
./configure --enable-odbc && make install
|
|
\end{verbatim}
|
|
\end{enumerate}
|
|
|
|
|
|
\makesubsubsection{configureodbc}{Database Connection}
|
|
\ind{ODBC!Database Connection}
|
|
|
|
The actual database access is defined in the option \term{odbc\_server}. Its
|
|
value is used to defined if we want to use ODBC, or one of the two native
|
|
interface available, PostgreSQL or MySQL.
|
|
|
|
To use a relational database through ODBC, you can pass the ODBC connection
|
|
string as \term{odbc\_server} parameter. For example:
|
|
\begin{verbatim}
|
|
{odbc_server, "DSN=database;UID=ejabberd;PWD=password"}.
|
|
\end{verbatim}
|
|
|
|
By default \ejabberd{} opens 10 connections to the database for each virtual host.
|
|
Use this option to modify the value:
|
|
\begin{verbatim}
|
|
{odbc_pool_size, 10}.
|
|
\end{verbatim}
|
|
|
|
You can configure an interval to make a dummy SQL request
|
|
to keep alive the connections to the database.
|
|
The default value is 'undefined', so no keepalive requests are made.
|
|
Specify in seconds: for example 28800 means 8 hours.
|
|
\begin{verbatim}
|
|
{odbc_keepalive_interval, undefined}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsubsection{odbcauth}{Authentication}
|
|
\ind{ODBC!authentication}
|
|
|
|
The first configuration step is to define the odbc \term{auth\_method}. For
|
|
example:
|
|
\begin{verbatim}
|
|
{auth_method, [odbc]}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsubsection{odbcstorage}{Storage}
|
|
\ind{ODBC!storage}
|
|
|
|
An ODBC compatible database also can be used to store information into from
|
|
several \ejabberd{} modules. See section~\ref{modoverview} to see which
|
|
modules have a version with the `\_odbc'. This suffix indicates that the module
|
|
can be used with ODBC compatible relational databases. To enable storage to your
|
|
database, just make sure that your database is running well (see previous
|
|
sections), and replace the suffix-less or ldap module variant with the odbc
|
|
module variant. Keep in mind that you cannot have several variants of the same
|
|
module loaded!
|
|
|
|
\makesubsection{ldap}{LDAP}
|
|
\ind{databases!LDAP}
|
|
|
|
\ejabberd{} has built-in LDAP support. You can authenticate users against LDAP
|
|
server and use LDAP directory as vCard storage. Shared rosters are not supported
|
|
yet.
|
|
|
|
Note that \ejabberd{} treats LDAP as a read-only storage:
|
|
it is possible to consult data, but not possible to
|
|
create accounts, change password or edit vCard that is stored in LDAP.
|
|
|
|
|
|
\makesubsubsection{ldapconnection}{Connection}
|
|
|
|
Parameters:
|
|
\begin{description}
|
|
\titem{\{ldap\_servers, [Servers, ...]\}} \ind{options!ldap\_server}List of IP addresses or DNS names of your
|
|
LDAP servers. This option is required.
|
|
\titem{\{ldap\_encrypt, none|tls\}} \ind{options!ldap\_encrypt}Type of connection encryption to the LDAP server.
|
|
Allowed values are: \term{none}, \term{tls}.
|
|
Note that STARTTLS is not supported.
|
|
The default value is: \term{none}.
|
|
\titem{\{ldap\_port, Number\}} \ind{options!ldap\_port}Port to connect to your LDAP server.
|
|
The default port is~389 if encryption is disabled; and 636 if encryption is enabled.
|
|
If you configure a value, it is stored in \ejabberd{}'s database.
|
|
Then, if you remove that value from the configuration file,
|
|
the value previously stored in the database will be used instead of the default port.
|
|
\titem{\{ldap\_rootdn, RootDN\}} \ind{options!ldap\_rootdn}Bind DN. The default value
|
|
is~\term{""} which means `anonymous connection'.
|
|
\titem{\{ldap\_password, Password\}} \ind{options!ldap\_password}Bind password. The default
|
|
value is \term{""}.
|
|
\end{description}
|
|
|
|
Example:
|
|
\begin{verbatim}
|
|
{auth_method, ldap}.
|
|
{ldap_servers, ["ldap.example.org"]}.
|
|
{ldap_port, 389}.
|
|
{ldap_rootdn, "cn=Manager,dc=domain,dc=org"}.
|
|
{ldap_password, "secret"}.
|
|
\end{verbatim}
|
|
|
|
Note that current LDAP implementation does not support SSL secured communication
|
|
and SASL authentication.
|
|
|
|
\makesubsubsection{ldapauth}{Authentication}
|
|
|
|
You can authenticate users against an LDAP directory. Available options are:
|
|
|
|
\begin{description}
|
|
\titem{\{ldap\_base, Base\}}\ind{options!ldap\_base}LDAP base directory which stores
|
|
users accounts. This option is required.
|
|
\titem{\{ldap\_uids, [ \{ldap\_uidattr\} | \{ldap\_uidattr, ldap\_uidattr\_format\}, ...]\}}\ind{options!ldap\_uids}
|
|
LDAP attribute which holds a list of attributes to use as alternatives for getting the JID.
|
|
The default attributes are \term{[\{"uid", "\%u"\}]}.
|
|
The attributes are of the form:
|
|
\term{[\{ldap\_uidattr\}]} or \term{[\{ldap\_uidattr, ldap\_uidattr\_format\}]}.
|
|
You can use as many comma separated attributes as needed.
|
|
The values for \term{ldap\_uidattr} and
|
|
\term{ldap\_uidattr\_format} are described as follow:
|
|
\begin{description}
|
|
\titem{ldap\_uidattr}\ind{options!ldap\_uidattr}LDAP attribute which holds
|
|
the user's part of a JID. The default value is \term{"uid"}.
|
|
\titem{ldap\_uidattr\_format}\ind{options!ldap\_uidattr\_format}Format of
|
|
the \term{ldap\_uidattr} variable. The format \emph{must} contain one and
|
|
only one pattern variable \term{"\%u"} which will be replaced by the
|
|
user's part of a JID. For example, \term{"\%u@example.org"}. The default
|
|
value is \term{"\%u"}.
|
|
\end{description}
|
|
\titem{\{ldap\_filter, Filter\}}\ind{options!ldap\_filter}\ind{protocols!RFC 4515:
|
|
LDAP String Representation of Search Filters}
|
|
\footahref{http://tools.ietf.org/html/rfc4515}{RFC 4515} LDAP filter. The
|
|
default is \term{none}. Example:
|
|
\term{"(\&(objectClass=shadowAccount)(memberOf=Jabber Users))"}. Please, do
|
|
not forget to close brackets and do not use superfluous whitespaces. Also you
|
|
\emph{must not} use \option{ldap\_uidattr} attribute in filter because this
|
|
attribute will be substituted in LDAP filter automatically.
|
|
|
|
\titem{\{ldap\_local\_filter, Filter\}}\ind{options!ldap\_local\_filter}
|
|
If you can't use \term{ldap\_filter} due to performance reasons
|
|
(the LDAP server has many users registered),
|
|
you can use this local filter.
|
|
The local filter checks an attribute in ejabberd,
|
|
not in LDAP, so this limits the load on the LDAP directory.
|
|
The default filter is: \term{undefined}.
|
|
Example values:
|
|
\begin{verbatim}
|
|
{ldap_local_filter, {notequal, {"accountStatus",["disabled"]}}}.
|
|
{ldap_local_filter, {equal, {"accountStatus",["enabled"]}}}.
|
|
{ldap_local_filter, undefined}.
|
|
\end{verbatim}
|
|
|
|
\end{description}
|
|
|
|
\makesubsubsection{ldapexamples}{Examples}
|
|
|
|
\makeparagraph{ldapcommonexample}{Common example}
|
|
|
|
Let's say \term{ldap.example.org} is the name of our LDAP server. We have
|
|
users with their passwords in \term{"ou=Users,dc=example,dc=org"} directory.
|
|
Also we have addressbook, which contains users emails and their additional
|
|
infos in \term{"ou=AddressBook,dc=example,dc=org"} directory.
|
|
The connection to the LDAP server is encrypted using TLS,
|
|
and using the custom port 6123.
|
|
Corresponding authentication section should looks like this:
|
|
|
|
\begin{verbatim}
|
|
%% Authentication method
|
|
{auth_method, ldap}.
|
|
%% DNS name of our LDAP server
|
|
{ldap_servers, ["ldap.example.org"]}.
|
|
%% Bind to LDAP server as "cn=Manager,dc=example,dc=org" with password "secret"
|
|
{ldap_rootdn, "cn=Manager,dc=example,dc=org"}.
|
|
{ldap_password, "secret"}.
|
|
{ldap_encrypt, tls}.
|
|
{ldap_port, 6123}.
|
|
%% Define the user's base
|
|
{ldap_base, "ou=Users,dc=example,dc=org"}.
|
|
%% We want to authorize users from 'shadowAccount' object class only
|
|
{ldap_filter, "(objectClass=shadowAccount)"}.
|
|
\end{verbatim}
|
|
|
|
Now we want to use users LDAP-info as their vCards. We have four attributes
|
|
defined in our LDAP schema: \term{"mail"} --- email address, \term{"givenName"}
|
|
--- first name, \term{"sn"} --- second name, \term{"birthDay"} --- birthday.
|
|
Also we want users to search each other. Let's see how we can set it up:
|
|
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_vcard_ldap,
|
|
[
|
|
%% We use the same server and port, but want to bind anonymously because
|
|
%% our LDAP server accepts anonymous requests to
|
|
%% "ou=AddressBook,dc=example,dc=org" subtree.
|
|
{ldap_rootdn, ""},
|
|
{ldap_password, ""},
|
|
%% define the addressbook's base
|
|
{ldap_base, "ou=AddressBook,dc=example,dc=org"},
|
|
%% uidattr: user's part of JID is located in the "mail" attribute
|
|
%% uidattr_format: common format for our emails
|
|
{ldap_uids, [{"mail", "%u@mail.example.org"}]},
|
|
%% We have to define empty filter here, because entries in addressbook does not
|
|
%% belong to shadowAccount object class
|
|
{ldap_filter, ""},
|
|
%% Now we want to define vCard pattern
|
|
{ldap_vcard_map,
|
|
[{"NICKNAME", "%u", []}, % just use user's part of JID as his nickname
|
|
{"GIVEN", "%s", ["givenName"]},
|
|
{"FAMILY", "%s", ["sn"]},
|
|
{"FN", "%s, %s", ["sn", "givenName"]}, % example: "Smith, John"
|
|
{"EMAIL", "%s", ["mail"]},
|
|
{"BDAY", "%s", ["birthDay"]}]},
|
|
%% Search form
|
|
{ldap_search_fields,
|
|
[{"User", "%u"},
|
|
{"Name", "givenName"},
|
|
{"Family Name", "sn"},
|
|
{"Email", "mail"},
|
|
{"Birthday", "birthDay"}]},
|
|
%% vCard fields to be reported
|
|
%% Note that JID is always returned with search results
|
|
{ldap_search_reported,
|
|
[{"Full Name", "FN"},
|
|
{"Nickname", "NICKNAME"},
|
|
{"Birthday", "BDAY"}]}
|
|
]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
Note that \modvcardldap{} module checks for the existence of the user before
|
|
searching in his information in LDAP.
|
|
|
|
|
|
\makeparagraph{ad}{Active Directory}
|
|
\ind{databases!Active Directory}
|
|
|
|
Active Directory is just an LDAP-server with predefined attributes. A sample
|
|
configuration is shown below:
|
|
|
|
\begin{verbatim}
|
|
{auth_method, ldap}.
|
|
{ldap_servers, ["office.org"]}. % List of LDAP servers
|
|
{ldap_base, "DC=office,DC=org"}. % Search base of LDAP directory
|
|
{ldap_rootdn, "CN=Administrator,CN=Users,DC=office,DC=org"}. % LDAP manager
|
|
{ldap_password, "*******"}. % Password to LDAP manager
|
|
{ldap_uids, [{"sAMAccountName"}]}.
|
|
{ldap_filter, "(memberOf=*)"}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_vcard_ldap,
|
|
[{ldap_vcard_map,
|
|
[{"NICKNAME", "%u", []},
|
|
{"GIVEN", "%s", ["givenName"]},
|
|
{"MIDDLE", "%s", ["initials"]},
|
|
{"FAMILY", "%s", ["sn"]},
|
|
{"FN", "%s", ["displayName"]},
|
|
{"EMAIL", "%s", ["mail"]},
|
|
{"ORGNAME", "%s", ["company"]},
|
|
{"ORGUNIT", "%s", ["department"]},
|
|
{"CTRY", "%s", ["c"]},
|
|
{"LOCALITY", "%s", ["l"]},
|
|
{"STREET", "%s", ["streetAddress"]},
|
|
{"REGION", "%s", ["st"]},
|
|
{"PCODE", "%s", ["postalCode"]},
|
|
{"TITLE", "%s", ["title"]},
|
|
{"URL", "%s", ["wWWHomePage"]},
|
|
{"DESC", "%s", ["description"]},
|
|
{"TEL", "%s", ["telephoneNumber"]}]},
|
|
{ldap_search_fields,
|
|
[{"User", "%u"},
|
|
{"Name", "givenName"},
|
|
{"Family Name", "sn"},
|
|
{"Email", "mail"},
|
|
{"Company", "company"},
|
|
{"Department", "department"},
|
|
{"Role", "title"},
|
|
{"Description", "description"},
|
|
{"Phone", "telephoneNumber"}]},
|
|
{ldap_search_reported,
|
|
[{"Full Name", "FN"},
|
|
{"Nickname", "NICKNAME"},
|
|
{"Email", "EMAIL"}]}
|
|
]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
|
|
\makesection{modules}{Modules Configuration}
|
|
\ind{modules}
|
|
|
|
The option \term{modules} defines the list of modules that will be loaded after
|
|
\ejabberd{}'s startup. Each entry in the list is a tuple in which the first
|
|
element is the name of a module and the second is a list of options for that
|
|
module.
|
|
|
|
The syntax is:
|
|
\esyntax{\{modules, [ \{ModuleName, ModuleOptions\}, ...]\}.}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item In this example only the module \modecho{} is loaded and no module
|
|
options are specified between the square brackets:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
{mod_echo, []}
|
|
]}.
|
|
\end{verbatim}
|
|
\item In the second example the modules \modecho{}, \modtime{}, and
|
|
\modversion{} are loaded without options. Remark that, besides the last entry,
|
|
all entries end with a comma:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
{mod_echo, []},
|
|
{mod_time, []},
|
|
{mod_version, []}
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modoverview}{Modules Overview}
|
|
\ind{modules!overview}\ind{XMPP compliancy}
|
|
|
|
The following table lists all modules included in \ejabberd{}.
|
|
|
|
\begin{table}[H]
|
|
\centering
|
|
\begin{tabular}{|l|l|l|}
|
|
\hline {\bf Module} & {\bf Feature} & {\bf Dependencies} \\
|
|
\hline
|
|
\hline \modadhoc{} & Ad-Hoc Commands (\xepref{0050}) & \\
|
|
\hline \ahrefloc{modannounce}{\modannounce{}} & Manage announcements & recommends \modadhoc{} \\
|
|
\hline \modcaps{} & Entity Capabilities (\xepref{0115}) & \\
|
|
\hline \modconfigure{} & Server configuration using Ad-Hoc & \modadhoc{} \\
|
|
\hline \ahrefloc{moddisco}{\moddisco{}} & Service Discovery (\xepref{0030}) & \\
|
|
\hline \ahrefloc{modecho}{\modecho{}} & Echoes Jabber packets & \\
|
|
\hline \ahrefloc{modirc}{\modirc{}} & IRC transport & \\
|
|
\hline \ahrefloc{modlast}{\modlast{}} & Last Activity (\xepref{0012}) & \\
|
|
\hline \ahrefloc{modlast}{\modlastodbc{}} & Last Activity (\xepref{0012}) & supported DB (*) \\
|
|
\hline \ahrefloc{modmuc}{\modmuc{}} & Multi-User Chat (\xepref{0045}) & \\
|
|
\hline \ahrefloc{modmuclog}{\modmuclog{}} & Multi-User Chat room logging & \modmuc{} \\
|
|
\hline \ahrefloc{modoffline}{\modoffline{}} & Offline message storage (\xepref{0160}) & \\
|
|
\hline \ahrefloc{modoffline}{\modofflineodbc{}} & Offline message storage (\xepref{0160}) & supported DB (*) \\
|
|
\hline \ahrefloc{modping}{\modping{}} & XMPP Ping and periodic keepalives (\xepref{0199}) & \\
|
|
\hline \ahrefloc{modprivacy}{\modprivacy{}} & Blocking Communication (XMPP IM) & \\
|
|
\hline \ahrefloc{modprivacy}{\modprivacyodbc{}} & Blocking Communication (XMPP IM) & supported DB (*) \\
|
|
\hline \ahrefloc{modprivate}{\modprivate{}} & Private XML Storage (\xepref{0049}) & \\
|
|
\hline \ahrefloc{modprivate}{\modprivateodbc{}} & Private XML Storage (\xepref{0049}) & supported DB (*) \\
|
|
\hline \ahrefloc{modproxy}{\modproxy{}} & SOCKS5 Bytestreams (\xepref{0065}) & \\
|
|
\hline \ahrefloc{modpubsub}{\modpubsub{}} & Pub-Sub (\xepref{0060}), PEP (\xepref{0163}) & \modcaps{} \\
|
|
\hline \ahrefloc{modpubsub}{\modpubsubodbc{}} & Pub-Sub (\xepref{0060}), PEP (\xepref{0163}) & supported DB (*) and \modcaps{} \\
|
|
\hline \ahrefloc{modregister}{\modregister{}} & In-Band Registration (\xepref{0077}) & \\
|
|
\hline \ahrefloc{modroster}{\modroster{}} & Roster management (XMPP IM) & \\
|
|
\hline \ahrefloc{modroster}{\modrosterodbc{}} & Roster management (XMPP IM) & supported DB (*) \\
|
|
\hline \ahrefloc{modservicelog}{\modservicelog{}} & Copy user messages to logger service & \\
|
|
\hline \ahrefloc{modsharedroster}{\modsharedroster{}} & Shared roster management & \modroster{} or \\
|
|
& & \modrosterodbc\\
|
|
\hline \ahrefloc{modstats}{\modstats{}} & Statistics Gathering (\xepref{0039}) & \\
|
|
\hline \ahrefloc{modtime}{\modtime{}} & Entity Time (\xepref{0202}) & \\
|
|
\hline \ahrefloc{modvcard}{\modvcard{}} & vcard-temp (\xepref{0054}) & \\
|
|
\hline \ahrefloc{modvcardldap}{\modvcardldap{}} & vcard-temp (\xepref{0054}) & LDAP server \\
|
|
\hline \ahrefloc{modvcard}{\modvcardodbc{}} & vcard-temp (\xepref{0054}) & supported DB (*) \\
|
|
\hline \ahrefloc{modversion}{\modversion{}} & Software Version (\xepref{0092}) & \\
|
|
\hline
|
|
\end{tabular}
|
|
\end{table}
|
|
|
|
\begin{itemize}
|
|
\item (*) This module requires a supported database. For a list of supported databases, see section~\ref{database}.
|
|
\end{itemize}
|
|
|
|
You can see which database backend each module needs by looking at the suffix:
|
|
\begin{itemize}
|
|
\item No suffix, this means that the modules uses Erlang's built-in database
|
|
Mnesia as backend.
|
|
\item `\_odbc', this means that the module needs a supported database
|
|
(see~\ref{database}) as backend.
|
|
\item `\_ldap', this means that the module needs an LDAP server as backend.
|
|
\end{itemize}
|
|
|
|
If you want to,
|
|
it is possible to use a relational database to store pieces of
|
|
information. You can do this by changing the module name to a name with an
|
|
\term{\_odbc} suffix in \ejabberd{} config file. You can use a relational
|
|
database for the following data:
|
|
|
|
\begin{itemize}
|
|
\item Last connection date and time: Use \term{mod\_last\_odbc} instead of
|
|
\term{mod\_last}.
|
|
\item Offline messages: Use \term{mod\_offline\_odbc} instead of
|
|
\term{mod\_offline}.
|
|
\item Rosters: Use \term{mod\_roster\_odbc} instead of \term{mod\_roster}.
|
|
\item Users' VCARD: Use \term{mod\_vcard\_odbc} instead of \term{mod\_vcard}.
|
|
\item Private XML storage: Use \term{mod\_private\_odbc} instead of \term{mod\_private}.
|
|
\item User rules for blocking communications: Use \term{mod\_privacy\_odbc} instead of \term{mod\_privacy}.
|
|
\end{itemize}
|
|
|
|
You can find more
|
|
\footahref{http://www.ejabberd.im/contributions}{contributed modules} on the
|
|
\ejabberd{} website. Please remember that these contributions might not work or
|
|
that they can contain severe bugs and security leaks. Therefore, use them at
|
|
your own risk!
|
|
|
|
|
|
\makesubsection{modcommonoptions}{Common Options}
|
|
|
|
The following options are used by many modules. Therefore, they are described in
|
|
this separate section.
|
|
|
|
\makesubsubsection{modiqdiscoption}{\option{iqdisc}}
|
|
\ind{options!iqdisc}
|
|
|
|
Many modules define handlers for processing IQ queries of different namespaces
|
|
to this server or to a user (e.\,g.\ to \jid{example.org} or to
|
|
\jid{user@example.org}). This option defines processing discipline for
|
|
these queries.
|
|
|
|
The syntax is:
|
|
\esyntax{\{iqdisc, Value\}}
|
|
|
|
Possible \term{Value} are:
|
|
\begin{description}
|
|
\titem{no\_queue} All queries of a namespace with this processing discipline are
|
|
processed immediately. This also means that no other packets can be processed
|
|
until this one has been completely processed. Hence this discipline is not
|
|
recommended if the processing of a query can take a relatively long time.
|
|
\titem{one\_queue} In this case a separate queue is created for the processing
|
|
of IQ queries of a namespace with this discipline. In addition, the processing
|
|
of this queue is done in parallel with that of other packets. This discipline
|
|
is most recommended.
|
|
\titem{\{queues, N\}} N separate queues are created to process the
|
|
queries. The queries are thus process in parallel, but in a
|
|
controlled way.
|
|
\titem{parallel} For every packet with this discipline a separate Erlang process
|
|
is spawned. Consequently, all these packets are processed in parallel.
|
|
Although spawning of Erlang process has a relatively low cost, this can break
|
|
the server's normal work, because the Erlang emulator has a limit on the
|
|
number of processes (32000 by default).
|
|
\end{description}
|
|
|
|
Example:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_time, [{iqdisc, no_queue}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsubsection{modhostoption}{\option{host}}
|
|
\ind{options!host}
|
|
|
|
This option defines the Jabber ID of a service provided by an \ejabberd{} module.
|
|
|
|
The syntax is:
|
|
\esyntax{\{host, HostName\}}
|
|
|
|
If you include the keyword "@HOST@" in the HostName,
|
|
it is replaced at start time with the real virtual host string.
|
|
|
|
This example configures
|
|
the \ind{modules!\modecho{}}echo module to provide its echoing service
|
|
in the Jabber ID \jid{mirror.example.org}:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_echo, [{host, "mirror.example.org"}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
However, if there are several virtual hosts and this module is enabled in all of them,
|
|
the "@HOST@" keyword must be used:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_echo, [{host, "mirror.@HOST@"}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{modannounce}{\modannounce{}}
|
|
\ind{modules!\modannounce{}}\ind{MOTD}\ind{message of the day}\ind{announcements}
|
|
|
|
This module enables configured users to broadcast announcements and to set
|
|
the message of the day (MOTD).
|
|
Configured users can perform these actions with a
|
|
\Jabber{} client either using Ad-hoc commands
|
|
or sending messages to specific JIDs.
|
|
|
|
The Ad-hoc commands are listed in the Server Discovery.
|
|
For this feature to work, \modadhoc{} must be enabled.
|
|
|
|
The specific JIDs where messages can be sent are listed bellow.
|
|
The first JID in each entry will apply only to the specified virtual host
|
|
\jid{example.org}, while the JID between brackets will apply to all virtual
|
|
hosts in ejabberd.
|
|
\begin{description}
|
|
\titem{example.org/announce/all (example.org/announce/all-hosts/all)} The
|
|
message is sent to all registered users. If the user is online and connected
|
|
to several resources, only the resource with the highest priority will receive
|
|
the message. If the registered user is not connected, the message will be
|
|
stored offline in assumption that \ind{modules!\modoffline{}}offline storage
|
|
(see section~\ref{modoffline}) is enabled.
|
|
\titem{example.org/announce/online (example.org/announce/all-hosts/online)}The
|
|
message is sent to all connected users. If the user is online and connected
|
|
to several resources, all resources will receive the message.
|
|
\titem{example.org/announce/motd (example.org/announce/all-hosts/motd)}The
|
|
message is set as the message of the day (MOTD) and is sent to users when they
|
|
login. In addition the message is sent to all connected users (similar to
|
|
\term{announce/online}).
|
|
\titem{example.org/announce/motd/update (example.org/announce/all-hosts/motd/update)}
|
|
The message is set as message of the day (MOTD) and is sent to users when they
|
|
login. The message is \emph{not sent} to any currently connected user.
|
|
\titem{example.org/announce/motd/delete (example.org/announce/all-hosts/motd/delete)}
|
|
Any message sent to this JID removes the existing message of the day (MOTD).
|
|
\end{description}
|
|
|
|
Options:
|
|
\begin{description}
|
|
\titem{\{access, AccessName\}} \ind{options!access}This option specifies who is allowed to
|
|
send announcements and to set the message of the day (by default, nobody is
|
|
able to send such messages).
|
|
\end{description}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item Only administrators can send announcements:
|
|
\begin{verbatim}
|
|
{access, announce, [{allow, admins}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_adhoc, []},
|
|
{mod_announce, [{access, announce}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item Administrators as well as the direction can send announcements:
|
|
\begin{verbatim}
|
|
{acl, direction, {user, "big_boss", "example.org"}}.
|
|
{acl, direction, {user, "assistant", "example.org"}}.
|
|
{acl, admins, {user, "admin", "example.org"}}.
|
|
|
|
{access, announce, [{allow, admins},
|
|
{allow, direction}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_adhoc, []},
|
|
{mod_announce, [{access, announce}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
Note that \modannounce{} can be resource intensive on large
|
|
deployments as it can broadcast lot of messages. This module should be
|
|
disabled for instances of \ejabberd{} with hundreds of thousands users.
|
|
|
|
\makesubsection{moddisco}{\moddisco{}}
|
|
\ind{modules!\moddisco{}}
|
|
\ind{protocols!XEP-0030: Service Discovery}
|
|
\ind{protocols!XEP-0011: Jabber Browsing}
|
|
\ind{protocols!XEP-0094: Agent Information}
|
|
\ind{protocols!XEP-0157: Contact Addresses for XMPP Services}
|
|
|
|
This module adds support for Service Discovery (\xepref{0030}). With
|
|
this module enabled, services on your server can be discovered by
|
|
\Jabber{} clients. Note that \ejabberd{} has no modules with support
|
|
for the superseded Jabber Browsing (\xepref{0011}) and Agent Information
|
|
(\xepref{0094}). Accordingly, \Jabber{} clients need to have support for
|
|
the newer Service Discovery protocol if you want them be able to discover
|
|
the services you offer.
|
|
|
|
Options:
|
|
\begin{description}
|
|
\iqdiscitem{Service Discovery (\ns{http://jabber.org/protocol/disco\#items} and
|
|
\ns{http://jabber.org/protocol/disco\#info})}
|
|
\titem{\{extra\_domains, [Domain, ...]\}} \ind{options!extra\_domains}With this option,
|
|
you can specify a list of extra domains that are added to the Service Discovery item list.
|
|
\titem{\{server\_info, [ \{Modules, Field, [Value, ...]\}, ... ]\}} \ind{options!server\_info}
|
|
Specify additional information about the server,
|
|
as described in Contact Addresses for XMPP Services (\xepref{0157}).
|
|
\term{Modules} can be the keyword `all',
|
|
in which case the information is reported in all the services;
|
|
or a list of \ejabberd{} modules,
|
|
in which case the information is only specified for the services provided by those modules.
|
|
Any arbitrary \term{Field} and \term{Value} can be specified, not only contact addresses.
|
|
\end{description}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item To serve a link to the Jabber User Directory on \jid{jabber.org}:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_disco, [{extra_domains, ["users.jabber.org"]}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item To serve a link to the transports on another server:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_disco, [{extra_domains, ["icq.example.com",
|
|
"msn.example.com"]}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item To serve a link to a few friendly servers:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_disco, [{extra_domains, ["example.org",
|
|
"example.com"]}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item With this configuration, all services show abuse addresses,
|
|
feedback address on the main server,
|
|
and admin addresses for both the main server and the vJUD service:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_disco, [{server_info, [
|
|
{all,
|
|
"abuse-addresses",
|
|
["mailto:abuse@shakespeare.lit"]},
|
|
{[mod_muc],
|
|
"Web chatroom logs",
|
|
["http://www.example.org/muc-logs"]},
|
|
{[mod_disco],
|
|
"feedback-addresses",
|
|
["http://shakespeare.lit/feedback.php", "mailto:feedback@shakespeare.lit", "xmpp:feedback@shakespeare.lit"]},
|
|
{[mod_disco, mod_vcard],
|
|
"admin-addresses",
|
|
["mailto:xmpp@shakespeare.lit", "xmpp:admins@shakespeare.lit"]}
|
|
]}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modecho}{\modecho{}}
|
|
\ind{modules!\modecho{}}\ind{debugging}
|
|
|
|
This module simply echoes any \Jabber{}
|
|
packet back to the sender. This mirror can be of interest for
|
|
\ejabberd{} and \Jabber{} client debugging.
|
|
|
|
Options:
|
|
\begin{description}
|
|
\hostitem{echo}
|
|
\end{description}
|
|
|
|
Example: Mirror, mirror, on the wall, who is the most beautiful
|
|
of them all?
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_echo, [{host, "mirror.example.org"}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{modhttpbind}{\modhttpbind{}}
|
|
\ind{modules!\modhttpbind{}}\ind{modhttpbind}
|
|
|
|
This module implements XMPP over Bosh (formerly known as HTTP Binding)
|
|
as defined in \xepref{0124} and \xepref{0206}.
|
|
It extends ejabberd's built in HTTP service with a configurable
|
|
resource at which this service will be hosted.
|
|
|
|
To use HTTP-Binding, enable the module:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_http_bind, []},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
and add \verb|http_bind| in the HTTP service. For example:
|
|
\begin{verbatim}
|
|
{listen,
|
|
[
|
|
...
|
|
{5280, ejabberd_http, [
|
|
http_bind,
|
|
http_poll,
|
|
web_admin
|
|
]
|
|
},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
With this configuration, the module will serve the requests sent to
|
|
\verb|http://example.org:5280/http-bind/|
|
|
Remember that this page is not designed to be used by web browsers,
|
|
it is used by Jabber clients that support XMPP over Bosh.
|
|
|
|
If you want to set the service in a different URI path or use a different module,
|
|
you can configure it manually using the option \verb|request_handlers|.
|
|
For example:
|
|
\begin{verbatim}
|
|
{listen,
|
|
[
|
|
...
|
|
{5280, ejabberd_http, [
|
|
{request_handlers, [{["http-bind"], mod_http_bind}]},
|
|
http_poll,
|
|
web_admin
|
|
]
|
|
},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
Options:
|
|
\begin{description}
|
|
\titem{\{max\_inactivity, Seconds\}} \ind{options!max\_inactivity}
|
|
Define the maximum inactivity period in seconds.
|
|
Default value is 30 seconds.
|
|
For example, to set 50 seconds:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_http_bind, [ {max_inactivity, 50} ]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{description}
|
|
|
|
|
|
\makesubsection{modhttpfileserver}{\modhttpfileserver{}}
|
|
\ind{modules!\modhttpfileserver{}}\ind{modhttpfileserver}
|
|
|
|
This simple module serves files from the local disk over HTTP.
|
|
|
|
Options:
|
|
\begin{description}
|
|
\titem{\{docroot, Path\}} \ind{options!docroot}
|
|
Directory to serve the files.
|
|
\titem{\{accesslog, Path\}} \ind{options!accesslog}
|
|
File to log accesses using an Apache-like format.
|
|
No log will be recorded if this option is not specified.
|
|
\titem{\{directory\_indices, [Index, ...]\}} \ind{options!directoryindices}
|
|
Indicate one or more directory index files, similarly to Apache's
|
|
DirectoryIndex variable. When a web request hits a directory
|
|
instead of a regular file, those directory indices are looked in
|
|
order, and the first one found is returned.
|
|
%B \titem{content\_types} \ind{options!contenttypes}
|
|
%M \titem{\{content\_types, \{Extension, Type\} \}} \ind{options!contenttypes}
|
|
%B \titem{\{content\_types, [ Extension, Type, ... ]\}} \ind{options!contenttypes}
|
|
%B \titem{\{content\_types, [ {Extension, Type}, ... ]\}} \ind{options!contenttypes}
|
|
%M \titem{\{content\_types, [ \{Extension, Type\}, ... ]\}} \ind{options!contenttypes}
|
|
Specify a mapping of extensions to content types.
|
|
There are several content types already defined,
|
|
with this option you can add new definitions, modify or delete existing ones.
|
|
To delete an existing definition, simply define it with a value: `undefined'.
|
|
\titem{\{default\_content\_type, Type\}} \ind{options!defaultcontenttype}
|
|
Specify the content type to use for unknown extensions.
|
|
Default value is `application/octet-stream'.
|
|
\end{description}
|
|
|
|
This example configuration will serve the files from
|
|
the local directory \verb|/var/www|
|
|
in the address \verb|http://example.org:5280/pub/archive/|.
|
|
In this example a new content type \term{ogg} is defined,
|
|
\term{png} is redefined, and \term{jpg} definition is deleted.
|
|
To use this module you must enable it:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_http_fileserver, [
|
|
{docroot, "/var/www"},
|
|
{accesslog, "/var/log/ejabberd/access.log"},
|
|
{directory_indices, ["index.html", "main.htm"]},
|
|
{content_types, [{".ogg", "audio/ogg"},
|
|
{".png", "image/png"},
|
|
{".jpg", undefined}
|
|
]},
|
|
{default_content_type, "text/html"}
|
|
]
|
|
},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
And define it as a handler in the HTTP service:
|
|
\begin{verbatim}
|
|
{listen,
|
|
[
|
|
...
|
|
{5280, ejabberd_http, [
|
|
...
|
|
{request_handlers, [
|
|
...
|
|
{["pub", "archive"], mod_http_fileserver},
|
|
...
|
|
]
|
|
},
|
|
...
|
|
]
|
|
},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{modirc}{\modirc{}}
|
|
\ind{modules!\modirc{}}\ind{IRC}
|
|
|
|
This module is an IRC transport that can be used to join channels on IRC
|
|
servers.
|
|
|
|
End user information:
|
|
\ind{protocols!groupchat 1.0}\ind{protocols!XEP-0045: Multi-User Chat}
|
|
\begin{itemize}
|
|
\item A \Jabber{} client with `groupchat 1.0' support or Multi-User
|
|
Chat support (\xepref{0045}) is necessary to join IRC channels.
|
|
\item An IRC channel can be joined in nearly the same way as joining a
|
|
\Jabber{} Multi-User Chat room. The difference is that the room name will
|
|
be `channel\%\jid{irc.example.org}' in case \jid{irc.example.org} is
|
|
the IRC server hosting `channel'. And of course the host should point
|
|
to the IRC transport instead of the Multi-User Chat service.
|
|
\item You can register your nickame by sending `IDENTIFY password' to \\
|
|
\jid{nickserver!irc.example.org@irc.jabberserver.org}.
|
|
\item Entering your password is possible by sending `LOGIN nick password' \\
|
|
to \jid{nickserver!irc.example.org@irc.jabberserver.org}.
|
|
\item The IRC transport provides Ad-Hoc Commands (\xepref{0050})
|
|
to join a channel, and to set custom IRC username and encoding.
|
|
\item When using a popular \Jabber{} server, it can occur that no
|
|
connection can be achieved with some IRC servers because they limit the
|
|
number of conections from one IP.
|
|
\end{itemize}
|
|
|
|
Options:
|
|
\begin{description}
|
|
\hostitem{irc}
|
|
\titem{\{access, AccessName\}} \ind{options!access}This option can be used to specify who
|
|
may use the IRC transport (default value: \term{all}).
|
|
\titem{\{default\_encoding, Encoding\}} \ind{options!defaultencoding}Set the default IRC encoding.
|
|
Default value: \term{"koi8-r"}
|
|
\end{description}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item In the first example, the IRC transport is available on (all) your
|
|
virtual host(s) with the prefix `\jid{irc.}'. Furthermore, anyone is
|
|
able to use the transport. The default encoding is set to "iso8859-15".
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_irc, [{access, all}, {default_encoding, "iso8859-15"}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item In next example the IRC transport is available with JIDs with prefix \jid{irc-t.net}.
|
|
Moreover, the transport is only accessible to two users
|
|
of \term{example.org}, and any user of \term{example.com}:
|
|
\begin{verbatim}
|
|
{acl, paying_customers, {user, "customer1", "example.org"}}.
|
|
{acl, paying_customers, {user, "customer2", "example.org"}}.
|
|
{acl, paying_customers, {server, "example.com"}}.
|
|
|
|
{access, irc_users, [{allow, paying_customers}, {deny, all}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_irc, [{access, irc_users},
|
|
{host, "irc.example.net"}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modlast}{\modlast{}}
|
|
\ind{modules!\modlast{}}\ind{protocols!XEP-0012: Last Activity}
|
|
|
|
This module adds support for Last Activity (\xepref{0012}). It can be used to
|
|
discover when a disconnected user last accessed the server, to know when a
|
|
connected user was last active on the server, or to query the uptime of the
|
|
\ejabberd{} server.
|
|
|
|
Options:
|
|
\begin{description}
|
|
\iqdiscitem{Last activity (\ns{jabber:iq:last})}
|
|
\end{description}
|
|
|
|
\makesubsection{modmuc}{\modmuc{}}
|
|
\ind{modules!\modmuc{}}\ind{protocols!XEP-0045: Multi-User Chat}\ind{conferencing}
|
|
|
|
This module provides a Multi-User Chat (\xepref{0045}) service.
|
|
Users can discover existing rooms, join or create them.
|
|
Occupants of a room can chat in public or have private chats.
|
|
|
|
Some of the features of Multi-User Chat:
|
|
\begin{itemize}
|
|
\item Sending public and private messages to room occupants.
|
|
\item Inviting other users to a room.
|
|
\item Setting a room subject.
|
|
\item Creating password protected rooms.
|
|
\item Kicking and banning occupants.
|
|
\end{itemize}
|
|
|
|
The MUC service allows any Jabber ID to register a nickname,
|
|
so nobody else can use that nickname in any room in the MUC service.
|
|
To register a nickname, open the Service Discovery in your
|
|
Jabber client and register in the MUC service.
|
|
|
|
This module supports clustering and load
|
|
balancing. One module can be started per cluster node. Rooms are
|
|
distributed at creation time on all available MUC module
|
|
instances. The multi-user chat module is clustered but the rooms
|
|
themselves are not clustered nor fault-tolerant: if the node managing a
|
|
set of rooms goes down, the rooms disappear and they will be recreated
|
|
on an available node on first connection attempt.
|
|
|
|
Module options:
|
|
\begin{description}
|
|
\hostitem{conference}
|
|
\titem{\{access, AccessName\}} \ind{options!access}You can specify who is allowed to use
|
|
the Multi-User Chat service. By default everyone is allowed to use it.
|
|
\titem{\{access\_create, AccessName\}} \ind{options!access\_create}To configure who is
|
|
allowed to create new rooms at the Multi-User Chat service, this option
|
|
can be used. By default everybody is allowed to create rooms.
|
|
\titem{\{access\_persistent, AccessName\}} \ind{options!access\_persistent}To configure who is
|
|
allowed to modify the 'persistent' room option.
|
|
By default everybody is allowed to modify that option.
|
|
\titem{\{access\_admin, AccessName\}} \ind{options!access\_admin}This option specifies
|
|
who is allowed to administrate the Multi-User Chat service. The default
|
|
value is \term{none}, which means that only the room creator can
|
|
administer his room.
|
|
The administrators can send a normal message to the service JID,
|
|
and it will be shown in all active rooms as a service message.
|
|
The administrators can send a groupchat message to the JID of an active room,
|
|
and the message will be shown in the room as a service message.
|
|
\titem{\{history\_size, Size\}} \ind{options!history\_size}A small history of
|
|
the current discussion is sent to users when they enter the
|
|
room. With this option you can define the number of history messages
|
|
to keep and send to users joining the room. The value is an
|
|
integer. Setting the value to \term{0} disables the history feature
|
|
and, as a result, nothing is kept in memory. The default value is
|
|
\term{20}. This value is global and thus affects all rooms on the
|
|
service.
|
|
\titem{\{max\_users, Number\}} \ind{options!max\_users} This option defines at
|
|
the service level, the maximum number of users allowed per
|
|
room. It can be lowered in each room configuration but cannot be
|
|
increased in individual room configuration. The default value is
|
|
200.
|
|
\titem{\{max\_users\_admin\_threshold, Number\}}
|
|
\ind{options!max\_users\_admin\_threshold} This option defines the
|
|
number of service admins or room owners allowed to enter the room when
|
|
the maximum number of allowed occupants was reached. The default limit
|
|
is 5.
|
|
\titem{\{max\_user\_conferences, Number\}}
|
|
\ind{options!max\_user\_conferences} This option defines the maximum
|
|
number of rooms that any given user can join. The default value
|
|
is 10. This option is used to prevent possible abuses. Note that
|
|
this is a soft limit: some users can sometimes join more conferences
|
|
in cluster configurations.
|
|
\titem{\{max\_room\_id, Number\}} \ind{options!max\_room\_id}
|
|
This option defines the maximum number of characters that Room ID
|
|
can have when creating a new room.
|
|
The default value is to not limit: infinite.
|
|
\titem{\{max\_room\_name, Number\}} \ind{options!max\_room\_name}
|
|
This option defines the maximum number of characters that Room Name
|
|
can have when configuring the room.
|
|
The default value is to not limit: infinite.
|
|
\titem{\{max\_room\_desc, Number\}} \ind{options!max\_room\_desc}
|
|
This option defines the maximum number of characters that Room Description
|
|
can have when configuring the room.
|
|
The default value is to not limit: infinite.
|
|
\titem{\{min\_message\_interval, Number\}} \ind{options!min\_message\_interval}
|
|
This option defines the minimum interval between two messages send
|
|
by an occupant in seconds. This option is global and valid for all
|
|
rooms. A decimal value can be used. When this option is not defined,
|
|
message rate is not limited. This feature can be used to protect a
|
|
MUC service from occupant abuses and limit number of messages that will
|
|
be broadcasted by the service. A good value for this minimum message
|
|
interval is 0.4 second. If an occupant tries to send messages faster, an
|
|
error is send back explaining that the message has been discarded
|
|
and describing the reason why the message is not acceptable.
|
|
\titem{\{min\_presence\_interval, Number\}}
|
|
\ind{options!min\_presence\_interval} This option defines the
|
|
minimum of time between presence changes coming from a given occupant in
|
|
seconds. This option is global and valid for all rooms. A
|
|
decimal value can be used. When this option is not defined, no
|
|
restriction is applied. This option can be used to protect a MUC
|
|
service for occupants abuses. If an occupant tries
|
|
to change its presence more often than the specified interval, the
|
|
presence is cached by \ejabberd{} and only the last presence is
|
|
broadcasted to all occupants in the room after expiration of the
|
|
interval delay. Intermediate presence packets are silently
|
|
discarded. A good value for this option is 4 seconds.
|
|
\titem{\{default\_room\_options, [ \{OptionName, OptionValue\}, ...]\}} \ind{options!default\_room\_options}
|
|
This module option allows to define the desired default room options.
|
|
Note that the creator of a room can modify the options of his room
|
|
at any time using a Jabber client with MUC capability.
|
|
The available room options and the default values are:
|
|
\begin{description}
|
|
\titem{\{allow\_change\_subj, true|false\}} Allow occupants to change the subject.
|
|
\titem{\{allow\_private\_messages, true|false\}} Occupants can send private messages to other occupants.
|
|
\titem{\{allow\_query\_users, true|false\}} Occupants can send IQ queries to other occupants.
|
|
\titem{\{allow\_user\_invites, false|true\}} Allow occupants to send invitations.
|
|
\titem{\{allow\_visitor\_nickchange, true|false\}} Allow visitors to
|
|
change nickname.
|
|
\titem{\{allow\_visitor\_status, true|false\}} Allow visitors to send
|
|
status text in presence updates. If disallowed, the \term{status}
|
|
text is stripped before broadcasting the presence update to all
|
|
the room occupants.
|
|
\titem{\{anonymous, true|false\}} The room is anonymous:
|
|
occupants don't see the real JIDs of other occupants.
|
|
Note that the room moderators can always see the real JIDs of the occupants.
|
|
\titem{\{logging, false|true\}} The public messages are logged using \term{mod\_muc\_log}.
|
|
\titem{\{max\_users, 200\}} Maximum number of occupants in the room.
|
|
\titem{\{members\_by\_default, true|false\}} The occupants that enter the room are participants by default, so they have 'voice'.
|
|
\titem{\{members\_only, false|true\}} Only members of the room can enter.
|
|
\titem{\{moderated, true|false\}} Only occupants with 'voice' can send public messages.
|
|
\titem{\{password, "roompass123"\}} Password of the room. You may want to enable the next option too.
|
|
\titem{\{password\_protected, false|true\}} The password is required to enter the room.
|
|
\titem{\{persistent, false|true\}} The room persists even if the last participant leaves.
|
|
\titem{\{public, true|false\}} The room is public in the list of the MUC service, so it can be discovered.
|
|
\titem{\{public\_list, true|false\}} The list of participants is public, without requiring to enter the room.
|
|
\titem{\{title, "Room Title"\}} A human-readable title of the room.
|
|
\end{description}
|
|
All of those room options can be set to \term{true} or \term{false},
|
|
except \term{password} and \term{title} which are strings,
|
|
and \term{max\_users} that is integer.
|
|
\end{description}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item In the first example everyone is allowed to use the Multi-User Chat
|
|
service. Everyone will also be able to create new rooms but only the user
|
|
\jid{admin@example.org} is allowed to administrate any room. In this
|
|
example he is also a global administrator. When \jid{admin@example.org}
|
|
sends a message such as `Tomorrow, the \Jabber{} server will be moved
|
|
to new hardware. This will involve service breakdowns around 23:00 UMT.
|
|
We apologise for this inconvenience.' to \jid{conference.example.org},
|
|
it will be displayed in all active rooms. In this example the history
|
|
feature is disabled.
|
|
\begin{verbatim}
|
|
{acl, admin, {user, "admin", "example.org"}}.
|
|
|
|
{access, muc_admin, [{allow, admin}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_muc, [{access, all},
|
|
{access_create, all},
|
|
{access_admin, muc_admin},
|
|
{history_size, 0}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item In the second example the Multi-User Chat service is only accessible by
|
|
paying customers registered on our domains and on other servers. Of course
|
|
the administrator is also allowed to access rooms. In addition, he is the
|
|
only authority able to create and administer rooms. When
|
|
\jid{admin@example.org} sends a message such as `Tomorrow, the \Jabber{}
|
|
server will be moved to new hardware. This will involve service breakdowns
|
|
around 23:00 UMT. We apologise for this inconvenience.' to
|
|
\jid{conference.example.org}, it will be displayed in all active rooms. No
|
|
\term{history\_size} option is used, this means that the feature is enabled
|
|
and the default value of 20 history messages will be send to the users.
|
|
\begin{verbatim}
|
|
{acl, paying_customers, {user, "customer1", "example.net"}}.
|
|
{acl, paying_customers, {user, "customer2", "example.com"}}.
|
|
{acl, paying_customers, {user, "customer3", "example.org"}}.
|
|
{acl, admin, {user, "admin", "example.org"}}.
|
|
|
|
{access, muc_admin, [{allow, admin},
|
|
{deny, all}]}.
|
|
{access, muc_access, [{allow, paying_customers},
|
|
{allow, admin},
|
|
{deny, all}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_muc, [{access, muc_access},
|
|
{access_create, muc_admin},
|
|
{access_admin, muc_admin}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\item In the following example, MUC anti abuse options are used. An
|
|
occupant cannot send more than one message every 0.4 seconds and cannot
|
|
change its presence more than once every 4 seconds.
|
|
The length of Room IDs and Room Names are limited to 20 characters,
|
|
and Room Description to 300 characters. No ACLs are
|
|
defined, but some user restriction could be added as well:
|
|
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_muc, [{min_message_interval, 0.4},
|
|
{min_presence_interval, 4},
|
|
{max_room_id, 20},
|
|
{max_room_name, 20},
|
|
{max_room_desc, 300}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\item This example shows how to use \option{default\_room\_options} to make sure
|
|
the newly created rooms have by default those options.
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_muc, [{access, muc_access},
|
|
{access_create, muc_admin},
|
|
{default_room_options,
|
|
[
|
|
{allow_change_subj, false},
|
|
{allow_query_users, true},
|
|
{allow_private_messages, true},
|
|
{members_by_default, false},
|
|
{title, "New chatroom"},
|
|
{anonymous, false}
|
|
]},
|
|
{access_admin, muc_admin}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modmuclog}{\modmuclog{}}
|
|
\ind{modules!\modmuclog{}}
|
|
|
|
This module enables optional logging of Multi-User Chat (MUC) public conversations to
|
|
HTML. Once you enable this module, users can join a room using a MUC capable
|
|
Jabber client, and if they have enough privileges, they can request the
|
|
configuration form in which they can set the option to enable room logging.
|
|
|
|
Features:
|
|
\begin{itemize}
|
|
\item Room details are added on top of each page: room title, JID,
|
|
author, subject and configuration.
|
|
\item \ind{protocols!RFC 5122: Internationalized Resource Identifiers (IRIs) and Uniform Resource Identifiers (URIs) for the Extensible Messaging and Presence Protocol (XMPP)}
|
|
The room JID in the generated HTML is a link to join the room (using
|
|
\footahref{http://xmpp.org/rfcs/rfc5122.html}{XMPP URI}).
|
|
\item Subject and room configuration changes are tracked and displayed.
|
|
\item Joins, leaves, nick changes, kicks, bans and `/me' are tracked and
|
|
displayed, including the reason if available.
|
|
\item Generated HTML files are XHTML 1.0 Transitional and CSS compliant.
|
|
\item Timestamps are self-referencing links.
|
|
\item Links on top for quicker navigation: Previous day, Next day, Up.
|
|
\item CSS is used for style definition, and a custom CSS file can be used.
|
|
\item URLs on messages and subjects are converted to hyperlinks.
|
|
\item Timezone used on timestamps is shown on the log files.
|
|
\item A custom link can be added on top of each page.
|
|
\end{itemize}
|
|
|
|
Options:
|
|
\begin{description}
|
|
\titem{\{access\_log, AccessName\}}\ind{options!access\_log}
|
|
This option restricts which occupants are allowed to enable or disable room
|
|
logging. The default value is \term{muc\_admin}. Note for this default setting
|
|
you need to have an access rule for \term{muc\_admin} in order to take effect.
|
|
\titem{\{cssfile, false|URL\}}\ind{options!cssfile}
|
|
With this option you can set whether the HTML files should have a custom CSS
|
|
file or if they need to use the embedded CSS file. Allowed values are
|
|
\term{false} and an URL to a CSS file. With the first value, HTML files will
|
|
include the embedded CSS code. With the latter, you can specify the URL of the
|
|
custom CSS file (for example: \term{"http://example.com/my.css"}). The default value
|
|
is \term{false}.
|
|
\titem{\{dirname, room\_jid|room\_name\}}\ind{options!dirname}
|
|
Allows to configure the name of the room directory.
|
|
Allowed values are \term{room\_jid} and \term{room\_name}.
|
|
With the first value, the room directory name will be the full room JID.
|
|
With the latter, the room directory name will be only the room name,
|
|
not including the MUC service name.
|
|
The default value is \term{room\_jid}.
|
|
\titem{\{dirtype, subdirs|plain\}}\ind{options!dirtype}
|
|
The type of the created directories can be specified with this option. Allowed
|
|
values are \term{subdirs} and \term{plain}. With the first value,
|
|
subdirectories are created for each year and month. With the latter, the
|
|
names of the log files contain the full date, and there are no subdirectories.
|
|
The default value is \term{subdirs}.
|
|
\titem{\{file\_format, html|plaintext\}}\ind{options!file\_format}
|
|
Define the format of the log files:
|
|
\term{html} stores in HTML format,
|
|
\term{plaintext} stores in plain text.
|
|
The default value is \term{html}.
|
|
\titem{\{outdir, Path\}}\ind{options!outdir}
|
|
This option sets the full path to the directory in which the HTML files should
|
|
be stored. Make sure the \ejabberd{} daemon user has write access on that
|
|
directory. The default value is \term{"www/muc"}.
|
|
\titem{\{spam\_prevention true|false\}}\ind{options!spam\_prevention}
|
|
To prevent spam, the \term{spam\_prevention} option adds a special attribute
|
|
to links that prevent their indexation by search engines. The default value
|
|
is \term{true}, which mean that nofollow attributes will be added to user
|
|
submitted links.
|
|
\titem{\{timezone, local|universal\}}\ind{options!timezone}
|
|
The time zone for the logs is configurable with this option. Allowed values
|
|
are \term{local} and \term{universal}. With the first value, the local time,
|
|
as reported to Erlang by the operating system, will be used. With the latter,
|
|
GMT/UTC time will be used. The default value is \term{local}.
|
|
\titem{\{top\_link, \{URL, Text\}\}}\ind{options!top\_link}
|
|
With this option you can customize the link on the top right corner of each
|
|
log file. The default value is \term{\{"/", "Home"\}}.
|
|
\end{description}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item In the first example any room owner can enable logging, and a
|
|
custom CSS file will be used (http://example.com/my.css). The names
|
|
of the log files will contain the full date, and there will be no
|
|
subdirectories. The log files will be stored in /var/www/muclogs, and the
|
|
time zone will be GMT/UTC. Finally, the top link will be
|
|
\verb|<a href="http://www.jabber.ru/">Jabber.ru</a>|.
|
|
\begin{verbatim}
|
|
{access, muc, [{allow, all}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_muc_log, [
|
|
{access_log, muc},
|
|
{cssfile, "http://example.com/my.css"},
|
|
{dirtype, plain},
|
|
{dirname, room_jid},
|
|
{outdir, "/var/www/muclogs"},
|
|
{timezone, universal},
|
|
{spam_prevention, true},
|
|
{top_link, {"http://www.jabber.ru/", "Jabber.ru"}}
|
|
]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item In the second example only \jid{admin1@example.org} and
|
|
\jid{admin2@example.net} can enable logging, and the embedded CSS file will be
|
|
used. The names of the log files will only contain the day (number),
|
|
and there will be subdirectories for each year and month. The log files will
|
|
be stored in /var/www/muclogs, and the local time will be used. Finally, the
|
|
top link will be the default \verb|<a href="/">Home</a>|.
|
|
\begin{verbatim}
|
|
{acl, admins, {user, "admin1", "example.org"}}.
|
|
{acl, admins, {user, "admin2", "example.net"}}.
|
|
|
|
{access, muc_log, [{allow, admins},
|
|
{deny, all}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_muc_log, [
|
|
{access_log, muc_log},
|
|
{cssfile, false},
|
|
{dirtype, subdirs},
|
|
{outdir, "/var/www/muclogs"},
|
|
{timezone, local}
|
|
]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modoffline}{\modoffline{}}
|
|
\ind{modules!\modoffline{}}
|
|
|
|
This module implements offline message storage (\xepref{0160}).
|
|
This means that all messages
|
|
sent to an offline user will be stored on the server until that user comes
|
|
online again. Thus it is very similar to how email works. Note that
|
|
\term{ejabberdctl}\ind{ejabberdctl} has a command to delete expired messages
|
|
(see section~\ref{ejabberdctl}).
|
|
|
|
\begin{description}
|
|
\titem{\{access\_max\_user\_messages, Number\}}\ind{options!access\_max\_user\_messages}
|
|
This option defines which access rule will be enforced to limit
|
|
the maximum number of offline messages that a user can have (quota).
|
|
When a user has too many offline messages, any new messages that he receive are discarded,
|
|
and a resource-constraint error is returned to the sender.
|
|
The default value is \term{max\_user\_offline\_messages}.
|
|
Then you can define an access rule with a syntax similar to
|
|
\term{max\_user\_sessions} (see \ref{configmaxsessions}).
|
|
\end{description}
|
|
|
|
This example allows power users to have as much as 5000 offline messages,
|
|
administrators up to 2000,
|
|
and all the other users up to 100.
|
|
\begin{verbatim}
|
|
{acl, admin, {user, "admin1", "localhost"}}.
|
|
{acl, admin, {user, "admin2", "example.org"}}.
|
|
{acl, poweruser, {user, "bob", "example.org"}}.
|
|
{acl, poweruser, {user, "jane", "example.org"}}.
|
|
|
|
{access, max_user_offline_messages, [ {5000, poweruser}, {2000, admin}, {100, all} ]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_offline, [ {access_max_user_messages, max_user_offline_messages} ]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{modping}{\modping{}}
|
|
\ind{modules!\modping{}}
|
|
|
|
This module implements support for XMPP Ping (\xepref{0199}) and periodic keepalives.
|
|
When this module is enabled ejabberd responds correctly to
|
|
ping requests, as defined in the protocol.
|
|
|
|
Configuration options:
|
|
\begin{description}
|
|
\titem{\{send\_pings, true|false\}}\ind{options!send\_pings}
|
|
If this option is set to \term{true}, the server sends pings to connected clients
|
|
that are not active in a given interval \term{ping\_interval}.
|
|
This is useful to keep client connections alive or checking availability.
|
|
By default this option is disabled.
|
|
% because it is mostly not needed and consumes resources.
|
|
\titem{\{ping\_interval, Seconds\}}\ind{options!ping\_interval}
|
|
How often to send pings to connected clients, if the previous option is enabled.
|
|
If a client connection does not send or receive any stanza in this interval,
|
|
a ping request is sent to the client.
|
|
The default value is 60 seconds.
|
|
\titem{\{timeout\_action, none|kill\}}\ind{options!timeout\_action}
|
|
What to do when a client does not answer to a server ping request in less than 32 seconds.
|
|
% Those 32 seconds are defined in ejabberd_local.erl: -define(IQ_TIMEOUT, 32000).
|
|
The default is to do nothing.
|
|
\end{description}
|
|
|
|
This example enables Ping responses, configures the module to send pings
|
|
to client connections that are inactive for 4 minutes,
|
|
and if a client does not answer to the ping in less than 32 seconds, its connection is closed:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_ping, [{send_pings, true}, {ping_interval, 240}, {timeout_action, kill}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{modprivacy}{\modprivacy{}}
|
|
\ind{modules!\modprivacy{}}\ind{Blocking Communication}\ind{Privacy Rules}\ind{protocols!RFC 3921: XMPP IM}
|
|
|
|
This module implements Blocking Communication (also known as Privacy Rules)
|
|
as defined in section 10 from XMPP IM. If end users have support for it in
|
|
their \Jabber{} client, they will be able to:
|
|
\begin{quote}
|
|
\begin{itemize}
|
|
\item Retrieving one's privacy lists.
|
|
\item Adding, removing, and editing one's privacy lists.
|
|
\item Setting, changing, or declining active lists.
|
|
\item Setting, changing, or declining the default list (i.e., the list that
|
|
is active by default).
|
|
\item Allowing or blocking messages based on JID, group, or subscription type
|
|
(or globally).
|
|
\item Allowing or blocking inbound presence notifications based on JID, group,
|
|
or subscription type (or globally).
|
|
\item Allowing or blocking outbound presence notifications based on JID, group,
|
|
or subscription type (or globally).
|
|
\item Allowing or blocking IQ stanzas based on JID, group, or subscription type
|
|
(or globally).
|
|
\item Allowing or blocking all communications based on JID, group, or
|
|
subscription type (or globally).
|
|
\end{itemize}
|
|
(from \ahrefurl{http://xmpp.org/specs/rfc3921.html\#privacy})
|
|
\end{quote}
|
|
|
|
Options:
|
|
\begin{description}
|
|
\iqdiscitem{Blocking Communication (\ns{jabber:iq:privacy})}
|
|
\end{description}
|
|
|
|
\makesubsection{modprivate}{\modprivate{}}
|
|
\ind{modules!\modprivate{}}\ind{protocols!XEP-0049: Private XML Storage}\ind{protocols!XEP-0048: Bookmark Storage}
|
|
|
|
This module adds support for Private XML Storage (\xepref{0049}):
|
|
\begin{quote}
|
|
Using this method, Jabber entities can store private data on the server and
|
|
retrieve it whenever necessary. The data stored might be anything, as long as
|
|
it is valid XML. One typical usage for this namespace is the server-side storage
|
|
of client-specific preferences; another is Bookmark Storage (\xepref{0048}).
|
|
\end{quote}
|
|
|
|
Options:
|
|
\begin{description}
|
|
\iqdiscitem{Private XML Storage (\ns{jabber:iq:private})}
|
|
\end{description}
|
|
|
|
\makesubsection{modproxy}{\modproxy{}}
|
|
\ind{modules!\modversion{}}\ind{protocols!XEP-0065: SOCKS5 Bytestreams}
|
|
|
|
This module implements SOCKS5 Bytestreams (\xepref{0065}).
|
|
It allows \ejabberd{} to act as a file transfer proxy between two
|
|
XMPP clients.
|
|
|
|
Options:
|
|
\begin{description}
|
|
\hostitem{proxy}
|
|
\titem{\{name, Text\}}\ind{options!name}Defines Service Discovery name of the service.
|
|
Default is \term{"SOCKS5 Bytestreams"}.
|
|
\titem{\{ip, IPTuple\}}\ind{options!ip}This option specifies which network interface
|
|
to listen for. Default is an IP address of the service's DNS name, or,
|
|
if fails, \verb|{127,0,0,1}|.
|
|
\titem{\{port, Number\}}\ind{options!port}This option defines port to listen for
|
|
incoming connections. Default is~7777.
|
|
\titem{\{auth\_type, anonymous|plain\}}\ind{options!auth\_type}SOCKS5 authentication type.
|
|
Possible values are \term{anonymous} and \term{plain}. Default is
|
|
\term{anonymous}.
|
|
\titem{\{access, AccessName\}}\ind{options!access}Defines ACL for file transfer initiators.
|
|
Default is \term{all}.
|
|
\titem{\{max\_connections, Number\}}\ind{options!max\_connections}Maximum number of
|
|
active connections per file transfer initiator. No limit by default.
|
|
\titem{\{shaper, none|ShaperName\}}\ind{options!shaper}This option defines shaper for
|
|
the file transfer peers. Shaper with the maximum bandwidth will be selected.
|
|
Default is \term{none}.
|
|
\end{description}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item The simpliest configuration of the module:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_proxy65, []},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item More complicated configuration.
|
|
\begin{verbatim}
|
|
{acl, proxy_users, {server, "example.org"}}.
|
|
{access, proxy65_access, [{allow, proxy_users}, {deny, all}]}.
|
|
|
|
{acl, admin, {user, "admin", "example.org"}}.
|
|
{shaper, proxyrate, {maxrate, 10240}}. %% 10 Kbytes/sec
|
|
{access, proxy65_shaper, [{none, admin}, {proxyrate, proxy_users}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_proxy65, [{host, "proxy1.example.org"},
|
|
{name, "File Transfer Proxy"},
|
|
{ip, {200,150,100,1}},
|
|
{port, 7778},
|
|
{max_connections, 5},
|
|
{access, proxy65_access},
|
|
{shaper, proxy65_shaper}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modpubsub}{\modpubsub{}}
|
|
\ind{modules!\modpubsub{}}\ind{protocols!XEP-0060: Publish-Subscribe}
|
|
|
|
This module offers a Publish-Subscribe Service (\xepref{0060}).
|
|
The functionality in \modpubsub{} can be extended using plugins.
|
|
The plugin that implements PEP (Personal Eventing via Pubsub) (\xepref{0163})
|
|
is enabled in the default ejabberd configuration file,
|
|
and it requires \modcaps{}.
|
|
|
|
Options:
|
|
\begin{description}
|
|
\hostitem{pubsub}
|
|
\titem{\{access\_createnode, AccessName\}} \ind{options!access\_createnode}
|
|
This option restricts which users are allowed to create pubsub nodes using
|
|
ACL and ACCESS. The default value is \term{pubsub\_createnode}. % Not clear enough + do not use abbreviations.
|
|
\titem{\{plugins, [ Plugin, ...]\}} \ind{options!plugins}
|
|
To specify which pubsub node plugins to use.
|
|
The first one in the list is used by default.
|
|
If this option is not defined, the default plugins list is: \term{["flat"]}.
|
|
PubSub clients can define which plugin to use when creating a node:
|
|
add \term{type='plugin-name'} attribute to the \term{create} stanza element.
|
|
\titem{\{nodetree, Nodetree\}} \ind{options!nodetree}
|
|
To specify which nodetree to use.
|
|
If not defined, the default pubsub nodetree is used: "tree".
|
|
Only one nodetree can be used per host, and is shared by all node plugins.
|
|
|
|
The "virtual" nodetree does not store nodes on database.
|
|
This saves resources on systems with tons of nodes.
|
|
If using the "virtual" nodetree,
|
|
you can only enable those node plugins:
|
|
["flat","pep"] or ["flat"];
|
|
any other plugins configuration will not work.
|
|
Also, all nodes will have the defaut configuration,
|
|
and this can not be changed.
|
|
Using "virtual" nodetree requires to start from a clean database,
|
|
it will not work if you used the default "tree" nodetree before.
|
|
|
|
The "dag" nodetree provides experimental support for PubSub Collection Nodes (\xepref{0248}).
|
|
In that case you should also add "dag" node plugin as default, for example:
|
|
\term{\{plugins, ["dag","flat","hometree","pep"]\}}
|
|
\titem{\{pep\_sendlast\_offline, false|true\}} \ind{options!pep\_sendlast\_offline}
|
|
To specify whether or not we should get last published PEP items
|
|
from users in our roster which are offline when we connect. Value is true or false.
|
|
If not defined, pubsub assumes false so we only get last items of online contacts.
|
|
\titem{\{last\_item\_cache, false|true\}} \ind{options!last\_item\_cache}
|
|
To specify whether or not pubsub should cache last items. Value is true
|
|
or false. If not defined, pubsub do not cache last items. On systems with not so many nodes,
|
|
caching last items speeds up pubsub and allows to raise user connection rate. The cost is memory
|
|
usage, as every item is stored in memory.
|
|
\titem{\{pep\_mapping, [ \{Key, Value\}, ...]\}} \ind{pep\_mapping}
|
|
This allow to define a Key-Value list to choose defined node plugins on given PEP namespace.
|
|
The following example will use node\_tune instead of node\_pep for every PEP node with tune namespace:
|
|
\begin{verbatim}
|
|
{mod_pubsub, [{pep_mapping, [{"http://jabber.org/protocol/tune", "tune"}]}]}
|
|
\end{verbatim}
|
|
%\titem{served\_hosts} \ind{options!served\_hosts}
|
|
% This option allows to create additional pubsub virtual hosts in a single module instance.
|
|
\end{description}
|
|
|
|
Example of configuration that uses flat nodes as default, and allows use of flat, nodetree and pep nodes:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_pubsub, [
|
|
{access_createnode, pubsub_createnode},
|
|
{plugins, ["flat", "hometree", "pep"]}
|
|
]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
Using ODBC database requires use of dedicated plugins. The following example shows previous configuration
|
|
with ODBC usage:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_pubsub_odbc, [
|
|
{access_createnode, pubsub_createnode},
|
|
{plugins, ["flat_odbc", "hometree_odbc", "pep_odbc"]}
|
|
]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{modregister}{\modregister{}}
|
|
\ind{modules!\modregister{}}\ind{protocols!XEP-0077: In-Band Registration}\ind{public registration}
|
|
|
|
This module adds support for In-Band Registration (\xepref{0077}). This protocol
|
|
enables end users to use a \Jabber{} client to:
|
|
\begin{itemize}
|
|
\item Register a new account on the server.
|
|
\item Change the password from an existing account on the server.
|
|
\item Delete an existing account on the server.
|
|
\end{itemize}
|
|
|
|
|
|
Options:
|
|
\begin{description}
|
|
\titem{\{access, AccessName\}} \ind{options!access}This option can be configured to specify
|
|
rules to restrict registration. If a rule returns `deny' on the requested
|
|
user name, registration for that user name is denied. (there are no
|
|
restrictions by default).
|
|
\titem{\{welcome\_message, Message\}} \ind{options!welcomem}Set a welcome message that
|
|
is sent to each newly registered account. The first string is the subject, and
|
|
the second string is the message body.
|
|
In the body you can set a newline with the characters: \verb|\n|
|
|
\titem{\{registration\_watchers, [ JID, ...]\}} \ind{options!rwatchers}This option defines a
|
|
list of JIDs which will be notified each time a new account is registered.
|
|
\iqdiscitem{In-Band Registration (\ns{jabber:iq:register})}
|
|
\end{description}
|
|
|
|
This module reads also another option defined globally for the server:
|
|
\term{\{registration\_timeout, Timeout\}}. \ind{options!registratimeout}
|
|
This option limits the frequency of registration from a given IP or username.
|
|
So, a user can't register a new account from the same IP address or JID during
|
|
this number of seconds after previous registration.
|
|
Timeout is expressed in seconds, and must be an integer.
|
|
To disable this limitation,
|
|
instead of an integer put a word like: \term{infinity}.
|
|
Default value: 600 seconds.
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item Next example prohibits the registration of too short account names:
|
|
\begin{verbatim}
|
|
{acl, shortname, {user_glob, "?"}}.
|
|
{acl, shortname, {user_glob, "??"}}.
|
|
%% The same using regexp:
|
|
%%{acl, shortname, {user_regexp, "^..?$"}}.
|
|
|
|
{access, register, [{deny, shortname},
|
|
{allow, all}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_register, [{access, register}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item This configuration prohibits usage of In-Band Registration
|
|
to create or delete accounts,
|
|
but allows existing accounts to change the password:
|
|
\begin{verbatim}
|
|
{access, register, [{deny, all}]}.
|
|
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_register, [{access, register}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item
|
|
This configuration disables all In-Band Registration
|
|
functionality: create, delete accounts and change password:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
%% {mod_register, [{access, register}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item Define the welcome message and two registration watchers.
|
|
Also define a registration timeout of one hour:
|
|
\begin{verbatim}
|
|
{registration_timeout, 3600}.
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_register,
|
|
[
|
|
{welcome_message, {"Welcome!", "Hi.\nWelcome to this Jabber server.\n Check http://www.jabber.org\n\nBye"}},
|
|
{registration_watchers, ["admin1@example.org", "boss@example.net"]}
|
|
]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modroster}{\modroster{}}
|
|
\ind{modules!\modroster{}}\ind{roster management}\ind{protocols!RFC 3921: XMPP IM}
|
|
|
|
This module implements roster management as defined in
|
|
\footahref{http://xmpp.org/specs/rfc3921.html\#roster}{RFC 3921: XMPP IM}.
|
|
It also supports Roster Versioning (\xepref{0237}).
|
|
|
|
Options:
|
|
\begin{description}
|
|
\iqdiscitem{Roster Management (\ns{jabber:iq:roster})}
|
|
\titem{\{versioning, false|true\}} \ind{options!versioning}Enables
|
|
Roster Versioning.
|
|
This option is disabled by default.
|
|
\titem{\{store\_current\_id, false|true\}} \ind{options!storecurrentid}
|
|
If this option is enabled, the current version number is stored on the database.
|
|
If disabled, the version number is calculated on the fly each time.
|
|
Enabling this option reduces the load for both ejabberd and the database.
|
|
This option does not affect the client in any way.
|
|
This option is only useful if Roster Versioning is enabled.
|
|
This option is disabled by default.
|
|
Important: if you use \modsharedroster, you must disable this option.
|
|
\end{description}
|
|
|
|
This example configuration enables Roster Versioning with storage of current id:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_roster, [{versioning, true}, {store_current_id, true}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
|
|
\makesubsection{modservicelog}{\modservicelog{}}
|
|
\ind{modules!\modservicelog{}}\ind{message auditing}\ind{Bandersnatch}
|
|
|
|
This module adds support for logging end user packets via a \Jabber{} message
|
|
auditing service such as
|
|
\footahref{http://www.funkypenguin.info/project/bandersnatch/}{Bandersnatch}. All user
|
|
packets are encapsulated in a \verb|<route/>| element and sent to the specified
|
|
service(s).
|
|
|
|
Options:
|
|
\begin{description}
|
|
\titem{\{loggers, [Names, ...]\}} \ind{options!loggers}With this option a (list of) service(s)
|
|
that will receive the packets can be specified.
|
|
\end{description}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item To log all end user packets to the Bandersnatch service running on
|
|
\jid{bandersnatch.example.com}:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_service_log, [{loggers, ["bandersnatch.example.com"]}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item To log all end user packets to the Bandersnatch service running on
|
|
\jid{bandersnatch.example.com} and the backup service on
|
|
\jid{bandersnatch.example.org}:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_service_log, [{loggers, ["bandersnatch.example.com",
|
|
"bandersnatch.example.org"]}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modsharedroster}{\modsharedroster{}}
|
|
\ind{modules!\modsharedroster{}}\ind{shared roster groups}
|
|
|
|
This module enables you to create shared roster groups. This means that you can
|
|
create groups of people that can see members from (other) groups in their
|
|
rosters. The big advantages of this feature are that end users do not need to
|
|
manually add all users to their rosters, and that they cannot permanently delete
|
|
users from the shared roster groups.
|
|
A shared roster group can have members from any Jabber server,
|
|
but the presence will only be available from and to members
|
|
of the same virtual host where the group is created.
|
|
|
|
Shared roster groups can be edited \emph{only} via the Web Admin. Each group
|
|
has a unique identification and the following parameters:
|
|
\begin{description}
|
|
\item[Name] The name of the group, which will be displayed in the roster.
|
|
\item[Description] The description of the group. This parameter does not affect
|
|
anything.
|
|
\item[Members] A list of full JIDs of group members, entered one per line in
|
|
the Web Admin.
|
|
To put as members all the registered users in the virtual hosts,
|
|
you can use the special directive: @all@.
|
|
Note that this directive is designed for a small server with just a few hundred users.
|
|
\item[Displayed groups] A list of groups that will be in the rosters of this
|
|
group's members.
|
|
\end{description}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item Take the case of a computer club that wants all its members seeing each
|
|
other in their rosters. To achieve this, they need to create a shared roster
|
|
group similar to next table:
|
|
\begin{table}[H]
|
|
\centering
|
|
\begin{tabular}{|l|l|}
|
|
\hline Identification& Group `\texttt{club\_members}'\\
|
|
\hline Name& Club Members\\
|
|
\hline Description& Members from the computer club\\
|
|
\hline Members&
|
|
{\begin{tabular}{l}
|
|
\jid{member1@example.org}\\
|
|
\jid{member2@example.org}\\
|
|
\jid{member3@example.org}
|
|
\end{tabular}
|
|
}\\
|
|
\hline Displayed groups& \texttt{club\_members}\\
|
|
\hline
|
|
\end{tabular}
|
|
\end{table}
|
|
\item In another case we have a company which has three divisions: Management,
|
|
Marketing and Sales. All group members should see all other members in their
|
|
rosters. Additionally, all managers should have all marketing and sales people
|
|
in their roster. Simultaneously, all marketeers and the whole sales team
|
|
should see all managers. This scenario can be achieved by creating shared
|
|
roster groups as shown in the following table:
|
|
\begin{table}[H]
|
|
\centering
|
|
\begin{tabular}{|l|l|l|l|}
|
|
\hline Identification&
|
|
Group `\texttt{management}'&
|
|
Group `\texttt{marketing}'&
|
|
Group `\texttt{sales}'\\
|
|
\hline Name& Management& Marketing& Sales\\
|
|
\hline Description& \\
|
|
Members&
|
|
{\begin{tabular}{l}
|
|
\jid{manager1@example.org}\\
|
|
\jid{manager2@example.org}\\
|
|
\jid{manager3@example.org}\\
|
|
\jid{manager4@example.org}
|
|
\end{tabular}
|
|
}&
|
|
{\begin{tabular}{l}
|
|
\jid{marketeer1@example.org}\\
|
|
\jid{marketeer2@example.org}\\
|
|
\jid{marketeer3@example.org}\\
|
|
\jid{marketeer4@example.org}
|
|
\end{tabular}
|
|
}&
|
|
{\begin{tabular}{l}
|
|
\jid{saleswoman1@example.org}\\
|
|
\jid{salesman1@example.org}\\
|
|
\jid{saleswoman2@example.org}\\
|
|
\jid{salesman2@example.org}
|
|
\end{tabular}
|
|
}\\
|
|
\hline Displayed groups&
|
|
{\begin{tabular}{l}
|
|
\texttt{management}\\
|
|
\texttt{marketing}\\
|
|
\texttt{sales}
|
|
\end{tabular}
|
|
}&
|
|
{\begin{tabular}{l}
|
|
\texttt{management}\\
|
|
\texttt{marketing}
|
|
\end{tabular}
|
|
}&
|
|
{\begin{tabular}{l}
|
|
\texttt{management}\\
|
|
\texttt{sales}
|
|
\end{tabular}
|
|
}\\
|
|
\hline
|
|
\end{tabular}
|
|
\end{table}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modstats}{\modstats{}}
|
|
\ind{modules!\modstats{}}\ind{protocols!XEP-0039: Statistics Gathering}\ind{statistics}
|
|
|
|
This module adds support for Statistics Gathering (\xepref{0039}). This protocol
|
|
allows you to retrieve next statistics from your \ejabberd{} deployment:
|
|
\begin{itemize}
|
|
\item Total number of registered users on the current virtual host (users/total).
|
|
\item Total number of registered users on all virtual hosts (users/all-hosts/total).
|
|
\item Total number of online users on the current virtual host (users/online).
|
|
\item Total number of online users on all virtual hosts (users/all-hosts/online).
|
|
\end{itemize}
|
|
|
|
Options:
|
|
\begin{description}
|
|
\iqdiscitem{Statistics Gathering (\ns{http://jabber.org/protocol/stats})}
|
|
\end{description}
|
|
|
|
As there are only a small amount of clients (for \ind{Tkabber}example
|
|
\footahref{http://tkabber.jabber.ru/}{Tkabber}) and software libraries with
|
|
support for this XEP, a few examples are given of the XML you need to send
|
|
in order to get the statistics. Here they are:
|
|
\begin{itemize}
|
|
\item You can request the number of online users on the current virtual host
|
|
(\jid{example.org}) by sending:
|
|
\begin{verbatim}
|
|
<iq to='example.org' type='get'>
|
|
<query xmlns='http://jabber.org/protocol/stats'>
|
|
<stat name='users/online'/>
|
|
</query>
|
|
</iq>
|
|
\end{verbatim}
|
|
\item You can request the total number of registered users on all virtual hosts
|
|
by sending:
|
|
\begin{verbatim}
|
|
<iq to='example.org' type='get'>
|
|
<query xmlns='http://jabber.org/protocol/stats'>
|
|
<stat name='users/all-hosts/total'/>
|
|
</query>
|
|
</iq>
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modtime}{\modtime{}}
|
|
\ind{modules!\modtime{}}\ind{protocols!XEP-0202: Entity Time}
|
|
|
|
This module features support for Entity Time (\xepref{0202}). By using this XEP,
|
|
you are able to discover the time at another entity's location.
|
|
|
|
Options:
|
|
\begin{description}
|
|
\iqdiscitem{Entity Time (\ns{jabber:iq:time})}
|
|
\end{description}
|
|
|
|
\makesubsection{modvcard}{\modvcard{}}
|
|
\ind{modules!\modvcard{}}\ind{JUD}\ind{Jabber User Directory}\ind{vCard}\ind{protocols!XEP-0054: vcard-temp}
|
|
|
|
This module allows end users to store and retrieve their vCard, and to retrieve
|
|
other users vCards, as defined in vcard-temp (\xepref{0054}). The module also
|
|
implements an uncomplicated \Jabber{} User Directory based on the vCards of
|
|
these users. Moreover, it enables the server to send its vCard when queried.
|
|
|
|
Options:
|
|
\begin{description}
|
|
\hostitem{vjud}
|
|
\iqdiscitem{\ns{vcard-temp}}
|
|
\titem{\{search, true|false\}}\ind{options!search}This option specifies whether the search
|
|
functionality is enabled or not
|
|
If disabled, the option \term{host} will be ignored and the
|
|
\Jabber{} User Directory service will not appear in the Service Discovery item
|
|
list. The default value is \term{true}.
|
|
\titem{\{matches, infinity|Number\}}\ind{options!matches}With this option, the number of reported
|
|
search results can be limited. If the option's value is set to \term{infinity},
|
|
all search results are reported. The default value is \term{30}.
|
|
\titem{\{allow\_return\_all, false|true\}}\ind{options!allow\_return\_all}This option enables
|
|
you to specify if search operations with empty input fields should return all
|
|
users who added some information to their vCard. The default value is
|
|
\term{false}.
|
|
\titem{\{search\_all\_hosts, true|false\}}\ind{options!search\_all\_hosts}If this option is set
|
|
to \term{true}, search operations will apply to all virtual hosts. Otherwise
|
|
only the current host will be searched. The default value is \term{true}.
|
|
This option is available in \modvcard, but not available in \modvcardodbc.
|
|
\end{description}
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item In this first situation, search results are limited to twenty items,
|
|
every user who added information to their vCard will be listed when people
|
|
do an empty search, and only users from the current host will be returned:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_vcard, [{search, true},
|
|
{matches, 20},
|
|
{allow_return_all, true},
|
|
{search_all_hosts, false}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item The second situation differs in a way that search results are not limited,
|
|
and that all virtual hosts will be searched instead of only the current one:
|
|
\begin{verbatim}
|
|
{modules,
|
|
[
|
|
...
|
|
{mod_vcard, [{search, true},
|
|
{matches, infinity},
|
|
{allow_return_all, true}]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modvcardldap}{\modvcardldap{}}
|
|
\ind{modules!\modvcardldap{}}\ind{JUD}\ind{Jabber User Directory}\ind{vCard}\ind{protocols!XEP-0054: vcard-temp}
|
|
|
|
%TODO: verify if the referers to the LDAP section are still correct
|
|
|
|
\ejabberd{} can map LDAP attributes to vCard fields. This behaviour is
|
|
implemented in the \modvcardldap{} module. This module does not depend on the
|
|
authentication method (see~\ref{ldapauth}).
|
|
|
|
Note that \ejabberd{} treats LDAP as a read-only storage:
|
|
it is possible to consult data, but not possible to
|
|
create accounts, change password or edit vCard that is stored in LDAP.
|
|
|
|
The \modvcardldap{} module has
|
|
its own optional parameters. The first group of parameters has the same
|
|
meaning as the top-level LDAP parameters to set the authentication method:
|
|
\option{ldap\_servers}, \option{ldap\_port}, \option{ldap\_rootdn},
|
|
\option{ldap\_password}, \option{ldap\_base}, \option{ldap\_uids}, and
|
|
\option{ldap\_filter}. See section~\ref{ldapauth} for detailed information
|
|
about these options. If one of these options is not set, \ejabberd{} will look
|
|
for the top-level option with the same name.
|
|
|
|
The second group of parameters
|
|
consists of the following \modvcardldap{}-specific options:
|
|
|
|
\begin{description}
|
|
\hostitem{vjud}
|
|
\iqdiscitem{\ns{vcard-temp}}
|
|
\titem{\{search, true|false\}}\ind{options!search}This option specifies whether the search
|
|
functionality is enabled (value: \term{true}) or disabled (value:
|
|
\term{false}). If disabled, the option \term{host} will be ignored and the
|
|
\Jabber{} User Directory service will not appear in the Service Discovery item
|
|
list. The default value is \term{true}.
|
|
\titem{\{matches, infinity|Number\}}\ind{options!matches}With this option, the number of reported
|
|
search results can be limited. If the option's value is set to \term{infinity},
|
|
all search results are reported. The default value is \term{30}.
|
|
\titem{\{ldap\_vcard\_map, [ \{Name, Pattern, LDAPattributes\}, ...]\}} \ind{options!ldap\_vcard\_map}
|
|
With this option you can set the table that maps LDAP attributes to vCard fields.
|
|
\ind{protocols!RFC 2426: vCard MIME Directory Profile}
|
|
\term{Name} is the type name of the vCard as defined in
|
|
\footahref{http://tools.ietf.org/html/rfc2426}{RFC 2426}.
|
|
\term{Pattern} is a string which contains pattern variables
|
|
\term{"\%u"}, \term{"\%d"} or \term{"\%s"}.
|
|
\term{LDAPattributes} is the list containing LDAP attributes.
|
|
The pattern variables
|
|
\term{"\%s"} will be sequentially replaced
|
|
with the values of LDAP attributes from \term{List\_of\_LDAP\_attributes},
|
|
\term{"\%u"} will be replaced with the user part of a JID,
|
|
and \term{"\%d"} will be replaced with the domain part of a JID.
|
|
The default is:
|
|
\begin{verbatim}
|
|
[{"NICKNAME", "%u", []},
|
|
{"FN", "%s", ["displayName"]},
|
|
{"LAST", "%s", ["sn"]},
|
|
{"FIRST", "%s", ["givenName"]},
|
|
{"MIDDLE", "%s", ["initials"]},
|
|
{"ORGNAME", "%s", ["o"]},
|
|
{"ORGUNIT", "%s", ["ou"]},
|
|
{"CTRY", "%s", ["c"]},
|
|
{"LOCALITY", "%s", ["l"]},
|
|
{"STREET", "%s", ["street"]},
|
|
{"REGION", "%s", ["st"]},
|
|
{"PCODE", "%s", ["postalCode"]},
|
|
{"TITLE", "%s", ["title"]},
|
|
{"URL", "%s", ["labeleduri"]},
|
|
{"DESC", "%s", ["description"]},
|
|
{"TEL", "%s", ["telephoneNumber"]},
|
|
{"EMAIL", "%s", ["mail"]},
|
|
{"BDAY", "%s", ["birthDay"]},
|
|
{"ROLE", "%s", ["employeeType"]},
|
|
{"PHOTO", "%s", ["jpegPhoto"]}]
|
|
\end{verbatim}
|
|
\titem{\{ldap\_search\_fields, [ \{Name, Attribute\}, ...]\}}\ind{options!ldap\_search\_fields}This option
|
|
defines the search form and the LDAP attributes to search within.
|
|
\term{Name} is the name of a search form
|
|
field which will be automatically translated by using the translation
|
|
files (see \term{msgs/*.msg} for available words). \term{Attribute} is the
|
|
LDAP attribute or the pattern \term{"\%u"}. The default is:
|
|
\begin{verbatim}
|
|
[{"User", "%u"},
|
|
{"Full Name", "displayName"},
|
|
{"Given Name", "givenName"},
|
|
{"Middle Name", "initials"},
|
|
{"Family Name", "sn"},
|
|
{"Nickname", "%u"},
|
|
{"Birthday", "birthDay"},
|
|
{"Country", "c"},
|
|
{"City", "l"},
|
|
{"Email", "mail"},
|
|
{"Organization Name", "o"},
|
|
{"Organization Unit", "ou"}]
|
|
\end{verbatim}
|
|
\titem{\{ldap\_search\_reported, [ \{SearchField, VcardField\}, ...]\}}\ind{options!ldap\_search\_reported}This option
|
|
defines which search fields should be reported.
|
|
\term{SearchField} is the name of a search form
|
|
field which will be automatically translated by using the translation
|
|
files (see \term{msgs/*.msg} for available words). \term{VcardField} is the
|
|
vCard field name defined in the \option{ldap\_vcard\_map} option. The default
|
|
is:
|
|
\begin{verbatim}
|
|
[{"Full Name", "FN"},
|
|
{"Given Name", "FIRST"},
|
|
{"Middle Name", "MIDDLE"},
|
|
{"Family Name", "LAST"},
|
|
{"Nickname", "NICKNAME"},
|
|
{"Birthday", "BDAY"},
|
|
{"Country", "CTRY"},
|
|
{"City", "LOCALITY"},
|
|
{"Email", "EMAIL"},
|
|
{"Organization Name", "ORGNAME"},
|
|
{"Organization Unit", "ORGUNIT"}]
|
|
\end{verbatim}
|
|
\end{description}
|
|
|
|
%TODO: this examples still should be organised better
|
|
Examples:
|
|
\begin{itemize}
|
|
\item
|
|
|
|
Let's say \term{ldap.example.org} is the name of our LDAP server. We have
|
|
users with their passwords in \term{"ou=Users,dc=example,dc=org"} directory.
|
|
Also we have addressbook, which contains users emails and their additional
|
|
infos in \term{"ou=AddressBook,dc=example,dc=org"} directory. Corresponding
|
|
authentication section should looks like this:
|
|
|
|
\begin{verbatim}
|
|
%% authentication method
|
|
{auth_method, ldap}.
|
|
%% DNS name of our LDAP server
|
|
{ldap_servers, ["ldap.example.org"]}.
|
|
%% We want to authorize users from 'shadowAccount' object class only
|
|
{ldap_filter, "(objectClass=shadowAccount)"}.
|
|
\end{verbatim}
|
|
|
|
Now we want to use users LDAP-info as their vCards. We have four attributes
|
|
defined in our LDAP schema: \term{"mail"} --- email address, \term{"givenName"}
|
|
--- first name, \term{"sn"} --- second name, \term{"birthDay"} --- birthday.
|
|
Also we want users to search each other. Let's see how we can set it up:
|
|
|
|
\begin{verbatim}
|
|
{modules,
|
|
...
|
|
{mod_vcard_ldap,
|
|
[
|
|
%% We use the same server and port, but want to bind anonymously because
|
|
%% our LDAP server accepts anonymous requests to
|
|
%% "ou=AddressBook,dc=example,dc=org" subtree.
|
|
{ldap_rootdn, ""},
|
|
{ldap_password, ""},
|
|
%% define the addressbook's base
|
|
{ldap_base, "ou=AddressBook,dc=example,dc=org"},
|
|
%% uidattr: user's part of JID is located in the "mail" attribute
|
|
%% uidattr_format: common format for our emails
|
|
{ldap_uids, [{"mail","%u@mail.example.org"}]},
|
|
%% We have to define empty filter here, because entries in addressbook does not
|
|
%% belong to shadowAccount object class
|
|
{ldap_filter, ""},
|
|
%% Now we want to define vCard pattern
|
|
{ldap_vcard_map,
|
|
[{"NICKNAME", "%u", []}, % just use user's part of JID as his nickname
|
|
{"FIRST", "%s", ["givenName"]},
|
|
{"LAST", "%s", ["sn"]},
|
|
{"FN", "%s, %s", ["sn", "givenName"]}, % example: "Smith, John"
|
|
{"EMAIL", "%s", ["mail"]},
|
|
{"BDAY", "%s", ["birthDay"]}]},
|
|
%% Search form
|
|
{ldap_search_fields,
|
|
[{"User", "%u"},
|
|
{"Name", "givenName"},
|
|
{"Family Name", "sn"},
|
|
{"Email", "mail"},
|
|
{"Birthday", "birthDay"}]},
|
|
%% vCard fields to be reported
|
|
%% Note that JID is always returned with search results
|
|
{ldap_search_reported,
|
|
[{"Full Name", "FN"},
|
|
{"Nickname", "NICKNAME"},
|
|
{"Birthday", "BDAY"}]}
|
|
]}
|
|
...
|
|
}.
|
|
\end{verbatim}
|
|
|
|
Note that \modvcardldap{} module checks an existence of the user before
|
|
searching his info in LDAP.
|
|
|
|
\item \term{ldap\_vcard\_map} example:
|
|
\begin{verbatim}
|
|
{ldap_vcard_map,
|
|
[{"NICKNAME", "%u", []},
|
|
{"FN", "%s", ["displayName"]},
|
|
{"CTRY", "Russia", []},
|
|
{"EMAIL", "%u@%d", []},
|
|
{"DESC", "%s\n%s", ["title", "description"]}
|
|
]},
|
|
\end{verbatim}
|
|
\item \term{ldap\_search\_fields} example:
|
|
\begin{verbatim}
|
|
{ldap_search_fields,
|
|
[{"User", "uid"},
|
|
{"Full Name", "displayName"},
|
|
{"Email", "mail"}
|
|
]},
|
|
\end{verbatim}
|
|
\item \term{ldap\_search\_reported} example:
|
|
\begin{verbatim}
|
|
{ldap_search_reported,
|
|
[{"Full Name", "FN"},
|
|
{"Email", "EMAIL"},
|
|
{"Birthday", "BDAY"},
|
|
{"Nickname", "NICKNAME"}
|
|
]},
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
\makesubsection{modversion}{\modversion{}}
|
|
\ind{modules!\modversion{}}\ind{protocols!XEP-0092: Software Version}
|
|
|
|
This module implements Software Version (\xepref{0092}). Consequently, it
|
|
answers \ejabberd{}'s version when queried.
|
|
|
|
Options:
|
|
\begin{description}
|
|
\titem{\{show\_os, true|false\}}\ind{options!showos}Should the operating system be revealed or not.
|
|
The default value is \term{true}.
|
|
\iqdiscitem{Software Version (\ns{jabber:iq:version})}
|
|
\end{description}
|
|
|
|
\makechapter{manage}{Managing an \ejabberd{} Server}
|
|
|
|
|
|
\makesection{ejabberdctl}{\term{ejabberdctl}}
|
|
|
|
With the \term{ejabberdctl} command line administration script
|
|
you can execute \term{ejabberdctl commands} (described in the next section, \ref{ectl-commands})
|
|
and also many general \term{ejabberd commands} (described in section \ref{eja-commands}).
|
|
This means you can start, stop and perform many other administrative tasks
|
|
in a local or remote \ejabberd{} server (by providing the argument \term{--node NODENAME}).
|
|
|
|
The \term{ejabberdctl} script can be configured in the file \term{ejabberdctl.cfg}.
|
|
This file includes detailed information about each configurable option. See section \ref{erlangconfiguration}.
|
|
|
|
The \term{ejabberdctl} script returns a numerical status code.
|
|
Success is represented by \term{0},
|
|
error is represented by \term{1},
|
|
and other codes may be used for specific results.
|
|
This can be used by other scripts to determine automatically
|
|
if a command succeeded or failed,
|
|
for example using: \term{echo \$?}
|
|
|
|
\makesubsection{ectl-commands}{ejabberdctl Commands}
|
|
|
|
When \term{ejabberdctl} is executed without any parameter,
|
|
it displays the available options. If there isn't an \ejabberd{} server running,
|
|
the available parameters are:
|
|
\begin{description}
|
|
\titem{start} Start \ejabberd{} in background mode. This is the default method.
|
|
\titem{debug} Attach an Erlang shell to an already existing \ejabberd{} server. This allows to execute commands interactively in the \ejabberd{} server.
|
|
\titem{live} Start \ejabberd{} in live mode: the shell keeps attached to the started server, showing log messages and allowing to execute interactive commands.
|
|
\end{description}
|
|
|
|
If there is an \ejabberd{} server running in the system,
|
|
\term{ejabberdctl} shows the \term{ejabberdctl commands} described bellow
|
|
and all the \term{ejabberd commands} available in that server (see \ref{list-eja-commands}).
|
|
|
|
The \term{ejabberdctl commands} are:
|
|
\begin{description}
|
|
\titem{help} Get help about ejabberdctl or any available command. Try \term{ejabberdctl help help}.
|
|
\titem{status} Check the status of the \ejabberd{} server.
|
|
\titem{stop} Stop the \ejabberd{} server.
|
|
\titem{restart} Restart the \ejabberd{} server.
|
|
\titem{mnesia} Get information about the Mnesia database.
|
|
\end{description}
|
|
|
|
The \term{ejabberdctl} script can be restricted to require authentication
|
|
and execute some \term{ejabberd commands}; see \ref{accesscommands}.
|
|
Add the option to the file \term{ejabberd.cfg}.
|
|
In this example there is no restriction:
|
|
\begin{verbatim}
|
|
{ejabberdctl_access_commands, []}.
|
|
\end{verbatim}
|
|
|
|
If account \term{robot1@example.org} is registered in \ejabberd{} with password \term{abcdef}
|
|
(which MD5 is E8B501798950FC58AAD83C8C14978E),
|
|
and \term{ejabberd.cfg} contains this setting:
|
|
\begin{verbatim}
|
|
{hosts, ["example.org"]}.
|
|
{acl, bots, {user, "robot1", "example.org"}}.
|
|
{access, ctlaccess, [{allow, bots}]}.
|
|
{ejabberdctl_access_commands, [ {ctlaccess, [registered_users, register], []} ]}.
|
|
\end{verbatim}
|
|
then you can do this in the shell:
|
|
\begin{verbatim}
|
|
$ ejabberdctl registered_users example.org
|
|
Error: no_auth_provided
|
|
$ ejabberdctl --auth robot1 example.org E8B501798950FC58AAD83C8C14978E registered_users example.org
|
|
robot1
|
|
testuser1
|
|
testuser2
|
|
\end{verbatim}
|
|
|
|
|
|
\makesubsection{erlangconfiguration}{Erlang Runtime System}
|
|
|
|
\ejabberd{} is an Erlang/OTP application that runs inside an Erlang runtime system.
|
|
This system is configured using environment variables and command line parameters.
|
|
The \term{ejabberdctl} administration script uses many of those possibilities.
|
|
You can configure some of them with the file \term{ejabberdctl.cfg},
|
|
which includes detailed description about them.
|
|
This section describes for reference purposes
|
|
all the environment variables and command line parameters.
|
|
|
|
The environment variables:
|
|
\begin{description}
|
|
\titem{EJABBERD\_CONFIG\_PATH}
|
|
Path to the ejabberd configuration file.
|
|
\titem{EJABBERD\_MSGS\_PATH}
|
|
Path to the directory with translated strings.
|
|
\titem{EJABBERD\_LOG\_PATH}
|
|
Path to the ejabberd service log file.
|
|
\titem{EJABBERD\_SO\_PATH}
|
|
Path to the directory with binary system libraries.
|
|
\titem{EJABBERD\_DOC\_PATH}
|
|
Path to the directory with ejabberd documentation.
|
|
\titem{EJABBERD\_PID\_PATH}
|
|
Path to the PID file that ejabberd can create when started.
|
|
\titem{HOME}
|
|
Path to the directory that is considered \ejabberd{}'s home.
|
|
This path is used to read the file \term{.erlang.cookie}.
|
|
\titem{ERL\_CRASH\_DUMP}
|
|
Path to the file where crash reports will be dumped.
|
|
\titem{ERL\_INETRC}
|
|
Indicates which IP name resolution to use.
|
|
If using \term{-sname}, specify either this option or \term{-kernel inetrc filepath}.
|
|
\titem{ERL\_MAX\_PORTS}
|
|
Maximum number of simultaneously open Erlang ports.
|
|
\titem{ERL\_MAX\_ETS\_TABLES}
|
|
Maximum number of ETS and Mnesia tables.
|
|
\end{description}
|
|
|
|
The command line parameters:
|
|
\begin{description}
|
|
\titem{-sname ejabberd}
|
|
The Erlang node will be identified using only the first part
|
|
of the host name, i.\,e. other Erlang nodes outside this domain cannot contact
|
|
this node. This is the preferable option in most cases.
|
|
\titem{-name ejabberd}
|
|
The Erlang node will be fully identified.
|
|
This is only useful if you plan to setup an \ejabberd{} cluster with nodes in different networks.
|
|
\titem{-kernel inetrc "/etc/ejabberd/inetrc"}
|
|
Indicates which IP name resolution to use.
|
|
If using \term{-sname}, specify either this option or \term{ERL\_INETRC}.
|
|
\titem{-kernel inet\_dist\_listen\_min 4200 inet\_dist\_listen\_min 4210}
|
|
Define the first and last ports that \term{epmd} (section \ref{epmd}) can listen to.
|
|
\titem{-detached}
|
|
Starts the Erlang system detached from the system console.
|
|
Useful for running daemons and backgrounds processes.
|
|
\titem{-noinput}
|
|
Ensures that the Erlang system never tries to read any input.
|
|
Useful for running daemons and backgrounds processes.
|
|
\titem{-pa /var/lib/ejabberd/ebin}
|
|
Specify the directory where Erlang binary files (*.beam) are located.
|
|
\titem{-s ejabberd}
|
|
Tell Erlang runtime system to start the \ejabberd{} application.
|
|
\titem{-mnesia dir "/var/lib/ejabberd/"}
|
|
Specify the Mnesia database directory.
|
|
\titem{-sasl sasl\_error\_logger \{file, "/var/log/ejabberd/erlang.log"\}}
|
|
Path to the Erlang/OTP system log file.
|
|
SASL here means ``System Architecture Support Libraries''
|
|
not ``Simple Authentication and Security Layer''.
|
|
\titem{+K [true|false]}
|
|
Kernel polling.
|
|
\titem{-smp [auto|enable|disable]}
|
|
SMP support.
|
|
\titem{+P 250000}
|
|
Maximum number of Erlang processes.
|
|
\titem{-remsh ejabberd@localhost}
|
|
Open an Erlang shell in a remote Erlang node.
|
|
\titem{-hidden}
|
|
The connections to other nodes are hidden (not published).
|
|
The result is that this node is not considered part of the cluster.
|
|
This is important when starting a temporary \term{ctl} or \term{debug} node.
|
|
\end{description}
|
|
Note that some characters need to be escaped when used in shell scripts, for instance \verb|"| and \verb|{}|.
|
|
You can find other options in the Erlang manual page (\shell{erl -man erl}).
|
|
|
|
\makesection{eja-commands}{\ejabberd{} Commands}
|
|
|
|
An \term{ejabberd command} is an abstract function identified by a name,
|
|
with a defined number and type of calling arguments and type of result
|
|
that is registered in the \term{ejabberd\_commands} service.
|
|
Those commands can be defined in any Erlang module and executed using any valid frontend.
|
|
|
|
\ejabberd{} includes a frontend to execute \term{ejabberd commands}: the script \term{ejabberdctl}.
|
|
Other known frontends that can be installed to execute ejabberd commands in different ways are:
|
|
\term{ejabberd\_xmlrpc} (XML-RPC service),
|
|
\term{mod\_rest} (HTTP POST service),
|
|
\term{mod\_shcommands} (ejabberd WebAdmin page).
|
|
|
|
\makesubsection{list-eja-commands}{List of ejabberd Commands}
|
|
|
|
\ejabberd{} includes a few ejabberd Commands by default.
|
|
When more modules are installed, new commands may be available in the frontends.
|
|
|
|
The easiest way to get a list of the available commands, and get help for them is to use
|
|
the ejabberdctl script:
|
|
\begin{verbatim}
|
|
$ ejabberdctl help
|
|
Usage: ejabberdctl [--node nodename] [--auth user host password] command [options]
|
|
|
|
Available commands in this ejabberd node:
|
|
backup file Store the database to backup file
|
|
connected_users List all established sessions
|
|
connected_users_number Get the number of established sessions
|
|
delete_expired_messages Delete expired offline messages from database
|
|
delete_old_messages days Delete offline messages older than DAYS
|
|
...
|
|
\end{verbatim}
|
|
|
|
The more interesting ones are:
|
|
\begin{description}
|
|
\titem{reopen\_log} Reopen the log files after they were renamed.
|
|
If the old files were not renamed before calling this command,
|
|
they are automatically renamed to \term{"*-old.log"}. See section \ref{logfiles}.
|
|
\titem {backup ejabberd.backup}
|
|
Store internal Mnesia database to a binary backup file.
|
|
\titem {restore ejabberd.backup}
|
|
Restore immediately from a binary backup file the internal Mnesia database.
|
|
This will consume quite some memory for big servers.
|
|
\titem {install\_fallback ejabberd.backup}
|
|
The binary backup file is installed as fallback:
|
|
it will be used to restore the database at the next ejabberd start.
|
|
Similar to \term{restore}, but requires less memory.
|
|
\titem {dump ejabberd.dump}
|
|
Dump internal Mnesia database to a text file dump.
|
|
\titem {load ejabberd.dump}
|
|
Restore immediately from a text file dump.
|
|
This is not recommended for big databases, as it will consume much time,
|
|
memory and processor. In that case it's preferable to use \term{backup} and \term{install\_fallback}.
|
|
%%More information about backuping can
|
|
%% be found in section~\ref{backup}.
|
|
\titem{import\_piefxis, export\_piefxis, export\_piefxis\_host} \ind{migrate between servers}
|
|
These options can be used to migrate accounts
|
|
using \xepref{0227} formatted XML files
|
|
from/to other \Jabber{}/XMPP servers
|
|
or move users of a vhost to another ejabberd installation.
|
|
See also
|
|
\footahref{https://support.process-one.net/doc/display/P1/ejabberd+migration+kit}{ejabberd migration kit}.
|
|
\titem{import\_file, import\_dir} \ind{migration from other software}
|
|
These options can be used to migrate accounts
|
|
using jabberd1.4 formatted XML files.
|
|
from other \Jabber{}/XMPP servers
|
|
There exist tutorials to
|
|
\footahref{http://www.ejabberd.im/migrate-to-ejabberd}{migrate from other software to ejabberd}.
|
|
\titem{delete\_expired\_messages} This option can be used to delete old messages
|
|
in offline storage. This might be useful when the number of offline messages
|
|
is very high.
|
|
\end{description}
|
|
|
|
\makesubsection{accesscommands}{Restrict Execution with AccessCommands}
|
|
|
|
The frontends can be configured to restrict access to certain commands.
|
|
In that case, authentication information must be provided.
|
|
In each frontend the \term{AccessCommands} option is defined
|
|
in a different place. But in all cases the option syntax is the same:
|
|
\begin{verbatim}
|
|
AccessCommands = [ {Access, CommandNames, Arguments}, ...]
|
|
Access = atom()
|
|
CommandNames = all | [CommandName]
|
|
CommandName = atom()
|
|
Arguments = [ {ArgumentName, ArgumentValue}, ...]
|
|
ArgumentName = atom()
|
|
ArgumentValue = any()
|
|
\end{verbatim}
|
|
|
|
The default value is to not define any restriction: \term{[]}.
|
|
If at least one restriction is defined, then the frontend expects
|
|
that authentication information is provided when executing a command.
|
|
The authentication information is Username, Hostname and Password of a local Jabber account
|
|
that has permission to execute the corresponding command.
|
|
This means that the account must be registered in the local ejabberd,
|
|
because the information will be verified.
|
|
It is possible to provide the plaintext password or its MD5 sum.
|
|
|
|
When one or several access restrictions are defined and the
|
|
authentication information is provided,
|
|
each restriction is verified until one matches completely:
|
|
the account matches the Access rule,
|
|
the command name is listed in CommandNames,
|
|
and the provided arguments do not contradict Arguments.
|
|
|
|
As an example to understand the syntax, let's suppose those options:
|
|
\begin{verbatim}
|
|
{hosts, ["example.org"]}.
|
|
{acl, bots, {user, "robot1", "example.org"}}.
|
|
{access, commaccess, [{allow, bots}]}.
|
|
\end{verbatim}
|
|
|
|
This list of access restrictions allows only \term{robot1@example.org} to execute all commands:
|
|
\begin{verbatim}
|
|
[{commaccess, all, []}]
|
|
\end{verbatim}
|
|
|
|
See another list of restrictions (the corresponding ACL and ACCESS are not shown):
|
|
\begin{verbatim}
|
|
[
|
|
%% This bot can execute all commands:
|
|
{bot, all, []},
|
|
%% This bot can only execute the command 'dump'. No argument restriction:
|
|
{bot_backups, [dump], []}
|
|
%% This bot can execute all commands,
|
|
%% but if a 'host' argument is provided, it must be "example.org":
|
|
{bot_all_example, all, [{host, "example.org"}]},
|
|
%% This bot can only execute the command 'register',
|
|
%% and if argument 'host' is provided, it must be "example.org":
|
|
{bot_reg_example, [register], [{host, "example.org"}]},
|
|
%% This bot can execute the commands 'register' and 'unregister',
|
|
%% if argument host is provided, it must be "test.org":
|
|
{_bot_reg_test, [register, unregister], [{host, "test.org"}]}
|
|
]
|
|
\end{verbatim}
|
|
|
|
\makesection{webadmin}{Web Admin}
|
|
\ind{web admin}
|
|
|
|
The \ejabberd{} Web Admin allows to administer most of \ejabberd{} using a web browser.
|
|
|
|
This feature is enabled by default:
|
|
a \term{ejabberd\_http} listener with the option \term{web\_admin} (see
|
|
section~\ref{listened}) is included in the listening ports. Then you can open
|
|
\verb|http://server:port/admin/| in your favourite web browser. You
|
|
will be asked to enter the username (the \emph{full} \Jabber{} ID) and password
|
|
of an \ejabberd{} user with administrator rights. After authentication
|
|
you will see a page similar to figure~\ref{fig:webadmmain}.
|
|
|
|
\begin{figure}[htbp]
|
|
\centering
|
|
\insimg{webadmmain.png}
|
|
\caption{Top page from the Web Admin}
|
|
\label{fig:webadmmain}
|
|
\end{figure}
|
|
Here you can edit access restrictions, manage users, create backups,
|
|
manage the database, enable/disable ports listened for, view server
|
|
statistics,\ldots
|
|
|
|
Examples:
|
|
\begin{itemize}
|
|
\item You can serve the Web Admin on the same port as the
|
|
\ind{protocols!XEP-0025: HTTP Polling}HTTP Polling interface. In this example
|
|
you should point your web browser to \verb|http://example.org:5280/admin/| to
|
|
administer all virtual hosts or to
|
|
\verb|http://example.org:5280/admin/server/example.com/| to administer only
|
|
the virtual host \jid{example.com}. Before you get access to the Web Admin
|
|
you need to enter as username, the JID and password from a registered user
|
|
that is allowed to configure \ejabberd{}. In this example you can enter as
|
|
username `\jid{admin@example.net}' to administer all virtual hosts (first
|
|
URL). If you log in with `\jid{admin@example.com}' on \\
|
|
\verb|http://example.org:5280/admin/server/example.com/| you can only
|
|
administer the virtual host \jid{example.com}.
|
|
\begin{verbatim}
|
|
{acl, admins, {user, "admin", "example.net"}}.
|
|
{host_config, "example.com", [{acl, admins, {user, "admin", "example.com"}}]}.
|
|
{access, configure, [{allow, admins}]}.
|
|
|
|
{hosts, ["example.org"]}.
|
|
|
|
{listen,
|
|
[
|
|
...
|
|
{5280, ejabberd_http, [http_poll, web_admin]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\item For security reasons, you can serve the Web Admin on a secured
|
|
connection, on a port differing from the HTTP Polling interface, and bind it
|
|
to the internal LAN IP. The Web Admin will be accessible by pointing your
|
|
web browser to \verb|https://192.168.1.1:5282/admin/|:
|
|
\begin{verbatim}
|
|
|
|
{hosts, ["example.org"]}.
|
|
|
|
{listen,
|
|
[
|
|
...
|
|
{5280, ejabberd_http, [
|
|
http_poll
|
|
]},
|
|
{{5282, "192.168.1.1"}, ejabberd_http, [
|
|
web_admin,
|
|
tls, {certfile, "/usr/local/etc/server.pem"}
|
|
]},
|
|
...
|
|
]}.
|
|
\end{verbatim}
|
|
\end{itemize}
|
|
|
|
Certain pages in the ejabberd Web Admin contain a link to a related
|
|
section in the ejabberd Installation and Operation Guide.
|
|
In order to view such links, a copy in HTML format of the Guide must
|
|
be installed in the system.
|
|
The file is searched by default in
|
|
\term{"/share/doc/ejabberd/guide.html"}.
|
|
The directory of the documentation can be specified in
|
|
the environment variable \term{EJABBERD\_DOC\_PATH}.
|
|
See section \ref{erlangconfiguration}.
|
|
|
|
|
|
\makesection{adhoccommands}{Ad-hoc Commands}
|
|
|
|
If you enable \modconfigure\ and \modadhoc,
|
|
you can perform several administrative tasks in \ejabberd{}
|
|
with a Jabber client.
|
|
The client must support Ad-Hoc Commands (\xepref{0050}),
|
|
and you must login in the Jabber server with
|
|
an account with proper privileges.
|
|
|
|
|
|
\makesection{changeerlangnodename}{Change Computer Hostname}
|
|
|
|
\ejabberd{} uses the distributed Mnesia database.
|
|
Being distributed, Mnesia enforces consistency of its file,
|
|
so it stores the name of the Erlang node in it (see section \ref{nodename}).
|
|
The name of an Erlang node includes the hostname of the computer.
|
|
So, the name of the Erlang node changes
|
|
if you change the name of the machine in which \ejabberd{} runs,
|
|
or when you move \ejabberd{} to a different machine.
|
|
|
|
You have two ways to use the old Mnesia database in an ejabberd with new node name:
|
|
put the old node name in \term{ejabberdctl.cfg},
|
|
or convert the database to the new node name.
|
|
|
|
Those example steps will backup, convert and load the Mnesia database.
|
|
You need to have either the old Mnesia spool dir or a backup of Mnesia.
|
|
If you already have a backup file of the old database, you can go directly to step 5.
|
|
You also need to know the old node name and the new node name.
|
|
If you don't know them, look for them by executing \term{ejabberdctl}
|
|
or in the ejabberd log files.
|
|
|
|
Before starting, setup some variables:
|
|
\begin{verbatim}
|
|
OLDNODE=ejabberd@oldmachine
|
|
NEWNODE=ejabberd@newmachine
|
|
OLDFILE=/tmp/old.backup
|
|
NEWFILE=/tmp/new.backup
|
|
\end{verbatim}
|
|
|
|
\begin{enumerate}
|
|
\item Start ejabberd enforcing the old node name:
|
|
\begin{verbatim}
|
|
ejabberdctl --node $OLDNODE start
|
|
\end{verbatim}
|
|
|
|
\item Generate a backup file:
|
|
\begin{verbatim}
|
|
ejabberdctl --node $OLDNODE backup $OLDFILE
|
|
\end{verbatim}
|
|
|
|
\item Stop the old node:
|
|
\begin{verbatim}
|
|
ejabberdctl --node $OLDNODE stop
|
|
\end{verbatim}
|
|
|
|
\item Make sure there aren't files in the Mnesia spool dir. For example:
|
|
\begin{verbatim}
|
|
mkdir /var/lib/ejabberd/oldfiles
|
|
mv /var/lib/ejabberd/*.* /var/lib/ejabberd/oldfiles/
|
|
\end{verbatim}
|
|
|
|
\item Start ejabberd. There isn't any need to specify the node name anymore:
|
|
\begin{verbatim}
|
|
ejabberdctl start
|
|
\end{verbatim}
|
|
|
|
\item Convert the backup to new node name:
|
|
\begin{verbatim}
|
|
ejabberdctl mnesia_change_nodename $OLDNODE $NEWNODE $OLDFILE $NEWFILE
|
|
\end{verbatim}
|
|
|
|
\item Import the new backup:
|
|
\begin{verbatim}
|
|
ejabberdctl restore $NEWFILE
|
|
\end{verbatim}
|
|
|
|
\item Check that the information of the old database is available: accounts, rosters...
|
|
After you finish, remember to delete the temporary backup files from public directories.
|
|
\end{enumerate}
|
|
|
|
|
|
\makechapter{secure}{Securing \ejabberd{}}
|
|
|
|
\makesection{firewall}{Firewall Settings}
|
|
\ind{firewall}\ind{ports}\ind{SASL}\ind{TLS}\ind{clustering!ports}
|
|
|
|
You need to take the following TCP ports in mind when configuring your firewall:
|
|
\begin{table}[H]
|
|
\centering
|
|
\begin{tabular}{|l|l|}
|
|
\hline {\bf Port} & {\bf Description} \\
|
|
\hline \hline 5222& Standard port for Jabber/XMPP client connections, plain or STARTTLS.\\
|
|
\hline 5223& Standard port for Jabber client connections using the old SSL method.\\
|
|
\hline 5269& Standard port for Jabber/XMPP server connections.\\
|
|
\hline 4369& EPMD (section \ref{epmd}) listens for Erlang node name requests.\\
|
|
\hline port range& Used for connections between Erlang nodes. This range is configurable (see section \ref{epmd}).\\
|
|
\hline
|
|
\end{tabular}
|
|
\end{table}
|
|
|
|
\makesection{epmd}{epmd}
|
|
|
|
\footahref{http://www.erlang.org/doc/man/epmd.html}{epmd (Erlang Port Mapper Daemon)}
|
|
is a small name server included in Erlang/OTP
|
|
and used by Erlang programs when establishing distributed Erlang communications.
|
|
\ejabberd{} needs \term{epmd} to use \term{ejabberdctl} and also when clustering \ejabberd{} nodes.
|
|
This small program is automatically started by Erlang, and is never stopped.
|
|
If \ejabberd{} is stopped, and there aren't any other Erlang programs
|
|
running in the system, you can safely stop \term{epmd} if you want.
|
|
|
|
\ejabberd{} runs inside an Erlang node.
|
|
To communicate with \ejabberd{}, the script \term{ejabberdctl} starts a new Erlang node
|
|
and connects to the Erlang node that holds \ejabberd{}.
|
|
In order for this communication to work,
|
|
\term{epmd} must be running and listening for name requests in the port 4369.
|
|
You should block the port 4369 in the firewall in such a way that
|
|
only the programs in your machine can access it.
|
|
|
|
If you build a cluster of several \ejabberd{} instances,
|
|
each \ejabberd{} instance is called an \ejabberd{} node.
|
|
Those \ejabberd{} nodes use a special Erlang communication method to
|
|
build the cluster, and EPMD is again needed listening in the port 4369.
|
|
So, if you plan to build a cluster of \ejabberd{} nodes
|
|
you must open the port 4369 for the machines involved in the cluster.
|
|
Remember to block the port so Internet doesn't have access to it.
|
|
|
|
Once an Erlang node solved the node name of another Erlang node using EPMD and port 4369,
|
|
the nodes communicate directly.
|
|
The ports used in this case by default are random,
|
|
but can be configured in the file \term{ejabberdctl.cfg}.
|
|
The Erlang command-line parameter used internally is, for example:
|
|
\begin{verbatim}
|
|
erl ... -kernel inet_dist_listen_min 4370 inet_dist_listen_max 4375
|
|
\end{verbatim}
|
|
|
|
|
|
\makesection{cookie}{Erlang Cookie}
|
|
|
|
The Erlang cookie is a string with numbers and letters.
|
|
An Erlang node reads the cookie at startup from the command-line parameter \term{-setcookie}.
|
|
If not indicated, the cookie is read from the cookie file \term{\$HOME/.erlang.cookie}.
|
|
If this file does not exist, it is created immediately with a random cookie.
|
|
Two Erlang nodes communicate only if they have the same cookie.
|
|
Setting a cookie on the Erlang node allows you to structure your Erlang network
|
|
and define which nodes are allowed to connect to which.
|
|
|
|
Thanks to Erlang cookies, you can prevent access to the Erlang node by mistake,
|
|
for example when there are several Erlang nodes running different programs in the same machine.
|
|
|
|
Setting a secret cookie is a simple method
|
|
to difficult unauthorized access to your Erlang node.
|
|
However, the cookie system is not ultimately effective
|
|
to prevent unauthorized access or intrusion to an Erlang node.
|
|
The communication between Erlang nodes are not encrypted,
|
|
so the cookie could be read sniffing the traffic on the network.
|
|
The recommended way to secure the Erlang node is to block the port 4369.
|
|
|
|
|
|
\makesection{nodename}{Erlang Node Name}
|
|
|
|
An Erlang node may have a node name.
|
|
The name can be short (if indicated with the command-line parameter \term{-sname})
|
|
or long (if indicated with the parameter \term{-name}).
|
|
Starting an Erlang node with -sname limits the communication between Erlang nodes to the LAN.
|
|
|
|
Using the option \term{-sname} instead of \term{-name} is a simple method
|
|
to difficult unauthorized access to your Erlang node.
|
|
However, it is not ultimately effective to prevent access to the Erlang node,
|
|
because it may be possible to fake the fact that you are on another network
|
|
using a modified version of Erlang \term{epmd}.
|
|
The recommended way to secure the Erlang node is to block the port 4369.
|
|
|
|
|
|
\makesection{secure-files}{Securing Sensible Files}
|
|
|
|
\ejabberd{} stores sensible data in the file system either in plain text or binary files.
|
|
The file system permissions should be set to only allow the proper user to read,
|
|
write and execute those files and directories.
|
|
|
|
\begin{description}
|
|
\titem{ejabberd configuration file: /etc/ejabberd/ejabberd.cfg}
|
|
Contains the JID of administrators
|
|
and passwords of external components.
|
|
The backup files probably contain also this information,
|
|
so it is preferable to secure the whole \term{/etc/ejabberd/} directory.
|
|
\titem{ejabberd service log: /var/log/ejabberd/ejabberd.log}
|
|
Contains IP addresses of clients.
|
|
If the loglevel is set to 5, it contains whole conversations and passwords.
|
|
If a logrotate system is used, there may be several log files with similar information,
|
|
so it is preferable to secure the whole \term{/var/log/ejabberd/} directory.
|
|
\titem{Mnesia database spool files in /var/lib/ejabberd/}
|
|
The files store binary data, but some parts are still readable.
|
|
The files are generated by Mnesia and their permissions cannot be set directly,
|
|
so it is preferable to secure the whole \term{/var/lib/ejabberd/} directory.
|
|
\titem{Erlang cookie file: /var/lib/ejabberd/.erlang.cookie}
|
|
See section \ref{cookie}.
|
|
\end{description}
|
|
|
|
|
|
\makechapter{clustering}{Clustering}
|
|
\ind{clustering}
|
|
|
|
\makesection{howitworks}{How it Works}
|
|
\ind{clustering!how it works}
|
|
|
|
A \Jabber{} domain is served by one or more \ejabberd{} nodes. These nodes can
|
|
be run on different machines that are connected via a network. They all
|
|
must have the ability to connect to port 4369 of all another nodes, and must
|
|
have the same magic cookie (see Erlang/OTP documentation, in other words the
|
|
file \term{\~{}ejabberd/.erlang.cookie} must be the same on all nodes). This is
|
|
needed because all nodes exchange information about connected users, s2s
|
|
connections, registered services, etc\ldots
|
|
|
|
Each \ejabberd{} node has the following modules:
|
|
\begin{itemize}
|
|
\item router,
|
|
\item local router,
|
|
\item session manager,
|
|
\item s2s manager.
|
|
\end{itemize}
|
|
|
|
\makesubsection{router}{Router}
|
|
\ind{clustering!router}
|
|
|
|
This module is the main router of \Jabber{} packets on each node. It
|
|
routes them based on their destination's domains. It uses a global
|
|
routing table. The domain of the packet's destination is searched in the
|
|
routing table, and if it is found, the packet is routed to the
|
|
appropriate process. If not, it is sent to the s2s manager.
|
|
|
|
\makesubsection{localrouter}{Local Router}
|
|
\ind{clustering!local router}
|
|
|
|
This module routes packets which have a destination domain equal to
|
|
one of this server's host names. If the destination JID has a non-empty user
|
|
part, it is routed to the session manager, otherwise it is processed depending
|
|
on its content.
|
|
|
|
\makesubsection{sessionmanager}{Session Manager}
|
|
\ind{clustering!session manager}
|
|
|
|
This module routes packets to local users. It looks up to which user
|
|
resource a packet must be sent via a presence table. Then the packet is
|
|
either routed to the appropriate c2s process, or stored in offline
|
|
storage, or bounced back.
|
|
|
|
\makesubsection{s2smanager}{s2s Manager}
|
|
\ind{clustering!s2s manager}
|
|
|
|
This module routes packets to other \Jabber{} servers. First, it
|
|
checks if an opened s2s connection from the domain of the packet's
|
|
source to the domain of the packet's destination exists. If that is the case,
|
|
the s2s manager routes the packet to the process
|
|
serving this connection, otherwise a new connection is opened.
|
|
|
|
\makesection{cluster}{Clustering Setup}
|
|
\ind{clustering!setup}
|
|
|
|
Suppose you already configured \ejabberd{} on one machine named (\term{first}),
|
|
and you need to setup another one to make an \ejabberd{} cluster. Then do
|
|
following steps:
|
|
|
|
\begin{enumerate}
|
|
\item Copy \verb|~ejabberd/.erlang.cookie| file from \term{first} to
|
|
\term{second}.
|
|
|
|
(alt) You can also add `\verb|-cookie content_of_.erlang.cookie|'
|
|
option to all `\shell{erl}' commands below.
|
|
|
|
\item On \term{second} run the following command as the \ejabberd{} daemon user,
|
|
in the working directory of \ejabberd{}:
|
|
|
|
\begin{verbatim}
|
|
erl -sname ejabberd \
|
|
-mnesia dir "/var/lib/ejabberd/" \
|
|
-mnesia extra_db_nodes "['ejabberd@first']" \
|
|
-s mnesia
|
|
\end{verbatim}
|
|
|
|
This will start Mnesia serving the same database as \node{ejabberd@first}.
|
|
You can check this by running the command `\verb|mnesia:info().|'. You
|
|
should see a lot of remote tables and a line like the following:
|
|
|
|
Note: the Mnesia directory may be different in your system.
|
|
To know where does ejabberd expect Mnesia to be installed by default,
|
|
call \ref{ejabberdctl} without options and it will show some help,
|
|
including the Mnesia database spool dir.
|
|
|
|
\begin{verbatim}
|
|
running db nodes = [ejabberd@first, ejabberd@second]
|
|
\end{verbatim}
|
|
|
|
|
|
\item Now run the following in the same `\shell{erl}' session:
|
|
|
|
\begin{verbatim}
|
|
mnesia:change_table_copy_type(schema, node(), disc_copies).
|
|
\end{verbatim}
|
|
|
|
This will create local disc storage for the database.
|
|
|
|
(alt) Change storage type of the \term{scheme} table to `RAM and disc
|
|
copy' on the second node via the Web Admin.
|
|
|
|
|
|
\item Now you can add replicas of various tables to this node with
|
|
`\verb|mnesia:add_table_copy|' or
|
|
`\verb|mnesia:change_table_copy_type|' as above (just replace
|
|
`\verb|schema|' with another table name and `\verb|disc_copies|'
|
|
can be replaced with `\verb|ram_copies|' or
|
|
`\verb|disc_only_copies|').
|
|
|
|
Which tables to replicate is very dependant on your needs, you can get
|
|
some hints from the command `\verb|mnesia:info().|', by looking at the
|
|
size of tables and the default storage type for each table on 'first'.
|
|
|
|
Replicating a table makes lookups in this table faster on this node.
|
|
Writing, on the other hand, will be slower. And of course if machine with one
|
|
of the replicas is down, other replicas will be used.
|
|
|
|
Also \footahref{http://www.erlang.org/doc/apps/mnesia/Mnesia\_chap5.html\#5.3}
|
|
{section 5.3 (Table Fragmentation) of Mnesia User's Guide} can be helpful.
|
|
% The above URL needs update every Erlang release!
|
|
|
|
(alt) Same as in previous item, but for other tables.
|
|
|
|
|
|
\item Run `\verb|init:stop().|' or just `\verb|q().|' to exit from
|
|
the Erlang shell. This probably can take some time if Mnesia has not yet
|
|
transfered and processed all data it needed from \term{first}.
|
|
|
|
|
|
\item Now run \ejabberd{} on \term{second} with a configuration similar as
|
|
on \term{first}: you probably do not need to duplicate `\verb|acl|'
|
|
and `\verb|access|' options because they will be taken from
|
|
\term{first}; and \verb|mod_irc| should be
|
|
enabled only on one machine in the cluster.
|
|
\end{enumerate}
|
|
|
|
You can repeat these steps for other machines supposed to serve this
|
|
domain.
|
|
|
|
\makesection{servicelb}{Service Load-Balancing}
|
|
\ind{component load-balancing}
|
|
|
|
\makesubsection{componentlb}{Components Load-Balancing}
|
|
|
|
\makesubsection{domainlb}{Domain Load-Balancing Algorithm}
|
|
\ind{options!domain\_balancing}
|
|
|
|
\ejabberd{} includes an algorithm to load balance the components that are plugged on an \ejabberd{} cluster. It means that you can plug one or several instances of the same component on each \ejabberd{} cluster and that the traffic will be automatically distributed.
|
|
|
|
The default distribution algorithm try to deliver to a local instance of a component. If several local instances are available, one instance is chosen randomly. If no instance is available locally, one instance is chosen randomly among the remote component instances.
|
|
|
|
If you need a different behaviour, you can change the load balancing behaviour with the option \option{domain\_balancing}. The syntax of the option is the following:
|
|
\esyntax{\{domain\_balancing, "component.example.com", BalancingCriteria\}.}
|
|
|
|
Several balancing criteria are available:
|
|
\begin{itemize}
|
|
\item \term{destination}: the full JID of the packet \term{to} attribute is used.
|
|
\item \term{source}: the full JID of the packet \term{from} attribute is used.
|
|
\item \term{bare\_destination}: the bare JID (without resource) of the packet \term{to} attribute is used.
|
|
\item \term{bare\_source}: the bare JID (without resource) of the packet \term{from} attribute is used.
|
|
\end{itemize}
|
|
|
|
If the value corresponding to the criteria is the same, the same component instance in the cluster will be used.
|
|
|
|
\makesubsection{lbbuckets}{Load-Balancing Buckets}
|
|
\ind{options!domain\_balancing\_component\_number}
|
|
|
|
When there is a risk of failure for a given component, domain balancing can cause service trouble. If one component is failing the service will not work correctly unless the sessions are rebalanced.
|
|
|
|
In this case, it is best to limit the problem to the sessions handled by the failing component. This is what the \term{domain\_balancing\_component\_number} option does, making the load balancing algorithm not dynamic, but sticky on a fix number of component instances.
|
|
|
|
The syntax is:
|
|
\esyntax{\{domain\_balancing\_component\_number, "component.example.com", Number\}.}
|
|
|
|
|
|
|
|
% TODO
|
|
% See also the section about ejabberdctl!!!!
|
|
%\section{Backup and Restore}
|
|
%\label{backup}
|
|
%\ind{backup}
|
|
|
|
\makechapter{debugging}{Debugging}
|
|
\ind{debugging}
|
|
|
|
\makesection{logfiles}{Log Files}
|
|
|
|
An \ejabberd{} node writes two log files:
|
|
\begin{description}
|
|
\titem{ejabberd.log} is the ejabberd service log, with the messages reported by \ejabberd{} code
|
|
\titem{erlang.log} is the Erlang/OTP system log, with the messages reported by Erlang/OTP using SASL (System Architecture Support Libraries)
|
|
\end{description}
|
|
|
|
The option \term{loglevel} modifies the verbosity of the file ejabberd.log. The syntax is:
|
|
\esyntax{\{loglevel, Level\}.}
|
|
|
|
The possible \term{Level} are:
|
|
\begin{description}
|
|
\titem{0} No ejabberd log at all (not recommended)
|
|
\titem{1} Critical
|
|
\titem{2} Error
|
|
\titem{3} Warning
|
|
\titem{4} Info
|
|
\titem{5} Debug
|
|
\end{description}
|
|
For example, the default configuration is:
|
|
\begin{verbatim}
|
|
{loglevel, 4}.
|
|
\end{verbatim}
|
|
|
|
The log files grow continually, so it is recommended to rotate them periodically.
|
|
To rotate the log files, rename the files and then reopen them.
|
|
The ejabberdctl command \term{reopen-log}
|
|
(please refer to section \ref{ectl-commands})
|
|
reopens the log files,
|
|
and also renames the old ones if you didn't rename them.
|
|
|
|
|
|
\makesection{debugconsole}{Debug Console}
|
|
|
|
The Debug Console is an Erlang shell attached to an already running \ejabberd{} server.
|
|
With this Erlang shell, an experienced administrator can perform complex tasks.
|
|
|
|
This shell gives complete control over the \ejabberd{} server,
|
|
so it is important to use it with extremely care.
|
|
There are some simple and safe examples in the article
|
|
\footahref{http://www.ejabberd.im/interconnect-erl-nodes}{Interconnecting Erlang Nodes}
|
|
|
|
To exit the shell, close the window or press the keys: control+c control+c.
|
|
|
|
|
|
\makesection{watchdog}{Watchdog Alerts}
|
|
\ind{debugging!watchdog}
|
|
|
|
\ejabberd{} includes a watchdog mechanism that may be useful to developers
|
|
when troubleshooting a problem related to memory usage.
|
|
If a process in the \ejabberd{} server consumes more memory than the configured threshold,
|
|
a message is sent to the Jabber accounts defined with the option
|
|
\term{watchdog\_admins}
|
|
\ind{options!watchdog\_admins} in the \ejabberd{} configuration file.
|
|
|
|
The syntax is:
|
|
\esyntax{\{watchdog\_admins, [JID, ...]\}.}
|
|
|
|
The memory consumed is measured in \term{words}:
|
|
a word on 32-bit architecture is 4 bytes,
|
|
and a word on 64-bit architecture is 8 bytes.
|
|
The threshold by default is 1000000 words.
|
|
This value can be configured with the option \term{watchdog\_large\_heap},
|
|
or in a conversation with the watchdog alert bot.
|
|
|
|
The syntax is:
|
|
\esyntax{\{watchdog\_large\_heap, Number\}.}
|
|
|
|
Example configuration:
|
|
\begin{verbatim}
|
|
{watchdog_admins, ["admin2@localhost", "admin2@example.org"]}.
|
|
{watchdog_large_heap, 30000000}.
|
|
\end{verbatim}
|
|
|
|
To remove watchdog admins, remove them in the option.
|
|
To remove all watchdog admins, set the option with an empty list:
|
|
\begin{verbatim}
|
|
{watchdog_admins, []}.
|
|
\end{verbatim}
|
|
|
|
\appendix{}
|
|
|
|
\makechapter{i18ni10n}{Internationalization and Localization}
|
|
\ind{xml:lang}\ind{internationalization}\ind{localization}\ind{i18n}\ind{l10n}
|
|
|
|
The source code of \ejabberd{} supports localization.
|
|
The translators can edit the
|
|
\footahref{http://www.gnu.org/software/gettext/}{gettext} .po files
|
|
using any capable program (KBabel, Lokalize, Poedit...) or a simple text editor.
|
|
|
|
Then gettext
|
|
is used to extract, update and export those .po files to the .msg format read by \ejabberd{}.
|
|
To perform those management tasks, in the \term{src/} directory execute \term{make translations}.
|
|
The translatable strings are extracted from source code to generate the file \term{ejabberd.pot}.
|
|
This file is merged with each .po file to produce updated .po files.
|
|
Finally those .po files are exported to .msg files, that have a format easily readable by \ejabberd{}.
|
|
|
|
All built-in modules support the \texttt{xml:lang} attribute inside IQ queries.
|
|
Figure~\ref{fig:discorus}, for example, shows the reply to the following query:
|
|
\begin{verbatim}
|
|
<iq id='5'
|
|
to='example.org'
|
|
type='get'
|
|
xml:lang='ru'>
|
|
<query xmlns='http://jabber.org/protocol/disco#items'/>
|
|
</iq>
|
|
\end{verbatim}
|
|
|
|
\begin{figure}[htbp]
|
|
\centering
|
|
\insimg{discorus.png}
|
|
\caption{Service Discovery when \texttt{xml:lang='ru'}}
|
|
\label{fig:discorus}
|
|
\end{figure}
|
|
|
|
The Web Admin also supports the \verb|Accept-Language| HTTP header.
|
|
|
|
\begin{figure}[htbp]
|
|
\centering
|
|
\insimg{webadmmainru.png}
|
|
\caption{Web Admin showing a virtual host when the web browser provides the
|
|
HTTP header `Accept-Language: ru'}
|
|
\label{fig:webadmmainru}
|
|
\end{figure}
|
|
|
|
|
|
%\section{Ultra Complex Example}
|
|
%\label{ultracomplexexample}
|
|
%TODO: a very big example covering the whole guide, with a good explanation before the example: different authenticaton mechanisms, transports, ACLs, multple virtual hosts, virtual host specific settings and general settings, modules,...
|
|
|
|
\makechapter{releasenotes}{Release Notes}
|
|
\ind{release notes}
|
|
|
|
Release notes are available from \footahref{http://www.process-one.net/en/ejabberd/release\_notes/}{ejabberd Home Page}
|
|
|
|
\makechapter{acknowledgements}{Acknowledgements}
|
|
|
|
Thanks to all people who contributed to this guide:
|
|
\begin{itemize}
|
|
\item Alexey Shchepin (\ahrefurl{xmpp:aleksey@jabber.ru})
|
|
\item Badlop (\ahrefurl{xmpp:badlop@jabberes.org})
|
|
\item Evgeniy Khramtsov (\ahrefurl{xmpp:xram@jabber.ru})
|
|
\item Florian Zumbiehl (\ahrefurl{xmpp:florz@florz.de})
|
|
\item Michael Grigutsch (\ahrefurl{xmpp:migri@jabber.i-pobox.net})
|
|
\item Mickael Remond (\ahrefurl{xmpp:mremond@process-one.net})
|
|
\item Sander Devrieze (\ahrefurl{xmpp:s.devrieze@gmail.com})
|
|
\item Sergei Golovan (\ahrefurl{xmpp:sgolovan@nes.ru})
|
|
\item Vsevolod Pelipas (\ahrefurl{xmpp:vsevoload@jabber.ru})
|
|
\end{itemize}
|
|
|
|
|
|
\makechapter{copyright}{Copyright Information}
|
|
|
|
Ejabberd Installation and Operation Guide.\\
|
|
Copyright \copyright{} 2003 --- 2009 ProcessOne
|
|
|
|
This document is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This document 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 document; if not, write to the Free Software Foundation, Inc., 51 Franklin
|
|
Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
%TODO: a glossary describing common terms
|
|
%\makesection{glossary}{Glossary}
|
|
%\ind{glossary}
|
|
|
|
%\begin{description}
|
|
%\titem{c2s}
|
|
%\titem{s2s}
|
|
%\titem{STARTTLS}
|
|
%\titem{XEP} (\XMPP{} Extension Protocol)
|
|
%\titem{Resource}
|
|
%\titem{Roster}
|
|
%\titem{Transport}
|
|
%\titem{JID} (\Jabber{} ID) <Wikipedia>
|
|
%\titem{JUD} (\Jabber{} User Directory)
|
|
%\titem{vCard} <Wikipedia>
|
|
%\titem{Publish-Subscribe}
|
|
%\titem{Namespace}
|
|
%\titem{Erlang} <Wikipedia>
|
|
%\titem{Fault-tolerant}
|
|
%\titem{Distributed} <Wikipedia>
|
|
%\titem{Node} <Wikipedia>
|
|
%\titem{Tuple} <Wikipedia>
|
|
%\titem{Regular Expression}
|
|
%\titem{ACL} (Access Control List) <Wikipedia>
|
|
%\titem{IPv6} <Wikipedia>
|
|
%\titem{Jabber}
|
|
%\titem{LDAP} (Lightweight Directory Access Protocol) <Wikipedia>
|
|
%\titem{ODBC} (Open Database Connectivity) <Wikipedia>
|
|
%\titem{Virtual Hosting} <Wikipedia>
|
|
|
|
%\end{description}
|
|
|
|
|
|
|
|
% Remove the index from the HTML version to save size and bandwith.
|
|
\begin{latexonly}
|
|
\printindex
|
|
\end{latexonly}
|
|
|
|
\end{document}
|