drivers/net/ppp/ppp_deflate.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ppp_deflate.c - interface the zlib procedures for Deflate compression
   4  * and decompression (as used by gzip) to the PPP code.
   5  *
   6  * Copyright 1994-1998 Paul Mackerras.
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/slab.h>
  11 #include <linux/vmalloc.h>
  12 #include <linux/init.h>
  13 #include <linux/string.h>
  14
  15 #include <linux/ppp_defs.h>
  16 #include <linux/ppp-comp.h>
  17
  18 #include <linux/zlib.h>
  19 #include <asm/unaligned.h>
  20
  21 /*
  22  * State for a Deflate (de)compressor.
  23  */
  24 struct ppp_deflate_state {
  25     int         seqno;
  26     int         w_size;
  27     int         unit;
  28     int         mru;
  29     int         debug;
  30     z_stream    strm;
  31     struct compstat stats;
  32 };
  33
  34 #define DEFLATE_OVHD    2               /* Deflate overhead/packet */
  35
  36 static void     *z_comp_alloc(unsigned char *options, int opt_len);
  37 static void     *z_decomp_alloc(unsigned char *options, int opt_len);
  38 static void     z_comp_free(void *state);
  39 static void     z_decomp_free(void *state);
  40 static int      z_comp_init(void *state, unsigned char *options,
  41                                  int opt_len,
  42                                  int unit, int hdrlen, int debug);
  43 static int      z_decomp_init(void *state, unsigned char *options,
  44                                    int opt_len,
  45                                    int unit, int hdrlen, int mru, int debug);
  46 static int      z_compress(void *state, unsigned char *rptr,
  47                                 unsigned char *obuf,
  48                                 int isize, int osize);
  49 static void     z_incomp(void *state, unsigned char *ibuf, int icnt);
  50 static int      z_decompress(void *state, unsigned char *ibuf,
  51                                 int isize, unsigned char *obuf, int osize);
  52 static void     z_comp_reset(void *state);
  53 static void     z_decomp_reset(void *state);
  54 static void     z_comp_stats(void *state, struct compstat *stats);
  55
  56 /**
  57  *      z_comp_free - free the memory used by a compressor
  58  *      @arg:   pointer to the private state for the compressor.
  59  */
  60 static void z_comp_free(void *arg)
  61 {
  62         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
  63
  64         if (state) {
  65                 zlib_deflateEnd(&state->strm);
  66                 vfree(state->strm.workspace);
  67                 kfree(state);
  68         }
  69 }
  70
  71 /**
  72  *      z_comp_alloc - allocate space for a compressor.
  73  *      @options: pointer to CCP option data
  74  *      @opt_len: length of the CCP option at @options.
  75  *
  76  *      The @options pointer points to the a buffer containing the
  77  *      CCP option data for the compression being negotiated.  It is
  78  *      formatted according to RFC1979, and describes the window
  79  *      size that the peer is requesting that we use in compressing
  80  *      data to be sent to it.
  81  *
  82  *      Returns the pointer to the private state for the compressor,
  83  *      or NULL if we could not allocate enough memory.
  84  */
  85 static void *z_comp_alloc(unsigned char *options, int opt_len)
  86 {
  87         struct ppp_deflate_state *state;
  88         int w_size;
  89
  90         if (opt_len != CILEN_DEFLATE ||
  91             (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) ||
  92             options[1] != CILEN_DEFLATE ||
  93             DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL ||
  94             options[3] != DEFLATE_CHK_SEQUENCE)
  95                 return NULL;
  96         w_size = DEFLATE_SIZE(options[2]);
  97         if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
  98                 return NULL;
  99
 100         state = kzalloc(sizeof(*state),
 101                                                      GFP_KERNEL);
 102         if (state == NULL)
 103                 return NULL;
 104
 105         state->strm.next_in   = NULL;
 106         state->w_size         = w_size;
 107         state->strm.workspace = vmalloc(zlib_deflate_workspacesize(-w_size, 8));
 108         if (state->strm.workspace == NULL)
 109                 goto out_free;
 110
 111         if (zlib_deflateInit2(&state->strm, Z_DEFAULT_COMPRESSION,
 112                          DEFLATE_METHOD_VAL, -w_size, 8, Z_DEFAULT_STRATEGY)
 113             != Z_OK)
 114                 goto out_free;
 115         return (void *) state;
 116
 117 out_free:
 118         z_comp_free(state);
 119         return NULL;
 120 }
 121
 122 /**
 123  *      z_comp_init - initialize a previously-allocated compressor.
 124  *      @arg:   pointer to the private state for the compressor
 125  *      @options: pointer to the CCP option data describing the
 126  *              compression that was negotiated with the peer
 127  *      @opt_len: length of the CCP option data at @options
 128  *      @unit:  PPP unit number for diagnostic messages
 129  *      @hdrlen: ignored (present for backwards compatibility)
 130  *      @debug: debug flag; if non-zero, debug messages are printed.
 131  *
 132  *      The CCP options described by @options must match the options
 133  *      specified when the compressor was allocated.  The compressor
 134  *      history is reset.  Returns 0 for failure (CCP options don't
 135  *      match) or 1 for success.
 136  */
 137 static int z_comp_init(void *arg, unsigned char *options, int opt_len,
 138                        int unit, int hdrlen, int debug)
 139 {
 140         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 141
 142         if (opt_len < CILEN_DEFLATE ||
 143             (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) ||
 144             options[1] != CILEN_DEFLATE ||
 145             DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL ||
 146             DEFLATE_SIZE(options[2]) != state->w_size ||
 147             options[3] != DEFLATE_CHK_SEQUENCE)
 148                 return 0;
 149
 150         state->seqno = 0;
 151         state->unit  = unit;
 152         state->debug = debug;
 153
 154         zlib_deflateReset(&state->strm);
 155
 156         return 1;
 157 }
 158
 159 /**
 160  *      z_comp_reset - reset a previously-allocated compressor.
 161  *      @arg:   pointer to private state for the compressor.
 162  *
 163  *      This clears the history for the compressor and makes it
 164  *      ready to start emitting a new compressed stream.
 165  */
 166 static void z_comp_reset(void *arg)
 167 {
 168         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 169
 170         state->seqno = 0;
 171         zlib_deflateReset(&state->strm);
 172 }
 173
 174 /**
 175  *      z_compress - compress a PPP packet with Deflate compression.
 176  *      @arg:   pointer to private state for the compressor
 177  *      @rptr:  uncompressed packet (input)
 178  *      @obuf:  compressed packet (output)
 179  *      @isize: size of uncompressed packet
 180  *      @osize: space available at @obuf
 181  *
 182  *      Returns the length of the compressed packet, or 0 if the
 183  *      packet is incompressible.
 184  */
 185 static int z_compress(void *arg, unsigned char *rptr, unsigned char *obuf,
 186                int isize, int osize)
 187 {
 188         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 189         int r, proto, off, olen, oavail;
 190         unsigned char *wptr;
 191
 192         /*
 193          * Check that the protocol is in the range we handle.
 194          */
 195         proto = PPP_PROTOCOL(rptr);
 196         if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
 197                 return 0;
 198
 199         /* Don't generate compressed packets which are larger than
 200            the uncompressed packet. */
 201         if (osize > isize)
 202                 osize = isize;
 203
 204         wptr = obuf;
 205
 206         /*
 207          * Copy over the PPP header and store the 2-byte sequence number.
 208          */
 209         wptr[0] = PPP_ADDRESS(rptr);
 210         wptr[1] = PPP_CONTROL(rptr);
 211         put_unaligned_be16(PPP_COMP, wptr + 2);
 212         wptr += PPP_HDRLEN;
 213         put_unaligned_be16(state->seqno, wptr);
 214         wptr += DEFLATE_OVHD;
 215         olen = PPP_HDRLEN + DEFLATE_OVHD;
 216         state->strm.next_out = wptr;
 217         state->strm.avail_out = oavail = osize - olen;
 218         ++state->seqno;
 219
 220         off = (proto > 0xff) ? 2 : 3;   /* skip 1st proto byte if 0 */
 221         rptr += off;
 222         state->strm.next_in = rptr;
 223         state->strm.avail_in = (isize - off);
 224
 225         for (;;) {
 226                 r = zlib_deflate(&state->strm, Z_PACKET_FLUSH);
 227                 if (r != Z_OK) {
 228                         if (state->debug)
 229                                 printk(KERN_ERR
 230                                        "z_compress: deflate returned %d\n", r);
 231                         break;
 232                 }
 233                 if (state->strm.avail_out == 0) {
 234                         olen += oavail;
 235                         state->strm.next_out = NULL;
 236                         state->strm.avail_out = oavail = 1000000;
 237                 } else {
 238                         break;          /* all done */
 239                 }
 240         }
 241         olen += oavail - state->strm.avail_out;
 242
 243         /*
 244          * See if we managed to reduce the size of the packet.
 245          */
 246         if (olen < isize && olen <= osize) {
 247                 state->stats.comp_bytes += olen;
 248                 state->stats.comp_packets++;
 249         } else {
 250                 state->stats.inc_bytes += isize;
 251                 state->stats.inc_packets++;
 252                 olen = 0;
 253         }
 254         state->stats.unc_bytes += isize;
 255         state->stats.unc_packets++;
 256
 257         return olen;
 258 }
 259
 260 /**
 261  *      z_comp_stats - return compression statistics for a compressor
 262  *              or decompressor.
 263  *      @arg:   pointer to private space for the (de)compressor
 264  *      @stats: pointer to a struct compstat to receive the result.
 265  */
 266 static void z_comp_stats(void *arg, struct compstat *stats)
 267 {
 268         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 269
 270         *stats = state->stats;
 271 }
 272
 273 /**
 274  *      z_decomp_free - Free the memory used by a decompressor.
 275  *      @arg:   pointer to private space for the decompressor.
 276  */
 277 static void z_decomp_free(void *arg)
 278 {
 279         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 280
 281         if (state) {
 282                 vfree(state->strm.workspace);
 283                 kfree(state);
 284         }
 285 }
 286
 287 /**
 288  *      z_decomp_alloc - allocate space for a decompressor.
 289  *      @options: pointer to CCP option data
 290  *      @opt_len: length of the CCP option at @options.
 291  *
 292  *      The @options pointer points to the a buffer containing the
 293  *      CCP option data for the compression being negotiated.  It is
 294  *      formatted according to RFC1979, and describes the window
 295  *      size that we are requesting the peer to use in compressing
 296  *      data to be sent to us.
 297  *
 298  *      Returns the pointer to the private state for the decompressor,
 299  *      or NULL if we could not allocate enough memory.
 300  */
 301 static void *z_decomp_alloc(unsigned char *options, int opt_len)
 302 {
 303         struct ppp_deflate_state *state;
 304         int w_size;
 305
 306         if (opt_len != CILEN_DEFLATE ||
 307             (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) ||
 308             options[1] != CILEN_DEFLATE ||
 309             DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL ||
 310             options[3] != DEFLATE_CHK_SEQUENCE)
 311                 return NULL;
 312         w_size = DEFLATE_SIZE(options[2]);
 313         if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
 314                 return NULL;
 315
 316         state = kzalloc(sizeof(*state), GFP_KERNEL);
 317         if (state == NULL)
 318                 return NULL;
 319
 320         state->w_size         = w_size;
 321         state->strm.next_out  = NULL;
 322         state->strm.workspace = vmalloc(zlib_inflate_workspacesize());
 323         if (state->strm.workspace == NULL)
 324                 goto out_free;
 325
 326         if (zlib_inflateInit2(&state->strm, -w_size) != Z_OK)
 327                 goto out_free;
 328         return (void *) state;
 329
 330 out_free:
 331         z_decomp_free(state);
 332         return NULL;
 333 }
 334
 335 /**
 336  *      z_decomp_init - initialize a previously-allocated decompressor.
 337  *      @arg:   pointer to the private state for the decompressor
 338  *      @options: pointer to the CCP option data describing the
 339  *              compression that was negotiated with the peer
 340  *      @opt_len: length of the CCP option data at @options
 341  *      @unit:  PPP unit number for diagnostic messages
 342  *      @hdrlen: ignored (present for backwards compatibility)
 343  *      @mru:   maximum length of decompressed packets
 344  *      @debug: debug flag; if non-zero, debug messages are printed.
 345  *
 346  *      The CCP options described by @options must match the options
 347  *      specified when the decompressor was allocated.  The decompressor
 348  *      history is reset.  Returns 0 for failure (CCP options don't
 349  *      match) or 1 for success.
 350  */
 351 static int z_decomp_init(void *arg, unsigned char *options, int opt_len,
 352                          int unit, int hdrlen, int mru, int debug)
 353 {
 354         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 355
 356         if (opt_len < CILEN_DEFLATE ||
 357             (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) ||
 358             options[1] != CILEN_DEFLATE ||
 359             DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL ||
 360             DEFLATE_SIZE(options[2]) != state->w_size ||
 361             options[3] != DEFLATE_CHK_SEQUENCE)
 362                 return 0;
 363
 364         state->seqno = 0;
 365         state->unit  = unit;
 366         state->debug = debug;
 367         state->mru   = mru;
 368
 369         zlib_inflateReset(&state->strm);
 370
 371         return 1;
 372 }
 373
 374 /**
 375  *      z_decomp_reset - reset a previously-allocated decompressor.
 376  *      @arg:   pointer to private state for the decompressor.
 377  *
 378  *      This clears the history for the decompressor and makes it
 379  *      ready to receive a new compressed stream.
 380  */
 381 static void z_decomp_reset(void *arg)
 382 {
 383         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 384
 385         state->seqno = 0;
 386         zlib_inflateReset(&state->strm);
 387 }
 388
 389 /**
 390  *      z_decompress - decompress a Deflate-compressed packet.
 391  *      @arg:   pointer to private state for the decompressor
 392  *      @ibuf:  pointer to input (compressed) packet data
 393  *      @isize: length of input packet
 394  *      @obuf:  pointer to space for output (decompressed) packet
 395  *      @osize: amount of space available at @obuf
 396  *
 397  * Because of patent problems, we return DECOMP_ERROR for errors
 398  * found by inspecting the input data and for system problems, but
 399  * DECOMP_FATALERROR for any errors which could possibly be said to
 400  * be being detected "after" decompression.  For DECOMP_ERROR,
 401  * we can issue a CCP reset-request; for DECOMP_FATALERROR, we may be
 402  * infringing a patent of Motorola's if we do, so we take CCP down
 403  * instead.
 404  *
 405  * Given that the frame has the correct sequence number and a good FCS,
 406  * errors such as invalid codes in the input most likely indicate a
 407  * bug, so we return DECOMP_FATALERROR for them in order to turn off
 408  * compression, even though they are detected by inspecting the input.
 409  */
 410 static int z_decompress(void *arg, unsigned char *ibuf, int isize,
 411                  unsigned char *obuf, int osize)
 412 {
 413         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 414         int olen, seq, r;
 415         int decode_proto, overflow;
 416         unsigned char overflow_buf[1];
 417
 418         if (isize <= PPP_HDRLEN + DEFLATE_OVHD) {
 419                 if (state->debug)
 420                         printk(KERN_DEBUG "z_decompress%d: short pkt (%d)\n",
 421                                state->unit, isize);
 422                 return DECOMP_ERROR;
 423         }
 424
 425         /* Check the sequence number. */
 426         seq = get_unaligned_be16(ibuf + PPP_HDRLEN);
 427         if (seq != (state->seqno & 0xffff)) {
 428                 if (state->debug)
 429                         printk(KERN_DEBUG "z_decompress%d: bad seq # %d, expected %d\n",
 430                                state->unit, seq, state->seqno & 0xffff);
 431                 return DECOMP_ERROR;
 432         }
 433         ++state->seqno;
 434
 435         /*
 436          * Fill in the first part of the PPP header.  The protocol field
 437          * comes from the decompressed data.
 438          */
 439         obuf[0] = PPP_ADDRESS(ibuf);
 440         obuf[1] = PPP_CONTROL(ibuf);
 441         obuf[2] = 0;
 442
 443         /*
 444          * Set up to call inflate.  We set avail_out to 1 initially so we can
 445          * look at the first byte of the output and decide whether we have
 446          * a 1-byte or 2-byte protocol field.
 447          */
 448         state->strm.next_in = ibuf + PPP_HDRLEN + DEFLATE_OVHD;
 449         state->strm.avail_in = isize - (PPP_HDRLEN + DEFLATE_OVHD);
 450         state->strm.next_out = obuf + 3;
 451         state->strm.avail_out = 1;
 452         decode_proto = 1;
 453         overflow = 0;
 454
 455         /*
 456          * Call inflate, supplying more input or output as needed.
 457          */
 458         for (;;) {
 459                 r = zlib_inflate(&state->strm, Z_PACKET_FLUSH);
 460                 if (r != Z_OK) {
 461                         if (state->debug)
 462                                 printk(KERN_DEBUG "z_decompress%d: inflate returned %d (%s)\n",
 463                                        state->unit, r, (state->strm.msg? state->strm.msg: ""));
 464                         return DECOMP_FATALERROR;
 465                 }
 466                 if (state->strm.avail_out != 0)
 467                         break;          /* all done */
 468                 if (decode_proto) {
 469                         state->strm.avail_out = osize - PPP_HDRLEN;
 470                         if ((obuf[3] & 1) == 0) {
 471                                 /* 2-byte protocol field */
 472                                 obuf[2] = obuf[3];
 473                                 --state->strm.next_out;
 474                                 ++state->strm.avail_out;
 475                         }
 476                         decode_proto = 0;
 477                 } else if (!overflow) {
 478                         /*
 479                          * We've filled up the output buffer; the only way to
 480                          * find out whether inflate has any more characters
 481                          * left is to give it another byte of output space.
 482                          */
 483                         state->strm.next_out = overflow_buf;
 484                         state->strm.avail_out = 1;
 485                         overflow = 1;
 486                 } else {
 487                         if (state->debug)
 488                                 printk(KERN_DEBUG "z_decompress%d: ran out of mru\n",
 489                                        state->unit);
 490                         return DECOMP_FATALERROR;
 491                 }
 492         }
 493
 494         if (decode_proto) {
 495                 if (state->debug)
 496                         printk(KERN_DEBUG "z_decompress%d: didn't get proto\n",
 497                                state->unit);
 498                 return DECOMP_ERROR;
 499         }
 500
 501         olen = osize + overflow - state->strm.avail_out;
 502         state->stats.unc_bytes += olen;
 503         state->stats.unc_packets++;
 504         state->stats.comp_bytes += isize;
 505         state->stats.comp_packets++;
 506
 507         return olen;
 508 }
 509
 510 /**
 511  *      z_incomp - add incompressible input data to the history.
 512  *      @arg:   pointer to private state for the decompressor
 513  *      @ibuf:  pointer to input packet data
 514  *      @icnt:  length of input data.
 515  */
 516 static void z_incomp(void *arg, unsigned char *ibuf, int icnt)
 517 {
 518         struct ppp_deflate_state *state = (struct ppp_deflate_state *) arg;
 519         int proto, r;
 520
 521         /*
 522          * Check that the protocol is one we handle.
 523          */
 524         proto = PPP_PROTOCOL(ibuf);
 525         if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
 526                 return;
 527
 528         ++state->seqno;
 529
 530         /*
 531          * We start at the either the 1st or 2nd byte of the protocol field,
 532          * depending on whether the protocol value is compressible.
 533          */
 534         state->strm.next_in = ibuf + 3;
 535         state->strm.avail_in = icnt - 3;
 536         if (proto > 0xff) {
 537                 --state->strm.next_in;
 538                 ++state->strm.avail_in;
 539         }
 540
 541         r = zlib_inflateIncomp(&state->strm);
 542         if (r != Z_OK) {
 543                 /* gak! */
 544                 if (state->debug) {
 545                         printk(KERN_DEBUG "z_incomp%d: inflateIncomp returned %d (%s)\n",
 546                                state->unit, r, (state->strm.msg? state->strm.msg: ""));
 547                 }
 548                 return;
 549         }
 550
 551         /*
 552          * Update stats.
 553          */
 554         state->stats.inc_bytes += icnt;
 555         state->stats.inc_packets++;
 556         state->stats.unc_bytes += icnt;
 557         state->stats.unc_packets++;
 558 }
 559
 560 /*************************************************************
 561  * Module interface table
 562  *************************************************************/
 563
 564 /* These are in ppp_generic.c */
 565 extern int  ppp_register_compressor   (struct compressor *cp);
 566 extern void ppp_unregister_compressor (struct compressor *cp);
 567
 568 /*
 569  * Procedures exported to if_ppp.c.
 570  */
 571 static struct compressor ppp_deflate = {
 572         .compress_proto =       CI_DEFLATE,
 573         .comp_alloc =           z_comp_alloc,
 574         .comp_free =            z_comp_free,
 575         .comp_init =            z_comp_init,
 576         .comp_reset =           z_comp_reset,
 577         .compress =             z_compress,
 578         .comp_stat =            z_comp_stats,
 579         .decomp_alloc =         z_decomp_alloc,
 580         .decomp_free =          z_decomp_free,
 581         .decomp_init =          z_decomp_init,
 582         .decomp_reset =         z_decomp_reset,
 583         .decompress =           z_decompress,
 584         .incomp =               z_incomp,
 585         .decomp_stat =          z_comp_stats,
 586         .owner =                THIS_MODULE
 587 };
 588
 589 static struct compressor ppp_deflate_draft = {
 590         .compress_proto =       CI_DEFLATE_DRAFT,
 591         .comp_alloc =           z_comp_alloc,
 592         .comp_free =            z_comp_free,
 593         .comp_init =            z_comp_init,
 594         .comp_reset =           z_comp_reset,
 595         .compress =             z_compress,
 596         .comp_stat =            z_comp_stats,
 597         .decomp_alloc =         z_decomp_alloc,
 598         .decomp_free =          z_decomp_free,
 599         .decomp_init =          z_decomp_init,
 600         .decomp_reset =         z_decomp_reset,
 601         .decompress =           z_decompress,
 602         .incomp =               z_incomp,
 603         .decomp_stat =          z_comp_stats,
 604         .owner =                THIS_MODULE
 605 };
 606
 607 static int __init deflate_init(void)
 608 {
 609         int rc;
 610
 611         rc = ppp_register_compressor(&ppp_deflate);
 612         if (rc)
 613                 return rc;
 614
 615         rc = ppp_register_compressor(&ppp_deflate_draft);
 616         if (rc) {
 617                 ppp_unregister_compressor(&ppp_deflate);
 618                 return rc;
 619         }
 620
 621         pr_info("PPP Deflate Compression module registered\n");
 622         return 0;
 623 }
 624
 625 static void __exit deflate_cleanup(void)
 626 {
 627         ppp_unregister_compressor(&ppp_deflate);
 628         ppp_unregister_compressor(&ppp_deflate_draft);
 629 }
 630
 631 module_init(deflate_init);
 632 module_exit(deflate_cleanup);
 633 MODULE_LICENSE("Dual BSD/GPL");
 634 MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE));
 635 MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE_DRAFT));