yaps.doc

使用Modem发送网上传呼

                               Table of Contents
                                       
    1. Introduction
    2. Installation
    3. Configuration
    4. Command Line
    5. Sending/Expecting Syntax
    6. Scripting
    7. Examples
    8. Changelog
       
                                 Introduction
                                       
   Welcome to Yaps, Yet Another Paging Package. The program is used to
   send textual messages to a remote paging device using a modem gateway.
   Many pager companies offer such modem gateways and are using specific
   protocols. The most often used one, TAP is implemented beside others
   (more or less complete.) This command line program uses a global and a
   private configuration file to get information about each paging
   service, installed modems and possibly other.
   
   As the main part is implemented as a library it is not very
   complicated to write a client/server solution. For the legal status
   see the File Copying.
   
                                 Installation
                                       
   The software is written, tested and designed on and for Unix(tm) like
   operating systems and requires the so called Posix system calls and
   function library. Gnumake and GCC are required, too (or some changes
   to the Makefile and the code may be neccessary.) It is known to run at
   least on following operating systems:
     * Linux (native system)
     * Solaris 2.5.1 (Frank K鋐er)
     * SunOS 4.1.3 aka Solaris 1.1 (Frank K鋐er)
       
   (more may follow.)
   
   Typically these steps should be enough to install the package:
   
   Edit Config
          For GCC the settings of CC and CFLAGS should be okay. Define
          SLANG=True, if you like to use the SLang scripting language,
          which can be found on space.mit.edu. Install it somewhere the
          compiler can find it. Define LUA=True for using the lua
          scripting language, which is located on ftp.icad.puc-rio.br.
          READ THE COPYRIGHT RELATED FILES OF EACH PACKAGE BEFORE
          INSTALLING IT!
          
   Edit config.h
          This is used to adapt the software to various variants of
          Unix(tm). If you do not have a regex.h file, either set
          HAVE_REGEX_T to zero or install the GNU regular expression
          library. Be sure the library and includefile can be found by
          the compiler and the name of the header file is regex.h,
          otherwise make a (symbolic) link to this file. Add the libary
          to EXLIB = in Config.
          
   make depend
          This create the dependency file which will be included during
          make.
          
   make (or make all)
          This compiles the library, the program driver and links the
          program. The documentation is created using lynx. As lynx is
          not on every system the already formated result is included as
          well.
          
   make install
          This copies the program and the global configuration file to
          the final location. This step requires a working install
          program. If this is missing, you have to install it by hand
          (well, two files should not be too much.)
          
   Edit the global configuration file
          With your favorite editor you should edit the global
          configuration file (which will be installed as /etc/yaps.rc on
          default) and change everything as required. See the
          Configuration section for a detailed description of the
          contents of the file.
          
   Done!
          You may play around with your configuration until you are
          satisfied, but this fine tuning is up to you.
          
   If you have problems during compilation, feel free to send me a mail.
   
                                 Configuration
                                       
   The program reads first the global configuration file /etc/yaps.rc
   (when not overwritten by command line switch), then the local one in
   ~/.yapsrc to get its configuration. Command line options may overwrite
   some settings in these files. Both configuration files have the same
   layout where the local one can overwrite settings of the global one.
   Each file is seperated in sections, where a section is started with
   [<name>] or [] for the global section. When a file is opened all
   entries are stored in the global section until a section name appears.
   If a section expression [..] is followed by a comma seperate list of
   names, then these are the fallback sections, i.e. variables not found
   int his section are taken from the fallback sections before trying the
   global one.
   
   If the first character is a bar (|) then the rest is taken as a
   filename to be included at this point. The current section is NOT
   affected by this call. Each line may have exactly one entry (or a
   comment starting with a hash sign in the first column) where the
   variable name is seperated by whitespaces from its value. If the first
   character of the value is a backslash (\), then this is removed. This
   allowes creating values starting with whitespaces. But if a value
   should start with a backslash itself, be sure to escape it with
   another backslash. A line can split over several physical line, if
   each line (expect the last one) ends with a backslash. If the value
   starts with an opening curly bracket ({) then all lines up to the
   closing curly bracket (}) in the first column are taken as the value
   for that variable. The brackets (and the lines where they appear) are
   not part of the value.
   
   The value may either be textual, numeric, boolean or a check
   expression. Textual values are starting with the first non whitespace
   character and continue to the end of the line. Numeric values are a
   sequence of digits which are parsed by the C-function atoi(3). Boolean
   may either be T, Y, 1 or + for true and F, N, 0 or - for false (or in
   greater detail, everything that is not true is false.) Case is here
   not significant. The check is a sequence of special characters which
   must match the given string. If a > is found, then the rest is
   optional, but must still match, if a < is found and the string is not
   at its end, it is considered as too long. These characters are
   supported:
     * 1 numeric
     * h hexadecimal
     * l lowercase
     * u uppercase
     * a alpha
     * n alphanumeric
     * p printable
     * x ascii
     * every other character matches every character
       
   Some simple examples:
     * >1 A string with unlimited length, but made only out of numeric
       values.
     * aaa A string of exact three alpha characters.
     * >xxxx< A string of length zero up to four made of ASCII
       characters.
     * ....>1111< A string starting with exact four characters, followed
       by zero to four numeric characters.
       
   Alternative one can specify the check by a description, if the
   checkstring is prefixed by a plus sign. This is then a comma seperated
   list of checks, which are seperated by an equal sign into variable and
   value. These variables are supported:
     * type=<type> Each character in the string must match the type,
       which may be one of the following:
          + numeric only digits are allowed.
          + sedecimal only hexdigits are allowed.
          + lower only lowercase characters are allowed.
          + upper only uppercase characters are allowed.
          + alpha only alpha characters are allowed.
          + alphanumeric only digits and alpha characters are allowed.
          + print only printable characters are allowed.
          + ascii only ASCII characters are allowed.
     * length=<length> The string must have exact this length.
     * minimum=<length> The string must at least this length.
     * maximum=<length> The string must not be longer than this length.
       
   The global section defines global values or default values for other
   sections. Some section may not inherit these values, but currently
   there is only one and is marked as such.
   
