drivers/net/npf/win_bpf_filter_init.c

   1 /*
   2  * Copyright (c) 2001
   3  *      Politecnico di Torino.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the Politecnico
  13  * di Torino, and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  *
  21  *
  22  *
  23  * Portions copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
  24  *      The Regents of the University of California.  All rights reserved.
  25  *
  26  * This code is derived from the Stanford/CMU enet packet filter,
  27  * (net/enet.c) distributed as part of 4.3BSD, and code contributed
  28  * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
  29  * Berkeley Laboratory.
  30  *
  31  * Redistribution and use in source and binary forms, with or without
  32  * modification, are permitted provided that the following conditions
  33  * are met:
  34  * 1. Redistributions of source code must retain the above copyright
  35  *    notice, this list of conditions and the following disclaimer.
  36  * 2. Redistributions in binary form must reproduce the above copyright
  37  *    notice, this list of conditions and the following disclaimer in the
  38  *    documentation and/or other materials provided with the distribution.
  39  * 3. All advertising materials mentioning features or use of this software
  40  *    must display the following acknowledgement:
  41  *      This product includes software developed by the University of
  42  *      California, Berkeley and its contributors.
  43  * 4. Neither the name of the University nor the names of its contributors
  44  *    may be used to endorse or promote products derived from this software
  45  *    without specific prior written permission.
  46  *
  47  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  48  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  50  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  51  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  52  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  53  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  54  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  55  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  56  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  57  * SUCH DAMAGE.
  58  */
  59
  60 #include "tme.h"
  61 #include "win_bpf.h"
  62
  63 /*
  64  * Initialize the filter machine
  65  */
  66 uint32 bpf_filter_init(register struct bpf_insn *pc, MEM_TYPE *mem_ex, TME_CORE *tme, struct time_conv *time_ref)
  67 {
  68         register uint32 A, X;
  69         int32 mem[BPF_MEMWORDS];
  70         register int32 k;
  71         uint32 *tmp;
  72         uint16 *tmp2;
  73         uint32 j;
  74         if (pc == 0)
  75                 /*
  76                  * No filter means accept all.
  77                  */
  78                  return (uint32)-1;
  79         A = 0;
  80         X = 0;
  81         --pc;
  82         while (1) {
  83                 ++pc;
  84                 switch (pc->code) {
  85
  86                 default:
  87                         return 0;
  88
  89 /* RET INSTRUCTIONS */
  90                 case BPF_RET|BPF_K:
  91                         return (uint32)pc->k;
  92
  93                 case BPF_RET|BPF_A:
  94                         return (uint32)A;
  95 /* END RET INSTRUCTIONS */
  96
  97 /* LD NO PACKET INSTRUCTIONS */
  98                 case BPF_LD|BPF_IMM:
  99                         A = pc->k;
 100                         continue;
 101
 102                 case BPF_LDX|BPF_IMM:
 103                         X = pc->k;
 104                         continue;
 105
 106                 case BPF_LD|BPF_MEM:
 107                         A = mem[pc->k];
 108                         continue;
 109
 110                 case BPF_LDX|BPF_MEM:
 111                         X = mem[pc->k];
 112                         continue;
 113
 114                 case BPF_LD|BPF_MEM_EX_IMM|BPF_B:
 115                         A= mem_ex->buffer[pc->k];
 116                         continue;
 117
 118                 case BPF_LDX|BPF_MEM_EX_IMM|BPF_B:
 119                         X= mem_ex->buffer[pc->k];
 120                         continue;
 121
 122                 case BPF_LD|BPF_MEM_EX_IMM|BPF_H:
 123                         tmp2=(uint16*)&mem_ex->buffer[pc->k];
 124 #ifndef __GNUC__
 125                         __asm
 126                         {
 127                                 push eax
 128                                 push ebx
 129                                 mov ebx,tmp2
 130                                 xor eax, eax
 131                                 mov ax, [ebx]
 132                                 bswap eax
 133                                 mov A, eax
 134                                 pop ebx
 135                                 pop eax
 136                         }
 137 #else
 138                         asm("push %%eax;"
 139                                 "push %%ebx;"
 140                                 "mov %1,%%ebx;"
 141                                 "xor %%eax, %%eax;"
 142                                 "mov (%%ebx), %%ax;"
 143                                 "bswap %%eax;"
 144                                 "mov %%eax, %0;"
 145                                 "pop %%ebx;"
 146                                 "pop %%eax;"
 147                 :"=a"(A),"=c"(tmp2): );
 148 #endif
 149                         continue;
 150
 151                 case BPF_LDX|BPF_MEM_EX_IMM|BPF_H:
 152                         tmp2=(uint16*)&mem_ex->buffer[pc->k];
 153 #ifndef __GNUC__
 154                         __asm
 155                         {
 156                                 push eax
 157                                 push ebx
 158                                 mov ebx,tmp2
 159                                 xor eax, eax
 160                                 mov ax, [ebx]
 161                                 bswap eax
 162                                 mov X, eax
 163                                 pop ebx
 164                                 pop eax
 165                         }
 166 #else
 167                         asm("push %%eax;"
 168                                 "push %%ebx;"
 169                                 "mov %1,%%ebx;"
 170                                 "xor %%eax, %%eax;"
 171                                 "mov (%%ebx), %%ax;"
 172                                 "bswap %%eax;"
 173                                 "mov %%eax, %0;"
 174                                 "pop %%ebx;"
 175                                 "pop %%eax;"
 176                 :"=a"(X),"=c"(tmp2): );
 177 #endif
 178                         continue;
 179
 180                 case BPF_LD|BPF_MEM_EX_IMM|BPF_W:
 181                         tmp=(uint32*)&mem_ex->buffer[pc->k];
 182 #ifndef __GNUC__
 183                         __asm
 184                         {
 185                                 push eax
 186                                 push ebx
 187                                 mov ebx,tmp
 188                                 mov eax, [ebx]
 189                                 bswap eax
 190                                 mov A, eax
 191                                 pop ebx
 192                                 pop eax
 193                         }
 194 #else
 195                         asm("push %%eax;"
 196                                 "push %%ebx;"
 197                                 "mov %1,%%ebx;"
 198                                 "xor %%eax, %%eax;"
 199                                 "mov (%%ebx), %%ax;"
 200                                 "bswap %%eax;"
 201                                 "mov %%eax, %0;"
 202                                 "pop %%ebx;"
 203                                 "pop %%eax;"
 204                 :"=a"(A),"=c"(tmp): );
 205 #endif
 206                         continue;
 207
 208                 case BPF_LDX|BPF_MEM_EX_IMM|BPF_W:
 209                         tmp=(uint32*)&mem_ex->buffer[pc->k];
 210 #ifndef __GNUC__
 211                         __asm
 212                         {
 213                                 push eax
 214                                 push ebx
 215                                 mov ebx,tmp
 216                                 mov eax, [ebx]
 217                                 bswap eax
 218                                 mov X, eax
 219                                 pop ebx
 220                                 pop eax
 221                         }
 222 #else
 223                         asm("push %%eax;"
 224                                 "push %%ebx;"
 225                                 "mov %1,%%ebx;"
 226                                 "xor %%eax, %%eax;"
 227                                 "mov (%%ebx), %%ax;"
 228                                 "bswap %%eax;"
 229                                 "mov %%eax, %0;"
 230                                 "pop %%ebx;"
 231                                 "pop %%eax;"
 232                 :"=a"(X),"=c"(tmp): );
 233 #endif
 234                         continue;
 235
 236                 case BPF_LD|BPF_MEM_EX_IND|BPF_B:
 237                         k = X + pc->k;
 238                         if ((int32)k>= (int32)mem_ex->size) {
 239                                 return 0;
 240                         }
 241                         A= mem_ex->buffer[k];
 242                         continue;
 243
 244                 case BPF_LD|BPF_MEM_EX_IND|BPF_H:
 245                         k = X + pc->k;
 246                         if ((int32)(k+1)>= (int32)mem_ex->size) {
 247                                 return 0;
 248                         }
 249                         tmp2=(uint16*)&mem_ex->buffer[k];
 250 #ifndef __GNUC__
 251                         __asm
 252                         {
 253                                 push eax
 254                                 push ebx
 255                                 mov ebx,tmp2
 256                                 xor eax, eax
 257                                 mov ax, [ebx]
 258                                 bswap eax
 259                                 mov A, eax
 260                                 pop ebx
 261                                 pop eax
 262                         }
 263 #else
 264                         asm("push %%eax;"
 265                                 "push %%ebx;"
 266                                 "mov %1,%%ebx;"
 267                                 "xor %%eax, %%eax;"
 268                                 "mov (%%ebx), %%ax;"
 269                                 "bswap %%eax;"
 270                                 "mov %%eax, %0;"
 271                                 "pop %%ebx;"
 272                                 "pop %%eax;"
 273                 :"=a"(A),"=c"(tmp2): );
 274 #endif
 275                         continue;
 276
 277                 case BPF_LD|BPF_MEM_EX_IND|BPF_W:
 278                         k = X + pc->k;
 279                         if ((int32)(k+3)>= (int32)mem_ex->size) {
 280                                 return 0;
 281                         }
 282                         tmp=(uint32*)&mem_ex->buffer[k];
 283 #ifndef __GNUC__
 284                         __asm
 285                         {
 286                                 push eax
 287                                 push ebx
 288                                 mov ebx,tmp
 289                                 mov eax, [ebx]
 290                                 bswap eax
 291                                 mov A, eax
 292                                 pop ebx
 293                                 pop eax
 294                         }
 295 #else
 296                         asm("push %%eax;"
 297                                 "push %%ebx;"
 298                                 "mov %1,%%ebx;"
 299                                 "xor %%eax, %%eax;"
 300                                 "mov (%%ebx), %%ax;"
 301                                 "bswap %%eax;"
 302                                 "mov %%eax, %0;"
 303                                 "pop %%ebx;"
 304                                 "pop %%eax;"
 305                 :"=a"(A),"=c"(tmp): );
 306 #endif
 307                         continue;
 308 /* END LD NO PACKET INSTRUCTIONS */
 309
 310 /* STORE INSTRUCTIONS */
 311                 case BPF_ST:
 312                         mem[pc->k] = A;
 313                         continue;
 314
 315                 case BPF_STX:
 316                         mem[pc->k] = X;
 317                         continue;
 318
 319                 case BPF_ST|BPF_MEM_EX_IMM|BPF_B:
 320                         mem_ex->buffer[pc->k]=(uint8)A;
 321                         continue;
 322
 323                 case BPF_STX|BPF_MEM_EX_IMM|BPF_B:
 324                         mem_ex->buffer[pc->k]=(uint8)X;
 325                         continue;
 326
 327                 case BPF_ST|BPF_MEM_EX_IMM|BPF_W:
 328                         tmp=(uint32*)&mem_ex->buffer[pc->k];
 329 #ifndef __GNUC__
 330                         __asm
 331                         {
 332                                 push eax
 333                                 push ebx
 334                                 mov ebx, tmp
 335                                 mov eax, A
 336                                 bswap eax
 337                                 mov [ebx], eax
 338                                 pop ebx
 339                                 pop eax
 340                         }
 341 #else
 342                         asm("push %%eax;"
 343                                 "push %%ebx;"
 344                                 "mov %1,%%ebx;"
 345                                 "xor %%eax, %%eax;"
 346                                 "mov (%%ebx), %%ax;"
 347                                 "bswap %%eax;"
 348                                 "mov %%eax, %0;"
 349                                 "pop %%ebx;"
 350                                 "pop %%eax;"
 351                 :"=a"(A),"=c"(tmp): );
 352 #endif
 353                         continue;
 354
 355                 case BPF_STX|BPF_MEM_EX_IMM|BPF_W:
 356                         tmp=(uint32*)&mem_ex->buffer[pc->k];
 357 #ifndef __GNUC__
 358                         __asm
 359                         {
 360                                 push eax
 361                                 push ebx
 362                                 mov ebx, tmp
 363                                 mov eax, X
 364                                 bswap eax
 365                                 mov [ebx], eax
 366                                 pop ebx
 367                                 pop eax
 368                         }
 369 #else
 370                         asm("push %%eax;"
 371                                 "push %%ebx;"
 372                                 "mov %1,%%ebx;"
 373                                 "xor %%eax, %%eax;"
 374                                 "mov (%%ebx), %%ax;"
 375                                 "bswap %%eax;"
 376                                 "mov %%eax, %0;"
 377                                 "pop %%ebx;"
 378                                 "pop %%eax;"
 379                 :"=a"(X),"=c"(tmp): );
 380 #endif
 381                         continue;
 382
 383                 case BPF_ST|BPF_MEM_EX_IMM|BPF_H:
 384                         tmp2=(uint16*)&mem_ex->buffer[pc->k];
 385 #ifndef __GNUC__
 386                         __asm
 387                         {
 388                                 push eax
 389                                 push ebx
 390                                 mov ebx, tmp2
 391                                 mov eax, A
 392                                 xchg ah, al
 393                                 mov [ebx], ax
 394                                 pop ebx
 395                                 pop eax
 396                         }
 397 #else
 398                         asm("push %%eax;"
 399                                 "push %%ebx;"
 400                                 "mov %1,%%ebx;"
 401                                 "xor %%eax, %%eax;"
 402                                 "mov (%%ebx), %%ax;"
 403                                 "bswap %%eax;"
 404                                 "mov %%eax, %0;"
 405                                 "pop %%ebx;"
 406                                 "pop %%eax;"
 407                 :"=a"(A),"=c"(tmp2): );
 408 #endif
 409                         continue;
 410
 411                 case BPF_STX|BPF_MEM_EX_IMM|BPF_H:
 412                         tmp2=(uint16*)&mem_ex->buffer[pc->k];
 413 #ifndef __GNUC__
 414                         __asm
 415                         {
 416                                 push eax
 417                                 push ebx
 418                                 mov ebx, tmp2
 419                                 mov eax, X
 420                                 xchg ah, al
 421                                 mov [ebx], ax
 422                                 pop ebx
 423                                 pop eax
 424                         }
 425 #else
 426                         asm("push %%eax;"
 427                                 "push %%ebx;"
 428                                 "mov %1,%%ebx;"
 429                                 "xor %%eax, %%eax;"
 430                                 "mov (%%ebx), %%ax;"
 431                                 "bswap %%eax;"
 432                                 "mov %%eax, %0;"
 433                                 "pop %%ebx;"
 434                                 "pop %%eax;"
 435                 :"=a"(X),"=c"(tmp2): );
 436 #endif
 437                         continue;
 438
 439                 case BPF_ST|BPF_MEM_EX_IND|BPF_B:
 440                         mem_ex->buffer[pc->k+X]=(uint8)A;
 441
 442                 case BPF_ST|BPF_MEM_EX_IND|BPF_W:
 443                         tmp=(uint32*)&mem_ex->buffer[pc->k+X];
 444 #ifndef __GNUC__
 445                         __asm
 446                         {
 447                                 push eax
 448                                 push ebx
 449                                 mov ebx, tmp
 450                                 mov eax, A
 451                                 bswap eax
 452                                 mov [ebx], eax
 453                                 pop ebx
 454                                 pop eax
 455                         }
 456 #else
 457                         asm("push %%eax;"
 458                                 "push %%ebx;"
 459                                 "mov %1,%%ebx;"
 460                                 "xor %%eax, %%eax;"
 461                                 "mov (%%ebx), %%ax;"
 462                                 "bswap %%eax;"
 463                                 "mov %%eax, %0;"
 464                                 "pop %%ebx;"
 465                                 "pop %%eax;"
 466                 :"=a"(A),"=c"(tmp): );
 467 #endif
 468                         continue;
 469
 470                 case BPF_ST|BPF_MEM_EX_IND|BPF_H:
 471                         tmp2=(uint16*)&mem_ex->buffer[pc->k+X];
 472 #ifndef __GNUC__
 473                         __asm
 474                         {
 475                                 push eax
 476                                 push ebx
 477                                 mov ebx, tmp2
 478                                 mov eax, A
 479                                 xchg ah, al
 480                                 mov [ebx], ax
 481                                 pop ebx
 482                                 pop eax
 483                         }
 484 #else
 485                         asm("push %%eax;"
 486                                 "push %%ebx;"
 487                                 "mov %1,%%ebx;"
 488                                 "xor %%eax, %%eax;"
 489                                 "mov (%%ebx), %%ax;"
 490                                 "bswap %%eax;"
 491                                 "mov %%eax, %0;"
 492                                 "pop %%ebx;"
 493                                 "pop %%eax;"
 494                 :"=a"(A),"=c"(tmp2): );
 495 #endif
 496                         continue;
 497 /* END STORE INSTRUCTIONS */
 498
 499 /* JUMP INSTRUCTIONS */
 500                 case BPF_JMP|BPF_JA:
 501                         pc += pc->k;
 502                         continue;
 503
 504                 case BPF_JMP|BPF_JGT|BPF_K:
 505                         pc += ((int32)A > (int32)pc->k) ? pc->jt : pc->jf;
 506                         continue;
 507
 508                 case BPF_JMP|BPF_JGE|BPF_K:
 509                         pc += ((int32)A >= (int32)pc->k) ? pc->jt : pc->jf;
 510                         continue;
 511
 512                 case BPF_JMP|BPF_JEQ|BPF_K:
 513                         pc += ((int32)A == (int32)pc->k) ? pc->jt : pc->jf;
 514                         continue;
 515
 516                 case BPF_JMP|BPF_JSET|BPF_K:
 517                         pc += (A & pc->k) ? pc->jt : pc->jf;
 518                         continue;
 519
 520                 case BPF_JMP|BPF_JGT|BPF_X:
 521                         pc += (A > X) ? pc->jt : pc->jf;
 522                         continue;
 523
 524                 case BPF_JMP|BPF_JGE|BPF_X:
 525                         pc += (A >= X) ? pc->jt : pc->jf;
 526                         continue;
 527
 528                 case BPF_JMP|BPF_JEQ|BPF_X:
 529                         pc += (A == X) ? pc->jt : pc->jf;
 530                         continue;
 531
 532                 case BPF_JMP|BPF_JSET|BPF_X:
 533                         pc += (A & X) ? pc->jt : pc->jf;
 534                         continue;
 535 /* END JUMP INSTRUCTIONS */
 536
 537 /* ARITHMETIC INSTRUCTIONS */
 538                 case BPF_ALU|BPF_ADD|BPF_X:
 539                         A += X;
 540                         continue;
 541
 542                 case BPF_ALU|BPF_SUB|BPF_X:
 543                         A -= X;
 544                         continue;
 545
 546                 case BPF_ALU|BPF_MUL|BPF_X:
 547                         A *= X;
 548                         continue;
 549
 550                 case BPF_ALU|BPF_DIV|BPF_X:
 551                         if (X == 0)
 552                                 return 0;
 553                         A /= X;
 554                         continue;
 555
 556                 case BPF_ALU|BPF_AND|BPF_X:
 557                         A &= X;
 558                         continue;
 559
 560                 case BPF_ALU|BPF_OR|BPF_X:
 561                         A |= X;
 562                         continue;
 563
 564                 case BPF_ALU|BPF_LSH|BPF_X:
 565                         A <<= X;
 566                         continue;
 567
 568                 case BPF_ALU|BPF_RSH|BPF_X:
 569                         A >>= X;
 570                         continue;
 571
 572                 case BPF_ALU|BPF_ADD|BPF_K:
 573                         A += pc->k;
 574                         continue;
 575
 576                 case BPF_ALU|BPF_SUB|BPF_K:
 577                         A -= pc->k;
 578                         continue;
 579
 580                 case BPF_ALU|BPF_MUL|BPF_K:
 581                         A *= pc->k;
 582                         continue;
 583
 584                 case BPF_ALU|BPF_DIV|BPF_K:
 585                         A /= pc->k;
 586                         continue;
 587
 588                 case BPF_ALU|BPF_AND|BPF_K:
 589                         A &= pc->k;
 590                         continue;
 591
 592                 case BPF_ALU|BPF_OR|BPF_K:
 593                         A |= pc->k;
 594                         continue;
 595
 596                 case BPF_ALU|BPF_LSH|BPF_K:
 597                         A <<= pc->k;
 598                         continue;
 599
 600                 case BPF_ALU|BPF_RSH|BPF_K:
 601                         A >>= pc->k;
 602                         continue;
 603
 604                 case BPF_ALU|BPF_NEG:
 605                         (int32)A = -((int32)A);
 606                         continue;
 607 /* ARITHMETIC INSTRUCTIONS */
 608
 609 /* MISC INSTRUCTIONS */
 610                 case BPF_MISC|BPF_TAX:
 611                         X = A;
 612                         continue;
 613
 614                 case BPF_MISC|BPF_TXA:
 615                         A = X;
 616                         continue;
 617 /* END MISC INSTRUCTIONS */
 618
 619 /* TME INSTRUCTIONS */
 620                 case BPF_MISC|BPF_TME|BPF_LOOKUP:
 621                         j=lookup_frontend(mem_ex,tme,pc->k,time_ref);
 622                         if (j==TME_ERROR)
 623                                 return 0;
 624                         pc += (j == TME_TRUE) ? pc->jt : pc->jf;
 625                         continue;
 626
 627                 case BPF_MISC|BPF_TME|BPF_EXECUTE:
 628                         if (execute_frontend(mem_ex,tme,0,pc->k)==TME_ERROR)
 629                                 return 0;
 630                         continue;
 631
 632                 case BPF_MISC|BPF_TME|BPF_INIT:
 633                         if (init_tme_block(tme,pc->k)==TME_ERROR)
 634                                 return 0;
 635                         continue;
 636
 637                 case BPF_MISC|BPF_TME|BPF_VALIDATE:
 638                         if (validate_tme_block(mem_ex,tme,A,pc->k)==TME_ERROR)
 639                                 return 0;
 640                         continue;
 641
 642                 case BPF_MISC|BPF_TME|BPF_SET_MEMORY:
 643                         if (init_extended_memory(pc->k,mem_ex)==TME_ERROR)
 644                                 return 0;
 645                         continue;
 646
 647                 case BPF_MISC|BPF_TME|BPF_SET_ACTIVE:
 648                         if (set_active_tme_block(tme,pc->k)==TME_ERROR)
 649                                 return 0;
 650                         continue;
 651
 652                 case BPF_MISC|BPF_TME|BPF_SET_ACTIVE_READ:
 653                         if (set_active_tme_block(tme,pc->k)==TME_ERROR)
 654                                 return 0;
 655                         continue;
 656                 case BPF_MISC|BPF_TME|BPF_SET_WORKING:
 657                         if ((pc->k<0)||(pc->k>=MAX_TME_DATA_BLOCKS))
 658                                 return 0;
 659                         tme->working=pc->k;
 660                         continue;
 661
 662
 663
 664                 case BPF_MISC|BPF_TME|BPF_RESET:
 665                         if (reset_tme(tme)==TME_ERROR)
 666                                 return 0;
 667                         continue;
 668
 669                 case BPF_MISC|BPF_TME|BPF_GET_REGISTER_VALUE:
 670                         if (get_tme_block_register(&tme->block_data[tme->working],mem_ex,pc->k,&j)==TME_ERROR)
 671                                 return 0;
 672                         A=j;
 673                         continue;
 674
 675                 case BPF_MISC|BPF_TME|BPF_SET_REGISTER_VALUE:
 676                         if (set_tme_block_register(&tme->block_data[tme->working],mem_ex,pc->k,A,TRUE)==TME_ERROR)
 677                                 return 0;
 678                         continue;
 679
 680                 case BPF_MISC|BPF_TME|BPF_SET_AUTODELETION:
 681                         set_autodeletion(&tme->block_data[tme->working],pc->k);
 682                         continue;
 683
 684 /* END TME INSTRUCTIONS */
 685
 686                 }
 687         }
 688 }
 689