:doctype: book = FLSSRV manual limes datentechnik gmbh + v5.1.21-26794, 2020-01-03 20:24:34: + release. + + + + + Frankenstein Limes Integrated Extended Security (FLIES(R)) + Copyright (C) limes datentechnik (R) gmbh + All rights reserved + + + + + == Trademarks Below, you can find all trademarks or registered trademarks of limes datentechnik (R) gmbh. These trademarked terms are marked with the appropriate symbol ((R) or (TM)), indicating registered or common law trademarks owned by limes datentechnik (R) gmbh at the time this information was published. The following terms are trademarks of limes datentechnik (R) gmbh in Germany, other countries, or both: * limes(R) - Short company name of the owner of this document * limes datentechnik(R) - Company name of the owner of this document * FLCL(R) - Frankenstein Limes Command Line * FLCC(R) - Frankenstein Limes Control Center * FLAM(R) - Frankenstein Limes Access Method * FLUC(R) - Frankenstein Limes Universal Converter * FLIES(R) - Frankenstein Limes Integrated Extended Security * FLAMFILE(R) - A file based on FLAM syntax == Abstract This document provides information about using the Frankenstein Limes Integrated Extended Security (FLIES) Server. It contains advanced guidelines and information to run this network server. With the FLIES server FLAMFILES can be accessed over the net. == Supported systems FLAM is available for a variety of operating systems. For example: ------------------------------------------------------------------------ Platform: Operating System: x86 Linux, Windows, Solaris SPARC Solaris pSeries AIX, Linux zSeries z/OS, z/Linux ------------------------------------------------------------------------ [preface] == Preface The FLSSRV command line is implemented with the CLE/P library. The CLE/P library was developed by limes datentechnik and released as open source under the ZLIB license. CLE/P is a compiler to provide a platform independent command line interface for each kind of batch processing environment. The CLE/P library provides a lot of features including all the built-in functions below. For example: We use this library to automatically create this document as part of our build process; If we add a parameter to the CLE/P tables and build the FL5 project, this manual will be regenerated as well in order to be always up to date. This manual is generated with the built-in function GENDOCU provided by the CLE/P library by calling the command below: ----------------------------------------------------------------------- flssrv gendocu flssrvbk.txt ----------------------------------------------------------------------- Based on that the document is always in sync with the implementation but some redundancies are the result of such generated documentation. This manual was designed as a reference book and in this context it is useful for a parameter to be described in all places where it is of relevance. [[clep.main]] == 1. Command line parser The COMMAND LINE PROCESSOR (CLEP) is a user application programming interface for several platforms including Windows, Unix and z/OS that simplifies and standardizes parameter string processing. The CLEP provides two separate functions: * COMMAND LINE PARSER (CLP) - Compiles a parameter string from a command to a data structure * COMMAND LINE EXECUTOR (CLE) - Supporting execution of different commands with parameter strings The COMMAND LINE EXECUTOR provides a list of commands and some built-in functions, please use <>, <> and <> to get extensive information about these capabilities. Additionally the built-in function <> can generate a complete or a part of the user manual. To read the parameter of a command, a compiler (CLP) is applied. To see the regular expressions (lexems) and the corresponding grammar, please use the built-in functions <> and <>. The return/condition/exit codes of the executable and the reason codes of the different commands can be reviewed with the built-in function <>. See <> and, if available, <> for the meaning of the used return and reason codes. The CLE uses an owner management in order to separate the settings for different clients and a property management for each command. If problems occur, a trace might be activated. For each command execution the owner and environment variables can be defined in the configuration file. To see the current configuration use the built-in function <>. The default trace file is 'stdout'. If the trace is activated before a trace file is defined, the trace will be printed on the screen. To manage the tracing use built-in function <>. Last but not least it is possible to view the license, version and other information about the program. This is the RELEASE build version of the FLAMCLEP. === 1.1. Command line considerations The command line parser supports abbreviation of keywords depending on the unique first characters. This is only useful if you work in dialog. If the command is specified in a persistent way (e.g. in a script) writing the complete keyword is recommended, to ensure that the script must not be changed to work with a later version of the program. For example: Version X supports only one keyword starting with V (VERSION). Version X+1, supports the keywords VERSION and VERIFY. If you use version X with VER=4711 anything is fine but with with version X+1 it will fail, because one more character is required (VERS=4711) for the keyword to be unique. The same is valid for the required string support. The CLP supports strings without enclosing. These strings depend on the keywords used in a name space. If new key words are added in future version, the string could cause errors and must be enclosed. Concerning this it is recommended to enclose strings if the command is defined in a script. For example: ------------------------------------------------------------------------ Version X: STRING=my/data/Name NUMBER=42 Version X+1 supports the new keyword NAME, this requires: STRING='my/data/Name' NUMBER=42 NAME='Hugo' ------------------------------------------------------------------------ The last item which could result in a damaged command syntax after a program update is the use of implicit array definitions after an assignment, because the end of such an array might change, for example if an array of numbers defined an a switch is the end. In a new version such a switch could be a number with a default value, if only the keyword is defined. In this case the defined number referenced by this keyword is then part of the number array and the parameter is lost. Concerning this it is recommended to use enclosed array definitions. For example: ------------------------------------------------------------------------ instead of: FLOATARRAY=1,2,3,PI use: FLOATARRAY[1,2,3,PI] ------------------------------------------------------------------------ All these capabilities are implemented to be compatible with several existing command lines syntaxes and to limit the effort to port old commands or to simplify the interactive use. But in certain cases, the command interpretation could fail, if not the unique/enclosed variant of keywords, strings and arrays are used. [[clep.main.usedenv]] === 1.2. Used environment variables Below you can find the list of environment variables used by CLE and CLP. * LANG - to determine the CCSID on EBCDIC systems * HOME - to determine the home directory on UNIX/WIN * USER - to determine the current user id on UNIX/WIN * ENVID - for the current environment qualifier (D/T/P) if key label template mapping used (default is 'T') * OWNERID - used for current owner if not already defined * CLP_NOW - The current point in time used for predefined constants (0tYYYY/MM/DD.HH:MM:SS) * CLP_STRING_CCSID - CCSID used for interpretation of critical punctuation character on EBCDIC systems (default is taken from LANG) * CLP_DEFAULT_DCB - The default record format and record length in C file mode format (default is 'recfm=VB, lrecl=516' only for z/OS) * FLSSRV_CONFIG_FILE - the configuration filename (default is '$HOME/.flssrv.config' on UNIX/WIN or '&SYSUID..FLSSRV.CONFIG' on mainframes) * FLSSRV_DEFAULT_OWNER_ID - the default owner ID (default is 'limes') * owner_FLSSRV_command_PROPERTY_FILENAME - To override default property file names * path_argument - to override the hard coded default property value Environment variables can be set from the system or in the program configuration file with the built-in function <>. Particularly on mainframe systems the configuration file is an easy way to define environment variables. Additionally on host systems the DD name STDENV and with lower priority the data set name '&SYSUID..STDENV' is supported. On the other architectures the file '.stdenv' in the working or with lower priority in the home directory can be used to define environment variables. The STDENV files allows to define the FLSSRV_CONFIG_FILE, FLSSRV_DEFAULT_OWNER_ID, LANG and other environment variables in JCL: Below a you can find a sample with a z/OS DD name allocation. ----------------------------------------------------------------------- //STDENV DD * FLSSRV_CONFIG_FILE=GLOBAL.FLSSRV.CONFIG LANG=de_DE.IBM-1141 HOME=/u/hugo USER=hugo ENVID=T /* ----------------------------------------------------------------------- The definition of the LANG variable outside of the program configuration file is recommended, so that the system character set is defined in each situation. The program configuration file name is used as is, there are no replacements () possible, because it is used in front of establishment of the environment it self. Often it will be useful to have a dedicated environment per user on mainframes. In such a case it makes sense to define the environment in a dedicated file for each user. ----------------------------------------------------------------------- //STDENV DD DSN=USER.ENVIR(&SYSUID.), DSP=SHR ----------------------------------------------------------------------- Since z/OSv2r1 you can also used exported JCL symbols like environment variables. The exported JCL symbols have lower priority then the same environment variable. The service CEEGTJS is called dynamically and the language environment must be in the STEPLIB concatenation to use it. Additional all z/OS system symbols can be used in the in the string replacement (<&LDAY>). The environment variable have the highest priority, followed by the exported JCL symbols. The lowest priority have system symbols. If the variable name not found, then no replacement are done and the angle bracket keep still in place. ------------------------------------------------------------------------ //E0 EXPORT SYMLIST=* //S1 SET BLKSIZE=27886 //S3 SET LRECL=128 ------------------------------------------------------------------------ For z/OS, the default record format and record length for non-existent output files is `recfm=VB, lrecl=516`. An attempt is made to open an existing file with `recfm=*` for overwriting (DISP=OLD). If this fails, another attempt is made with `recfm=VB, lrecl=516` to write a new file (DISP=NEW). The environment variable CLP_DEFAULT_DCB can be used to change this default file mode string. See 'Keyword Parameters for File Mode' for fopen() in _z/OS XL C/C++ Runtime Library Reference_ for more information and for the correct syntax. Beside 'recfm' with a valid record format (not '*' or '+') and 'lrecl', the 'space' parameter can be set. All other file mode parameters are managed by CLP. Beside all the environment variables managed by CLE it is possible to set all properties as environment variables to override the hard coded default values with CLP. If a property is defined as environment variable and in a property file, then the value in the property file overrides the setting in the environment. The environment variable name for each property is build by the rules below: * convert all characters to upper case * replace all dots (`.`) by underline (`_`) To get a list and help for all properties please use the built-in function 'GENPROP' to generate property files. The properties can be defined per owner, per program and general. The owner specific definition overrides the program specific definition and the program specific definition overrides the general definition. Examples: ----------------------------------------------------------------------- CONV_READ_TEXT_ENL2LF=OFF #in general the 0x15 to 0x25 conversion is off# HUGO_FLCL_CONV_READ_TEXT_ENL2LF=ON # for owner 'hugo' the conversion is on# ----------------------------------------------------------------------- The value string behind the sign (including the comment) will be used as supplement for the command line processor. Aliases are not supported in this case. You can only define properties for the main argument. If a string must be enclosed with apostrophe, please don't use double quotation marks, because these are used in addition if a new property file is build based on the environment settings. ----------------------------------------------------------------------- FLCL_ICNV_FROM='IBM-1141' # this is the best solution FLCL_ICNV_TO=UTF-8 # "UTF-8" could result in errors ----------------------------------------------------------------------- See <> for the current property file content. === 1.3. Environment variable mapping Each value enclosed with angle brackets (`<>`) are replaced with the corresponding environment variable (``). This feature is available at each starting point of a lexem and inside of a normal string. If the environment variable not defined the replacements below are still possible: * - Current user id in upper case * - Current user id (case sensitive) * - Current user id in upper case == * - Current user id in title case * - Current user id in lower case * - Replaces with the users data directory, if this not available the replacements below are done: ** On UNIX with /home/ ** On USS with /u/ ** On ZOS with [[clep.main.filemap]] === 1.4. Filename mapping All filenames used by CLEP are additionally mapped based on the rules below: * The tilde character (`~`) is replaced with the string "" * DD names on mainframes must be prefixed with "DD:" * Data set names on mainframes are always full qualified * Path names on mainframes must contain a least one slash (`/`) * Data set names on USS must start with // ** Full qualified names with HLQ must enclose in apostrophes ("//''") ** If apostrophes are not used the SYSUID is prefixed as HLQ * Normal file names on other platforms could be relative *ATTENTION:* If a requested environment variable is not defined, the replacement is done with the empty string. This can result in unexpected behavior. To use a "<" or "~" as a part of a filename the character must be specified twice. Beside this rules the replacement technologies of your shell can be used, but on some platforms $HOME, $USER or something similar might not be available, for such cases the possibilities above are implemented. This file name mapping is provided by the library CLEPUTL and should also be used for file names managed by the commands supported with this program. === 1.5. Key label name mapping The key label name mapping works like the file name mapping, but you can additional use `^` to replace it with the OWNERID (`^=`), `!` to replace it with the environment identifier (`!=`) and `~` is only replaced with login user id. If the environment ID not defined then `T` for test is used by default. [[clep.main.ebcdic]] === 1.6. Special EBCDIC code page support To interpret commands correctly the punctuation characters below are on different code points depending on the EBCDIC CCSID used to enter these values. ------------------------------------------------------------------------ CRITICAL PUNCTUATION CHARACTERS: ! $ # @ [ \\ ] ^ ` { | } ~ ------------------------------------------------------------------------ These critical characters are interpreted normally dependent on the environment variable LANG. If the environment variable LANG is not defined then the default CCSID IBM1047 (Open Systems Latin-1) is used. Below is the current list of supported CCSIDs on EBCDIC systems. ------------------------------------------------------------------------ SUPPORTED EBCDIC CODE PAGES FOR COMMAND ENTRY: "IBM-1140","IBM-1141","IBM-1142","IBM-1143", "IBM-1144","IBM-1145","IBM-1146","IBM-1147", "IBM-1148","IBM-1149","IBM-1153","IBM-1154", "IBM-1156","IBM-1122","IBM-1047","IBM-924", "IBM-500","IBM-273","IBM-037","IBM-875","IBM-424", "IBM-277","IBM-278","IBM-280","IBM-284","IBM-285", "IBM-297","IBM-871","IBM-870","IBM-1025","IBM-1112", "IBM-1157" ------------------------------------------------------------------------ You can define the code page explicitly (LANG=de_DE.IBM-1141) or only the language code (LANG=de_DE, LANG=C). If only the language code defined then the CCSID is derived from the language code (DE=IBM-1141, US=IBM-1140, C=IBM-1047, ...). If possible, these critical characters are also converted for print outs. At output it is not possible to convert anything correctly, because some strings for print out are coming from other sources (like system messages and others). Only all known literals are converted, for unknown variables such a conversion is not possible and CLEP expects that such strings are encoded in the correct system code page, but there is no guaranty for this. To be independent of the environment escaping of the CLP strings is possible for the critical punctuation characters on EBCDIC systems. See list below: ------------------------------------------------------------------------ ! = &EXC; - Exclamation mark $ = &DLR; - Dollar sign # = &HSH; - Hashtag (number sign) @ = &ATS; - At sign [ = &SBO; - Square bracket open \\ = &BSL; - Backslash ] = &SBC; - Square bracket close ^ = &CRT; - Caret (circumflex) ` = &GRV; - Grave accent { = &CBO; - Curly bracket open | = &VBR; - Vertical bar } = &CBC; - Curly bracket close ~ = &TLD; - Tilde ------------------------------------------------------------------------ A escape sequence starts with the ampersand (&) followed be 3 character (not case sensitive) and is terminated with semicolon (;). With an X and 2 hexadecimal digit the definition of a binary byte value are possible. If such a sequence in the string required then the ampersand must be typed twice (&&). To mark a part or the of whole string in a certain CCSID the escape sequence must contain 1 to 6 digits. Few samples can be found below: ------------------------------------------------------------------------ &1047; all in 1047 &0; reset to system code page &1140; no in 1140 ------------------------------------------------------------------------ At the beginning the system code page is active except the environment variable CLP_STRING_CCSID is defined. The defined CCSID is valid till the next CCSID definition. An unsupported CCSID (0) can be used to restore the interpretation to the system code page. *ATTENTION:* This is no character set conversion, only the UNICODE code points 0-127 which are on different code points in the different EBCDIC code pages are replaced. All other higher code points (e.g. German Umlauts ('ä','ü','ö')) are not touched. The partial CCSID conversion are mainly useful for application programming interfaces. At compile time the CCSID for literals must be defined. This CCSID could be differ from the system CCSID (local character set) of variable parameter. In such a case a application can mark the literal part in the CCSID used for literals at compile time, and the variable part could be conform to the CCSID defined over the LANG variable. See the C example below: ------------------------------------------------------------------------ snprintf(acCmd,sizeof(acCmd),"&1047;get.file='&0;%s&1047'",pcFilename); ------------------------------------------------------------------------ C-Code are normally in 1047 and if no literal conversion defined then the literals also in 1047. The file name is a parameter in local character set. In Cobol the default code page for literals is 1140. To define the CCSID for CLP strings from outside, the environment variable CLP_STRING_CCSID can be defined. This is useful if an application cannot recompile with the correct code page for the literals. On ASCII/UTF-8 platforms a miss-interpretation of punctuation characters smaller than 128 is not possible. On such platforms the LANG variable is not used for command interpretation or printouts. The escape and CCSID sequences are supported but have no effect on these platforms. This helps to develop platform independent code for CLP strings. [[CLEP.BUILTIN.FUNCTIONS]] === 1.7. Built-in functions Numerous built-in functions are available to obtain extensive help about syntax, errors, commands and functions of a program with help messages, manual pages and documentation. Other built-in functions can be used for owner, property, environment and trace management. All built-in functions have the purpose to simplify handling of powerful and sometimes complex commands. [[CLEP.BUILTIN.SYNTAX]] ==== 1.7.1. Function 'SYNTAX' .Synopsis ----------------------------------------------------------------------- HELP: Provides the syntax for each command PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv SYNTAX [command[.path] [DEPTH1 | ... | DEPTH9 | ALL]] ----------------------------------------------------------------------- .Description The syntax function shows how the arguments can be set on the command line. Depending on depth the syntax is printed in one line or in structured form. A structured print out means that you have a question or exclamation mark before the argument. * question mark - optional parameter * exclamation mark - required parameter The *path* is a dotted keyword list in accordance with the syntax of the corresponding command. ------------------------------------------------------------------------ command.para1.para2.para3 ------------------------------------------------------------------------ .Options * DEPTH1 / DEPTH2 / ... / DEPTH9 ** Specifies the depth of the output. Default is DEPTH1. If the depth is greater than 1 the structured print out is used. * ALL ** Shows complete syntax for the specified path, not just DEPTH1. Structured print out is used. .Examples ----------------------------------------------------------------------- :> FLSSRV SYNTAX :> FLSSRV SYNTAX command :> FLSSRV SYNTAX command ALL :> FLSSRV SYNTAX command.para :> FLSSRV SYNTAX command.para ALL ----------------------------------------------------------------------- [[CLEP.BUILTIN.HELP]] ==== 1.7.2. Function 'HELP' .Synopsis ----------------------------------------------------------------------- HELP: Provides quick help for arguments PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv HELP [command[.path] [DEPTH1 | ... | DEPTH9 | ALL]] [MAN] ----------------------------------------------------------------------- .Description The help function can provide extensive information about each parameter which is adjustable on the command line. With the help functionality you get a structured list of arguments: * keyword - the keyword for the argument * (TYPE: ...) - the type of this argument * help message - the short help text * (PROPERTY: [...]) - the current hard coded property value (optional) The keyword can be abbreviated, but it must be unique for this list. The required letters are upper case if case sensitive mode is used. With the case sensitive mode an additional line is required to mark the appropriate letter. The *path* is a dotted keyword list in accordance with the syntax of the corresponding command. ------------------------------------------------------------------------ command.para1.para2.para3 ------------------------------------------------------------------------ Help can also be used to show the corresponding detailed description of the manual pages with keyword *MAN*. .Options * DEPTH1 / DEPTH2 / ... / DEPTH9 ** Specifies the depth of the output. Default is DEPTH1. * ALL ** Shows complete help below specified path, not just DEPTH1 and includes all aliases defined for a certain argument. * MAN ** Shows additionally the detailed description for this program, command or parameter and the next level of arguments including the aliases. .Examples ----------------------------------------------------------------------- :> FLSSRV HELP :> FLSSRV HELP MAN :> FLSSRV HELP command :> FLSSRV HELP command MAN :> FLSSRV HELP command ALL :> FLSSRV HELP command.para :> FLSSRV HELP command.para MAN :> FLSSRV HELP command.para ALL ----------------------------------------------------------------------- [[CLEP.BUILTIN.MANPAGE]] ==== 1.7.3. Function 'MANPAGE' .Synopsis ----------------------------------------------------------------------- HELP: Provides manual pages (detailed help) PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv MANPAGE [function | command[.path][=filename]] | [filename] ----------------------------------------------------------------------- .Description Shows the manpages of the program, all commands and built-in functions and if available for each argument up to selections/constant definitions. This function prints the corresponding section from the user manual on the screen (doctype: *book*). If a filename is given then the doctype *manpage* of ASCIIDOC is written to the file. Do not use space characters between the key, assignment character (=) and filename. The files in ASCIIDOC format can be used to generate manpages with the tool http://www.methods.co.nz/asciidoc/[ASCIIDOC]. .Examples ----------------------------------------------------------------------- :> FLSSRV MANPAGE :> FLSSRV MANPAGE filename :> FLSSRV MANPAGE command :> FLSSRV MANPAGE command=filename :> FLSSRV MANPAGE function :> FLSSRV MANPAGE function=filename :> FLSSRV MANPAGE command.para :> FLSSRV MANPAGE command.para=filename ----------------------------------------------------------------------- [[CLEP.BUILTIN.GENDOCU]] ==== 1.7.4. Function 'GENDOCU' .Synopsis ----------------------------------------------------------------------- HELP: Generates auxiliary documentation (ASCIIDOC text format) PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv GENDOCU [command[.path]=]filename [NONBR] [SHORT] ----------------------------------------------------------------------- .Description The complete user manual is generated when only the filename is given. If a command, or command path, is specified the corresponding section of the user manual is written to a file. The generated files are in ASCIIDOC format, to be readable as normal text document on all platforms and easily convertible into HTML, PDF or other formats with http://www.methods.co.nz/asciidoc/[ASCIIDOC]. The example below generates the complete manual and convert it in a second step to a HTML5 document. ------------------------------------------------------------------------ :> flssrv gendocu book.txt :> asciidoc -b html5 -f asciidoc-html5.conf -a toc2 -a toclevels=4 -o book.html book.txt ------------------------------------------------------------------------ The numbering will vary in places where the complete manual uses a bullet list for arguments and constants, when no detailed description is available and some of these arguments are required for the path. The numbering can be disabled by setting the optional keyword NONBR. This is useful if numbering is generated by a post processing utility (for example 'pdflatex'). To create a short manual without the CLP parameter description the optional keyword SHORT can be used. This is useful for example, if you deliver a text file and no dictionary can be used. In opposite to the built-in function <> at text file generation the corresponding path string is written to the synopsis but index chapter and index terms are not generated anymore. Do not use space characters between the key, assignment character (=) and filename. .Examples ----------------------------------------------------------------------- :> FLSSRV GENDOCU flssrv.manual.txt NONBR :> FLSSRV GENDOCU flssrv.manual.txt SHORT :> FLSSRV GENDOCU command=command.manual.txt :> FLSSRV GENDOCU command.argument=argument.manual.txt ----------------------------------------------------------------------- [[CLEP.BUILTIN.HTMLDOC]] ==== 1.7.5. Function 'HTMLDOC' .Synopsis ----------------------------------------------------------------------- HELP: Generates the complete HTML documentation into a folder PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv HTMLDOC [path] [NUMBERS] [TYPE] [SHORT] ----------------------------------------------------------------------- .Description This built-in function generates the complete user manual in HTML format into a folder. The folder can be defined as optional parameter. If no path given, then the current directory is used as default. With the optional keyword `NUMBERS` the numbering of headlines can be activated. The keyword `TYPE` add the type information to each generated headline. The keyword `SHORT` will result in a short version of the document, not containing the parameter of the commands and other CLP strings. In opposite to the built-in function <> at HTML generation no path is written to the synopsis but index terms are generated by default. The built-in function can only be used if a call back function for HTML documentation provided. If not a error will be issued if HTMLDOC is executed. The callback function is called for each prepared page and the unique pointer to the original manual string can be used to determine if this page already created and if so then only a link to this existing page is required. This interface allows to generated more flexible (with dictionary, index, search) and redundancy free HTML documentation. To understand the service provider interface (open, close and callback function) for HTML generation see the DOXYGEN documentation of FLAMCLE/CLP.h .Examples ----------------------------------------------------------------------- :> FLSSRV HTMLDOC :> FLSSRV HTMLDOC . SHORT :> FLSSRV HTMLDOC /user/home/docu/flclbook :> FLSSRV HTMLDOC NUMBERS SHORT :> FLSSRV HTMLDOC /user/home/docu/flclbook SHORT ----------------------------------------------------------------------- [[CLEP.BUILTIN.GENPROP]] ==== 1.7.6. Function 'GENPROP' .Synopsis ----------------------------------------------------------------------- HELP: Generates a property file PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv GENPROP [command=]filename ----------------------------------------------------------------------- .Description A property file is generated for all commands if only a filename is provided. If a command is specified, a property file for this specific command is created. Property files can be used to define default settings for commands. For each parameter, a property entry is written to a text file. The text file contains comments to help in editing the properties. A property file can be activated with the built-in function SETPROP. Property files will be activated by their owner. A property file overrides hard coded properties and properties defined over environment variables. A specific property file overrides the general property file. At time of generation all current default settings are written to the property file. We recommend to work only with command specific property files, because the built-in function CHGPROP can be used to generate, update and activate a property file for a certain command. Do not use space characters between the key, assignment character (=) and filename. To optimize the program performance, one can remove all unnecessary properties. See <> for the current property file content. .Examples ----------------------------------------------------------------------- :> FLSSRV GENPROP owner.general.properties :> FLSSRV GENPROP command=owner.command.properties ----------------------------------------------------------------------- [[CLEP.BUILTIN.SETPROP]] ==== 1.7.7. Function 'SETPROP' .Synopsis ----------------------------------------------------------------------- HELP: Activate a property file PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv SETPROP [command=]filename ----------------------------------------------------------------------- .Description The filename is set as current global property file when no command is specified. The file name is set as current local property file when a command is given. The property file can be generated with GENPROP and will be activated for the current owner. After generation you can activate the property file, but there will be no effect until you change the settings inside the property file, because the current default settings are written. The filename can contain replacement/mapping rules (/). Do not use space characters between the key, assignment character (=) and filename. We recommend to work only with command specific property files, because the built-in function CHGPROP can be used to generate, update and activate a property file for a certain command. See <> for the current property file content. .Examples ----------------------------------------------------------------------- :> FLSSRV SETPROP general.properties :> FLSSRV SETPROP command=command.properties ----------------------------------------------------------------------- [[CLEP.BUILTIN.CHGPROP]] ==== 1.7.8. Function 'CHGPROP' .Synopsis ----------------------------------------------------------------------- HELP: Change a property value in the currently active property file PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv CHGPROP command [path[=value]]* ----------------------------------------------------------------------- .Description The built-in function updates property values in the currently active (see <>) property file for a dedicated command. If no property file is activated, a property file is generated (see <>), updated with the provided property list and activated (see <>). The first argument of CHGPROP is the command name. All other arguments are key-value pairs of properties that should be updated. The key is internally prefixed with the root (owner.program.command.). The values are enclosed in double quotation marks. Multiple properties of a command can be updated at once by separating them with a space character (please do not use spaces between key, assignment character (=) and the value). This set of properties is parsed by the CLP. If no property is provided, the property file for the command is either parsed or generated (if it does not exist) and then activated without updating properties. This behavior can be used to generate and activate command specific property files for the different commands. The built-in function reads and parses the currently active property file. Then it parses the provided property list and writes the updated property file back to disk. The currently active property file could be a global, not command specific property file. In such a case, a new command specific property file is generated and activated. Properties from the global property file are copied into the newly generated one. If no property file is defined (see <>) that corresponds to the owner, program and command, a property file is generated. The filename formats below are used to read or write property files from/to the home directory: On non-mainframe systems (WINDOWS, UNIX, MAC): ------------------------------------------------------------------------ ".owner.program.command.properties" ------------------------------------------------------------------------ On mainframe systems (ZOS, VSE, BS200, ...): ------------------------------------------------------------------------ ".OWNER.PROGRAM.COMMAND.PROPS" ------------------------------------------------------------------------ If the default filenames and/or path are not sufficient, you can change the filename of each property file by setting environment variables using the following naming convention: ------------------------------------------------------------------------ OWNER_PROGRAM_COMMAND_PROPERTY_FILENAME ------------------------------------------------------------------------ If no home directory is defined, then the current working directory is used as default directory to save the property files. On mainframes SYSUID is used for the first level qualifier, to represent the "home directory". Property files are managed per owner: This means that updates are only done for the current owner. To delete a property you can simply specify the path without the root and with out a sign. See <> for the current property file content. .Examples ----------------------------------------------------------------------- :> FLSSRV CHGPROP command overlay.object.argument=value :> FLSSRV CHGPROP command overlay.object.argument :> FLSSRV CHGPROP command object.argument=value1 argument=value2 ----------------------------------------------------------------------- [[CLEP.BUILTIN.DELPROP]] ==== 1.7.9. Function 'DELPROP' .Synopsis ----------------------------------------------------------------------- HELP: Remove a property file from configuration PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv DELPROP [command] ----------------------------------------------------------------------- .Description Without a command the current global property file is deleted from the configuration data. A command specific property file can be deleted from the configuration data when the command name is given. Property files are managed per owner, this means that delete is only done for the current owner. We recommend to work only with command specific property files. See <> for the current property file content. .Examples ----------------------------------------------------------------------- :> FLSSRV DELPROP :> FLSSRV DELPROP command ----------------------------------------------------------------------- [[CLEP.BUILTIN.GETPROP]] ==== 1.7.10. Function 'GETPROP' .Synopsis ----------------------------------------------------------------------- HELP: Show current properties PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv GETPROP [command[.path] [DEPTH1 | ... | DEPTH9 | DEPALL | DEFALL]] ----------------------------------------------------------------------- .Description All or certain properties can be shown for a dedicated path. The *path* is a dotted keyword list according to the syntax of the corresponding command. ------------------------------------------------------------------------ command.para1.para2.para3 ------------------------------------------------------------------------ A help message for a certain parameter will also show the assigned property value. See <> for the current property file content. .Options * `DEPTH1 / DEPTH2 / ... / DEPTH9` ** Specifies the depth of the output. Default is DEPTH1. * `DEPALL` ** Shows all properties to the specified path, not just DEPTH1. * `DEFALL` ** Shows all defined properties to the specified path. .Examples ----------------------------------------------------------------------- :> FLSSRV GETPROP :> FLSSRV GETPROP command :> FLSSRV GETPROP command DEFALL :> FLSSRV GETPROP command.para :> FLSSRV GETPROP command.para DEPALL ----------------------------------------------------------------------- [[CLEP.BUILTIN.SETOWNER]] ==== 1.7.11. Function 'SETOWNER' .Synopsis ----------------------------------------------------------------------- HELP: Defines the current owner PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv SETOWNER name ----------------------------------------------------------------------- .Description The current owner id (prefix or separation) can be changed. The owner concept is very powerful to separate different property settings. You can run the same command with different properties simply by switching the owner. The owner is a general solution to separate all settings and can be used for environment, client and other purposes. If not already defined, the owner is written to the environment table under the key word OWNERID. This environment variable can for example used as replacement in file names (~/.dat) or to refer a signature key. .Examples ----------------------------------------------------------------------- :> FLSSRV SETOWNER com.company ----------------------------------------------------------------------- [[CLEP.BUILTIN.GETOWNER]] ==== 1.7.12. Function 'GETOWNER' .Synopsis ----------------------------------------------------------------------- HELP: Show current owner setting PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv GETOWNER ----------------------------------------------------------------------- .Description The current owner id (prefix for separation) will be shown. The owner concept allows to manage different configurations as a logical separation of what is done with this id. .Examples ----------------------------------------------------------------------- :> FLSSRV GETOWNER ----------------------------------------------------------------------- [[CLEP.BUILTIN.SETENV]] ==== 1.7.13. Function 'SETENV' .Synopsis ----------------------------------------------------------------------- HELP: Set an environment variable PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv SETENV variable=value ----------------------------------------------------------------------- .Description This function allows to set environment variables within the configuration file for a certain owner. All defined environment variables are placed in the current environment table of the process before a command is executed. Do not use space characters between the key, assignment character (=) and value. *Attention:* The environment variables will be temporary overwritten .Examples ----------------------------------------------------------------------- :> FLSSRV SETENV LANG=DE_DE.IBM-1141 :> FLSSRV SETENV LANG=DE_DE.UTF-8 :> FLSSRV SETENV ENVID=T :> FLSSRV SETENV ENVID=P ----------------------------------------------------------------------- [[CLEP.BUILTIN.GETENV]] ==== 1.7.14. Function 'GETENV' .Synopsis ----------------------------------------------------------------------- HELP: Show the environment variables PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv GETENV ----------------------------------------------------------------------- .Description This function lists all environment variables which are set within the configuration file for a certain owner. All shown environment variables are placed in the environment table of the process. *Attention:* The environment variables will be temporary overwritten .Examples ----------------------------------------------------------------------- :> FLSSRV GETENV ----------------------------------------------------------------------- [[CLEP.BUILTIN.DELENV]] ==== 1.7.15. Function 'DELENV' .Synopsis ----------------------------------------------------------------------- HELP: Delete an environment variable PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv DELENV variable ----------------------------------------------------------------------- .Description This function will delete environment variables from the configuration file for a certain owner. .Examples ----------------------------------------------------------------------- :> FLSSRV DELENV LANG ----------------------------------------------------------------------- [[CLEP.BUILTIN.TRACE]] ==== 1.7.16. Function 'TRACE' .Synopsis ----------------------------------------------------------------------- HELP: Manage trace capabilities PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv TRACE ON | OFF | FILE=filename ----------------------------------------------------------------------- .Description Tracing for command line parser and commands can be enabled or disabled. A trace is only required to diagnose errors. In such a case a trace file must be defined first, then the trace can be activated, the erroneous command executed and the trace file sent to the support team. If no trace file is defined, stdout/stderr is used as default. To prevent tracing on the screen, please define a trace file first before tracing is switched on. Do not use space characters between the key, assignment character (=) and filename. .Examples ----------------------------------------------------------------------- :> FLSSRV TRACE FILE=filename :> FLSSRV TRACE ON :> FLSSRV TRACE OFF ----------------------------------------------------------------------- [[CLEP.BUILTIN.CONFIG]] ==== 1.7.17. Function 'CONFIG' .Synopsis ----------------------------------------------------------------------- HELP: Shows or clear all the current configuration settings PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv CONFIG [CLEAR] ----------------------------------------------------------------------- .Description The actual configuration list with owner id, property file names trace setting, environment variables and more is shown. With the option CLEAR the configuration data including the corresponding file will be deleted. The configuration file name can be defined by the environment variable: ------------------------------------------------------------------------ FLSSRV_CONFIG_FILE=config.file.name ------------------------------------------------------------------------ This can be used to work with a global configuration file. If this location is not defined, the configuration file is stored in the home directory with the name: ------------------------------------------------------------------------ .flssrv.config ------------------------------------------------------------------------ If no home directory is defined for the current user (this case is very improbable), the working directory is used. To read the configuration file when the environment variable above is not defined, CLE first looks in the working and then in the home directory. This makes it possible to prefer a property file, by copying it to the current working directory. On mainframes the data set name 'SYSUID.FLSSRV.CONFIG' is used as default. SYSUID as high level qualifier is a kind of replacement for the current home directory in other operating systems in this way. .Examples ----------------------------------------------------------------------- :> FLSSRV CONFIG :> FLSSRV CONFIG CLEAR ----------------------------------------------------------------------- [[CLEP.BUILTIN.GRAMMAR]] ==== 1.7.18. Function 'GRAMMAR' .Synopsis ----------------------------------------------------------------------- HELP: Shows the grammar for commands and properties PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv GRAMMAR ----------------------------------------------------------------------- .Description The grammar used for interpreting the command line and property files is shown. This is helpful for understanding how the commands and property files are interpreted by the command line processor. See <> for an explanation and the output of this command. .Examples ----------------------------------------------------------------------- :> FLSSRV GRAMMAR ----------------------------------------------------------------------- [[CLEP.BUILTIN.LEXEM]] ==== 1.7.19. Function 'LEXEM' .Synopsis ----------------------------------------------------------------------- HELP: Shows the regular expressions accepted in a command PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv LEXEM ----------------------------------------------------------------------- .Description The regular expression used for the tokens of the command syntax will be shown. This could be helpful in understanding how the commands and property files are interpreted by the command line processor. Moreover it will be shown how to define a number, a string, a keyword and other values inside a command. See <> for an explanation and the output of this command. .Examples ----------------------------------------------------------------------- :> FLSSRV LEXEM ----------------------------------------------------------------------- [[CLEP.BUILTIN.LICENSE]] ==== 1.7.20. Function 'LICENSE' .Synopsis ----------------------------------------------------------------------- HELP: List license information for the program PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv LICENSE ----------------------------------------------------------------------- .Description The license string of the software product is shown. This string is provided to the command line executer (CLE) by the calling program and should reflect the current license text for this program. .Examples ----------------------------------------------------------------------- :> FLSSRV LICENSE ----------------------------------------------------------------------- [[CLEP.BUILTIN.VERSION]] ==== 1.7.21. Function 'VERSION' .Synopsis ----------------------------------------------------------------------- HELP: List version information for the program PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv VERSION ----------------------------------------------------------------------- .Description The version of the software product is shown. This string is provided to the command line executer (CLE) by the calling program and should reflect the current version information for this program. See <> for the output of this command. .Examples ----------------------------------------------------------------------- :> FLSSRV VERSION ----------------------------------------------------------------------- [[CLEP.BUILTIN.ABOUT]] ==== 1.7.22. Function 'ABOUT' .Synopsis ----------------------------------------------------------------------- HELP: Show information about the program PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv ABOUT ----------------------------------------------------------------------- .Description Shows information about the software product like version, copyright, external libraries, license and other attributes. This string is provided to the command line executer (CLE) by the calling program and should reflect the current about information for this program (flssrv). See <> for the output of this command. .Examples ----------------------------------------------------------------------- :> FLSSRV ABOUT ----------------------------------------------------------------------- [[CLEP.BUILTIN.ERRORS]] ==== 1.7.23. Function 'ERRORS' .Synopsis ----------------------------------------------------------------------- HELP: Show information about return and reason codes of the program PATH: limes.flssrv TYPE: BUILT-IN FUNCTION SYNTAX: > flssrv ERRORS ----------------------------------------------------------------------- .Description This built-in function prints explanations for the return/condition/exit codes of the executable and, if available, the reason codes of executed commands. The command line executer (CLE) initialized the CLP structure. Calls the command line processor (CLP). Calls the mapping function, which converts the CLP structure in a corresponding command structure. Then it runs the command and as last step it calls the finish function with the command structure, to close all files and free all the allocated memory. If one of these steps fails, then a corresponding return (condition/exit) code is given back from the executable. Only the command execution can result in a error (return code 8) or in a warning (return code 4). The command it self must return a reason code for such a warning or error. This means that the return (condition/exit) code can be used to control the batch processing. The reason code gives more information about the error or warning. See <> and <> for an explanation and the output of this command. .Examples ----------------------------------------------------------------------- :> FLSSRV ERRORS ----------------------------------------------------------------------- == 2. FLIES Sever The FLIES(R) server allows remote read and write access to a FLAMARCHIVE (file, database, VSAM) by using a network connection with one of the supported protocols (IP, MQ, ...). Additionally it can act as a gateway to forward the client requests to another server. Search requests for segments are also possible, thereby making the limes access method network transparent. The segements transferred on the network are compressed and encrypted by the client if this was requested. This keeps control on the client side and reduces the amount of network traffic. === 2.1. Synopsis The synopsis collects the help, syntax and other important information for a program, function or parameter. It is a kind of quick reference and will used over the complete hierarchies in this document. Below you can find for example the synopsis for program FLSSRV. ----------------------------------------------------------------------- HELP: FLIES Server (Remote FLAM) PATH: limes TYPE: PROGRAM SYNTAX: > flssrv COMMAND/FUNCTION ... ----------------------------------------------------------------------- === 2.2. Environment Variables * LANG - to determine the default CCSID for this platform (Format: de_DE.UTF-8) * FLSSRV_CONFIG_FILE - defines the config filename (if not set default is '.flssrv.config') * FLSSRV_DEFAULT_OWNER_ID - defines the default owner ID (if not set default is 'limes') The enviroment variables can be set over the system or over the FLSSRV config file with built-in function 'SETENV'. Especially on mainframe systems the config file is a easy way to define environment variables for FLSSRV. === 2.3. Installation The product FLAM with all its components (FLCL, FLCC, FLSSRV, ...) is delivered in two parts. The main package contains the whole software and is available as download or via package repository (various Linux distributions). The second part is the license, which determines the features and platforms that can be used, where and for what you can use the software. If only the main package is installed, then a limited DEMO license can be used. ==== 2.3.1. License FLAM is protected against unauthorized use. The authorized usage of FLAM is only possible with a licence module provided by Limes Datentechnik. A licence allows the usage of FLAM on one or multiple computers, capacities, users or per usage. There is a difference between test licences for a limited period and unlimited (or limited) production licences. A test licence allows the testing and benchmarking of FLAM with all functions for a defined period (e.g. 30 days). * Test licenses must not be given to a third party. * During the test period, no backup copies of the test programs are allowed. * After the test period is expired all test programs must be deleted. A production licence allows the limited or unlimited usage of FLAM on any computer for which a licence was obtained. FLAM compresses structure-oriented using an algorithm that is a part of the Frankenstein-Limes method. This method has been patented in the Federal Republic of Germany and the United States of America and at the European Patent Bureau, registered by the inventor on 19th September 1985. ==== 2.3.2. Download FLAM(R) can be downloaded from our website with the following link: https://flam.de/en/download/flam/ INSTALL and README text files are included as guides for installation. The download area distinguishes several operating systems: [width="50%",cols="2,5",options="header"] |==== |Operating system | Link to installation instructions |AIX | https://flam.de/en/download/flam/aix/install.txt |HPUX | https://flam.de/en/download/flam/hpux/install.txt |Linux | https://flam.de/en/download/flam/linux/install.txt |Solaris | https://flam.de/en/download/flam/solaris/install.txt |Windows | https://flam.de/en/download/flam/windows/install.txt |zSeries Linux | https://flam.de/en/download/flam/zSeries/linux/install.txt |zSeries USS | https://flam.de/en/download/flam/zSeries/uss/install.txt |zSeries z/OS | https://flam.de/en/download/flam/zSeries/zos/install.txt |==== Manuals can be found at: https://flam.de/en/technology/download/documentation/ === 2.4. Syntax of FLSSRV Below you can see the main syntax for this program. This content is printed on the screen if the built-in function <> is used. Each command can be entered as an argument list on the command line or in a parameter file. To define a parameter file the assignment character (`=`) must be used. For an argument list a blank or if the command (main table) is of type overlay a dot (`.`) or if the command is of type object a round bracket open (`(`) must be given. If the round bracket open is used then the corresponding round bracket close (`)`) at the end of the command is mandatory. The dot and parenthesis are in accordance with the normal syntax. If an argument list is used all parameters (argv[]) are concatenated to one long string and this string is passed to the parser, to allow usage of all features of the shell to build the command line input. To make sure that anything you enter is passed one by one to the parser please use double (WINDOWS(R), UNIX) or single (z/OS(R)) quotation marks at the beginning and end of the argument list. If the dot for overlays or parenthesis for objects are used then the complete command must be included in double quotation marks. The examples below show all possible command entries for the type object: ----------------------------------------------------------------------- :> FLSSRV command temp() dummy='str' :> FLSSRV command(temp() dummy='str') :> FLSSRV command "temp() dummy='str'" :> FLSSRV "command(temp() dummy='str')" ----------------------------------------------------------------------- For a command of type overlay it looks like: ----------------------------------------------------------------------- :> FLSSRV command temp() :> FLSSRV command.temp() :> FLSSRV command "temp()" :> FLSSRV "command.temp()" ----------------------------------------------------------------------- In a parameter file you can start with a dot for an overlay or with parenthesis for an object or with the argument (overlay) or argument list (object) directly. ------------------------------------------------------------------------ Syntax for program 'flssrv': --| Commands: RUN --|--| flssrv [OWNER=oid] command "... argument list ..." [MAXCC=[max][-min]] [QUIET/SILENT] --|--| flssrv [OWNER=oid] command=" parameter file name " [MAXCC=[max][-min]] [QUIET/SILENT] --|--| flssrv [OWNER=oid] command=>"parameter file name " [MAXCC=[max][-min]] [QUIET/SILENT] --|--| You can optionally specify: --|--|--| the owner id for this command (to use custom configuration files) --|--|--| the maximum condition code (max) to suppress warnings --|--|--| the minimum condition code (min), zero is returned if the condition code would be smaller --|--|--| QUIET disables the normal log output of the command line executer --|--|--| SILENT disables log and errors messages of the command line executer --| Built-in functions: --|--| flssrv SYNTAX [command[.path] [DEPTH1 | ... | DEPTH9 | ALL]] --|--| flssrv HELP [command[.path] [DEPTH1 | ... | DEPTH9 | ALL]] [MAN] --|--| flssrv MANPAGE [function | command[.path][=filename]] | [filename] --|--| flssrv GENDOCU [command[.path]=]filename [NONBR] [SHORT] --|--| flssrv HTMLDOC [path] [NUMBERS] [TYPE] [SHORT] --|--| flssrv GENPROP [command=]filename --|--| flssrv SETPROP [command=]filename --|--| flssrv CHGPROP command [path[=value]]* --|--| flssrv DELPROP [command] --|--| flssrv GETPROP [command[.path] [DEPTH1 | ... | DEPTH9 | DEPALL | DEFALL]] --|--| flssrv SETOWNER name --|--| flssrv GETOWNER --|--| flssrv SETENV variable=value --|--| flssrv GETENV --|--| flssrv DELENV variable --|--| flssrv TRACE ON | OFF | FILE=filename --|--| flssrv CONFIG [CLEAR] --|--| flssrv GRAMMAR --|--| flssrv LEXEM --|--| flssrv LICENSE --|--| flssrv VERSION --|--| flssrv ABOUT --|--| flssrv ERRORS ------------------------------------------------------------------------ === 2.5. Help for FLSSRV Here you can see the static main help for this program. This content is printed on the screen if the built-in function <> is used without any further arguments. ------------------------------------------------------------------------ Help for program 'flssrv': --| Commands - to execute powerful subprograms --|--| flssrv RUN - run server --| Built-in functions - to give interactive support for the commands above --|--| flssrv SYNTAX - Provides the syntax for each command --|--| flssrv HELP - Provides quick help for arguments --|--| flssrv MANPAGE - Provides manual pages (detailed help) --|--| flssrv GENDOCU - Generates auxiliary documentation (ASCIIDOC text format) --|--| flssrv HTMLDOC - Generates the complete HTML documentation into a folder --|--| flssrv GENPROP - Generates a property file --|--| flssrv SETPROP - Activate a property file --|--| flssrv CHGPROP - Change a property value in the currently active property file --|--| flssrv DELPROP - Remove a property file from configuration --|--| flssrv GETPROP - Show current properties --|--| flssrv SETOWNER - Defines the current owner --|--| flssrv GETOWNER - Show current owner setting --|--| flssrv SETENV - Set an environment variable --|--| flssrv GETENV - Show the environment variables --|--| flssrv DELENV - Delete an environment variable --|--| flssrv TRACE - Manage trace capabilities --|--| flssrv CONFIG - Shows or clear all the current configuration settings --|--| flssrv GRAMMAR - Shows the grammar for commands and properties --|--| flssrv LEXEM - Shows the regular expressions accepted in a command --|--| flssrv LICENSE - List license information for the program --|--| flssrv VERSION - List version information for the program --|--| flssrv ABOUT - Show information about the program --|--| flssrv ERRORS - Show information about return and reason codes of the program For more information please use the built-in function 'MANPAGE' ------------------------------------------------------------------------ === 2.6. FLSSRV commands Commands are used to run powerful subprograms. The command line processor compiles a table defined syntax in a corresponding preinitialized data structure. This structure will be mapped to the parameter structure of the corresponding subprogram. The subprogram can be executed with the defined arguments/parameters. To support these variable commands several built-in functions are available and described in a separate <>. Each supported command is explained in a separate section in this document. Each section contains a synopsis including the help message, the path, the type and the syntax followed by a detailed description. If an argument of this command is an object or overlay or, if a detailed description is available for this argument, a separate section with synopsis (help, path, type, syntax) and description is written, otherwise a bullet list is printed which contains the keyword, the syntax and the help message. For the syntax of an overlay braces `{}` are used to keep all possible arguments of an overlay logically together. These braces are not part of the real syntax. The braces are only written to demonstrate clearly that one of these arguments must be selected with the DOT operator (optional) for defining the overlay. To be compatible with certain shells, the features below are implemented: * Strings can be enclosed with single '' or double "" quotation marks * Integrated strings (without spaces) can also defined without quotes * Keywords can also start with "-" or "--" in front of the qualifier * If it unique then parenthesis and the dot can be omit for object and overlays Commands can be declared in deep hierarchical depth. In order to simplify their handling the path is a powerful instrument for managing only relevant parts of it. Because of that the path is printed for each synopsis. To run commands under different owners, the owner id can be defined in front of the command. To suppress the outputs of the command line executer you can set QUIET or SILENT as the last parameter. Additional to QUIET, SILENT suppressed also the error messages. These options has no effect of the outputs of the commands and built-in functions. For job control, the maximum (and minimum) condition code (MAXCC=[max][-min]) of the command execution can optionally be set as the last parameter for each command. The value 'max' is the maximum condition code. If the condition code, that would be returned if MAXCC was not specified, would be greater than 'max', it is reduced to the value of 'max'. If the condition code would be smaller than 'min', the actually returned condition code is reduced to 0. Both, 'max' and 'min', values are optional. To only specify the minimum, simply omit the 'max' value, i.e. the MAXCC value starts with a hyphen. Example: The clause `MAXCC=8-4` will set each condition code greater than 8 to 8 and each condition code smaller than 4 to 0, while `MAXCC=-4` only sets condition codes smaller than 4 to 0. ------------------------------------------------------------------------ flssrv [OWNER=oid] command "... argument list ..." [MAXCC=[max][-min]] [QUIET] flssrv [OWNER=oid] command=" parameter file name " [MAXCC=[max][-min]] [QUIET] ------------------------------------------------------------------------ The parameter for each command can be provided as argument list on the command line or as parameter file. [[CLEP.COMMAND.RUN]] ==== 2.6.1. Command 'RUN' .Synopsis ----------------------------------------------------------------------- HELP: run server PATH: limes.flssrv TYPE: OBJECT SYNTAX: > flssrv RUN(PORT='str',CLIENT(),ROOTPATH='str',HLEN=num,DLEN=num,HANDLE_CLIENT=THREAD/PROCESS,DAEMONIZE,LOG()) ----------------------------------------------------------------------- .Description The RUN command must be used to to execute the FLIES(R) server. It is an object containg all parameters needed to configure its behaviour. To run the server with default values ----------------------------------------------------------------------- FLSSRV RUN ----------------------------------------------------------------------- is sufficient. To get help for a parameter use: ----------------------------------------------------------------------- FLSSRV HELP RUN.parameter[.parameter[...]] ----------------------------------------------------------------------- To read the manual page for a parameter, please use: ----------------------------------------------------------------------- FLSSRV MANPAGE RUN.parameter[.parameter[...]] ----------------------------------------------------------------------- To generate the user manual for the RUN command use: ----------------------------------------------------------------------- FLSSRV GENDOCU RUN=filename ----------------------------------------------------------------------- Parameters can be defined by the command line (directly or per file) or by properties read from the corresponding property file. .Examples ----------------------------------------------------------------------- FLSSRV RUN rootpath='/srv/flam' FLSSRV RUN handle_client=process ----------------------------------------------------------------------- .Arguments * `NUMBER: HLEN=num - Initial buffer length for header` * `NUMBER: DLEN=num - Initial buffer length for data` [[CLEP.APPENDIX.LEXEM]] == Appendix A. Lexem The regular expressions used by the command line compiler are shown below. This content is printed on the screen with the built-in function `LEXEM`. To describe the regular expression the following character classes are used: * :print: - all printable characters * :space: - all blanks, tabs and new lines * :cntr: - all control characters * :alpha: - all letters ([[a-z]|[A-Z]]) * :alnum: - all letters and digits [0-9] * :digit: - all decimal numbers [0-9] * :xdigit: - all hexadecimal numbers [[0-9]|[a-f||[A-F]] All comments and separators are ignored by the scanner and not passed with the token to the parser. This means that the separators (SEP) are used in the grammar but will never be part of or own tokens. If a binary entry for a string is possible and no classification is done it is taken as a binary string in local character set representation (c) without null termination. This default can be changed. In this case the help message for this argument should be described the default interpretation of the binary string. For binary strings it is still possible to enter a null-terminated string, but then the prefix *s* must be used. If no binary entry is feasible, only a null-terminated string in local character representation (s) can be built and taken by default. ------------------------------------------------------------------------ Lexemes (regular expressions) for argument list or parameter file --| COMMENT '#' [:print:]* '#' (will be ignored) --| LCOMMENT ';' [:print:]* 'nl' (will be ignored) --| SEPARATOR [:space: | :cntr: | ',']* (abbreviated with SEP) --| OPERATOR '=' | '.' | '(' | ')' | '[' | ']' | (SGN, DOT, RBO, RBC, SBO, SBC) --| '=>'| '+' | '-' | '*' | '/' | '{' | '}' (SAB, ADD, SUB, MUL, DIV, CBO,CBC) --| KEYWORD ['-'['-']][:alpha:]+[:alnum: | '_']* (always predefined) --| NUMBER ([+|-] [ :digit:]+) | (decimal (default)) --| num ([+|-]0b[ :digit:]+) | (binary) --| num ([+|-]0o[ :digit:]+) | (octal) --| num ([+|-]0d[ :digit:]+) | (decimal) --| num ([+|-]0x[ :xdigit:]+) | (hexadecimal) --| num ([+|-]0t(yyyy/mm/tt.hh:mm:ss)) | (relativ (+|-) or absolut time) --| FLOAT ([+|-] [ :digit:]+.[:digit:]+e|E[:digit:]+) | (decimal(default)) --| flt ([+|-]0d[ :digit:]+.[:digit:]+e|E[:digit:]+) (decimal) --| STRING ''' [:print:]* ''' | (default (if binary c else s)) --| str [s|S]''' [:print:]* ''' | (null-terminated string) --| str [c|C]''' [:print:]* ''' | (binary string in local character set) --| str [a|A]''' [:print:]* ''' | (binary string in ASCII) --| str [e|E]''' [:print:]* ''' | (binary string in EBCDIC) --| str [x|X]''' [:print:]* ''' | (binary string in hex notation) --| str [f|F]''' [:print:]* ''' | (read string from file (for passwords)) --| Strings can contain two '' to represent one ' --| Strings can also be enclosed in " or ` instead of ' --| Strings can directly start behind a '=' without enclosing ('`") --| In this case the string ends at the next separator or operator --| and keywords are preferred. To use keywords, separators or --| operators in strings, enclosing quotes are required. --| --| The predefined constant keyword below can be used in a value expressions --| NOW NUMBER - current time in seconds since 1970 (+0t0000) --| MINUTE NUMBER - minute in seconds (60) --| HOUR NUMBER - hour in seconds (60*60) --| DAY NUMBER - day in seconds (24*60*60) --| YEAR NUMBER - year in seconds (365*24*60*60) --| KiB NUMBER - kilobyte (1024) --| MiB NUMBER - megabyte (1024*1024) --| GiB NUMBER - gigabyte (1024*1024*1024) --| TiB NUMBER - terrabyte (1024*1024*1024*1024) --| RNDn NUMBER - simple random number with n * 8 bit in length (1,2,4,8) --| PI FLOAT - PI (3.14159265359) --| LCSTAMP STRING - current local stamp in format: YYYYMMDD.HHMMSS --| LCDATE STRING - current local date in format: YYYYMMDD --| LCYEAR STRING - current local year in format: YYYY --| LCYEAR2 STRING - current local year in format: YY --| LCMONTH STRING - current local month in format: MM --| LCDAY STRING - current local day in format: DD --| LCTIME STRING - current local time in format: HHMMSS --| LCHOUR STRING - current local hour in format: HH --| LCMINUTE STRING - current local minute in format: MM --| LCSECOND STRING - current local second in format: SS --| GMSTAMP STRING - current Greenwich mean stamp in format: YYYYMMDD.HHMMSS --| GMDATE STRING - current Greenwich mean date in format: YYYYMMDD --| GMYEAR STRING - current Greenwich mean year in format: YYYY --| GMYEAR2 STRING - current Greenwich mean year in format: YY --| GMMONTH STRING - current Greenwich mean month in format: MM --| GMDAY STRING - current Greenwich mean day in format: DD --| GMTIME STRING - current Greenwich mean time in format: HHMMSS --| GMHOUR STRING - current Greenwich mean hour in format: HH --| GMMINUTE STRING - current Greenwich mean minute in format: MM --| GMSECOND STRING - current Greenwich mean second in format: SS --| GMSECOND STRING - current Greenwich mean second in format: SS --| SnRND10 STRING - decimal random number of length n (1 to 8) --| SnRND16 STRING - hexadecimal random number of length n (1 to 8) --| --| SUPPLEMENT '"' [:print:]* '"' | (null-terminated string (properties)) --| Supplements can contain two "" to represent one " --| Supplements can also be enclosed in ' or ` instead of " --| Supplements can also be enclosed in ' or ` instead of " --| ENVIRONMENT VARIABLES '<'varnam'>' will replaced by the corresponding value --| Escape sequences for critical punctuation characters on EBCDIC systems --| '!' = '&EXC;' - Exclamation mark --| '$' = '&DLR;' - Dollar sign --| '#' = '&HSH;' - Hashtag (number sign) --| '@' = '&ATS;' - At sign --| '[' = '&SBO;' - Square bracket open --| '\' = '&BSL;' - Backslash --| ']' = '&SBC;' - Square bracket close --| '^' = '&CRT;' - Caret (circumflex) --| '`' = '&GRV;' - Grave accent --| '{' = '&CBO;' - Curly bracket open --| '|' = '&VBR;' - Vertical bar --| '}' = '&CBC;' - Curly bracket close --| '~' = '&TLD;' - Tilde --| Define CCSIDs for certain areas in CLP strings on EBCDIC systems (0-reset) --| '&' [:digit:]+ '; (..."&1047;get.file='&0;%s&1047;'",f) --| Escape sequences for hexadecimal byte values --| '&' ['X''x'] :xdigit: :xdigit: ';' ("&xF5;") ------------------------------------------------------------------------ [[CLEP.APPENDIX.GRAMMAR]] == Appendix B. Grammar Below you can see the grammar used by the command line compiler. This content is printed on the screen if the built-in function <> is used. There are two context free grammars, one is used for the command line the other for the parameter file. The parameter file contains mainly the same argument list as the command line. The property file defines the default settings. For this a different grammar is applied. Properties can be set for each argument, i.e. for arguments not used or arguments in overlays. Based on that, properties are set by using the path (dotted keyword list). A property is always a 'SUPPLEMENT' for the argument list on the command line or parameter file. Thus all defined properties have the same effect as arguments on the command line. A property sets this argument to the corresponding value if it is not defined on the command line. ------------------------------------------------------------------------ Grammar for argument list, parameter file or property file --| Command Line Parser --| command -> ['('] parameter_list [')'] (main=object) --| | ['.'] parameter (main=overlay) --| parameter_list -> parameter SEP parameter_list --| | EMPTY --| parameter -> switch | assignment | object | overlay | array --| switch -> KEYWORD --| assignment -> KEYWORD '=' value --| | KEYWORD '=' KEYWORD # SELECTION # --| | KEYWORD '=>' STRING # parameter file # --| object -> KEYWORD ['('] parameter_list [')'] --| | KEYWORD '=' STRING # parameter file # --| | KEYWORD '=>' STRING # parameter file # --| overlay -> KEYWORD ['.'] parameter --| | KEYWORD '=' STRING # parameter file # --| | KEYWORD '=>' STRING # parameter file # --| array -> KEYWORD '[' value_list ']' --| | KEYWORD '[' object_list ']' --| | KEYWORD '[' overlay_list ']' --| | KEYWORD '=' value_list # with certain limitations # --| It is recommended to use only enclosed array lists to know the end --| | KEYWORD '[=' STRING ']' # parameter file # --| | KEYWORD '[=>' STRING ']' # parameter file # --| value_list -> value SEP value_list --| | EMPTY --| object_list -> object SEP object_list --| | EMPTY --| overlay_list -> overlay SEP overlay_list --| | EMPTY --| A list of objects requires parenthesis to enclose the arguments --| --| value -> term '+' value --| | term '-' value --| | term --| term -> factor '*' term --| | factor '/' term --| | factor --| factor -> NUMBER | FLOAT | STRING --| | selection | variable | constant --| | '(' value ')' --| selection -> KEYWORD # value from a selection table # --| variable -> KEYWORD # value from a previous assignment # --| | KEYWORD '{' NUMBER '}' # with index for arrays# --| constant -> KEYWORD # see predefined constants at lexem # --| For strings only the operator '+' is implemented as concatenation --| Strings without an operator in between are also concatenated --| A number followed by a constant is a multiplication (4KiB=4*1024) --| --| Property File Parser --| properties -> property_list --| property_list -> property SEP property_list --| | EMPTY --| property -> keyword_list '=' SUPPLEMENT --| keyword_list -> KEYWORD '.' keyword_list --| | KEYWORD --| SUPPLEMENT is a string in double quotation marks ("property") ------------------------------------------------------------------------ [[CLEP.APPENDIX.PROPERTIES]] == Appendix C. Properties All properties can be written to a global property file with the built-in function <>: ------------------------------------------------------------------------ 'GENPROP filename'. ------------------------------------------------------------------------ A property file for a certain command can be generated with: ------------------------------------------------------------------------ 'GENPROP command=filename' ------------------------------------------------------------------------ The first command shows the valid root path for the property file. A property file can contain properties for more than one root path. The property file parser will only interpret properties where the root matches, i.e. if the property file is assigned to a certain owner and possibly to a certain command, then only properties for this owner, the program itself and possibly the command will be accepted, all other properties are ignored. The second long comment gives some help for handling a property file. Thereafter the generated properties for this root are listed for all supported commands. The format is: ------------------------------------------------------------------------ path = SUPPLEMENT # Type: tttttt Help: hhh...hhh # ------------------------------------------------------------------------ The path denotes the unique dotted keyword list for one argument. The 'SUPPLEMENT' is a string normally in double quotation marks containing the value list for this argument in accordance with the syntax of the command line parser (strings then normally in single quotation marks, a opposite usage of the quotation marks is possible but not recommended). This means for example that a string that requires apostrophes must be included in apostrophes `("'...'")`. The supplement string is returned by the corresponding command line parser if no value for this argument is entered on the command line or is included in the parameter file. Behind the property definition the type and help message are printed as comment to help in editing the generated property file. The property values can be related to the current default settings at time of generation, what means that if hard coded default values or another property file is already in use, then these values are taken over into the new property file. The property file can contain parameter which are not available on the command line. Such parameter are only documented in the property file. On the other side not all command line parameter are available as property. If a description for a property argument is available which is not a part of the user manual this description is written as comment in front of the corresponding property definition. Below you can see the documentation of all parameter which are only available as property followed by all defined default properties in form of a sample property file for all available commands. === Appendix C.1. Remaining documentation Below you can find the documentation for all parameters which are only available over the property definitions. These parameters are not a part of the description for each command above. This list is generated and can be empty. In this case all parameters are available over the command line. If available, the manual page otherwise the help message is printed. === Appendix C.2. Predefined defaults Below you can find a sample property file which contains all predefined default values for all supported commands when this documentation was created. ------------------------------------------------------------------------ # Property file for: limes.flssrv # #------------------------------------------------------------------- # # # # The property file can be used to overwrite the default values # # used if the argument is not defined on the command line. # # # #------------------------------------------------------------------- # # # # The values is assigned between "" conforming to the syntax. # # Example NUMBER array : "4711, 1, 2, 3" # # Example STRING array : "'str1' x'303000''str2',a'abc'" # # Example FLOAT array : "123.34, 1.58, PI" (PI as constant) # # # # The last example shows that one can use key words if a list # # of constants is defined for this argument. # # # # For a SWITCH one can use the special key words ON/OFF to enable or # # disable the SWITCH or define the value as a number # # Examples for a SWITCH : "ON"/"OFF"/"4711" # # # # For an OBJECT only the special key word INIT can be used to ensure # # that this OBJECT will be initialized if it was not set on the # # command line. If INIT is not set, then the elements of the OBJECT # # will be initialized only if you type at least obj() in the command # # line. If you want an object to be initialized when you don't use it# # on the command line then the special key word must be set. # # Examples for an OBJECT: ""/"INIT" # # # # For an OVERLAY it is the same logic as for objects but the keyword # # of the element to initialize must be used if the overlay is not # # set in the command line. # # Example OVERLAY array : "LINE TRIANGLE LINE RECTANGLE" # # Example for a OVERLAY : "RECTANGLE" # # # #------------------------------------------------------------------- # ------------------------------------------------------------------------ [[CLEP.APPENDIX.RETURNCODES]] == Appendix D. Returncodes The return codes of the program are also called completion codes and returned at program termination. This content is printed on the screen with the built-in function <>. * 0 - command line, command syntax, mapping, execution and finish of the command was successful * 1 - command line, command syntax, mapping, execution and finish of the command was successful but a warning can be found in the log * 2 - command line, command syntax, mapping, execution was successful but cleanup of the command failed (may not happened) * 4 - command line, command syntax and mapping was successful but execution of the command returned with a warning * 8 - command line, command syntax and mapping was successful but execution of the command returned with an error * 12 - command line and command syntax was OK but mapping of the parameter for command execution failed * 16 - command line was OK but command syntax was wrong (error from command line parser) * 20 - command string was wrong (please use built-in function "SYNTAX" for more information) * 24 - initialization of the parameter structure for the command failed (may not happened) * 28 - configuration is wrong (determination of configuration data failed, configuration file might be damaged) * 32 - table error (something within the predefined tables is wrong (internal error)) * 36 - system error (e.g. load of environment or open of file failed) * 40 - access control or license error * 44 - interface error (e.g. parameter pointer equals NULL (only at call of subprogram interface)) * 48 - memory allocation failed (e.g. dynamic string handling) * 64 - fatal error (basic things are damaged) * >64 - special condition codes from the command for job control The command line is interpreted by CLE the command string by CLP. For example: ------------------------------------------------------------------------ :> flcl conv "read.file='test.txt' write.flam(file='test.adc')" | | |-- the command string is compiled by CLP | | | and might result in a syntax error | |-- conv is part of the command line |-- flcl is part of the command line :> flcl conv=para.txt | | |-- para.txt is part of the command line, but the content | | of para.txt might contain a CLP syntax error | |-- conv is part of the command line |-- flcl is part of the command line ------------------------------------------------------------------------ A command execution (run) will return 0 or 1 on success, 4 if a warning occurs (only some of the files converted), 8 in case of an error or special condition codes greater then 64 can be returned. If the command execution was successful (return code 0) but a relevant warnings was logged then the return code is 1 (anything was fine, but please have a look in the log (e.g. a key is close to expire)). A return code of 2 indicates that a call to the finish function failed. Such a fail of the finish function is not recognizable if the run function (command execution) returns with a warning or an error. On the other side, if the finish failed then an additional warning in the log cannot determined because the condition code is still 2. All completion codes bigger than 8 and smaller or equal to 64 indicate an error in front of the command execution. A relevant warning is a warning written to the log by a used component. Warnings written by components which are removed from procession because the format does not fit or something else, are still in the log but not relevant for the completion code 1. [[CLEP.APPENDIX.REASONCODES]] === Appendix D.1. Reasoncodes Below you can find the list of reason codes returned after command execution. Each command returns a reason code for the corresponding warning (return code 4) or error (return code 8). This content is printed on the screen with the built-in function <>. * 1 - Fatal error (may not happen) * 2 - System error (wrong size of data types) * 3 - Handle error (not in right shape) * 4 - Interface error (parameter incorrect) * 5 - Activity not possible * 6 - Memory allocation failed (not enough memory) * 7 - Length error (need more data at read or more space at write) * 8 - Control code wrong * 9 - Version not supported * 10 - Function not supported * 11 - Mode not supported * 12 - Suite not supported * 13 - Confidentiality mode not supported * 14 - Integrity mode not supported * 15 - Verification mode not supported * 16 - Wrong header checksum * 17 - Wrong pot checksum * 18 - Wrong data checksum * 19 - Wrong checksum * 20 - Wrong message authentication code (MAC) * 21 - Wrong key test value * 22 - Syntax error (file not formatted correctly) * 23 - Count error (supplied or calculated amount wrong) * 24 - End of list (handle points behind last or first element) * 25 - Delete of file failed * 26 - Type error (supplied or calculated type wrong) * 27 - Rebuild required (flush not possible) * 28 - No change (informational) * 29 - Status error (handle not in right state) * 30 - Orientation not supported * 31 - Split method not supported * 32 - Maximum delimiter amount achieved * 33 - Error at compression * 34 - Error at decompression * 35 - Maximum header length achieved * 36 - Maximum data length achieved * 37 - Open of FLAMFILE failed * 38 - Record format not supported * 39 - Writing to file failed * 40 - Reading from file failed * 41 - Get position of file pointer failed * 42 - Set position of file pointer failed * 43 - End of file (informational) * 44 - Rename of FLAMFILE failed * 45 - Delete of FLAMFILE failed * 46 - Close of FLAMFILE failed * 47 - Seek in file does not work * 48 - Set of buffer size for FIO failed * 49 - FLAMFILE format not supported * 50 - No FLAMFILE * 51 - No entry found * 52 - Construct is empty * 53 - Connection error * 54 - Unsupported FLAM-ID * 55 - Remote procedure call failed * 56 - Method not supported * 57 - Open of original file failed * 58 - Error from ZLIB (GZIP) * 59 - Character set not supported * 60 - Space too small * 61 - Logging facility not available * 62 - Error from character conversion module * 63 - Open of hash output file failed * 64 - Close of original file failed * 65 - Error with FKME * 66 - Error at character conversion * 67 - Info not supported * 68 - Band not supported * 69 - Open of report file failed * 70 - Size error (supplied or calculated size wrong) * 71 - Invalid character encountered * 72 - Incomplete character encountered * 73 - Error with byte order mark (BOM) * 74 - Format wrong or not supported * 75 - Auto conversion not possible * 76 - Error from BZIP2 library * 77 - Environment variable are not or cannot be defined * 78 - Dynamic load of a function failed * 79 - Access control or license violation * 80 - Compression limit not reached * 81 - Error from LZMA/XZ library * 82 - Error from XML parser (EXPAT) * 83 - Whole first block is padding * 84 - Command line parser failed * 85 - Mapping failed * 86 - Open of temporary file failed * 87 - Wrong magic bytes * 88 - Corrupted or no FLAMFILE * 89 - Initialization error * 90 - Parameter not formatted correctly * 91 - Binary data detected * 92 - From and to are equal * 93 - Data is encrypted (key required) * 94 - Key value wrong * 95 - Reallocation required * 96 - Invalid username * 97 - Authentication failed * 98 - Hash calculation failed * 99 - Processing of one or more files failed * 100 - Hash/checksum file is empty * 101 - Read of hash/checksum file failed * 102 - Name of hash/checksum file is not valid * 103 - Hash/checksum file is not formatted correctly * 104 - Open of code table failed * 105 - Code table is not formatted correctly * 106 - Attribute settings not supported * 107 - Option wrong or not supported * 108 - Invalid parameter combination * 109 - Open of info file failed * 110 - Protocol wrong or not supported * 111 - Differences found * 112 - Try again with an ASCII code page (LATIN1) for read * 113 - Data incomplete * 114 - Procedure not supported * 115 - Key not found * 116 - OpenPGP error * 117 - Algorithm not supported * 118 - Key is inactive * 119 - Key is invalid * 120 - Key is expired * 121 - Positioning failed * 122 - Sequence error, incorrect order * 123 - Update not possible * 124 - Regular expression error * 125 - Value out of range * 126 - Usage measurement not possible * 127 - Dummy processing not possible * 128 - Open of inverse file failed * 129 - Internal error (may not happen) * 130 - Micro Focus support failed * 131 - Dynamic string library error * 132 - Open of usage log failed * 133 - Serialization failed * 134 - Deserialization failed * 135 - Program call (PC) failed * 136 - Row specification wrong * 137 - Record delimiter not supported * 138 - End of table (informational) * 139 - End of member (informational) * 140 - Have more data (informational) * 141 - Alignment error * 142 - Not enough space available (internal buffer too small) * 143 - Plausibility error * 144 - Unexpected remaining rest (data don't fit within processing) * 145 - Length parameter too small (the resulting space is not sufficient) * 146 - Virus found * 147 - Connection was closed * 148 - Error from anti virus scanner * 149 - Authorization failed * 150 - Command execution failed [[CLEP.APPENDIX.VERSION]] == Appendix E. Version Here you can see the version of the program and its components. This content is printed on the screen if the built-in function <> is used. ------------------------------------------------------------------------ 00 FLIES-SEVER VERSION: 5.1.21-26794 BUILD: RELEASE Jan 3 2020 19:55:24 ------------------------------------------------------------------------ [[CLEP.APPENDIX.ABOUT]] == Appendix F. About This is the about information for the program (flssrv). Its content is printed on the screen if the built-in function <> is used. ------------------------------------------------------------------------ 00 Frankenstein Limes Integrated Extended Security Server (FLIES(R) Server) 01 FLIES-SEVER VERSION: 5.1.21-26794 BUILD: RELEASE Jan 3 2020 19:55:24 Copyright (C) limes datentechnik (R) gmbh All rights reserved The FLIES(R) server is a convenient method to access a remote FLAMARCHIVE. On LINUX systems we use additionally the glibc as part of the operating system FLIES(R) server is a work that uses the library glibc in unmodified form based on the LGPL license Copyright (C) 1991-2012 Free Software Foundation, Inc. More information to this license you can find under: http://www.fsf.org/ http://www.gnu.org/licenses/lgpl-3.0.txt ------------------------------------------------------------------------ [glossary] == Glossary :ADC: Abbreviation for Advanced Data Compression, which is the default compression algorithm of FLAM4. :AES: The Advanced Encryption Standard (AES) is a symmetric crypto system, the successor of DES and 3DES. It uses the Rijndael algorithm with a fixed block size of 128 bits and a variable key length of 128, 192 or 256 bits, providing a high grade of security. :ASCII: The American Standard Code for Information Interchange (ASCII) is a 7-Bit encoding, which is the source for later character sets based on more bits. :AVS: Anti virus scanning :BAS: Abbreviation for base encoding. :BCS: Banking Communication Standard. + Specification for remote data transmission between customers and credit institutions. The BCS is used, for example, in cash management systems to enable multi-bank capability, i.e. the processing of data from different credit institutions with software. :BIG ENDIAN: Endianness refers to the term byte order. A big-endian machine stores the most significant byte first, i.e. at the lowest byte address. This behavior is most important when two computers with different byte orders communicate with each other. The big-endian format is used by Motorola 6800 and 68k, Xilinx Microblaze, IBM POWER, System/360, System/370, ESA/390, z/Architecture and PDP-10. :BIN: Abbreviation for binary. :BOM: The Byte Order Mark (BOM) characterizes in which order the bytes are interpreted. This is important when exchanging data between different systems. For UTF-16 and UTF-32 a BOM sign at the beginning of the data stream is necessary, as more than one byte is used for the encoding of one character. UTF-8 uses the BOM sign "EF BB BF", which is used to mark a text file as UTF-8, even though byte order is not issue here. :BOMUTF: With this option of the FLCL, you can determine the correct UTF CCSID from the byte order mark (BOM). :BOMUCS: With this option of the FLCL, you can determine the correct UCS CCSID from the byte order mark (BOM). :BYTE ORDER: The byte order is the order in which bytes are interpreted for entities that consist of multiple bytes, e.g. Unicode characters. This is important when exchanging data between different systems. A big-endian machine stores the most significant byte first, i.e. at the lowest byte address. A little-endian machine, however, stores the least significant byte first. :BZ2: Abbreviation for BZIP2. :CANONICAL EQUIVALENCE: Canonical equivalence is a fundamental equivalence between individual Unicode characters and sequences of Unicode characters. :CASEMETHOD: FLCL offers a method for converting unicode characters to uppercase, lowercase or some special representation (CASE=UPPER/LOWER). :CCSID: This is an abbreviation used by IBM for "Coded Character Set Identifier". The encoding of a specific code page is referred to by a 16-bit number. see also: https://en.wikipedia.org/wiki/CCSID[CCSID] :CHAR: Abbreviation for the conversion of character streams. :CHR: Abbreviation for character :CLAMD: Clam Anti Virus Daemon :CNV: Abbreviation for conversion. Collects all conversion components which transform data stream in data stream (e.g. character conversion, compression, de/encryption, de/encoding, ...). :CODEPAGE: IBM introduced a numbering scheme to character encodings (16 bits). This scheme was taken over by other vendors like Microsoft, SAP or Oracle Corporation. The term Codepage is used synonymously for character encoding or character set. :CODE POINT: A code point or code position is a single character in a list of characters represented as numerical values that create the code space. The Unicode code space has a total size of 17 * 65536 code points. The same code space may have several codepages. :COMPATIBILITY EQUIVALENCE: One speaks of compatibility equivalence of two sets of characters if their full compatibility decompositions are identical. :CONV: The sub-program FLUC offers all possible conversion and formatting methods via the CONV command. These are various read and write procedures, many useful conversion tools and some special data formatting features. :CNV: Conversion component :CRY: Abbreviation for crypto(graphy). :CX7: Compression encoding as printable characters in FLAM4 :CX8: Compression encoding as binary data in FLAM4 :DAT: Abbreviation for data. :DIACRITIC: A diacritic is also called diacritical mark, diacritical point or diacritical sign. Typical diacritical marks are the acute (´) and grave (`), which are often called accents. Diacritical marks may be a dash, dot or tick above or below a letter, or in some other position such as within the letter or between two letters. :DIR: Abbreviation for directory (walk). :EBCDIC: The Extended Binary Coded Decimals Interchange Code (EBCDIC) was developed by IBM as 8-Bit-encoding, which, however, does not use all code words. EBCDIC originates from the older 4-Bit-Code BCD (Binary Coded Decimals) and is applied solely on Mainframes. The EBCDIC codepages are available in German, US, Swedish, Arabian, Latin-1 and other languages. Moreover, there exists a Unicode set of characters based on EBCDIC and it is called UTF-EBCDIC. :BLK: Abbreviation for block. :ENV: Abbreviation for environment. :FINGERPRINT: In public-key cryptography, a public key fingerprint is a short sequence of bytes used to identify a longer public key. Fingerprints are created by applying a cryptographic hash function to a public key. Since fingerprints are shorter than the keys they refer to, they can be used to simplify certain key management tasks. + see also: https://en.wikipedia.org/wiki/Public_key_fingerprint/[Public key fingerprint] :FIO: Abbreviation for File I/O. All components to read or write files. The C programming language has a general mechanism for reading and writing files abstracting all Input/Output to streams of bytes. The operating system offers redirection which can be very useful. Examples are the standard input stream, standard output stream and standard error stream. :FKME: FLAM Key Management Exit/Extension Service provider interface to connect FLAM till version 4 with different kinds of cryptographic infrastructure, hardware security modules and/or key management systems. :FL4: Abbreviation for FLAM in Version 4 or lower. :FL5: Abbreviation for FLAM in Version 5. :FLAM: Frankenstein Limes Access Method. FLAM is our access method for encrypted and compressed data. In particular, FLAM is a utility for converting, compressing, encrypting (with AES (Advanced Encryption Standard)), signing and formatting of mass data with simple interfaces for integration in all kinds of solutions. All this is done with a minimum of CPU consumption, utilization of co-processors and the use of professional key management solutions. Ordinarily, FLAM provides - when used as sub-program - the commands COMP and DECO and makes use of an element interface for the subsystems/plugins/drivers and also the sub-program. :FLAM4: This component writes a Flamfile record-oriented. You can state the name of a Flamfile or that of a member. :FLAMFILE: The FLAMFILE is composed like a package file, as multiple files can be compressed. It is structured clearly and divided hierarchically in records, segments and members. In this connection a segment is referred to the single matrix of a compressed file and a member to the entity of segments that are part of the compressed file. In order to ensure the universal exchangeability, the FLAMFILE has to be available in a format that is representable on all operating systems (so-called heterogeneous compatibility). Each compressed data segment is unique referring to data content, environment and time. This allows - despite compression/encryption - an access down to the record-level, without decompressing/decrypting. :FLCC: Frankenstein Limes Control Center (GUI).In contrast to FLCL this is the graphical user interface for running FLAM, FLUC and FLIES, quasi a dialogue utility :FLCL: Frankenstein Limes Command Line. FLCL offers a command line for the three sub-programs FLAM, FLUC and FLIES. It is a quasi-batch utility for the sub-programs. Moreover, FLCL is a universal data format and character set converter, which can be included easily in professional internationalization projects. It supports different input and output formats (GZIP, PDF, B64...) and can be integrated into scripts or as sub-program. More than 150 codepages are supported. FLCL can be applied to various commonly used platforms if working with processable data streams or file I/O. :FLIES: Frankenstein Limes Integrated Extended Security. The sub-program FLIES governs the compressed and encrypted segments using commands like FIND and CHNGE. In particular, it is useful for processing Flamfiles, which however cannot be decrypted or decompressed. For instance the data in the file header is managed by FLIES to re-encrypt the file, change the data access, use as backup, archive or as mediator/headend. :FLUC: Frankenstein Limes Universal Converter. FLUC is a universal text converter with special focus on the high requirements in professional internationalization projects, where Mainframes and external applications are used as central backend. :FLUCUP: FLUC Subprogram as C interface (DLL) for Data source to target conversion. :FMT: Abbreviation for formatting. All components to parse a data stream in FLAM5 element list or build a data stream from FLAM5 elements list. :FROM-CODE: The FROM-Code specifies the character encoding of the input data that used as source encoding for character conversion. :GZIP: GZIP is a compression program for nearly every operation system and uses the DEFLATE algorithm from the ZLIB library. GZIP is the short form for GNU zip. The used algorithm is a combination of LZ77 and Huffmann encoding. The source code is licensed under the GPL. The program has 9 compression steps providing either optimal CPU time or compression ratios. The compressed file has the ending ".gz". As GZIP compresses only single files. Several files must first be combined with (for example) "tar" to a tarball which can then be compressed to a ".tar.gz" file. GZIP files have a 10-byte header, containing a magic number, a version number and a timestamp. With FLCL you are able to read and write GZIP files, to mark content as text data in the header, set operating/file system or modified time (seconds since 1970). :GZP: Abbreviation for GZIP. :HOST: see MAINFRAME :HSH: Abbreviation for hash (checksum) :ICNV: Abbreviation for iconv conversion with simplified commands on the command line. :ICONV: With the standard program iconv, characters can be translated between different encodings on UNIX-like systems. As iconv is now part of the GNU C Library, actual Linux systems are equipped with iconv. Under Windows(R), iconv is provided only as DLL or static library, which is under the license of the GPL and can be used via Cygwin or GnuWin32. Iconv is also supported as Dynamic Link Library for PHP. :ID: Abbreviation for identifier. :ISO-8859: The ISO-8859 norm family contains some useful 8-bit character sets (e.g. Latin-1 to Latin-15). The frequently used Latin-1 character set is identical with the first 256 characters of the Unicode character set. These codepages are also called extended Ascii. :LITTLE ENDIAN: A little-endian machine stores the least significant byte first. The endianness of a 16, 32 or 64 bits word or even bits can occur in some Unicode representations. Also mixed forms of endianness are possible, for example when the byte order within a 16 bits word differs from that of a 16 bits word within a 32 bits word. The little-endian format is used by x86 (including x86-64), 6502 (including 65802, 65C816), Z80 (including Z180, eZ80 etc.), MCS-48, 8051, DEC Alpha, Altera Nios II, Atmel AVR, SuperH, VAX, and PDP-11. :LOGGING: In FLCL various messages (warnings, errors, debug information, important information, input data) can be logged. The messages can be redirected from stderr to stdout or a file. :LXZ: Abbreviation for LZMA XZ. :MAINFRAME: A mainframe is a very complex and powerful computer system. Its capacity is far beyond that of a common Personal Computer and that of most servers. They are applied for the highly reliable processing of mass data, mass transactions and company critical data and gain importance again in connection with server consolidation and cloud computing. :MODE: With the keyword MODE in FLCL you can select the mode of operation. :NDC: Abbreviation for No Data Compression, which can be considered as copying data in FLAM4. :NFC: This is Normalization Form C (Canonical Decomposition, followed by Canonical Composition). :NFD: This is Normalization Form D (Canonical Decomposition). :NFKC: This is Normalization Form KC (Compatibility Decomposition, followed by Canonical Composition). :NFKD: This is Normalization Form KD (Compatibility Decomposition). :Normalization: The transformation of a character sequence in one of the four normal forms is called normalization. Normalization is necessary, because there is more than one differing possibility for many characters to be represented as a sequence of Unicode characters. The four normal forms consist of one form for the canonical equivalence, one for the compatible equivalence, and both can be in a "composed" or "decomposed" form. :OS: Abbreviation for operation/file system in the header :PADDING: Padding are bytes inserted to align the data to certain lengths or storage positions. Padding bytes are most commonly appended after the the last data byte. When reading padded data, the padding bytes are discarded. :PDS: Partitioned data set. A PDSE consists of a directory and zero or more members, :PDSE: Partitioned data set extended. Exactly same as PDS in many respects. PDSE data sets can be stored only on DASD, not on tape. Interesting thing is the directory can expand automatically as needed. Additionally it has an index which helps to locate the members inside the PDSE faster. SPACE from deleted members are automatically reused in PDSE . :PGP: Abbreviation for pretty good privacy (OpenPGP). :PLATFORM NEUTRAL: The components of FLAM are platform neutral. This means that they work independently from the used operating system. Operating systems can be for example LINUX, UNIX-like systems, WINDOWS(R) or z/OS(R). :PO: Data set organisation partitioned organized. :PS: Data set physical sequential file. :REC: Abbreviation for record. :SEPA: The Single Euro Payments Area (SEPA) is a project to harmonize the way retail payments are made and processed in Euro. The motivation behind it is to make payments in Euro and across the EU as fast, safe and efficient as national payments are now. SEPA shall enable customers to make cashless Euro payments to anyone in the EU, for instance by credit transfer, direct debit or debit card. + see also: https://en.wikipedia.org/wiki/Single_Euro_Payments_Area/[SEPA] :SIG: Abbreviation for signature :SSH: Secure shell + see also: https://en.wikipedia.org/wiki/Secure_Shell/[SSH] :SUB CHARSET: A Sub Charset is a partial quantity of a character set. For instance the new identity card issued in Germany (nPa) requires that each printed character - even the diacritical characters - is "composed". It means that they remain in their original form and are not "decomposed" into several bytes. For that reason, the Sub Charset "Latin in Unicodes" with some more than 500 letters is used. :SUBCHR: FLCL can substitute characters that are unsupported in their target encoding by system specific characters (e.g. 0x1A for ASCII or 0x3F for EBCDIC pages) or by arbitrary characters. In the first case, you must use SUBCHR=SYSTEM, in the other you can define your own substitution characters. On z/OS(R), the utility iconv is available on the system and replaces all invalid characters by system specific characters, including the BOM sign. Note that it does not stop in contrast to LINUX or WINDOWS(R) but completes conversion. :SUBSTITUTE: If a character exists in the source code but not in the target code, it will be converted to a converter-defined substitute character. :SURROGATE: The Unicode code space is divided into 17 planes of 65536 code points each. Some code points have no character value, some are reserved for private use, and some are permanently reserved as non-characters. UTF-16 with code points beyond these planes is encoded in 16 bit surrogate pairs (High surrogate and low surrogate), which are in fact replacement characters. UTF-16 surrogate values are illegal in UTF-32. Note that the conversion of UTF-16 strings into UTF-8 byte sequences requires that the High and Low surrogate have to be combined correctly before they are transfered into UTF-8. :SYSTEM TABLE: FLCL makes use of a pre-loaded system substitution table for the transliteration of characters. This is comparable to "translit.h" of iconv under LINUX. :TAB: Abbreviation for table. :TAR: Tape Archiver; Short for Tape Archive, and sometimes referred to as tarball, a file that has the TAR file extension is a file in the Consolidated Unix Archive format. A program or command that can open archives is needed to open a TAR file. Because the TAR file format is used to store multiple files in one single file, it's a popular method for both archiving purposes and for sending multiple files over the internet, like for software downloads. The TAR file format is common in Linux and Unix systems, but only for storing data, not compressing it. TAR files are often compressed after being created, but those become TGZ files, using the TGZ, TAR.GZ, or GZ extension. :TARGET: Trans-European Automated Real-time Gross Settlement Express Transfer System. + see also: https://www.ecb.europa.eu/paym/target/target2/html/index.en.html/[TARGET] :TXT: Abbreviation for text. :TO-CODE: With few utilities you can convert text from one encoding to another. The TO-Code specifies the output encoding that characters are converted to. :TRANSCRIPTION: To transcribe the expression of a language means by dictionary, to represent it in another writing system rather in that, in which the language is usually written respectively in which it is available in written form. For the term of transcription it does not matter, in which medium the expression is available. Note that the transliteration of an expression is a particular type of transcription. :TRANSLATION: This is the transfer of a (mostly written) and fixed text from the original language into any target language; the process will be also denoted as "Translating". :TRANSLITERATION: To transliterate an expression represented in writing S1 into a writing system S2 means, that the characters contained in the expression are exchanged from S1 to S2 according to a fixed rule. In the simplest case, this can be a table which assigns each character of S1 a character of S2. Frequently, there are complications for the simple case, if for example a single character is assigned to a digraph or vice versa or if a character is mapped in context A onto a specific character, in context B however onto another character. For example: in a payment order from Germany, the name of the receiver must be written explicitly in Latin letters so that a transliteration of the original text with help of a table is required. :UNICODE: The so-called Unicode is an attempt, started in the 90s, to standardize a single character set that eliminates the need for different and incompatible encodings in different countries and cultures. The text should be always readable with a Unicode-supporting appropriate editor. This allows an error free data exchange (for the purpose of readability) also on a global and international level. For this character set, 8 bits (1 byte) are no longer sufficient to for a representation of every possible character. The length of characters encoded in Unicode can be between 1 and 4 bytes. ISO 10646 is a practically equal notation of the Unicode character set called Universal Character Set (UCS). :URL: Uniform Resource Locator + see also: https://en.wikipedia.org/wiki/URL/[URL] :USER TABLE: For character set conversion in FLCL you can define your own user substitution table to transliterate those characters that are not handled respectively replaced by the system table. :UTF-8: The 8-Bit Unicode Transformation Format is the most commonly used encoding for Unicode characters. The term Unicode is used equivalent to UCS. UTF-8 has a central meaning in the global character conversion for internet protocols. :UTF-16: In UTF-16 an encoded byte sequence with a length of 2 bytes is assigned to each Unicode character. UTF-16 is used in Java for internal character sequence representation. UTF-16 is the eldest format of the Unicodes. :UTF-32: UTF-32 (UCS-4) is encoded with 4 bytes and therefore the most simple Unicode representation, as other formats need variable byte lengths for their representation. One disadvantage of UTF-32 is the greater space requirement compared to UTF-8 and ISO-8859 character sets and the missing backward compatibility to ASCII.# :VSAM: Virtual Storage Access Method + see also: https://www.ibm.com/support/knowledgecenter/zosbasics/com.ibm.zos.zconcepts/zconcepts_169.htm/[VSAM] :VR8: Enhanced compression encoding as binary data in FLAM4 :ZIP: ZIP is an archive file format that supports lossless data compression. [colophon] == Imprint ----------------------------------------------------------------------- limes datentechnik(R) gmbh Louisenstrasse 101 D-61348 Bad Homburg v.d.H. phone: +49(0)6172-5919-0 fax: +49(0)6172-5919-39 mail: info@flam.de web: www.flam.de or www.limes.de Amtsgericht: Bad Homburg vor der Hoehe HRB 3288 (gegr. 1985) Geschaeftsfuehrer: Diplom-Mathematiker Heinz-Ulrich Wiebach limes datentechnik(R): efficiency at the limit of possibility. -----------------------------------------------------------------------