Global section

   These are typical found in the global section and can be overwritten
   in other sections, if required.
   
   services <text>
          This is the comma seperated list of available services.
          
   call-id <text>
          If the pager allows to send the source caller id this id is
          used, if not overwritten by a command line argument.
          
   signature <text>
          If this is present, then the text is appended to each message
          sent to the pager (and if use-signature is True).
          
   verbose <num>
          Sets the debugging/verbosity level. The bigger the number, the
          more output is generated.
          
   logfile <text>
          If the given text is a valid filename the status of a sending
          request is loged there.
          
   logstring <text>
          If this is present, then only these parts are logged, which
          match the given string. Currently these elements are supported:
          
          + message had been trasmitted successfully
          - message had not been transmitted
          * part had been transmitted successfully
          / part had not been transmitted
          i informal logfile entry
          c cost relevant informations
          s session start
          e session end
          p protocol specific
            
   modems <text>
          This is a list of modem entries, seperated by commas.
          
   final-report <text>
          If this is set, a final report is written to the given
          filename. If filename is -, then it is written to stdout. This
          feature is intended for use in shell scripts, so the script
          could proof which message has actual send and which one has
          been rejected instead of simple rely on the return code of
          yaps.
          
Service section

   The names of these section are free to the user, but their contents
   describe a paging service (or a paging company.) Following variables
   are allowed for service sections:
   
   speed <num>
          The speed of the serial device.
          
   bits-per-byte <num>
          The number of bits per byte, supported are 5 to 8.
          
   parity <text>
          The used parity, this may either be none, even or odd.
          
   stopbits <num>
          The number of stopbits, supported are 1 or 2.
          
   phone <text>
          The phone number of the modem gateway for this service. If the
          number contains %P and insert-pager-id is set, then the pagerid
          is inserted into the phonenumber.
          
   protocol <text>
          This is the communication protocol, that this service requires.
          Currently are ascii, script, tap and ucp allowed.
          
   max-size <num>
          The maximal length of a message for this service.
          
   may-split <bool>
          If this is true, then a message, which is too long will be
          split into several messages.
          
   max-messages <num>
          The maximum number of messages per message, that can be send.
          If this is zero, then an unlimited number of messages can be
          send.
          
   truncate <bool>
          If this is set a message is not split, but truncated to the
          length allowed by the provider.
          
   use-call-id <bool>
          If this is true, then the caller-id is inserted. Where it is
          insert is protocol specific.
          
   use-signature <bool>
          If this is true and a signature is given, this is appended to
          each message.
          
   insert-pager-id <bool>
          If this is true, then the pagerid is inserted as part of the
          phone number. This implies, that only messages to the same
          receipiant can be send at one call.
          
   rm-invalids-cid <text>
          Remove every character in text, that appears in the caller id.
          This is designed to make a caller id more readable, but still
          useable by the desired service.
          
   rm-invalids-pid <text>
          Dito for pager ids.
          
   valid-pid <text>
          This is a regular expression to check wether a pager-id is
          valid for this service. If your system does not support Posix
          regular expression, you can use a simple replacement. This is
          just a list of strings, seperated by a bar which must match the
          beginning of the pager-id.
          
   change-pid <text>
          If the pager-id matches the regular expression of valid-pid,
          then this matching part is replaced with this string. If the
          string is just a minus (-), then the match is removed from the
          resulting pager-id.
          
   valid-cid <text>
          The same like valid-pid for the caller id.
          
   change-cid <text>
          The same like change-pid for the caller id.
          
   conv-table <text>
          The value is a filename to a character conversion table. This