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          STRING strftime(TIME time, STRING format)
50
51          VOID log(STRING s)
52
53          VOID syslog(INT priority, STRING s)
54
55          VOID timestamp(STRING s)
56
57          BOOL syntax(REAL)
58
59          STRING getenv(STRING name)
60
61          BOOL cache_req_body(BYTES size)
62
63          VOID late_100_continue(BOOL late)
64
65          VOID set_ip_tos(INT tos)
66
67          VOID rollback(HTTP h)
68
69          BOOL ban(STRING)
70
71          STRING ban_error()
72
73          INT real2integer(REAL r, INT fallback)
74
75          TIME real2time(REAL r, TIME fallback)
76
77          INT time2integer(TIME t, INT fallback)
78
79          REAL time2real(TIME t, REAL fallback)
80

DESCRIPTION

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

NUMERIC FUNCTIONS

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

STRING FUNCTIONS

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

FILE(SYSTEM) FUNCTIONS

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

TYPE INSPECTION FUNCTIONS

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

TYPE CONVERSION FUNCTIONS

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

LOGGING FUNCTIONS

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

CONTROL AND INFORMATION FUNCTIONS

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

DEPRECATED FUNCTIONS

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

COPYRIGHT

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