auto.c

00001 
00002 /* test program -> switch speed */
00003 /*
00004  *
00005  * Copyright (C) 2001-2003 FhG Fokus
00006  *
00007  * This file is part of ser, a free SIP server.
00008  *
00009  * ser is free software; you can redistribute it and/or modify
00010  * it under the terms of the GNU General Public License as published by
00011  * the Free Software Foundation; either version 2 of the License, or
00012  * (at your option) any later version
00013  *
00014  * For a license to use the ser software under conditions
00015  * other than those described here, or to purchase support for this
00016  * software, please contact iptel.org by e-mail at the following addresses:
00017  *    info@iptel.org
00018  *
00019  * ser is distributed in the hope that it will be useful,
00020  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00021  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00022  * GNU General Public License for more details.
00023  *
00024  * You should have received a copy of the GNU General Public License 
00025  * along with this program; if not, write to the Free Software 
00026  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00027  */
00028 
00029 
00030 
00031 /* parsing:           compact form:
00032  * Via:               v:
00033  * From:              f:
00034  * To:                t:
00035  * Cseq:              n/a
00036  * Call-ID:           i:
00037  * Contact:           m:
00038  * Max-Forwards:      n/a
00039  * Route:             n/a
00040  */
00041 
00042 enum { INITIAL=0,
00043                 VIA1, VIA2,
00044                 FROM1, FROM2, FROM3,
00045                 TO1,
00046                 C_START, CSEQ2, CSEQ3,
00047                          CALLID2, CALLID3, CALLID4, CALLID5, CALLID6,
00048                          CONTACT2, CONTACT3, CONTACT4, CONTACT5, CONTACT6,
00049                 M_START,      MAXFORWARDS2, MAXFORWARDS3, MAXFORWARDS4, MAXFORWARDS5,
00050                 MAXFORWARDS6, MAXFORWARDS7, MAXFORWARDS8, MAXFORWARDS9, MAXFORWARDS10,
00051                 MAXFORWARDS11,
00052                 ROUTE1, ROUTE2, ROUTE3, ROUTE4,
00053                 /* final states*/
00054                 F_VIA=1000, F_FROM, F_TO, F_CSEQ, F_CALLID, F_CONTACT, F_MAXFORWARDS,
00055                 F_ROUTE,
00056                 I_START,
00057 
00058                 UNKNOWN_HEADER=200,
00059                 BODY=220,
00060                 LF=25000,
00061         };
00062 
00063 #include <stdio.h>
00064 
00065 int main(int argc, char** argv)
00066 {
00067 
00068         char* t;
00069         register int state;
00070         int i;
00071         int err;
00072         err=0;
00073 
00074         state=INITIAL;
00075         printf(" %s (%d)\n", argv[0], argc);
00076         if (argc<2){
00077                         fprintf(stderr, " no parameters\n");
00078                         exit(-1);
00079         }
00080         
00081         for (i=0;i<10000000;i++){
00082                 
00083         for(t=argv[1];*t;t++){
00084                 switch(*t){
00085                         case 'V':
00086                         case 'v':
00087                                         switch(state){
00088                                                 case INITIAL:
00089                                                         state=VIA1;
00090                                                         break;
00091                                                 case UNKNOWN_HEADER: break;
00092                                                 default:
00093                                                         state=UNKNOWN_HEADER;
00094                                         }
00095                                         break;
00096                         case 'I':
00097                         case 'i':
00098                                         switch(state){
00099                                                 case VIA1:
00100                                                         state=VIA2;
00101                                                         break;
00102                                                 case CALLID5:
00103                                                         state=CALLID6;
00104                                                         break;
00105                                                 case INITIAL:
00106                                                         state=I_START;
00107                                                         break;
00108                                                 case UNKNOWN_HEADER: break;
00109                                                 default:
00110                                                         state=UNKNOWN_HEADER;
00111                                         }
00112                                         break;
00113                         case 'A':
00114                         case 'a':
00115                                         switch(state){
00116                                                 case VIA2:
00117                                                                 state=F_VIA;
00118                                                                 break;
00119                                                 case C_START:  /*CALLID1*/
00120                                                                 state=CALLID2;
00121                                                                 break;
00122                                                 case CONTACT4:
00123                                                                 state=CONTACT5;
00124                                                                 break;
00125                                                 case M_START:
00126                                                                 state=MAXFORWARDS2;
00127                                                                 break;
00128                                                 case MAXFORWARDS8:
00129                                                                 state=MAXFORWARDS9;
00130                                                                 break;
00131                                                 case UNKNOWN_HEADER: break;
00132                                                 default:
00133                                                                 state=UNKNOWN_HEADER;
00134                                         }
00135                                         break;
00136                         case 'F':
00137                         case 'f':
00138                                         switch(state){
00139                                                 case INITIAL:
00140                                                                 state=FROM1;
00141                                                                 break;
00142                                                 case MAXFORWARDS4:
00143                                                                 state=MAXFORWARDS5;
00144                                                                 break;
00145                                                 case UNKNOWN_HEADER: break;
00146                                                 default:
00147                                                                 state=UNKNOWN_HEADER;
00148                                         }
00149                                         break;
00150                         case 'R':
00151                         case 'r':
00152                                         switch(state){
00153                                                 case INITIAL:
00154                                                         state=ROUTE1;
00155                                                         break;
00156                                                 case FROM1:
00157                                                         state=FROM2;
00158                                                         break;
00159                                                 case MAXFORWARDS6:
00160                                                         state=MAXFORWARDS7;
00161                                                         break;
00162                                                 case MAXFORWARDS9:
00163                                                         state=MAXFORWARDS10;
00164                                                         break;
00165                                                 case UNKNOWN_HEADER: break;
00166                                                 default:
00167                                                         state=UNKNOWN_HEADER;
00168                                         }
00169                                         break;
00170                         case 'O':
00171                         case 'o':
00172                                         switch(state){
00173                                                 case FROM2:
00174                                                         state=FROM3;
00175                                                         break;
00176                                                 case TO1:
00177                                                         state=F_TO;
00178                                                         break;
00179                                                 case C_START: /*CONTACT1 */
00180                                                         state=CONTACT2;
00181                                                         break;
00182                                                 case ROUTE1:
00183                                                         state=ROUTE2;
00184                                                         break;
00185                                                 case MAXFORWARDS5:
00186                                                         state=MAXFORWARDS6;
00187                                                         break;
00188                                                 case UNKNOWN_HEADER: break;
00189                                                 default:
00190                                                         state=UNKNOWN_HEADER;
00191                                         }
00192                                         break;
00193                         case 'M':
00194                         case 'm':
00195                                                 switch(state){
00196                                                         case INITIAL:
00197                                                                 state=M_START;
00198                                                                 break;
00199                                                         case FROM3:
00200                                                                 state=F_FROM;
00201                                                                 break;
00202                                                         case UNKNOWN_HEADER: break;
00203                                                         default:
00204                                                                 state=UNKNOWN_HEADER;
00205                                                 }
00206                                                 break;
00207                         case 'T':
00208                         case 't':
00209                                                 switch(state){
00210                                                         case INITIAL:
00211                                                                 state=TO1;
00212                                                                 break;
00213                                                         case CONTACT3:
00214                                                                 state=CONTACT4;
00215                                                                 break;
00216                                                         case CONTACT6:
00217                                                                 state=F_CONTACT;
00218                                                                 break;
00219                                                         case ROUTE3:
00220                                                                 state=ROUTE4;
00221                                                                 break;
00222                                                         case UNKNOWN_HEADER: break;
00223                                                         default:
00224                                                                 state=UNKNOWN_HEADER;
00225                                                 }
00226                                                 break;
00227                         case 'C':
00228                         case 'c':
00229                                                 switch(state){
00230                                                         case INITIAL:
00231                                                                 state=C_START;
00232                                                                 break;
00233                                                         case CONTACT5:
00234                                                                 state=CONTACT6;
00235                                                                 break;
00236                                                         case UNKNOWN_HEADER: break;
00237                                                         default:
00238                                                                 state=UNKNOWN_HEADER;
00239                                                 }
00240                                                 break;
00241                         case 'S':
00242                         case 's':
00243                                                 switch(state){
00244                                                         case C_START:
00245                                                                 state=CSEQ2;
00246                                                                 break;
00247                                                         case MAXFORWARDS11:
00248                                                                 state=F_MAXFORWARDS;
00249                                                                 break;
00250                                                         case UNKNOWN_HEADER: break;
00251                                                         default:
00252                                                                 state=UNKNOWN_HEADER;
00253                                                 }
00254                                                 break;
00255                         case 'E':
00256                         case 'e':
00257                                                 switch(state){
00258                                                         case CSEQ2:
00259                                                                 state=CSEQ3;
00260                                                                 break;
00261                                                         case ROUTE4:
00262                                                                 state=F_ROUTE;
00263                                                                 break;
00264                                                         case UNKNOWN_HEADER: break;
00265                                                         default:
00266                                                                 state=UNKNOWN_HEADER;
00267                                                 }
00268                                                 break;
00269                         case 'Q':
00270                         case 'q':
00271                                                 switch(state){
00272                                                         case CSEQ3:
00273                                                                 state=F_CSEQ;
00274                                                                 break;
00275                                                         case UNKNOWN_HEADER: break;
00276                                                         default:
00277                                                                 state=UNKNOWN_HEADER;
00278                                                 }
00279                                                 break;
00280                         case 'L':
00281                         case 'l':
00282                                                 switch(state){
00283                                                         case CALLID2:
00284                                                                 state=CALLID3;
00285                                                                 break;
00286                                                         case CALLID3:
00287                                                                 state=CALLID4;
00288                                                                 break;
00289                                                         case UNKNOWN_HEADER: break;
00290                                                         default:
00291                                                                 state=UNKNOWN_HEADER;
00292                                                 }
00293                                                 break;
00294                         case 'D':
00295                         case 'd':
00296                                                 switch(state){
00297                                                         case CALLID6:
00298                                                                 state=F_CALLID;
00299                                                                 break;
00300                                                         case MAXFORWARDS10:
00301                                                                 state=MAXFORWARDS11;
00302                                                                 break;
00303                                                         case UNKNOWN_HEADER: break;
00304                                                         default:
00305                                                                 state=UNKNOWN_HEADER;
00306                                                 }
00307                                                 break;
00308                         case 'N':
00309                         case 'n':
00310                                                 switch(state){
00311                                                         case CONTACT2:
00312                                                                 state=CONTACT3;
00313                                                                 break;
00314                                                         case UNKNOWN_HEADER: break;
00315                                                         default:
00316                                                                 state=UNKNOWN_HEADER;
00317                                                 }
00318                                                 break;
00319                         case 'X':
00320                         case 'x':
00321                                                 switch(state){
00322                                                         case MAXFORWARDS2:
00323                                                                 state=MAXFORWARDS3;
00324                                                                 break;
00325                                                         case UNKNOWN_HEADER: break;
00326                                                         default:
00327                                                                 state=UNKNOWN_HEADER;
00328                                                 }
00329                                                 break;
00330                         case '-':
00331                                                 switch(state){
00332                                                         case CALLID4:
00333                                                                 state=CALLID5;
00334                                                                 break;
00335                                                         case MAXFORWARDS3:
00336                                                                 state=MAXFORWARDS4;
00337                                                                 break;
00338                                                         case UNKNOWN_HEADER: break;
00339                                                         default:
00340                                                                 state=UNKNOWN_HEADER;
00341                                                 }
00342                                                 break;
00343                         case 'W':
00344                         case 'w':
00345                                                 switch(state){
00346                                                         case MAXFORWARDS7:
00347                                                                 state=MAXFORWARDS8;
00348                                                                 break;
00349                                                         case UNKNOWN_HEADER: break;
00350                                                         default:
00351                                                                 state=UNKNOWN_HEADER;
00352                                                 }
00353                                                 break;
00354                         case 'U':
00355                         case 'u':
00356                                                 switch(state){
00357                                                         case ROUTE2:
00358                                                                 state=ROUTE3;
00359                                                                 break;
00360                                                         case UNKNOWN_HEADER: break;
00361                                                         default:
00362                                                                 state=UNKNOWN_HEADER;
00363                                                 }
00364                                                 break;
00365                         case ' ':
00366                                                 switch(state){
00367                                                         case INITIAL:
00368                                                                 break; /*eat space */
00369                                                         case F_VIA:
00370                                                         case F_FROM:
00371                                                         case F_TO:
00372                                                         case F_CSEQ:
00373                                                         case F_CALLID:
00374                                                         case F_CONTACT:
00375                                                         case F_MAXFORWARDS:
00376                                                         case F_ROUTE:
00377                                                                 break; /* eat trailing space*/
00378                                                         case VIA1:
00379                                                                 /*compact form: v: */
00380                                                                 state=F_VIA;
00381                                                                 break;
00382                                                         case FROM1:
00383                                                                 /*compact form f:*/
00384                                                                 state=F_FROM;
00385                                                                 break;
00386                                                         case TO1:
00387                                                                 /*compact form t:*/
00388                                                                 state=F_TO;
00389                                                                 break;
00390                                                         case I_START:
00391                                                                 /*compact form i: (Call-ID)*/
00392                                                                 state=F_CALLID;
00393                                                                 break;
00394                                                         case M_START:
00395                                                                 /*compact form m: (Contact)*/
00396                                                                 state=F_CONTACT;
00397                                                                 break;
00398                                                         case UNKNOWN_HEADER: break;
00399                                                         default:
00400                                                                 state=UNKNOWN_HEADER;
00401                                                 }
00402                                                 break;
00403                         case ':':
00404                                                 switch(state){
00405                                                         case F_VIA:
00406                                                         case VIA1: /* compact form*/
00407                                                         case F_FROM:
00408                                                         case FROM1: /*compact form*/
00409                                                         case F_TO:
00410                                                         case TO1: /*compact form*/
00411                                                         case F_CSEQ:
00412                                                         case F_CALLID:
00413                                                         case I_START: /*compact form*/
00414                                                         case F_CONTACT:
00415                                                         case M_START: /*compact form*/
00416                                                         case F_MAXFORWARDS:
00417                                                         case F_ROUTE:
00418                                                         //      printf("found header, state=%d\n", state);
00419                                                                 state=INITIAL; /* reset to test*/
00420                                                                 break;
00421                                                         case UNKNOWN_HEADER:
00422                                                         default:
00423                                                                 /*printf("found unknown header, state=%d\n", 
00424                                                                                         state);*/
00425                                                                 err=1;
00426                                                                 state=INITIAL;
00427                                                 }
00428                                                 break;
00429                         default:
00430                                         /*fprintf(stderr, "Unexpected char <%c> encountered"
00431                                                                                 " state=%d\n", *t, state);
00432                                                 exit(-1);*/
00433                                         state=UNKNOWN_HEADER;
00434                 }
00435         }
00436 
00437         } //for i
00438         if (err) printf("Error unknown header\n");
00439         printf("final state=%d\n", state);
00440 
00441         exit(0);
00442 
00443 }
00444
Generated on Tue May 22 2012 13:10:02 for SIP Router by  doxygen 1.7.1