vulpineawoo/solanum
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
solanum/doc/oper-guide/umodes.rst

277 lines
8.9 KiB
ReStructuredText
Raw Normal View History

fix duplicate headings, remove duplicate ToC
2017-03-25 15:15:03 +00:00
User modes
==========
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+a``, server administrator
----------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
This vanity usermode is used to denote a server administrator in WHOIS
output. All local “admin” privileges are independent of it, though
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
services packages may grant extra privileges to ``+a`` users.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+D``, deaf
------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
.. note:: This is a user umode, which anybody can set. It is not
specific to operators.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Users with the ``+D`` umode set will not receive messages sent to channels.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
Joins, parts, topic changes, mode changes, etc are received as normal,
as are private messages.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Support of this umode is indicated by the ``DEAF`` token in ``RPL_ISUPPORT``
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
(005); the parameter indicates the letter of the umode. Note that
several common IRCD implementations have an umode like this (typically
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+d``) but do not have the token in 005.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+g``, Caller ID
-----------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
.. note:: This is a user umode, which anybody can set. It is not
specific to operators.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Users with the ``+g`` umode set will only receive private messages
from users on a session-defined whitelist, defined by the ``/accept``
command. If a user who is not on the whitelist attempts to send a
private message, the target user will receive a rate-limited notice
saying that the user wishes to speak to them.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
Network operators are not affected by the callerid whitelist system in
the event that they need to speak to users who have it enabled.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Support of this umode is indicated by the ``CALLERID`` token in
``RPL_ISUPPORT`` (005); the optional parameter indicates the letter of
the umode, otherwise ``+g``.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+i``, invisible
-----------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
.. note:: This is a user umode, which anybody can set. It is not
specific to operators.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
review umodes.rst
2017-03-25 15:45:22 +00:00
Invisible users do not show up in ``WHO`` and ``NAMES`` unless you can see them.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+l``, receive locops
----------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
review umodes.rst
2017-03-25 15:45:22 +00:00
``LOCOPS`` is a version of ``OPERWALL`` that is sent to opers on a single server
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
only. With cluster{} and shared{} blocks they can optionally be
propagated further.
review umodes.rst
2017-03-25 15:45:22 +00:00
Unlike ``OPERWALL``, any oper can send and receive ``LOCOPS``.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+o``, operator
----------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
This indicates global operator status.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+Q``, disable forwarding
--------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
.. note:: This is a user umode, which anybody can set. It is not
specific to operators.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
This umode prevents you from being affected by channel forwarding. If
enabled on a channel, channel forwarding sends you to another channel if
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
you could not join. See channel mode ``+f`` for more information.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+R``, reject messages from unauthenticated users
--------------------------------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
.. note:: This is a user umode, which anybody can set. It is not
specific to operators.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
If a user has the ``+R`` umode set, then any users who are not authenticated
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
will receive an error message if they attempt to send a private message
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
or notice to the ``+R`` user.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Opers and accepted users (like in ``+g``) are exempt. Unlike ``+g``, the target
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
user is not notified of failed messages.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+s``, receive server notices
------------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
This umode allows an oper to receive server notices. The requested types
of server notices are specified as a parameter (“snomask”) to this
umode.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+S``, network service
-----------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
.. note:: This umode can only be set by servers named in a service{}
block.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
This umode grants various features useful for services. For example,
clients with this umode cannot be kicked or deopped on channels, can
review umodes.rst
2017-03-25 15:45:22 +00:00
send to any channel, do not show channels in ``WHOIS``, can be the target of
services aliases and do not appear in ``/stats p``. No server notices are
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
sent for hostname changes by services clients; server notices about
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
kills are sent to snomask ``+k`` instead of ``+s``.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
The exact effects of this umode are variable; no user or oper on an
actual charybdis server can set it.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+w``, receive wallops
-----------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
.. note:: This is a user umode, which anybody can set. It is not
specific to operators.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
review umodes.rst
2017-03-25 15:45:22 +00:00
Users with the ``+w`` umode set will receive ``WALLOPS`` messages sent by opers.
Opers with ``+w`` additionally receive ``WALLOPS`` sent by servers (e.g. remote
``CONNECT``, remote ``SQUIT``, various severe misconfigurations, many services
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
packages).
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+z``, receive operwall
------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
review umodes.rst
2017-03-25 15:45:22 +00:00
``OPERWALL`` differs from ``WALLOPS`` in that the ability to receive such
messages is restricted. Opers with ``+z`` set will receive ``OPERWALL``
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
messages.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+Z``, SSL user
----------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
This umode is set on clients connected via SSL/TLS. It cannot be set or
unset after initial connection.
Snomask usage
fix two headings to be toplevel
2017-03-25 16:33:06 +00:00
=============
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
review umodes.rst
2017-03-25 15:45:22 +00:00
Usage is as follows::
MODE nick +s +/-flags
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
To set snomasks.
review umodes.rst
2017-03-25 15:45:22 +00:00
::
MODE nick -s
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
To clear all snomasks.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Umode ``+s`` will be set if at least one snomask is set.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Umode ``+s`` is oper only by default, but even if you allow nonopers to set
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
it, they will not get any server notices.
Meanings of server notice masks
fix two headings to be toplevel
2017-03-25 16:33:06 +00:00
===============================
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+b``, bot warnings
--------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Opers with the ``+b`` snomask set will receive warning messages from the
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
server when potential flooders and spambots are detected.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+c``, client connections
--------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Opers who have the ``+c`` snomask set will receive server notices when
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
clients attach to the local server.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+C``, extended client connection notices
------------------------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Opers who have the ``+C`` snomask set will receive server notices when
clients attach to the local server. Unlike the ``+c`` snomask, the
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
information is displayed in a format intended to be parsed by scripts,
review umodes.rst
2017-03-25 15:45:22 +00:00
and includes the two unused fields of the ``USER`` command.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+d``, debug
-------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
The ``+d`` snomask provides opers extra information which may be of interest
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
to debuggers. It will also cause the user to receive server notices if
certain assertions fail inside the server. Its precise meaning is
variable. Do not depend on the effects of this snomask as they can and
will change without notice in later revisions.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+f``, full warning
--------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Opers with the ``+f`` snomask set will receive notices when a user
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
connection is denied because a connection limit is exceeded (one of the
limits in a class{} block, or the total per-server limit settable with
review umodes.rst
2017-03-25 15:45:22 +00:00
``/quote set max``).
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+F``, far client connection notices
-------------------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
.. note:: This snomask is only available if the ``sno_farconnect.so``
extension is loaded.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Opers with ``+F`` receive server notices when clients connect or disconnect
on other servers. The notices have the same format as those from the ``+c``
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
snomask, except that the class is ? and the source server of the notice
is the server the user is/was on.
No notices are generated for netsplits and netjoins. Hence, these
notices cannot be used to keep track of all clients on the network.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
There is no far equivalent of the ``+C`` snomask.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+k``, server kill notices
---------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Opers with the ``+k`` snomask set will receive server notices when services
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
kill users and when other servers kill and save (forced nick change to
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
UID) users. Kills and saves by this server are on ``+d`` or ``+s``.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+n``, nick change notices
---------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
An oper with ``+n`` set will receive a server notice every time a local user
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
changes their nick, giving the old and new nicks. This is mostly useful
for bots that track all users on a single server.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+r``, notices on name rejections
----------------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
Opers with this snomask set will receive a server notice when somebody
tries to use an invalid username, or if a dumb HTTP proxy tries to
connect.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+s``, generic server notices
------------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
This snomask allows an oper to receive generic server notices. This
includes kills from opers (except services).
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+u``, unauthorized connections
--------------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
This snomask allows an oper to see when users try to connect who do not
have an available auth{} block.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+W``, whois notifications
---------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
.. note:: This snomask is only available if the ``sno_whois.so``
extension is loaded.
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
review umodes.rst
2017-03-25 15:45:22 +00:00
Opers with ``+W`` receive notices when a ``WHOIS`` is executed on them on their
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
server (showing idle time).
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+x``, extra routing notices
-----------------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Opers who have the ``+x`` snomask set will get notices about servers
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
connecting and disconnecting on the whole network. This includes all
servers connected behind the affected link. This can get rather noisy
but is useful for keeping track of all linked servers.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+y``, spy
-----------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
review umodes.rst
2017-03-25 15:45:22 +00:00
Opers with ``+y`` receive notices when users try to join ``RESV``'ed (“juped”)
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
channels. Additionally, if certain extension modules are loaded, they
will receive notices when special commands are used.
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
``+Z``, operspy notices
-----------------------
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
some styling turn all +flags into preformatted flags, fix admonitions
2017-03-25 15:33:06 +00:00
Opers with ``+Z`` receive notices whenever an oper anywhere on the network
convert SGML guide to RST the rationale behind switching away from SGML/Docbook is the following: * SGML is hard to edit for humans * the output is not much prettier * the toolchain is not well supported and missing from the build * the build is not hooked into anywhere, no automation the reason why RST was chosen: * it allows for a strong structure like Docbook * the theme from Read The Docs is pretty * it also supports mobile devices * sphinx can easily output to PDF and ePUB formats * RST is plaintext that can be easily edited and diff'd * RST can be automatically built by ReadTheDocs and the toolchain is readily available * the output is also parsed by Github so documentation can be read straight from GH the reason why Markdown was not chosen: * the current strong structure would be hard to replicate * markdown is not standardized and output varies according to the implementation the docs were converted with Pandoc, using the following commands: mkdir oper-guide for source in sgml/oper-guide/*.sgml; do pandoc --toc -s -f docbook -t rst $source -o oper-guide/$(basename $source .sgml).rst done cd oper-guide sphinx-quickstart git add *.rst make.bat conf.py git add -f Makefile git rm -r ../sgml [merged from d4214e9445d9f9d0f0ede3e09a9f81deee9: doc/sgml/oper-guide/config.sgml]
2017-03-25 14:42:32 +00:00
uses operspy.
This snomask can be configured to be only effective for admins.
Reference in a new issue Copy permalink