TODO

TODO LIST
=========

- message spool list
    - Data structure:
        1) hash(sec) -> list(nanosec)
             - insert:
                 1) search second O(1)
                 2) 
        2) megalist(sec,nanosec)
            - insert
        3) 2-3-4 tree
           http://en.wikipedia.org/wiki/2-3-4_tree
        4) B-TREE
           http://en.wikipedia.org/wiki/B-tree

- for log use mechanisms such __builtin_va_arg_pack()
- implement main loop in another way:
    current situation:
      - two types of loops
          - send
          - receive
          - wtf is a listener?
      - receive loops depend on a flag mutex, so they are blocked indefinetely
        until a message arrives.
    desired situation:
      - only one type of thread? or three? four? five?
      - timer management easier for threads
      - thread config more homogeneus.
          - perhaps config hashtable?
- allow to choose seq generation algorithm for tcpraw thread.
- tcpopen:
    - integrate send function.
    - delay packets (to exploit better timeout)
- tcpraw:
    - set window to 0, and persisting.
    - acknowledge before receive.
    - zero window after syn+ack (test demostrated more than 350sec FIN1_WAIT)
- stress tests
- implement include statement
- ack acked:
    1) syn + sack + ack
    2) send req
    3) ack first bytes (A)
    4) ack more bytes (B)
    5) ack again A bytes
- monkey in the middle
- slow loris
- delayed send
    - possible solutions
        - sender thread with queue and signaling
            - pros:
              - easy to implement
            - contras:
              - memory bandwith
              - another queue and another thread
              - throughtput?

        - internal thread implementation
            - pro:
              - difficult to mix 'mqueue' with 'delayed send'
              - fast (if possible to implement)
            - contras:
              - how to wake thread when time comes up?
              - for each thread another "specialized" implementation?