Synchronet v3.17b-Win32 (install) has been released (Jan-2019).

New Synchronet YouTube channel

You can donate to the Synchronet project using PayPal.

Access Requirements

Access Requirement Strings (ARS) are used to specify the requirements of a specific Synchronet user account in order to have access to specific areas or functions of a Synchronet BBS.

Overview

You will find in SCFG and other Synchronet configuration files, places where the sysop may specify requirements to access a specific area or feature of the BBS. Usually these items will have ARS (Access Requirement String) or just “Requirements” as part of the name.

Most Access Requirements are “default allow”, meaning, if there are no requirements specified (i.e. the requirement string is blank), then the default behavior is allow access to that specific area/function to any user.

Some Requirement strings are “default deny”, meaning, if there are no requirements specified (i.e. the requirement string is blank), then no user will match that requirement. Examples of “default deny” requirements:

  • Operator Requirements
  • Exemption Requirements
  • Moderated Posting User
  • Pre-pack QWK Requirements

Configuration

SCFG has an interactive Requirements dialog screen which allows easy addition or clearing of the most common requirement parameters.

╔══════════════════════════════════════════════════════════╗
║                  Main Group Requirements                 ║
╠══════════════════════════════════════════════════════════╣
║ │Requirement String ()                                   ║
║ │Clear Requirements                                      ║
║ │Set Required Level                                      ║
║ │Set Required Flag                                       ║
║ │Set Required Age                                        ║
║ │Set Required Sex                                        ║
║ │Set Required Connect Rate                               ║
║ │Set Required Post/Call Ratio (percentage)               ║
║ │Set Required Number of Credits                          ║
║ │Set Required Upload/Download Byte Ratio (percentage)    ║
║ │Set Required Upload/Download File Ratio (percentage)    ║
║ │Set Required Time of Day                                ║
║ │Set Required Day of Week                                ║
║ │Set Required Node Number                                ║
║ │Set Required User Number                                ║
║ │Set Required Time Remaining                             ║
║ │Set Required Days Till Expiration                       ║
╚══════════════════════════════════════════════════════════╝

From this dialog screen, you can edit the Requirement String directly, or use the additional menu options to add the most common requirement parameters (and values) or clear the requirement string.

Syntax

Access Requirement Strings can consist entirely of English keywords and numbers or use short-hand symbols to fit a large number of security requirements into the limited space allowed for access requirement strings. Short-hand symbols and key words may be used interchangeably and combined in the same string. For clarity, it is suggested you use the keywords whenever possible. The string syntax is as follows:

usage: [not] [param] [not] [equal] <value> [or] [and] [...]

where: not      is the word "NOT" or the symbol '!' to specify reverse logic
       param    is one of any keywords (or short-hand symbols) that specifies
                a specific required parameter (default is LEVEL)
       equal    is the word "EQUAL", "EQUALS", the words "EQUAL TO", or the
                symbol '=' to specify exact equality required
       value    the required value (for either minimum requirement or equality)
       or       the word "OR" or the symbol '|' used to specify that ANY of two
                or more parameter values MAY be met to match the requirement
       and      the word "AND" or the symbol '&' may be used for clarity in
                reading when specifying that two or more parameter values MUST
                be met to match the requirement

Logic Operators

Logic operators may exist between one or more Boolean or Value Parameters. When no logic operator is specified, the default logic requirement is GREATER_OR_EQUAL and when multiple parameters are specified, AND (i.e. all the specified parameters must be evaluated to a TRUE condition).

Keyword Symbol Description
AND & More than one requirement (optional)
NOT ! Logical negation (e.g. NOT EQUAL)
EQUAL = Equality required
OR | Either of two or more parameters is required
( Begin nested requirement
) End nested requirement

Boolean Parameters

Boolean parameters are evaluated as true or false without any specified value for comparison.

