vmod_std(3)

1VMOD_STD(3)                                                        VMOD_STD(3)
2
3
4

NAME

6       vmod_std - Varnish Standard Module
7

SYNOPSIS

9          import std [as name] [from "path"]
10
11          REAL random(REAL lo, REAL hi)
12
13          REAL round(REAL r)
14
15          VOID collect(HEADER hdr, STRING sep)
16
17          STRING querysort(STRING)
18
19          STRING toupper(STRING s)
20
21          STRING tolower(STRING s)
22
23          STRING strstr(STRING s1, STRING s2)
24
25          BOOL fnmatch(STRING pattern, STRING subject, BOOL pathname, BOOL noescape, BOOL period)
26
27          STRING fileread(STRING)
28
29          BLOB blobread(STRING)
30
31          BOOL file_exists(STRING path)
32
33          BOOL healthy(BACKEND be)
34
35          INT port(IP ip)
36
37          DURATION duration([STRING s], [DURATION fallback], [REAL real], [INT integer])
38
39          BYTES bytes([STRING s], [BYTES fallback], [REAL real], [INT integer])
40
41          INT integer([STRING s], [INT fallback], [BOOL bool], [BYTES bytes], [DURATION duration], [REAL real], [TIME time])
42
43          IP ip(STRING s, [IP fallback], BOOL resolve, [STRING p])
44
45          REAL real([STRING s], [REAL fallback], [INT integer], [BOOL bool], [BYTES bytes], [DURATION duration], [TIME time])
46
47          TIME time([STRING s], [TIME fallback], [REAL real], [INT integer])
48
49          VOID log(STRING s)
50
51          VOID syslog(INT priority, STRING s)
52
53          VOID timestamp(STRING s)
54
55          BOOL syntax(REAL)
56
57          STRING getenv(STRING name)
58
59          BOOL cache_req_body(BYTES size)
60
61          VOID late_100_continue(BOOL late)
62
63          VOID set_ip_tos(INT tos)
64
65          VOID rollback(HTTP h)
66
67          BOOL ban(STRING)
68
69          STRING ban_error()
70
71          INT real2integer(REAL r, INT fallback)
72
73          TIME real2time(REAL r, TIME fallback)
74
75          INT time2integer(TIME t, INT fallback)
76
77          REAL time2real(TIME t, REAL fallback)
78

DESCRIPTION

80       vmod_std contains basic functions which are part and parcel of Varnish,
81       but which for reasons of architecture fit better in a VMOD.
82

NUMERIC FUNCTIONS

84   REAL random(REAL lo, REAL hi)
85       Returns a random real number between lo and hi.
86
87       This function uses the "testable" random generator  in  varnishd  which
88       enables  determinstic  tests to be run (See m00002.vtc).  This function
89       should not be used for cryptographic applications.
90
91       Example:
92
93          set beresp.http.random-number = std.random(1, 100);
94
95   REAL round(REAL r)
96       Rounds the real r to the nearest integer, but round halfway cases  away
97       from zero (see round(3)).
98

STRING FUNCTIONS

