wiretap/ascend_scanner.l

   1 /*
   2  * We don't read from the terminal.
   3  */
   4 %option never-interactive
   5
   6 /*
   7  * Prefix scanner routines with "ascend" rather than "yy", so this scanner
   8  * can coexist with other scanners.
   9  */
  10 %option prefix="ascend"
  11
  12 %{
  13 /* ascend_scanner.l
  14  *
  15  * $Id$
  16  *
  17  * Wiretap Library
  18  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
  19  *
  20  * This program is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU General Public License
  22  * as published by the Free Software Foundation; either version 2
  23  * of the License, or (at your option) any later version.
  24  *
  25  * This program is distributed in the hope that it will be useful,
  26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  * GNU General Public License for more details.
  29  *
  30  * You should have received a copy of the GNU General Public License
  31  * along with this program; if not, write to the Free Software
  32  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  33  */
  34
  35 #include "config.h"
  36
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40
  41 #ifdef HAVE_IO_H
  42 #include <io.h>         /* for isatty() on win32 */
  43 #endif
  44
  45 #include "wtap-int.h"
  46 #include "ascendtext.h"
  47 #include "ascend.h"
  48 #include "ascend-int.h"
  49 #include "file_wrappers.h"
  50 #include "ascend_scanner_lex.h"
  51
  52 FILE_T yy_fh;
  53 extern char *ascend_ra_ptr;
  54 extern char *ascend_ra_last;
  55 #define YY_INPUT(buf,result,max_size) { int c = file_getc(yy_fh);  \
  56 result = (c==EOF) ? YY_NULL : (buf[0] = c, 1); }
  57
  58 int at_eof;
  59 int mul, scratch;
  60
  61 #define NO_USER "<none>"
  62
  63 #ifndef HAVE_UNISTD_H
  64 #define YY_NO_UNISTD_H
  65 #endif
  66
  67
  68 %}
  69
  70 D [0-9]
  71 H [A-Fa-f0-9]
  72
  73 PPP_XPFX PPP-OUT
  74 PPP_RPFX PPP-IN
  75 ISDN_XPFX PRI-XMIT-
  76 ISDN_RPFX PRI-RCV-
  77 WAN_XPFX XMIT[\-:]*
  78 WAN_RPFX RECV[\-:]*
  79 ETHER_PFX ETHER
  80
  81 WDD_DATE    "Date:"
  82 WDD_TIME    "Time:"
  83 WDD_CAUSE   "Cause an attempt to place call to "
  84 WDD_CALLNUM [^\n\r\t ]+
  85 WDD_CHUNK   "WD_DIALOUT_DISP: chunk"
  86 WDD_TYPE    "type "[^\n\r\t ]+
  87
  88 %s sc_gen_task
  89 %s sc_gen_time_s
  90 %s sc_gen_time_u
  91 %s sc_gen_octets
  92 %s sc_gen_counter
  93 %s sc_gen_byte
  94
  95 %s sc_wds_user
  96 %s sc_wds_sess
  97
  98 %s sc_wdd_date_d
  99 %s sc_wdd_date_m
 100 %s sc_wdd_date_y
 101 %s sc_wdd_time
 102 %s sc_wdd_time_h
 103 %s sc_wdd_time_m
 104 %s sc_wdd_time_s
 105 %s sc_wdd_cause
 106 %s sc_wdd_callnum
 107 %s sc_wdd_chunk
 108 %s sc_wdd_chunknum
 109 %s sc_wdd_type
 110
 111 %s sc_chardisp
 112
 113 %s sc_isdn_call
 114 %s sc_ether_direction
 115
 116 %%
 117
 118 <INITIAL,sc_gen_byte>{ETHER_PFX} {
 119   BEGIN(sc_ether_direction);
 120   ascendlval.d = ASCEND_PFX_ETHER;
 121   return ETHER_PREFIX;
 122 }
 123
 124 <INITIAL,sc_gen_byte>{ISDN_XPFX} {
 125   BEGIN(sc_isdn_call);
 126   ascendlval.d = ASCEND_PFX_ISDN_X;
 127   return ISDN_PREFIX;
 128 }
 129
 130 <INITIAL,sc_gen_byte>{ISDN_RPFX} {
 131   BEGIN(sc_isdn_call);
 132   ascendlval.d = ASCEND_PFX_ISDN_R;
 133   return ISDN_PREFIX;
 134 }
 135
 136 <INITIAL,sc_gen_byte>{WAN_XPFX} {
 137   BEGIN(sc_wds_user);
 138   ascendlval.d = ASCEND_PFX_WDS_X;
 139   return WDS_PREFIX;
 140 }
 141
 142 <INITIAL,sc_gen_byte>{WAN_RPFX} {
 143   BEGIN(sc_wds_user);
 144   ascendlval.d = ASCEND_PFX_WDS_R;
 145   return WDS_PREFIX;
 146 }
 147
 148 <INITIAL,sc_gen_byte>{PPP_XPFX} {
 149   BEGIN(sc_wds_user);
 150   ascendlval.d = ASCEND_PFX_WDS_X;
 151   return WDS_PREFIX;
 152 }
 153
 154 <INITIAL,sc_gen_byte>{PPP_RPFX} {
 155   BEGIN(sc_wds_user);
 156   ascendlval.d = ASCEND_PFX_WDS_R;
 157   return WDS_PREFIX;
 158 }
 159
 160 <sc_ether_direction>[^\(]{2,20} {
 161   BEGIN(sc_gen_task);
 162   return STRING;
 163 }
 164
 165 <sc_isdn_call>[^\/\(:]{2,20} {
 166   BEGIN(sc_gen_task);
 167   return DECNUM;
 168 }
 169
 170 <sc_wds_user>[^:]{2,20} {
 171   char *atcopy = g_strdup(ascendtext);
 172   char colon = input();
 173   char after = input();
 174   int retval = STRING;
 175
 176   unput(after); unput(colon);
 177
 178   if (after != '(' && after != ' ') {
 179     BEGIN(sc_wds_sess);
 180     if (pseudo_header != NULL) {
 181       g_strlcpy(pseudo_header->user, atcopy, ASCEND_MAX_STR_LEN);
 182     }
 183   } else {      /* We have a version 7 file */
 184     BEGIN(sc_gen_task);
 185     if (pseudo_header != NULL) {
 186       g_strlcpy(pseudo_header->user, NO_USER, ASCEND_MAX_STR_LEN);
 187     }
 188     /* Are valid values ever > 2^32? If so we need to adjust YYSTYPE and a lot of */
 189     /* upstream code accordingly. */
 190     ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 191     retval = DECNUM;
 192   }
 193   g_free (atcopy);
 194   return retval;
 195 }
 196
 197 <sc_wds_sess>{D}* {
 198   BEGIN(sc_gen_task);
 199   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 200   return DECNUM;
 201 }
 202
 203 <sc_gen_task>(0x|0X)?{H}{2,8} {
 204   BEGIN(sc_gen_time_s);
 205   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 16);
 206   return HEXNUM;
 207 }
 208
 209 <sc_gen_task>\"[A-Za-z0-9_ ]+\" {
 210   return STRING;
 211 }
 212
 213 <sc_gen_time_s>{D}{1,10} {
 214   BEGIN(sc_gen_time_u);
 215   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 216   return DECNUM;
 217 }
 218
 219 <sc_gen_time_u>{D}{1,6} {
 220   char *atcopy = g_strdup(ascendtext);
 221   BEGIN(sc_gen_octets);
 222   /* only want the most significant 2 digits. convert to usecs */
 223   if (strlen(atcopy) > 2)
 224     atcopy[2] = '\0';
 225   ascendlval.d = (guint32) strtoul(atcopy, NULL, 10) * 10000;
 226   g_free(atcopy);
 227   return DECNUM;
 228 }
 229
 230 <sc_gen_octets>{D}{1,10} {
 231   BEGIN(sc_gen_counter);
 232   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 233   return DECNUM;
 234 }
 235
 236 <sc_gen_counter,sc_gen_byte>"["{H}{4}"]:" {
 237   BEGIN(sc_gen_byte);
 238   return COUNTER;
 239 }
 240
 241 <sc_gen_byte>{H}{2} {
 242   ascendlval.b = (guint8)(guint32) strtoul(ascendtext, NULL, 16);
 243   return HEXBYTE;
 244 }
 245
 246 <sc_gen_byte>" "{4} {
 247   BEGIN(sc_chardisp);
 248 }
 249
 250 <sc_chardisp>.* {
 251   BEGIN(sc_gen_byte);
 252 }
 253
 254 <INITIAL,sc_gen_byte>{WDD_DATE} {
 255   BEGIN(sc_wdd_date_d);
 256   return WDD_DATE;
 257 }
 258
 259 <sc_wdd_date_d>{D}{2} {
 260   BEGIN(sc_wdd_date_m);
 261   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 262   return DECNUM;
 263 }
 264
 265 <sc_wdd_date_m>{D}{2} {
 266   BEGIN(sc_wdd_date_y);
 267   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 268   return DECNUM;
 269 }
 270
 271 <sc_wdd_date_y>{D}{4} {
 272   BEGIN(sc_wdd_time);
 273   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 274   return DECNUM;
 275 }
 276
 277 <sc_wdd_time>{WDD_TIME} {
 278   BEGIN(sc_wdd_time_h);
 279   return KEYWORD;
 280 }
 281
 282 <sc_wdd_time_h>{D}{2} {
 283   BEGIN(sc_wdd_time_m);
 284   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 285   return DECNUM;
 286 }
 287
 288 <sc_wdd_time_m>{D}{2} {
 289   BEGIN(sc_wdd_time_s);
 290   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 291   return DECNUM;
 292 }
 293
 294 <sc_wdd_time_s>{D}{2} {
 295   BEGIN(sc_wdd_cause);
 296   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 10);
 297   return DECNUM;
 298 }
 299
 300 <sc_wdd_cause>{WDD_CAUSE} {
 301   BEGIN(sc_wdd_callnum);
 302   return KEYWORD;
 303 }
 304
 305 <sc_wdd_callnum>{WDD_CALLNUM} {
 306   BEGIN(sc_wdd_chunk);
 307   if (pseudo_header != NULL) {
 308     g_strlcpy(pseudo_header->call_num, ascendtext, ASCEND_MAX_STR_LEN);
 309   }
 310   return STRING;
 311 }
 312
 313 <INITIAL,sc_wdd_chunk,sc_gen_byte>{WDD_CHUNK} {
 314   BEGIN(sc_wdd_chunknum);
 315   return WDD_CHUNK;
 316 }
 317
 318 <sc_wdd_chunknum>{H}{1,8} {
 319   BEGIN(sc_wdd_type);
 320   ascendlval.d = (guint32) strtoul(ascendtext, NULL, 16);
 321   return HEXNUM;
 322 }
 323
 324 <sc_wdd_type>{WDD_TYPE} {
 325   BEGIN(sc_gen_task);
 326   return KEYWORD;
 327 }
 328
 329 <sc_gen_task>\/{D}+ {
 330   return SLASH_SUFFIX;
 331 }
 332
 333 (0x|0X)?{H}+ { return HEXNUM; }
 334
 335 task:|task|at|time:|octets { return KEYWORD; }
 336
 337 <<EOF>> { at_eof++; yyterminate(); }
 338
 339 (.|\n) ;
 340
 341 %%
 342
 343 void ascend_init_lexer(FILE_T fh)
 344 {
 345   yyrestart(0);
 346   yy_fh = fh;
 347   BEGIN(INITIAL);
 348 }
 349
 350 /*
 351  * We want to stop processing when we get to the end of the input.
 352  * (%option noyywrap is not used because if used then
 353  * some flex versions (eg: 2.5.35) generate code which causes
 354  * warnings by the Windows VC compiler).
 355  */
 356
 357 int yywrap(void) {
 358     return 1;
 359 }