src/tad/tadlexer_le.c

   1 /*
   2  * tadlexer_le.c
   3  *
   4  * Copyright (c) 2012 project bchan
   5  *
   6  * This software is provided 'as-is', without any express or implied
   7  * warranty. In no event will the authors be held liable for any damages
   8  * arising from the use of this software.
   9  *
  10  * Permission is granted to anyone to use this software for any purpose,
  11  * including commercial applications, and to alter it and redistribute it
  12  * freely, subject to the following restrictions:
  13  *
  14  * 1. The origin of this software must not be misrepresented; you must not
  15  *    claim that you wrote the original software. If you use this software
  16  *    in a product, an acknowledgment in the product documentation would be
  17  *    appreciated but is not required.
  18  *
  19  * 2. Altered source versions must be plainly marked as such, and must not be
  20  *    misrepresented as being the original software.
  21  *
  22  * 3. This notice may not be removed or altered from any source
  23  *    distribution.
  24  *
  25  */
  26
  27 #include "tadlexer_le.h"
  28
  29 #include        <basic.h>
  30 #include        <bstdio.h>
  31
  32 #define TADLEXER_LE_FLAG_FIXED_SEGMENT       0x00000001
  33 #define TADLEXER_LE_FLAG_VARIABLE_SEGMENT    0x00000002
  34 #define TADLEXER_LE_FLAG_SEGMENTID_DETERMINE 0x00000004
  35 #define TADLEXER_LE_FLAG_LENGTH_DETERMINE    0x00000008
  36 #define TADLEXER_LE_FLAG_READING_DATA        0x00000010
  37
  38 EXPORT Bool tadlexer_le_result_is_fixedsegment(tadlexer_le_result *result)
  39 {
  40         return ((result->flag & TADLEXER_LE_FLAG_FIXED_SEGMENT) != 0) ? True : False;
  41 }
  42
  43 EXPORT Bool tadlexer_le_result_is_variablesegment(tadlexer_le_result *result)
  44 {
  45         return ((result->flag & TADLEXER_LE_FLAG_VARIABLE_SEGMENT) != 0) ? True : False;
  46 }
  47
  48 EXPORT Bool tadlexer_le_result_is_segmentid_determined(tadlexer_le_result *result)
  49 {
  50         return ((result->flag & TADLEXER_LE_FLAG_SEGMENTID_DETERMINE) != 0) ? True : False;
  51 }
  52
  53 EXPORT Bool tadlexer_le_result_is_lengthdetermined(tadlexer_le_result *result)
  54 {
  55         return ((result->flag & TADLEXER_LE_FLAG_LENGTH_DETERMINE) != 0) ? True : False;
  56 }
  57
  58 EXPORT Bool tadlexer_le_result_is_readingdata(tadlexer_le_result *result)
  59 {
  60         return ((result->flag & TADLEXER_LE_FLAG_READING_DATA) != 0) ? True : False;
  61 }
  62
  63 EXPORT VOID tadlexer_le_inputbyte(tadlexer_le_t *lexer, UB b, tadlexer_le_result **result, W *result_len)
  64 {
  65         *result = &lexer->buf;
  66         *result_len = 1;
  67
  68         switch (lexer->state) {
  69         case HTTP_TADLEXER_LE_STATE_START:
  70                 lexer->segid = b;
  71                 lexer->state = HTTP_TADLEXER_LE_STATE_FIRST_BYTE;
  72                 lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
  73                 lexer->buf.flag = 0;
  74                 break;
  75         case HTTP_TADLEXER_LE_STATE_FIRST_BYTE:
  76                 if ((b == 0xFF)&&(((lexer->segid) & 0x80) == 0x80)) {
  77                         lexer->state = HTTP_TADLEXER_LE_STATE_SEGLEN_FIRST;
  78                         lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
  79                         lexer->buf.flag = TADLEXER_LE_FLAG_VARIABLE_SEGMENT | TADLEXER_LE_FLAG_SEGMENTID_DETERMINE;
  80                         lexer->buf.val.seg.id = lexer->segid;
  81                 } else {
  82                         lexer->state = HTTP_TADLEXER_LE_STATE_START;
  83                         lexer->buf.type = TADLEXER_LE_RESULTTYPE_SEGMENT_END;
  84                         lexer->buf.flag = TADLEXER_LE_FLAG_FIXED_SEGMENT;
  85                         lexer->buf.val.ch = lexer->segid | (b << 8);
  86                 }
  87                 break;
  88         case HTTP_TADLEXER_LE_STATE_SEGLEN_FIRST:
  89                 lexer->len = b;
  90                 lexer->state = HTTP_TADLEXER_LE_STATE_SEGLEN_SECOND;
  91                 lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
  92                 break;
  93         case HTTP_TADLEXER_LE_STATE_SEGLEN_SECOND:
  94                 lexer->len |= b << 8;
  95                 if (lexer->len == 0) {
  96                         lexer->state = HTTP_TADLEXER_LE_STATE_START;
  97                         lexer->buf.type = TADLEXER_LE_RESULTTYPE_SEGMENT_END;
  98                         lexer->buf.flag |= TADLEXER_LE_FLAG_LENGTH_DETERMINE;
  99                         lexer->buf.val.seg.id = lexer->segid;
 100                         lexer->buf.val.seg.len = 0;
 101                 } else if (lexer->len == 0xFFFF) {
 102                         lexer->state = HTTP_TADLEXER_LE_STATE_LSEGLEN_FIRST;
 103                         lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
 104                 } else {
 105                         lexer->state = HTTP_TADLEXER_LE_STATE_DATA;
 106                         lexer->len_read = 0;
 107                         lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
 108                         lexer->buf.flag |= TADLEXER_LE_FLAG_LENGTH_DETERMINE;
 109                         lexer->buf.val.seg.id = lexer->segid;
 110                         lexer->buf.val.seg.len = lexer->len;
 111                 }
 112                 break;
 113         case HTTP_TADLEXER_LE_STATE_LSEGLEN_FIRST:
 114                 lexer->len = b;
 115                 lexer->state = HTTP_TADLEXER_LE_STATE_LSEGLEN_SECOND;
 116                 lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
 117                 break;
 118         case HTTP_TADLEXER_LE_STATE_LSEGLEN_SECOND:
 119                 lexer->len |= b << 8;
 120                 lexer->state = HTTP_TADLEXER_LE_STATE_LSEGLEN_THIRD;
 121                 lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
 122                 break;
 123         case HTTP_TADLEXER_LE_STATE_LSEGLEN_THIRD:
 124                 lexer->len |= b << 16;
 125                 lexer->state = HTTP_TADLEXER_LE_STATE_LSEGLEN_FORTH;
 126                 lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
 127                 break;
 128         case HTTP_TADLEXER_LE_STATE_LSEGLEN_FORTH:
 129                 lexer->len |= b << 24;
 130                 lexer->state = HTTP_TADLEXER_LE_STATE_DATA;
 131                 lexer->len_read = 0;
 132                 lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
 133                 lexer->buf.flag |= TADLEXER_LE_FLAG_LENGTH_DETERMINE;
 134                 lexer->buf.val.seg.id = lexer->segid;
 135                 lexer->buf.val.seg.len = lexer->len;
 136                 break;
 137         case HTTP_TADLEXER_LE_STATE_DATA:
 138                 lexer->buf.flag |= TADLEXER_LE_FLAG_READING_DATA;
 139                 lexer->len_read++;
 140                 if (lexer->len_read == lexer->len) {
 141                         lexer->state = HTTP_TADLEXER_LE_STATE_START;
 142                         lexer->buf.type = TADLEXER_LE_RESULTTYPE_SEGMENT_END;
 143                 } else {
 144                         lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
 145                 }
 146                 break;
 147         }
 148 }
 149
 150 EXPORT VOID tadlexer_le_initialize(tadlexer_le_t *lexer)
 151 {
 152         lexer->state = HTTP_TADLEXER_LE_STATE_START;
 153         lexer->segid = 0;
 154         lexer->len = 0;
 155 }
 156
 157 EXPORT VOID tadlexer_le_finalize(tadlexer_le_t *lexer)
 158 {
 159 }