Keyword Symbol Description
ACTIVE User has an active account (not marked DELETED or INACTIVE)
ANSI $[ User is using an ANSI terminal
PETSCII User is using a PETSCII terminal
DELETED User account is marked DELETED
DOS BBS is running on MS-DOS
EXPERT User is in expert menu mode
GUEST User has the G (Guest) restriction
INACTIVE User account is marked INACTIVE
LINUX BBS is running on Linux
LOCAL $G Local execution (no remote user)
OS2 BBS is running on OS/2
QNODE User has the Q (QWK node) restriction
QUIET User is in quiet mode
RIP $* User is connected with a RIP-compatible terminal
SYSOP User has level 90+ or is a temporary sysop
WIN32 BBS is running on Windows
WIP User is connected with a WIP-compatible terminal
UNIX BBS is running on a UNIX clone

Value Parameters

Value parameters require a value (e.g. word or number) following the parameter keyword or symbol. This parameter is compared against the criteria of the system or the user using the current comparison logic.

Keyword Symbol Description
AGE $A User's age (years since birthdate, 0-255)
BPS $B User's current connect rate (bits-per-second; Telnet, RLogin, and SSH connections will have a BPS value of 30000)
COLS Terminal columns (e.g. 40 or 80+)
CREDIT $C User's number of credits in Kilobytes (0-65535)
DAY $W Day of the week (Sun, Mon, Tue, etc. or 0-6)
DIR $J Current file directory (Internal code or 1-65535)
DLS Total number of files downloaded by user
DLK Total number of kilobytes in files downloaded by user
DLM Total number of megabytes in files downloaded by user
EXEMPT $X Exemptions flag (A-Z)
EXPIRE $E Days till user account expires (0-65535)
FILE_CMDS Number of executed file menu commands (0-65535)
FLAG $F User's flag (1-4) and (A-Z)
GROUP $M Current message group (1-65535)
HOST Client hostname
IP Client IP address
LASTON $Y Days since last logon (0-65535)
LEVEL $L User's level (0-99)
LIB $I Current file library (1-65535)
LOCAL $G Logged on locally (no value argument)
LOGONS Number of user logons
MAIN_CMDS Number of executed main menu commands (0-65535)
NODE $N Current node (1-250)
PCR $P User's post/call ratio (0-100)
PROT Protocol in use (e.g. Telnet, SSH, HTTP, etc.)
RANDOM $Q Random number between 0 and value argument (0-65535)
REST $Z Restrictions flag (A-Z)
ROWS Terminal rows (e.g. 24)
SEX $S User's sex/gender (M or F)
SHELL User's selected command shell internal code
SUB $H Current message sub-board (Internal code or 1-65535)
TERM Terminal type (string)
TIME $T Time of day (HH:MM, 0-23:59)
TLEFT $R User's time left online (minutes, 0-255)
TUSED $O User's time online this call (minutes, 0-255)
UDR $K User's upload/download ratio (0-100)
UDFR $D User's upload/download file ratio (0-100)
ULS Total number of files uploaded by user
ULK Total number of kilobytes in files uploaded by user
ULM Total number of megabytes in files uploaded by user
USER $U User's number (1-xxxx)

General Usage Examples

General Example #1

LEVEL 60

This string specifies that only users with a level of 60 OR HIGHER meet this requirement. The space between the level and the required value is optional:

LEVEL60

is functionally equivalent, but doesn't read as well. You may also use short hand symbols in place of key words to save space:

$L 60

is also functionally equivalent. Once again, the space between the short hand symbol and the required value is optional. If a parameter is not specified, the requirement is assumed to be LEVEL. So the following string:

60

is also valid and evaluates the same as the above strings.

General Example #2

NOT LEVEL 60

This string specifies that only users with a level BELOW 60 will meet the requirement. The “NOT” key word can be include before or after the parameter:

LEVEL NOT 60

evaluates identically to the first string in this example.

Short-hand symbols may be used to abbreviate the string:

LEVEL !60

$L!60

!60

have exactly the same meaning as the first string in this example.

General Example #3

LEVEL EQUAL 60

This string specifies that only users with a level EQUAL TO 60 will meet this requirement. The key word “EQUALS” or the combination “EQUAL TO” may be used in place of “EQUAL” if preferred:

LEVEL EQUALS 60

and

LEVEL EQUAL TO 60

are both functionally equivalent to the first string in this example. Again, short-hand symbols may be used to make the string shorter:

LEVEL = 60

evaluates identically to the above example strings and the space on either side of the '=' symbol are also optional:

LEVEL=60

is valid and may be preferred by some sysops. Since level is the default parameter type, the following string is also valid:

=60

General Example #4

LEVEL 60 AND FLAG 1A

This string indicates that the user must have a level of 60 or higher AND have the flag 'A' from flag set #1. The user must meet both requirements in order to be considered as meeting all the requirements of the string. The “AND” portion of the string is only included for clarity in reading and is optional:

LEVEL 60 FLAG 1A

has the same meaning, but may be confusing when read. When specifying a flag from flag set #1, the set number may be eliminated:

LEVEL 60 AND FLAG A

is functionally the same and is the preferred method of referring to flags from flag set #1. When specifying the flag set, spaces can be on either side of the number, or eliminated entirely:

LEVEL 60 AND FLAG1 A

and

LEVEL 60 AND FLAG 1 A

and

LEVEL 60 AND FLAG1A

have the same meaning as the first string in this example, but are probably not as easy to read as the second string in this example.

The following strings all have the same meaning as the first string in this example but have been shortened using symbols and other short-cuts:

LEVEL 60 & $F A

$L60 AND $FA

$L60$FA

60$FA

but for reasons of clarity, the first string is preferred if space allows.

General Example #5

SEX F OR LEVEL 90

This string specifies that the user must be of FEMALE gender OR have a level of 90 or higher. The following strings are functionally equivalent to the above:

SEX F | LEVEL 90

SEXF|LEVEL90

$SF | $L90

$SF|$L90

General Example #6

USER NOT EQUAL TO 20

This string specifies that user #20 will not meet the requirement.

Shortened using symbols:

$U!=20

General Example #7

BPS 9600 OR NOT TIME 19:00

This string specifies that the user must be connected at 9600bps or higher, OR the time of day must be before 7pm. The value for the TIME parameter is in the format 24 hour format of HH:MM. If the specified time is on an even hour, then “:00” portion may be omitted:

BPS 9600 OR NOT TIME 19

has the same meaning.

You may also omit the “00” from the BPS value to shorten the string:

BPS 96 OR NOT TIME 19

Shortened versions:

$B 9600 OR NOT $T19

BPS9600|!TIME19

$B96|!$T19

General Example #8

BPS 9600 OR TIME NOT 18:00 OR TIME 21:30

This string specifies that the user must be connected at 9600bps or higher, OR the time of day must be before 6pm, OR the time of day must be after 9:30pm.

When specifying multiple parameters of the same type consecutively (in this example, two of the required parameters are “TIME”), the parameter does not need to be restated. For example, the string:

BPS 9600 OR TIME NOT 18:00 OR 21:30

has the same meaning as the first string in this example.

Shortened versions:

$B 9600 OR NOT $T 18 OR 21:30

$B96|$T!18|21:30

General Example #9

FLAG A OR FLAG B OR FLAG C OR LEVEL 90

The above string specifies that a user must have flag A, flag B, flag C, (all from flag set #1) or a level of 90 or higher to meet the requirement. Using the “sticky” parameter type feature of AR Strings, we can shorten the line:

FLAG A OR B OR C OR LEVEL 90

Utilizing symbols, we can shorten it even further:

FLAG A|B|C OR LEVEL 90

Taking it to extremes:

$FA|B|C|$L90

General Example #10

USER EQUALS 145 OR LEVEL 90

This string indicates that user number 145 will meet the requirement and all users with level 90 and higher (sysops).

Best shortened as:

USER=145 OR LEVEL 90

For ultimate compression:

$U=145|$L90

General Example #11

LEVEL 60 AND FLAG X AND FLAG Y AND FLAG Z

Compressed examples:

LEVEL 60 AND FLAG X AND Y AND Z

LEVEL 60 AND FLAG X Y Z

LEVEL 60 FLAG XYZ

LEVEL60 FLAGXYZ

$L60 $FXYZ

60$FXYZ

General Example #12

FLAG 2A OR FLAG 2B OR FLAG 4Z

This string specifies that the user must have either flag 'A or 'B' from flag set #2, or flag 'Z' from flag set #4. Using the “sticky” parameter type feature, this could be shortened to:

FLAG 2A OR B OR FLAG 4Z

If the flag set is not #1, you MUST specify the flag set number when using the FLAG keyword.

Example:

FLAG 2A OR FLAG B OR FLAG 4Z

is NOT the same as the first two strings in this example. The second flag (B) would be considered as from flag set #1, since a flag set number was not specified.

Correct and shortened version:

FLAG2A|B OR FLAG4Z

$F2A|B|$F4Z

Note: Multiple flag sets were developed for advanced sysops who found that the 26 flag limitation (A-Z) was insufficient and requested additional flag capabilities. Most sysops will probably not find it necessary to use more than 26 flags, and therefore have no need for flag sets 2 through 4.

General Example #13

NOT FLAG 2G

This string specifies that the user most not have flag 'G' from flag set #2. The NOT keyword can appear in several places in this string while keeping the exact same meaning:

FLAG NOT 2G

FLAG 2 NOT G

Condensed versions:

!$F2G

$F!2G

$F2!G

Nesting Expressions

All of the above string examples have been single expressions that evaluate to either true of false. Sometimes, you may wish to require access to an area using “nested” logic.

Example: If the user is level 90+, OR the user has the A flag, AND is 21+ years of age or older.

The above example could be read two ways.

1: The user must have level 90+, and either the A FLAG or be 21+ years old.

2: The user must be 21+ years old and have either the A FLAG or level 90+.

To clarify which of the above methods were intended, we use parentheses to separate the two true/false expressions.

1: LEVEL 90 OR (FLAG A AND AGE 21)

2: (LEVEL 90 OR FLAG A) AND AGE 21

Strings 1 and 2 are interpreted differently and correlate to the above two English logic statements.

Whenever using a combination of AND and OR logic, nested expressions are required. The following string:

LEVEL 90 OR FLAG A AND AGE 21

is INVALID and would most likely NOT produce the desired results.

Expressions may be nested, using parenthesis, as deep as is required.

Example: ((LEVEL 80 OR FLAG S) AND AGE 18) OR LEVEL 90

is a VALID string that would evaluate with the following:

  • User with level of 80 and age 17 would not qualify
  • User with level of 80, flag S and age 17 would not qualify
  • User with level of 80 and age 18 would qualify
  • User with flag S and age 18 would qualify
  • Any user with level 90+ would qualify regardless of age or flags

Nested Logic Examples

Nested Example #1

BPS 9600 OR (BPS 2400 AND TIME NOT 15:00)

User must be connected at 9600bps or higher, OR be connected at 2400bps or higher and the time of day being before 3pm. 9600bps and higher callers would always meet this requirement. 2400-7200bps callers will only meet this requirement between 12:00 midnight and 3pm in the afternoon. 1200bps and slower callers would never meet this requirement.

Note, that when nesting expressions, the parameter type DOES NOT stick from one expression to another.

Example:

BPS 9600 OR (2400 AND TIME NOT 15:00)

Is an INVALID string. The 2400 would be interpreted as a LEVEL requirement since it is as the beginning of a new expression and LEVEL is the default parameter type.

The first (correct) string in this example, can of course also be shortened using symbols (and eliminating the AND key word):

$B9600|($B2400$T!15)

Nested Example #2

(SEX M AND AGE 21) OR (SEX F AND AGE 18)

This string specifies that only male users of 21 years and older and female users of 18 and older will meet the requirement.

Shortened Example:

($SM$A21)|($SF$A18)

The logic of the above string is more verbose than necessary and could be reduced to:

AGE 21 OR (SEX F AND AGE 18)

producing the same results.

Nested Example #3

(BPS 2400 AND PCR 20) OR LEVEL 90

This string would indicate that users of any level will have access if they are connected at 2400bps and have a Post/Call ratio of 20% or higher - OR the users has as least level 90 (sysop).

Utilizing the default parameter type of level, the LEVEL key word can be omitted:

(BPS 2400 AND PCR 20) OR 90

to create a functionally equivalent, though more confusing, AR string.

A better way to shorten the string would be to eliminate the AND keyword and use symbols:

($B 2400 $P 20) | $L 90

Eliminating the spaces creates an even more compact string:

($B2400$P20)|$L90

Nested Example #4

NOT (USER=1 OR USER=20)

All users will meet this requirement accept user #1 and user #20.

The above string could also be stated in a non-nested format with the same results:

NOT USER=1 AND NOT USER=20

though the meaning is not quite as clear, they are functionally the same.

Note: The second method requires 2 bytes less in raw logic storage because it is not nested and will be interpreted slightly faster (by a matter of microseconds). Just in case you were wondering...

Nested Example #5

LEVEL 90 OR (TIME 12:00 AND TIME NOT 18:00)

Users with level 90 or higher will always meet this requirement. Users with levels below 90 will only meet this requirement between 12 noon and 6pm.

Re-arranged:

(TIME 12:00 AND TIME NOT 18:00) OR LEVEL 90

the string has exactly the same meaning. Eliminating the unnecessary occurrence of the second “TIME” parameter shortens the string while keeping it easily readable:

(TIME 12:00 AND NOT 18:00) OR LEVEL 90

Maximum compression:

($T12!18)|90

See Also


In Other Languages
Translations of this page: