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     ascendlval.d = strtol(ascendtext, NULL, 10);
 189     retval = DECNUM;
 190   }
 191   g_free (atcopy);
 192   return retval;
 193 }
 194
 195 <sc_wds_sess>{D}* {
 196   BEGIN(sc_gen_task);
 197   ascendlval.d = strtol(ascendtext, NULL, 10);
 198   return DECNUM;
 199 }
 200
 201 <sc_gen_task>(0x|0X)?{H}{2,8} {
 202   BEGIN(sc_gen_time_s);
 203   ascendlval.d = strtoul(ascendtext, NULL, 16);
 204   return HEXNUM;
 205 }
 206
 207 <sc_gen_task>\"[A-Za-z0-9_ ]+\" {
 208   return STRING;
 209 }
 210
 211 <sc_gen_time_s>{D}{1,10} {
 212   BEGIN(sc_gen_time_u);
 213   ascendlval.d = strtol(ascendtext, NULL, 10);
 214   return DECNUM;
 215 }
 216
 217 <sc_gen_time_u>{D}{1,6} {
 218   char *atcopy = g_strdup(ascendtext);
 219   BEGIN(sc_gen_octets);
 220   /* only want the most significant 2 digits. convert to usecs */
 221   if (strlen(atcopy) > 2)
 222     atcopy[2] = '\0';
 223   ascendlval.d = strtol(atcopy, NULL, 10) * 10000;
 224   g_free(atcopy);
 225   return DECNUM;
 226 }
 227
 228 <sc_gen_octets>{D}{1,10} {
 229   BEGIN(sc_gen_counter);
 230   ascendlval.d = strtol(ascendtext, NULL, 10);
 231   return DECNUM;
 232 }
 233
 234 <sc_gen_counter,sc_gen_byte>"["{H}{4}"]:" {
 235   BEGIN(sc_gen_byte);
 236   return COUNTER;
 237 }
 238
 239 <sc_gen_byte>{H}{2} {
 240   ascendlval.b = (guint8)strtol(ascendtext, NULL, 16);
 241   return HEXBYTE;
 242 }
 243
 244 <sc_gen_byte>" "{4} {
 245   BEGIN(sc_chardisp);
 246 }
 247
 248 <sc_chardisp>.* {
 249   BEGIN(sc_gen_byte);
 250 }
 251
 252 <INITIAL,sc_gen_byte>{WDD_DATE} {
 253   BEGIN(sc_wdd_date_d);
 254   return WDD_DATE;
 255 }
 256
 257 <sc_wdd_date_d>{D}{2} {
 258   BEGIN(sc_wdd_date_m);
 259   ascendlval.d = strtol(ascendtext, NULL, 10);
 260   return DECNUM;
 261 }
 262
 263 <sc_wdd_date_m>{D}{2} {
 264   BEGIN(sc_wdd_date_y);
 265   ascendlval.d = strtol(ascendtext, NULL, 10);
 266   return DECNUM;
 267 }
 268
 269 <sc_wdd_date_y>{D}{4} {
 270   BEGIN(sc_wdd_time);
 271   ascendlval.d = strtol(ascendtext, NULL, 10);
 272   return DECNUM;
 273 }
 274
 275 <sc_wdd_time>{WDD_TIME} {
 276   BEGIN(sc_wdd_time_h);
 277   return KEYWORD;
 278 }
 279
 280 <sc_wdd_time_h>{D}{2} {
 281   BEGIN(sc_wdd_time_m);
 282   ascendlval.d = strtol(ascendtext, NULL, 10);
 283   return DECNUM;
 284 }
 285
 286 <sc_wdd_time_m>{D}{2} {
 287   BEGIN(sc_wdd_time_s);
 288   ascendlval.d = strtol(ascendtext, NULL, 10);
 289   return DECNUM;
 290 }
 291
 292 <sc_wdd_time_s>{D}{2} {
 293   BEGIN(sc_wdd_cause);
 294   ascendlval.d = strtol(ascendtext, NULL, 10);
 295   return DECNUM;
 296 }
 297
 298 <sc_wdd_cause>{WDD_CAUSE} {
 299   BEGIN(sc_wdd_callnum);
 300   return KEYWORD;
 301 }
 302
 303 <sc_wdd_callnum>{WDD_CALLNUM} {
 304   BEGIN(sc_wdd_chunk);
 305   if (pseudo_header != NULL) {
 306     g_strlcpy(pseudo_header->call_num, ascendtext, ASCEND_MAX_STR_LEN);
 307   }
 308   return STRING;
 309 }
 310
 311 <INITIAL,sc_wdd_chunk,sc_gen_byte>{WDD_CHUNK} {
 312   BEGIN(sc_wdd_chunknum);
 313   return WDD_CHUNK;
 314 }
 315
 316 <sc_wdd_chunknum>{H}{1,8} {
 317   BEGIN(sc_wdd_type);
 318   ascendlval.d = strtoul(ascendtext, NULL, 16);
 319   return HEXNUM;
 320 }
 321
 322 <sc_wdd_type>{WDD_TYPE} {
 323   BEGIN(sc_gen_task);
 324   return KEYWORD;
 325 }
 326
 327 <sc_gen_task>\/{D}+ {
 328   return SLASH_SUFFIX;
 329 }
 330
 331 (0x|0X)?{H}+ { return HEXNUM; }
 332
 333 task:|task|at|time:|octets { return KEYWORD; }
 334
 335 <<EOF>> { at_eof++; yyterminate(); }
 336
 337 (.|\n) ;
 338
 339 %%
 340
 341 void ascend_init_lexer(FILE_T fh)
 342 {
 343   yyrestart(0);
 344   yy_fh = fh;
 345   BEGIN(INITIAL);
 346 }
 347
 348 /*
 349  * We want to stop processing when we get to the end of the input.
 350  * (%option noyywrap is not used because if used then
 351  * some flex versions (eg: 2.5.35) generate code which causes
 352  * warnings by the Windows VC compiler).
 353  */
 354
 355 int yywrap(void) {
 356     return 1;
 357 }