"Fossies" - the Fresh Open Source Software Archive

Member "haproxy-2.0.9/include/proto/sample.h" (15 Nov 2019, 5760 Bytes) of package /linux/misc/haproxy-2.0.9.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "sample.h" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * include/proto/sample.h
    3  * Functions for samples management.
    4  *
    5  * Copyright (C) 2009-2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
    6  * Copyright (C) 2012 Willy Tarreau <w@1wt.eu>
    7  *
    8  * This library is free software; you can redistribute it and/or
    9  * modify it under the terms of the GNU Lesser General Public
   10  * License as published by the Free Software Foundation, version 2.1
   11  * exclusively.
   12  *
   13  * This library is distributed in the hope that it will be useful,
   14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   16  * Lesser General Public License for more details.
   17  *
   18  * You should have received a copy of the GNU Lesser General Public
   19  * License along with this library; if not, write to the Free Software
   20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   21  */
   22 
   23 #ifndef _PROTO_SAMPLE_H
   24 #define _PROTO_SAMPLE_H
   25 
   26 #include <types/sample.h>
   27 #include <types/stick_table.h>
   28 
   29 extern const char *smp_to_type[SMP_TYPES];
   30 
   31 struct sample_expr *sample_parse_expr(char **str, int *idx, const char *file, int line, char **err, struct arg_list *al);
   32 struct sample_conv *find_sample_conv(const char *kw, int len);
   33 struct sample *sample_process(struct proxy *px, struct session *sess,
   34                               struct stream *strm, unsigned int opt,
   35                               struct sample_expr *expr, struct sample *p);
   36 struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
   37                                    struct stream *strm, unsigned int opt,
   38                                    struct sample_expr *expr, int smp_type);
   39 void release_sample_expr(struct sample_expr *expr);
   40 void sample_register_fetches(struct sample_fetch_kw_list *psl);
   41 void sample_register_convs(struct sample_conv_kw_list *psl);
   42 const char *sample_src_names(unsigned int use);
   43 const char *sample_ckp_names(unsigned int use);
   44 struct sample_fetch *find_sample_fetch(const char *kw, int len);
   45 struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx);
   46 struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx);
   47 int smp_resolve_args(struct proxy *p);
   48 int smp_expr_output_type(struct sample_expr *expr);
   49 int c_none(struct sample *smp);
   50 int smp_dup(struct sample *smp);
   51 
   52 /*
   53  * This function just apply a cast on sample. It returns 0 if the cast is not
   54  * available or if the cast fails, otherwise returns 1. It does not modify the
   55  * input sample on failure.
   56  */
   57 static inline
   58 int sample_convert(struct sample *sample, int req_type)
   59 {
   60     if (!sample_casts[sample->data.type][req_type])
   61         return 0;
   62     if (sample_casts[sample->data.type][req_type] == c_none)
   63         return 1;
   64     return sample_casts[sample->data.type][req_type](sample);
   65 }
   66 
   67 static inline
   68 struct sample *smp_set_owner(struct sample *smp, struct proxy *px,
   69                              struct session *sess, struct stream *strm, int opt)
   70 {
   71     smp->px   = px;
   72     smp->sess = sess;
   73     smp->strm = strm;
   74     smp->opt  = opt;
   75     return smp;
   76 }
   77 
   78 
   79 /* Returns 1 if a sample may be safely used. It performs a few checks on the
   80  * string length versus size, same for the binary version, and ensures that
   81  * strings are properly terminated by a zero. If this last point is not granted
   82  * but the string is not const, then the \0 is appended. Otherwise it returns 0,
   83  * meaning the caller may need to call smp_dup() before going further.
   84  */
   85 static inline
   86 int smp_is_safe(struct sample *smp)
   87 {
   88     switch (smp->data.type) {
   89     case SMP_T_METH:
   90         if (smp->data.u.meth.meth != HTTP_METH_OTHER)
   91             return 1;
   92         /* Fall through */
   93 
   94     case SMP_T_STR:
   95         if (smp->data.u.str.size && smp->data.u.str.data >= smp->data.u.str.size)
   96             return 0;
   97 
   98         if (smp->data.u.str.area[smp->data.u.str.data] == 0)
   99             return 1;
  100 
  101         if (!smp->data.u.str.size || (smp->flags & SMP_F_CONST))
  102             return 0;
  103 
  104         smp->data.u.str.area[smp->data.u.str.data] = 0;
  105         return 1;
  106 
  107     case SMP_T_BIN:
  108         return !smp->data.u.str.size || smp->data.u.str.data <= smp->data.u.str.size;
  109 
  110     default:
  111         return 1;
  112     }
  113 }
  114 
  115 /* checks that a sample may freely be used, or duplicates it to normalize it.
  116  * Returns 1 on success, 0 if the sample must not be used. The function also
  117  * checks for NULL to simplify the calling code.
  118  */
  119 static inline
  120 int smp_make_safe(struct sample *smp)
  121 {
  122     return smp && (smp_is_safe(smp) || smp_dup(smp));
  123 }
  124 
  125 /* Returns 1 if a sample may be safely modified in place. It performs a few
  126  * checks on the string length versus size, same for the binary version, and
  127  * ensures that strings are properly terminated by a zero, and of course that
  128  * the size is allocate and that the SMP_F_CONST flag is not set. If only the
  129  * trailing zero is missing, it is appended. Otherwise it returns 0, meaning
  130  * the caller may need to call smp_dup() before going further.
  131  */
  132 static inline
  133 int smp_is_rw(struct sample *smp)
  134 {
  135     if (smp->flags & SMP_F_CONST)
  136         return 0;
  137 
  138     switch (smp->data.type) {
  139     case SMP_T_METH:
  140         if (smp->data.u.meth.meth != HTTP_METH_OTHER)
  141             return 1;
  142         /* Fall through */
  143 
  144     case SMP_T_STR:
  145         if (!smp->data.u.str.size ||
  146             smp->data.u.str.data >= smp->data.u.str.size)
  147             return 0;
  148 
  149         if (smp->data.u.str.area[smp->data.u.str.data] != 0)
  150             smp->data.u.str.area[smp->data.u.str.data] = 0;
  151         return 1;
  152 
  153     case SMP_T_BIN:
  154         return smp->data.u.str.size &&
  155                smp->data.u.str.data <= smp->data.u.str.size;
  156 
  157     default:
  158         return 1;
  159     }
  160 }
  161 
  162 /* checks that a sample may freely be modified, or duplicates it to normalize
  163  * it and make it R/W. Returns 1 on success, 0 if the sample must not be used.
  164  * The function also checks for NULL to simplify the calling code.
  165  */
  166 static inline
  167 int smp_make_rw(struct sample *smp)
  168 {
  169     return smp && (smp_is_rw(smp) || smp_dup(smp));
  170 }
  171 
  172 #endif /* _PROTO_SAMPLE_H */