100   VOID collect(HEADER hdr, STRING sep=", )
101       Collapses  multiple hdr headers into one long header. The default sepa‐
102       rator sep is the standard comma separator to use when collapsing  head‐
103       ers, with an additional whitespace for pretty printing.
104
105       Care  should be taken when collapsing headers. In particular collapsing
106       Set-Cookie will lead to unexpected results on the browser side.
107
108       Using hdr from obj.http triggers a VCL failure.
109
110       Examples:
111
112          std.collect(req.http.accept);
113          std.collect(req.http.cookie, "; ");
114
115   STRING querysort(STRING)
116       Sorts the query string for cache normalization purposes.
117
118       Example:
119
120          set req.url = std.querysort(req.url);
121
122   STRING toupper(STRING s)
123       Converts the string s to uppercase.
124
125       Example:
126
127          set beresp.http.scream = std.toupper("yes!");
128
129   STRING tolower(STRING s)
130       Converts the string s to lowercase.
131
132       Example:
133
134          set beresp.http.nice = std.tolower("VerY");
135
136   STRING strstr(STRING s1, STRING s2)
137       Returns a string beginning at the first occurrence of the string s2  in
138       the string s1, or an empty string if s2 is not found.
139
140       Note that the comparison is case sensitive.
141
142       Example:
143
144          if (std.strstr(req.url, req.http.restrict)) {
145                  ...
146          }
147
148       This  will check if the content of req.http.restrict occurs anywhere in
149       req.url.
150
151   BOOL fnmatch(STRING pattern, STRING subject, BOOL pathname, BOOL  noescape,
152       BOOL period)
153          BOOL fnmatch(
154             STRING pattern,
155             STRING subject,
156             BOOL pathname=1,
157             BOOL noescape=0,
158             BOOL period=0
159          )
160
161       Shell-style  pattern matching; returns true if subject matches pattern,
162       where pattern may contain wildcard characters such as * or ?.
163
164       The match is executed by the implementation of fnmatch(3) on your  sys‐
165       tem. The rules for pattern matching on most systems include the follow‐
166       ing:
167
168       • * matches any sequence of characters
169
170       • ? matches a single character
171
172       • a bracket expression such as [abc] or  [!0-9]  is  interpreted  as  a
173         character  class  according to the rules of basic regular expressions
174         (not pcre2(3) regexen), except that ! is  used  for  character  class
175         negation instead of ^.
176
177       If pathname is true, then the forward slash character / is only matched
178       literally, and never matches *, ? or a bracket expression. Otherwise, /
179       may match one of those patterns.  By default, pathname is true.
180
181       If  noescape  is  true, then the backslash character \ is matched as an
182       ordinary character. Otherwise, \ is an escape  character,  and  matches
183       the character that follows it in the pattern. For example, \\ matches \
184       when noescape is true, and \\  when  false.  By  default,  noescape  is
185       false.
186
187       If  period is true, then a leading period character . only matches lit‐
188       erally, and never matches *, ? or a bracket  expression.  A  period  is
189       leading  if  it  is the first character in subject; if pathname is also
190       true, then a period that immediately follows a / is also leading (as in
191       /.).  By default, period is false.
192
193       std.fnmatch()  invokes  VCL failure and returns false if either of pat‐
194       tern or subject is NULL -- for example, if an unset  header  is  speci‐
195       fied.
196
197       Examples:
198
199          # Matches URLs such as /foo/bar and /foo/baz
200          if (std.fnmatch("/foo/\*", req.url)) { ... }
201
202          # Matches URLs such as /foo/bar/baz and /foo/baz/quux
203          if (std.fnmatch("/foo/\*/\*", bereq.url)) { ... }
204
205          # Matches /foo/bar/quux, but not /foo/bar/baz/quux
206          if (std.fnmatch("/foo/\*/quux", req.url)) { ... }
207
208          # Matches /foo/bar/quux and /foo/bar/baz/quux
209          if (std.fnmatch("/foo/\*/quux", req.url, pathname=false)) { ... }
210
211          # Matches /foo/bar, /foo/car and /foo/far
212          if (std.fnmatch("/foo/?ar", req.url)) { ... }
213
214          # Matches /foo/ followed by a non-digit
215          if (std.fnmatch("/foo/[!0-9]", req.url)) { ... }
216

FILE(SYSTEM) FUNCTIONS

218   STRING fileread(STRING)
219       Reads a text file and returns a string with the content.
220
221       The  entire file is cached on the first call, and subsequent calls will
222       return this cached contents, even if the file has changed in the  mean‐
223       time.
224
225       For binary files, use std.blobread() instead.
226
227       Example:
228
229          synthetic("Response was served by " + std.fileread("/etc/hostname"));
230
231       Consider that the entire contents of the file appear in the string that
232       is returned, including newlines that may result in invalid  headers  if
233       std.fileread()  is used to form a header. In that case, you may need to
234       modify the string, for example with regsub() (see vcl(7)):
235
236          set beresp.http.served-by = regsub(std.fileread("/etc/hostname"), "\R$", "");
237
238   BLOB blobread(STRING)
239       Reads any file and returns a blob with the content.
240
241       The entire file is cached on the first call, and subsequent calls  will
242       return  this cached contents, even if the file has changed in the mean‐
243       time.
244
245   BOOL file_exists(STRING path)
246       Returns true if path or the file pointed to by path exists, false  oth‐
247       erwise.
248
249       Example:
250
251          if (std.file_exists("/etc/return_503")) {
252                  return (synth(503, "Varnish is in maintenance"));
253          }
254

TYPE INSPECTION FUNCTIONS

256   BOOL healthy(BACKEND be)
257       Returns true if the backend be is healthy.
258
259   INT port(IP ip)
260       Returns  the  port  number of the IP address ip. Always returns 0 for a
261       *.ip variable when the address is a Unix domain socket.
262

TYPE CONVERSION FUNCTIONS

264       These functions all have the same form:
265
266          TYPE type([arguments], [fallback TYPE])
267
268       Precisely one of the arguments must be provided (besides  the  optional
269       fallback), and it will be converted to TYPE.
270
271       If  conversion  fails, fallback will be returned and if no fallback was
272       specified, the VCL will be failed.
273
274   DURATION duration([STRING s], [DURATION fallback], [REAL real], [INT  inte‐
275       ger])
276          DURATION duration(
277             [STRING s],
278             [DURATION fallback],
279             [REAL real],
280             [INT integer]
281          )
282
283       Returns a DURATION from a STRING, REAL or INT argument.
284
285       For  a  STRING s argument, s must be quantified by ms (milliseconds), s
286       (seconds), m (minutes), h (hours),``d`` (days), w (weeks) or y  (years)
287       units.
288
289       real and integer arguments are taken as seconds.
290
291       If  the conversion of an s argument fails, fallback will be returned if
292       provided, or a VCL failure will be triggered.
293
294       Conversions from real and integer arguments never fail.
295
296       Only one of the s, real or integer arguments may  be  given  or  a  VCL
297       failure will be triggered.
298
299       Examples:
300
301          set beresp.ttl = std.duration("1w", 3600s);
302          set beresp.ttl = std.duration(real=1.5);
303          set beresp.ttl = std.duration(integer=10);
304
305   BYTES bytes([STRING s], [BYTES fallback], [REAL real], [INT integer])
306          BYTES bytes(
307             [STRING s],
308             [BYTES fallback],
309             [REAL real],
310             [INT integer]
311          )
312
313       Returns BYTES from a STRING, REAL or INT argument.
314
315       A  STRING  s  argument can be quantified with a multiplier (k (kilo), m
316       (mega), g (giga), t (tera) or p (peta)).
317
318       real and integer arguments are taken as bytes.
319
320       If the conversion of an s argument fails, fallback will be returned  if
321       provided, or a VCL failure will be triggered.
322
323       Other  conversions may fail if the argument can not be represented, be‐
324       cause it is negative, too small or too large. Again, fallback  will  be
325       returned if provided, or a VCL failure will be triggered.
326
327       real arguments will be rounded down.
328
329       Only  one  of  the  s,  real or integer arguments may be given or a VCL
330       failure will be triggered.
331
332       Example:
333
334          std.cache_req_body(std.bytes(something.somewhere, 10K));
335          std.cache_req_body(std.bytes(integer=10*1024));
336          std.cache_req_body(std.bytes(real=10.0*1024));
337
338   INT integer([STRING s], [INT fallback], [BOOL bool], [BYTES bytes],  [DURA‐
339       TION duration], [REAL real], [TIME time])
340          INT integer(
341             [STRING s],
342             [INT fallback],
343             [BOOL bool],
344             [BYTES bytes],
345             [DURATION duration],
346             [REAL real],
347             [TIME time]
348          )
349
350       Returns an INT from a STRING, BOOL or other quantity.
351
352       If  the conversion of an s argument fails, fallback will be returned if
353       provided, or a VCL failure will be triggered.
354
355       A bool argument will be returned as 0 for false and 1  for  true.  This
356       conversion will never fail.
357
358       For  a bytes argument, the number of bytes will be returned.  This con‐
359       version will never fail.
360
361       A duration argument will be rounded down to the number of  seconds  and
362       returned.
363
364       A real argument will be rounded down and returned.
365
366       For  a  time  argument,  the  number  of  seconds  since the UNIX epoch
367       (1970-01-01 00:00:00 UTC) will be returned.
368
369       duration, real and time conversions may fail if the argument can not be
370       represented  because it is too small or too large. If so, fallback will
371       be returned if provided, or a VCL failure will be triggered.
372
373       Only one of the s, bool, bytes, duration, real or time arguments may be
374       given or a VCL failure will be triggered.
375
376       Examples:
377
378          if (std.integer(req.http.foo, 0) > 5) {
379                  ...
380          }
381
382          set resp.http.answer = std.integer(real=126.42/3);
383
384   IP ip(STRING s, [IP fallback], BOOL resolve=1, [STRING p])
385       Converts the string s to the first IP number returned by the system li‐
386       brary function getaddrinfo(3). If conversion fails,  fallback  will  be
387       returned or VCL failure will happen.
388
389       The IP address includes a port number that can be found with std.port()
390       that defaults to 80. The default port can be set to a  different  value
391       with  the p argument. It will be overriden if s contains both an IP ad‐
392       dress and a port number or service name.
393
394       When s contains both, the syntax  is  either  address:port  or  address
395       port.  If  the  address is a numerical IPv6 address it must be enclosed
396       between brackets, for example [::1] 80 or [::1]:http.  The fallback may
397       also contain both an address and a port, but its default port is always
398       80.
399
400       If resolve is false, getaddrinfo(3) is called using AI_NUMERICHOST  and
401       AI_NUMERICSERV  to  avoid  network  lookups  depending  on the system's
402       getaddrinfo(3) or nsswitch configuration.  This  makes  "numerical"  IP
403       strings and services cheaper to convert.
404
405       Example:
406
407          if (std.ip(req.http.X-forwarded-for, "0.0.0.0") ~ my_acl) {
408                  ...
409          }
410
411   REAL  real([STRING  s], [REAL fallback], [INT integer], [BOOL bool], [BYTES
412       bytes], [DURATION duration], [TIME time])
413          REAL real(
414             [STRING s],
415             [REAL fallback],
416             [INT integer],
417             [BOOL bool],
418             [BYTES bytes],
419             [DURATION duration],
420             [TIME time]
421          )
422
423       Returns a REAL from a STRING, BOOL or other quantity.
424
425       If the conversion of an s argument fails, fallback will be returned  if
426       provided, or a VCL failure will be triggered.
427
428       A bool argument will be returned as 0.0 for false and 1.0 for true.
429
430       For a bytes argument, the number of bytes will be returned.
431
432       For a duration argument, the number of seconds will be returned.
433
434       An integer argument will be returned as a REAL.
435
436       For  a  time  argument,  the  number  of  seconds  since the UNIX epoch
437       (1970-01-01 00:00:00 UTC) will be returned.
438
439       None of these conversions other than s will fail.
440
441       Only one of the s, integer, bool, bytes, duration or time arguments may
442       be given or a VCL failure will be triggered.
443
444       Example:
445
446          if (std.real(req.http.foo, 0.0) > 5.5) {
447                  ...
448          }
449
450   TIME time([STRING s], [TIME fallback], [REAL real], [INT integer])
451          TIME time([STRING s], [TIME fallback], [REAL real], [INT integer])
452
453       Returns a TIME from a STRING, REAL or INT argument.
454
455       For a STRING s argument, the following formats are supported:
456
457          "Sun, 06 Nov 1994 08:49:37 GMT"
458          "Sunday, 06-Nov-94 08:49:37 GMT"
459          "Sun Nov  6 08:49:37 1994"
460          "1994-11-06T08:49:37"
461          "784111777.00"
462          "784111777"
463
464       real and integer arguments are taken as seconds since the epoch.
465
466       If  the conversion of an s argument fails or a negative real or integer
467       argument is given, fallback will be returned  if  provided,  or  a  VCL
468       failure will be triggered.
469
470       Examples:
471
472          if (std.time(resp.http.last-modified, now) < now - 1w) {
473                  ...
474          }
475
476          if (std.time(int=2147483647) < now - 1w) {
477                  ...
478          }
479

LOGGING FUNCTIONS

481   VOID log(STRING s)
482       Logs  the  string  s  to  the  shared  memory  log,  using  vsl(7)  tag
483       SLT_VCL_Log.
484
485       Example:
486
487          std.log("Something fishy is going on with the vhost " + req.http.host);
488
489   VOID syslog(INT priority, STRING s)
490       Logs the string s to syslog tagged with priority. priority is formed by
491       ORing  the  facility  and level values. See your system's syslog.h file
492       for possible values.
493
494       Notice: Unlike VCL and other functions in the std vmod,  this  function
495       will  not  fail  VCL  processing for workspace overflows: For an out of
496       workspace condition, the std.syslog() function has no effect.
497
498       Example:
499
500          std.syslog(9, "Something is wrong");
501
502       This will send a message to syslog using LOG_USER | LOG_ALERT.
503
504   VOID timestamp(STRING s)
505       Introduces a timestamp in the log with  the  current  time,  using  the
506       string  s as the label. This is useful to time the execution of lengthy
507       VCL subroutines, and makes the  timestamps  inserted  automatically  by
508       Varnish more accurate.
509
510       Example:
511
512          std.timestamp("curl-request");
513

CONTROL AND INFORMATION FUNCTIONS

515   BOOL syntax(REAL)
516       Returns true if VCL version is at least REAL.
517
518   STRING getenv(STRING name)
519       Return environment variable name or the empty string. See getenv(3).
520
521       Example:
522
523          set req.http.My-Env = std.getenv("MY_ENV");
524
525   BOOL cache_req_body(BYTES size)
526       Caches  the  request  body if it is smaller than size.  Returns true if
527       the body was cached, false otherwise.
528
529       Normally the request body can only be sent  once.  Caching  it  enables
530       retrying backend requests with a request body, as usually the case with
531       POST and PUT.
532
533       Example:
534
535          if (std.cache_req_body(1KB)) {
536                  ...
537          }
538
539   VOID late_100_continue(BOOL late)
540       Controls when varnish reacts to an Expect: 100-continue client  request
541       header.
542
543       Varnish  always  generates  a 100 Continue response if requested by the
544       client trough the Expect: 100-continue header when waiting for  request
545       body data.
546
547       But, by default, the 100 Continue response is already generated immedi‐
548       ately after vcl_recv returns to reduce latencies under  the  assumption
549       that the request body will be read eventually.
550
551       Calling std.late_100_continue(true) in vcl_recv will cause the 100 Con‐
552       tinue response to only be sent when needed. This may  cause  additional
553       latencies for processing request bodies, but is the correct behavior by
554       strict interpretation of RFC7231.
555
556       This  function  has  no  effect  outside  vcl_recv  and  after  calling
557       std.cache_req_body() or any other function consuming the request body.
558
559       Example:
560
561          vcl_recv {
562                  std.late_100_continue(true);
563
564                  if (req.method == "POST") {
565                          std.late_100_continue(false);
566                          return (pass);
567                  }
568                  ...
569           }
570
571   VOID set_ip_tos(INT tos)
572       Sets  the  Differentiated Services Codepoint (DSCP) / IPv4 Type of Ser‐
573       vice (TOS) / IPv6 Traffic Class (TCLASS) byte for the  current  session
574       to tos. Silently ignored if the listen address is a Unix domain socket.
575
576       Please  note that setting the traffic class affects all requests on the
577       same http1.1 / http2 TCP connection and, in particular, is not  removed
578       at the end of the request.
579
580       Example:
581
582          if (req.url ~ "^/slow/") {
583                  std.set_ip_tos(0);
584          }
585
586   VOID rollback(HTTP h)
587       Restores the h HTTP headers to their original state.
588
589       Example:
590
591          std.rollback(bereq);
592
593   BOOL ban(STRING)
594       Invalidates  all  objects in cache that match the given expression with
595       the ban mechanism. Returns true if the ban succeeded and  false  other‐
596       wise. Error details are available via std.ban_error().
597
598       The format of STRING is:
599
600          <field> <operator> <arg> [&& <field> <oper> <arg> ...]
601
602       • <field>:
603
604         • string fields:
605
606           • req.url: The request url
607
608           • req.http.*: Any request header
609
610           • obj.status: The cache object status
611
612           • obj.http.*: Any cache object header
613
614           obj.status is treated as a string despite the fact that it is actu‐
615           ally an integer.
616
617         • duration fields:
618
619           • obj.ttl: Remaining ttl at the time the ban is issued
620
621           • obj.age: Object age at the time the ban is issued
622
623           • obj.grace: The grace time of the object
624
625           • obj.keep: The keep time of the object
626
627       • <operator>:
628
629         • for all fields:
630
631           • ==: <field> and <arg> are equal
632
633           • !=: <field> and <arg> are unequal
634
635           strings are compared case sensitively
636
637         • for string fields:
638
639           • ~: <field> matches the regular expression <arg>
640
641           • !~:<field> does not match the regular expression <arg>
642
643         • for duration fields:
644
645           • >: <field> is greater than <arg>
646
647           • >=: <field> is greater than or equal to <arg>
648
649           • <: <field> is less than <arg>
650
651           • <=: <field> is less than or equal to <arg>
652
653       • <arg>:
654
655         • for string fields:
656
657           Either a literal string or a regular expression.  Note  that  <arg>
658           does  not  use  any  of  the string delimiters like " or {"..."} or
659           """...""" used elsewhere in varnish. To match against strings  con‐
660           taining whitespace, regular expressions containing \s can be used.
661
662         • for duration fields:
663
664           A VCL duration like 10s, 5m or 1h, see vcl(7)_durations
665
666       Expressions can be chained using the and operator &&. For or semantics,
667       use several bans.
668
669       The unset <field> is not equal to any string, such that, for a  non-ex‐
670       isting  header,  the operators == and ~ always evaluate as false, while
671       the operators != and !~ always evaluate as true, respectively, for  any
672       value of <arg>.
673
674   STRING ban_error()
675       Returns a textual error description of the last std.ban() call from the
676       same task or the empty string if  there  either  was  no  error  or  no
677       std.ban() call.
678

DEPRECATED FUNCTIONS

680   INT real2integer(REAL r, INT fallback)
681       DEPRECATED:  This  function will be removed in a future version of var‐
682       nish, use std.integer() with a real argument and the std.round()  func‐
683       tion instead, for example:
684
685          std.integer(real=std.round(...), fallback=...)
686
687       Rounds  the real r to the nearest integer, but round halfway cases away
688       from zero (see round(3)). If conversion fails,  fallback  will  be  re‐
689       turned.
690
691       Examples:
692
693          set req.http.integer = std.real2integer(1140618699.00, 0);
694          set req.http.posone = real2integer( 0.5, 0);    # =  1.0
695          set req.http.negone = real2integer(-0.5, 0);    # = -1.0
696
697   TIME real2time(REAL r, TIME fallback)
698       DEPRECATED:  This  function will be removed in a future version of var‐
699       nish, use std.time() with a real argument and the std.round()  function
700       instead, for example:
701
702          std.time(real=std.round(...), fallback=...)
703
704       Rounds  the  real r to the nearest integer (see std.real2integer()) and
705       returns the corresponding time when interpreted as  a  unix  epoch.  If
706       conversion fails, fallback will be returned.
707
708       Example:
709
710          set req.http.time = std.real2time(1140618699.00, now);
711
712   INT time2integer(TIME t, INT fallback)
713       DEPRECATED:  This  function will be removed in a future version of var‐
714       nish, use std.integer() with a time argument instead, for example:
715
716          std.integer(time=..., fallback=...)
717
718       Converts the time t to a integer. If conversion fails, fallback will be
719       returned.
720
721       Example:
722
723          set req.http.int = std.time2integer(now, 0);
724
725   REAL time2real(TIME t, REAL fallback)
726       DEPRECATED:  This  function will be removed in a future version of var‐
727       nish, use std.real() with a time argument instead, for example:
728
729          std.real(time=..., fallback=...)
730
731       Converts the time t to a real. If conversion fails,  fallback  will  be
732       returned.
733
734       Example:
735
736          set req.http.real = std.time2real(now, 1.0);
737

COPYRIGHT

746          Copyright (c) 2010-2017 Varnish Software AS
747          All rights reserved.
748
749          Author: Poul-Henning Kamp <phk@FreeBSD.org>
750
751          SPDX-License-Identifier: BSD-2-Clause
752
753          Redistribution and use in source and binary forms, with or without
754          modification, are permitted provided that the following conditions
755          are met:
756          1. Redistributions of source code must retain the above copyright
757             notice, this list of conditions and the following disclaimer.
758          2. Redistributions in binary form must reproduce the above copyright
759             notice, this list of conditions and the following disclaimer in the
760             documentation and/or other materials provided with the distribution.
761
762          THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
763          ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
764          IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
765          ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
766          FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
767          DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
768          OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
769          HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
770          LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
771          OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
772          SUCH DAMAGE.
773
774
775
776
777                                                                   VMOD_STD(3)