Stability | experimental |
---|

The module provides k of n encoding - a way to generate (n - k) secondary blocks of data from k primary blocks such that any k blocks (primary or secondary) are sufficient to regenerate all blocks.

All blocks must be the same length and you need to keep track of which blocks you have in order to tell decode. By convention, the blocks are numbered 0..(n - 1) and blocks numbered < k are the primary blocks.

- data FECParams
- fec :: Int -> Int -> FECParams
- encode :: FECParams -> [ByteString] -> [ByteString]
- decode :: FECParams -> [(Int, ByteString)] -> [ByteString]
- secureDivide :: Int -> ByteString -> IO [ByteString]
- secureCombine :: [ByteString] -> ByteString
- enFEC :: Int -> Int -> ByteString -> [ByteString]
- deFEC :: Int -> Int -> [ByteString] -> ByteString

# Documentation

Return a FEC with the given parameters.

:: FECParams | |

-> [ByteString] | a list of |

-> [ByteString] | (n - k) output blocks |

Generate the secondary blocks from a list of the primary blocks. The
primary blocks must be in order and all of the same size. There must be
`k`

primary blocks.

:: FECParams | |

-> [(Int, ByteString)] | a list of |

-> [ByteString] | a list the |

Recover the primary blocks from a list of `k`

blocks. Each block must be
tagged with its number (see the module comments about block numbering)

# Utility functions

:: Int | the number of parts requested |

-> ByteString | the data to be split |

-> IO [ByteString] |

Break a ByteString into `n`

parts, equal in length to the original, such
that all `n`

are required to reconstruct the original, but having less
than `n`

parts reveals no information about the orginal.

This code works in IO monad because it needs a source of random bytes,
which it gets from *dev*urandom. If this file doesn't exist an
exception results

Not terribly fast - probably best to do it with short inputs (e.g. an encryption key)

secureCombine :: [ByteString] -> ByteStringSource

Reverse the operation of secureDivide. The order of the inputs doesn't matter, but they must all be the same length

:: Int | the number of blocks required to reconstruct |

-> Int | the total number of blocks |

-> ByteString | the data to divide |

-> [ByteString] | the resulting blocks |

A utility function which takes an arbitary input and FEC encodes it into a
number of blocks. The order the resulting blocks doesn't matter so long
as you have enough to present to `deFEC`

.

:: Int | the number of blocks required (matches call to |

-> Int | the total number of blocks (matches call to |

-> [ByteString] | a list of k, or more, blocks from |

-> ByteString |

Reverses the operation of `enFEC`

.