diff -uNr a/makefile b/makefile
--- a/makefile 61ff0ac23d53c7a2b8a2b221933ab0178457071cca1f024df8f30de6de8d394ecf1c58ce1636a7ad4dd7186ee4922714a7cd0a01aae34482653fbb5f1e513e5d
+++ b/makefile 8f9474f32279f09c4b5be90960f08b2ee20e69ba12fb3ebac5e47508325b3d2bb886e6d94f789e1764e7c177922a9951ceac9951e36a83383f313b73ec0396af
@@ -2,13 +2,12 @@
 .SUFFIXES:
 
 OUT        := smalpest
-CFLAGS     := -std=c99 -O3 -DNDEBUG -fdata-sections -ffunction-sections -Wno-parentheses
+CFLAGS     := -std=c99 -O3 -DNDEBUG  -fdata-sections -ffunction-sections -Wno-parentheses
 LDFLAGS    := -static -Wl,--gc-sections
 LDLIBS     := 
 OBJ        := \
 	src/addr.o \
 	src/addrcast.o \
-	src/banner.o \
 	src/black.o \
 	src/chain.o \
 	src/console.o \
@@ -41,6 +40,7 @@
 	src/peerio.o \
 	src/pending.o \
 	src/pest.o \
+	src/prod.o \
 	src/recv.o \
 	src/rekey.o \
 	src/rng.o \
@@ -68,3 +68,4 @@
 clean:
 	rm -f $(OUT)
 	rm -f src/*.o
+	rm -f src/otherpplgode/*.o
diff -uNr a/src/addrcast.c b/src/addrcast.c
--- a/src/addrcast.c 3f8b09bf6a9437da1e4ddf3d58a3f6f6fd7a61308ea17295d1a24a41196744f1ee1bee3949d529138f04946ebd2b738713f8aa65fbc577adc2afb32b1df8b099
+++ b/src/addrcast.c 5ebbd1681a9011936ddd5be4e1732645c3a7eee8a693d31b2eef50853d2d079bf0e86c3066d45e7e2566653adadb90d55088594087cedb06299e2bb50ca74d6f
@@ -48,7 +48,10 @@
 
   ac_black_ciph(ab,ar,pk->ciph_serp);
   ac_black_sign(ab,pk->key.sub.sign);
-  memset(ab+AC_BPAD_OFF,0x00,AC_BPAD_SIZE);
+
+  if(!rng_read(rng_fast_fd,ab+AC_BPAD_OFF,AC_BPAD_SIZE)){
+    return 0;
+  }
 
   stamp = mono_sec();
 
@@ -56,46 +59,78 @@
   return send_text(CMD_ADDRESSCAST,stamp,ab,sizeof(ab),0,0);
 }
 
-static void ac_red_write(uint8_t *ar,addr_t const *addr){
-  uint32_t cmd = 0;
-  uint32_t ip  = byteswap32(addr->ip);
+static bool ac_red_write(uint8_t *ar,addr_t const *addr){
+  uint32_t cmd  = 0;
+  uint16_t port = addr->port;
+  uint32_t ip   = byteswap32(addr->ip);
+
+  if(!rng_read(rng_fast_fd,ar+AC_NONCE_OFF,AC_NONCE_SIZE)){
+    return 0;
+  }
 
   write_u32(ar+AC_CMD_OFF,  &cmd);
-  write_u16(ar+AC_PORT_OFF, &addr->port);
+  write_u16(ar+AC_PORT_OFF, &port);
   write_u32(ar+AC_IP_OFF,   &ip);
-  memset(ar+AC_RPAD_OFF,0x00,AC_RPAD_SIZE);
+
+  if(!rng_read(rng_fast_fd,ar+AC_RPAD_OFF,AC_RPAD_SIZE)){
+    return 0;
+  }
+
+  return 1;
 }
 
-static void ac_red_read(uint8_t const *ar,addr_t *addr){
-  read_u16(ar+AC_PORT_OFF, &addr->port);
-  read_u32(ar+AC_IP_OFF,   &addr->ip);
-  addr->ip = byteswap32(addr->ip);
+static bool ac_red_read(uint8_t const *ar,addr_t *addr){
+  uint32_t cmd;
+  uint16_t port;
+  uint32_t ip;
+
+  read_u32(ar+AC_CMD_OFF,  &cmd);
+  read_u16(ar+AC_PORT_OFF, &port);
+  read_u32(ar+AC_IP_OFF,   &ip);
+
+  if(cmd != 0) return 0;
+
+  addr->port  = port;
+  addr->ip    = byteswap32(ip);
+  return 1;
 }
 
-void addrcast_broadcast(uint64_t time){
+void addrcast_broadcast(peer_t *p){
   uint8_t ar[AC_RED_SIZE];
-  addr_t  addr;
 
-  if(time < addrcast_last+acint) return;
+  if(addr_null(&acaddr)) return;
 
-  if(!*acaddr) return;
-  if(!addr_from_at(&addr,acaddr)){
-    irclog_err("address cast knob contains invalid address: "
-               "'%s' (format is ip:port)",acaddr);
-    addrcast_last = time;
+  if(!ac_red_write(ar,&acaddr)){
+    irclog_err("failed to create address cast");
     return;
   }
 
-  if(addrcast_last != 0){
-    ac_red_write(ar,&addr);
+  if(p){
+    if(!p->active &&
+       !p->paused &&
+       p->key_cnt > 0){
+      ac_send(ar,p);
+    }
+  }else{
     for(size_t x = 0;x < peer_cnt;x++){
       peer_t *p = peer+x;
-      if(!peer_cansend(p,0)) continue;
+      if(p->active)       continue;
+      if(p->paused)       continue;
+      if(p->key_cnt == 0) continue;
       ac_send(ar,p);
     }
-    BUF_ZERO(ar);
   }
 
+  BUF_ZERO(ar);
+}
+
+void addrcast_periodic(uint64_t time){
+  if(addrcast_last == 0) goto ret;
+  if(time < addrcast_last+acint) return;
+
+  addrcast_broadcast(0);
+
+ret:
   addrcast_last = time;
 }
 
@@ -110,7 +145,9 @@
 
   for(size_t x = 0;x < peer_cnt;x++){
     peer_t *p = peer+peer_idx[x];
-    //if(p->paused) continue; //TODO: ?
+
+    if(p->paused) continue;
+    if(p->active) continue;
 
     for(size_t y = 0;y < p->key_cnt;y++){
       pkey_t *pk = p->key+y;
@@ -123,27 +160,36 @@
   return 0;
 }
 
-static void ac_handle(uint8_t const *ab,char const *speaker){
+//ret 1 if im recipent
+static bool ac_handle(uint8_t const *ab,char const *speaker){
   uint8_t   ar[AC_RED_SIZE];
   peer_t   *p;
   pkey_t   *pk;
   addr_t    addr;
 
   if(!find_key(ab,&p,&pk)){
-    return;
+    return 0;
   }
 
   if(peer_lookup_noerr(speaker) != p){
-    return;
+    log_err("speaker mismatch in address cast received from peer '%s'",
+            p->handle[0]);
+    return 1;
   }
 
   ac_black_deciph(ar,ab,pk->ciph_serp);
-  ac_red_read(ar,&addr);
+  if(!ac_red_read(ar,&addr)){
+    log_err("nonzero address cast command received from peer '%s'",
+            p->handle[0]);
+    return 1;
+  }
   BUF_ZERO(ar);
 
   if(!addr_equal(&p->addr,&addr)){
     peer_addr_set(p,&addr,0);
+    prod_send(p,PROD_FLAG_REQANS);
   }
+  return 1;
 }
 
 void addrcast_handle(uint8_t       *r,
@@ -153,7 +199,9 @@
 
   uint8_t const *m  = r+MESSAGE_OFF;
   uint8_t const *ab = m+TEXT_OFF;
-  ac_handle(ab,speaker);
-  red_rebroadcast(r,hash,bounces);
+
+  if(!ac_handle(ab,speaker)){
+    red_rebroadcast(r,hash,bounces);
+  }
 }
 
diff -uNr a/src/banner.c b/src/banner.c
--- a/src/banner.c a2184cbe694780fc432a260a0850972fd75240d93b4ac4f8dd8fa5b9bf42e31529063612b1aef45e64a8782fb3385525c487b60a6d7b8b4a5c20f512035a0075
+++ b/src/banner.c false
@@ -1,45 +0,0 @@
-#include "pest.h"
-#include "packet.h"
-#include "peer.h"
-#include "log.h"
-#include "time.h"
-#include "util.h"
-#include "utf8.h"
-#include "state.h"
-#include <string.h>
-#include <assert.h>
-
-void banner_handle(peer_t *p,uint8_t const *m){
-  char banner[BANNER_BUF];
-
-  //TODO: vat do vith this
-  cpy_text(banner,sizeof(banner),m);
-
-  if(!utf8_valid(banner)){
-    log_err("banner from peer '%s' contains invalid UTF-8 sequence",
-            p->handle[0]);
-    return;
-  }
-
-  if(strcmp(banner,p->banner) != 0){
-    peer_banner_set(p,banner);
-  }
-}
-
-void banner_broadcast(uint64_t time){
-  uint64_t        stamp;
-  char const     *text;
-  size_t          text_len;
-
-  if(time < banner_last+baint) return;
-
-  if(banner_last != 0){
-    stamp     = mono_sec();
-    text      = *banner ? banner : PROG_FULLERNAME;
-    text_len  = strlen(text);
-    send_text(CMD_BANNER,stamp,(uint8_t const *)text,text_len,0,0);
-  }
-
-  banner_last = time;
-}
-
diff -uNr a/src/config.h b/src/config.h
--- a/src/config.h 6b094b264c5e4e31d80f16998d83a1b9eb444b81245319e790db98e6573a593dfabf9dff739ca18c7b7ede6b9cd5b53c9c6cdd8e76584b0aa5c9be52b04d2904
+++ b/src/config.h d158a0f38f06cf7e47d6b963bc2dbed1d18b6ececed955fc7adf635b5c57bd1e056ccf043099f5583796289ec1249fae28181cc655710b46d663f43fa5b1e941
@@ -6,11 +6,8 @@
 #define STACK_WIPE_SIZE       (4*MEGABYTE)    //amount of stack to zeroize/randomize
 //#define BIG_ENDIAN            //system endianess
 
-#define NET_SILENT_SLEEP     10 //milliseconds to sleep when no tcp/udp
 #define NET_RETRY_SLEEP    1000 //milliseconds to sleep when cant listen tcp/udp
-#define IRCD_RECV_MAX         4 //max number of recvs before yield to udp
-#define PEST_RECV_MAX        32 //max number of recvs before yield to tcp
-#define PEST_WAIT_IRC        10 //number of seconds to wait for irc connection before fire up pest
+#define PEST_WAIT_IRC           //disable pestron unless irctron is connected
 
 #define PEER_MAX             64 //max number of peers
 #define KILLFILE_MAX         64 //max number of entries in killfile
@@ -35,7 +32,7 @@
 
 #define LOG_STAMP_FMT         "%F %T"   //stamp format for log output
 #define LOG_HASH_BYTES        4 //number of least significant bytes of sha256 to display in log
-#define LOG_ANSI_COLORS         //use ansi colors for packet log output
+//#define LOG_ANSI_COLORS       //use ansi colors for packet log output
 #define LOG_COLLAPSE            //collapse broadcast messages into one log entry
 //#define LOG_MARTIAN           //log martian packets
 //#define LOG_STALE             //log stale (invalid timestamp) packets
diff -uNr a/src/crypto.h b/src/crypto.h
--- a/src/crypto.h 3a3b59be0a98bf4ea49825354a2f0533dfca9f6d92631043d24715e2460276b80a4a6d90d5476d8a41f3ec6e8a8ab4a837b881476c03dd397c52d3474ad81154
+++ b/src/crypto.h b32c1a7403579c7bc4e1633e0e6e2918ba4ed6b9f0a27c9081323907b2fb1076a9c3063618faf6e4a6ff7a40a1a0d04e035af4bc7ef93e9e3f10987d3dbc2dab
@@ -23,7 +23,7 @@
 size_t              base64_enc        (uint8_t const *in,size_t in_size,char *out,size_t out_size);
 
 int                 rng_open          (char const *path);
-void                rng_close         (int fd);
+void                rng_close         (int *fd);
 bool                rng_read          (int fd,void *data,size_t size);
 bool                rng_read_nolog    (int fd,void *data,size_t size);
 
diff -uNr a/src/def.h b/src/def.h
--- a/src/def.h 1638ad2755d86caee6036468b97b9daac5b734ac339b5cfc39e7ab9215fdd54533d1ba203e325aee144083bc5faf3eb67f3901f32b59e7e74f2fac6308228445
+++ b/src/def.h 8b67d10d27a52d09ef868470e74be25b7dcea6adec5854e34380683017b05511c904af79f11d6e962713d558ca543cfdd4712c1077d9e8f2fec0a3796b081967
@@ -2,7 +2,7 @@
 #define DEF_H
 
 #define PROG_NAME                       "smalpest"
-#define PROG_VERSION                    "97K"
+#define PROG_VERSION                    "96K"
 #define PROG_FULLNAME                   PROG_NAME "-" PROG_VERSION
 #define PROG_FULLERNAME                 PROG_FULLNAME " (spec " STR(PEST_VERSION) ")"
 
@@ -39,8 +39,7 @@
 #define FILE_RKINT                      "rkint"
 #define FILE_IGINT                      "igint"
 #define FILE_BANNER                     "banner"
-#define FILE_BAINT                      "baint"
-#define FILE_ACADDR                     "acaddr"
+#define FILE_PRODINT                    "prodint"
 #define FILE_ACINT                      "acint"
 #define FILE_IRCTIME                    "irctime"
 #define FILE_MASTER                     "master"
@@ -89,6 +88,8 @@
 #define PEER_ID_INVALID                 ((peerid_t)-1)
 #define B64_KEY_LEN                     BASE64_ENC_SIZE(KEY_SIZE,0)
 
+#define POLL_TIMEOUT                  100 //msec
+
 #define KNOB_VAL_LEN                  511
 #define KNOB_MIN                        INT64_MIN
 #define KNOB_MAX                        INT64_MAX
@@ -163,6 +164,12 @@
 };
 
 enum{
+  IDX_UDP,
+  IDX_TCP,
+  POLL_FD_N,
+};
+
+enum{
   TCP_CONNECT,
   TCP_DISCONNECT,
 };
diff -uNr a/src/ircd.c b/src/ircd.c
--- a/src/ircd.c a19d47e908d15f7719d74c87bfe84bc037a0fd2bfb3d4c97d3fad4e8fd4ef25cf275650e3f01005f40f8cb7a2398396ab60af6a0578e0fb1cedc81ad7b450b39
+++ b/src/ircd.c f88560d1f8dd1347622312cc8938b7e2aacc0613f6dc73f14968b02bfb851174d64b4e214b3d04ceb05553927b8db082a5874e080ada629388054cac89ab4cfc
@@ -169,10 +169,10 @@
   return 1;
 }
 
-void ircd_tick(void){
-  for(size_t x = 0;x < IRCD_RECV_MAX;x++){
-    if(!ircd_recv()) break;
-  }
+void ircd_tick(bool ready){
+  //vat a piss of shit
+  (void)ready;
+  ircd_recv();
 }
 
 size_t ircd_send(char const *str,size_t len){
diff -uNr a/src/ircd.h b/src/ircd.h
--- a/src/ircd.h e92250adc61344aa6bf843e5a307e7ab709474a89ad32e7224faa856b6d9af75a7f3c06edf3f42f733881daa430dad9e55c954408a5f0a48b82b0df462e1663e
+++ b/src/ircd.h e6d3d8a85966610f6e1b007d77fc1c5e50c3af299215cdfe0345ac7e770f783a3c972115d334960b008a3f35702212871d105c456509743c374bb53864ecb3c2
@@ -11,7 +11,7 @@
 void                ircd_exit   (void);
 void                ircd_ckill  (void);
 
-void                ircd_tick   (void);
+void                ircd_tick   (bool ready);
 
 size_t              ircd_send   (char const *str,size_t len);
 size_t              ircd_sendf  (char const *fmt,...);
diff -uNr a/src/irclog.c b/src/irclog.c
--- a/src/irclog.c 35471ea2fb33bcb3224b02db81dee39c47f2c6d209a3d11698d0cb533bca4c0e6e6b4c42bea3fbb2f107e05e7c9c92c99607cf783f1188b65856be185e2f6a03
+++ b/src/irclog.c 51e7c3d80b875a8ef3da8255bfcf34da1d44ccbda7421949dd65a78e7abd95aff5c8b73298373b3ac0a4ea4a1d7f46254cdcf6901c2611fce79dcd5113c978f7
@@ -24,7 +24,7 @@
     if(!*chan) chan = self_handle;
   }
 
-  b += snprintf(b,e-b,":%s NOTICE %s :%s",IRC_SERV,chan,pre);
+  b += snprintf(b,e-b,":%s NOTICE %s :%s",chan,chan,pre);
   b += vsnprintf(b,e-b,fmt,args);
   b  = strpcpy(b,"\r\n",e);
   ircd_send(buf,b-buf);
diff -uNr a/src/knob.c b/src/knob.c
--- a/src/knob.c 5814f521cdfbc39eee30747d5c2c4248eca748e8f10ec6b7679c5631626c83292517fd0c6c66145b0de149b14b8699ca0cfeea2891c53326142bb9dc198e8009
+++ b/src/knob.c bcfa9c0a1a74b3849b815d93cad3ea653f08854a4027d9e7d6958fd88115615a2bcce0ea5361ac6ae59e6ebb93386254a916cab50efe0997eec9682fce70016b
@@ -111,7 +111,7 @@
   return KNOB_SUCCESS;
 }
 
-static bool storeval_bool(knob_t const *k,char const *path){
+static unsigned storeval_bool(knob_t const *k,char const *path){
   bool const *v = k->data;
   return bool_store(path,*v) ? KNOB_SUCCESS : KNOB_STORE;
 }
@@ -120,7 +120,7 @@
   return bool_load(path,k->data) ? KNOB_SUCCESS : KNOB_LOAD;
 }
 
-static bool storeval_int(knob_t const *k,char const *path){
+static unsigned storeval_int(knob_t const *k,char const *path){
   int64_t const *v = k->data;
   return int_store(path,*v) ? KNOB_SUCCESS : KNOB_STORE;
 }
@@ -135,7 +135,7 @@
   return setval_int(k,buf);
 }
 
-static bool storeval_str(knob_t const *k,char const *path){
+static unsigned storeval_str(knob_t const *k,char const *path){
   char const **v = k->data;
   return str_store(path,*v) ? KNOB_SUCCESS : KNOB_STORE;
 }
diff -uNr a/src/knobs.h b/src/knobs.h
--- a/src/knobs.h a354d299c34ab6e19514c6f81937e945b831ce6e79833b316546ed28ab20c8bc426eab0aa0570fcbd6b5641a5faed67752e8911d10b54f1af6445901ea64fb7b
+++ b/src/knobs.h 40316d36a5187109264269543a93954a51273201978d0ba7ce780a47f8b11d59a108ef150536eb1e766c5352f0eb4134f9e8478a1eab28f79aa5844cbb45bd23
@@ -1,16 +1,8 @@
 static char        *p_banner = banner;
-static char        *p_acaddr = acaddr;
 static char        *p_master = master;
 
 static knob_t const knob[] = {
 
-  { .data       = &setport,
-    .name       = FILE_SETPORT,
-    .desc       = "update source port in addition to ip address in AT entries",
-    .type       = KNOB_BOOL,
-    .def.b      = 1,
-  },
-
   { .data       = &cutoff,
     .name       = FILE_CUTOFF,
     .desc       = "bounce cutoff for rejecting packets",
@@ -53,7 +45,7 @@
     .desc       = "interval in seconds between attempts "
                   "to repair broken chains",
     .type       = KNOB_INT,
-    .def.i      = 10,
+    .def.i      = 60,
     .min        = 1,
     .max        = KNOB_MAX,
   },
@@ -110,38 +102,27 @@
     .max        = sizeof(banner)-1,
   },
 
-  { .data       = &baint,
-    .name       = FILE_BAINT,
-    .desc       = "banner broadcast interval in seconds",
+  { .data       = &prodint,
+    .name       = FILE_PRODINT,
+    .desc       = "periodic prod interval in seconds",
     .type       = KNOB_INT,
-    .def.i      = 600,
+    .def.i      = 60,
     .min        = 1,
     .max        = KNOB_MAX,
   },
 
-  { .data       = &p_acaddr,
-    .name       = FILE_ACADDR,
-    .desc       = "if not '', ip:port that will be "
-                  "transmitted in periodic address casts",
-    .type       = KNOB_STR,
-    .def.s      = "",
-    .min        = 0,
-    .max        = sizeof(acaddr)-1,
-  },
-
   { .data       = &acint,
     .name       = FILE_ACINT,
-    .desc       = "address cast interval in seconds",
+    .desc       = "periodic address cast interval in seconds",
     .type       = KNOB_INT,
-    .def.i      = 600,
+    .def.i      = 60,
     .min        = 1,
     .max        = KNOB_MAX,
   },
 
   { .data       = &irctime,
     .name       = FILE_IRCTIME,
-    .desc       = "timeout in seconds before peer not "
-                  "sending packets parts channel",
+    .desc       = "timeout in seconds before peer becomes cold",
     .type       = KNOB_INT,
     .def.i      = 60,
     .min        = 1,
diff -uNr a/src/main.c b/src/main.c
--- a/src/main.c 61319746c46cbea068b556747f1647dafc2d937c4ab01001970a501db2abd458cea87bb8ed553bcc2dd8aed541952473a0579c8c81747b74fce385efddbb7970
+++ b/src/main.c b90d751f05eaf47373ad1472231b589234e5dfa63e28657d4f9be66dadf4c6ef6fb09dc9a19755b5f7cff9c0b88d020e339cabd7fddbd39b994308d89fd87af4
@@ -6,6 +6,7 @@
 #include "crypto.h"
 #include "io.h"
 #include "log.h"
+#include "net.h"
 #include "util.h"
 #include "string.h"
 #include "time.h"
@@ -50,13 +51,13 @@
   bool      store_pest_port = 0;
   bool      loaded_user     = 0;
   bool      loaded_pass     = 0;
-  uint64_t  time_start;
   uint64_t  time;
   uint64_t  ntime;
+  bool      active;
 
   signal(SIGINT,  term);
   signal(SIGTERM, term);
-  signal(SIGHUP,  term);
+  signal(SIGHUP,  SIG_IGN);
   signal(SIGPIPE, SIG_IGN);
 
   while((opt = getopt(argc,argv,"vhu:p:s:i:q:d:l:")) != -1){
@@ -145,28 +146,29 @@
   rng_fast_fd = rng_open(RNG_FAST_PATH);
   if(rng_slow_fd == -1) return 1;
   if(rng_fast_fd == -1) return 1;
-  
+
   ircd_init(irc_ev);
   if(!pest_init()) return 1;
   log_out(PROG_FULLERNAME " station running");
 
-  time_start = mono_sec();
   while(running){
-    bool active;
     time    = mono_sec();
     ntime   = mono_nsec();
-    active  = irc_joined || time-time_start > PEST_WAIT_IRC;
-    ircd_tick();
-    pest_tick(time,ntime,active);
+#ifdef PEST_WAIT_IRC
+    active  = irc_joined;
+#else
+    active  = 1;
+#endif
+    net_poll();
+    ircd_tick(tcp_ready());
+    pest_tick(udp_ready(),time,ntime,active);
   }
 
   log_out("station shutting down...");
   ircd_exit();
-  rng_close(rng_slow_fd);
-  rng_slow_fd = -1;
+  rng_close(&rng_slow_fd);
   if(!scram){
-    rng_close(rng_fast_fd);
-    rng_fast_fd = -1;
+    rng_close(&rng_fast_fd);
   }
   log_close();
   return 0;
@@ -194,9 +196,8 @@
     }
     state_rand();
     stack_rand();
-    
-    rng_close(rng_fast_fd);
-    rng_fast_fd = -1;
+
+    rng_close(&rng_fast_fd);
   }else{
     state_zero();
     stack_zero();
diff -uNr a/src/net.c b/src/net.c
--- a/src/net.c 5395ca90226939c2badd640df5f7b9e23b11122a4a41effd21009fc2adea7285f4bdf0302f9fe59b4eeb18e2994856ca89fc75f87e47c29c5c160f35c03ded81
+++ b/src/net.c 516b55300c89e33f6cd6a1552bdad2d90f9f87bc9c41a9cabe374838150b558f536187ae7252a9cf7c90c9aa24d154706f6339f3e03f3eeeb099629e69394b5d
@@ -60,7 +60,8 @@
     if(fcntl(udp_fd,F_SETFL,O_NONBLOCK) != 0){
       log_errno("fcntl");
       close(udp_fd);
-      udp_fd = -1;
+      udp_fd              = -1;
+      poll_fd[IDX_UDP].fd = -1;
       return 0;
     }
 
@@ -74,10 +75,13 @@
             sizeof(addr)) != 0){
       log_errno("bind");
       close(udp_fd);
-      udp_fd = -1;
+      udp_fd              = -1;
+      poll_fd[IDX_UDP].fd = -1;
       sleep_nsec(NET_RETRY_SLEEP*NSEC_MSEC);
       return 0;
     }
+
+    poll_fd[IDX_UDP].fd = udp_fd;
     log_out("listening on UDP port %u",port);
   }
 
@@ -93,13 +97,11 @@
 
   if(n == -1){
     if(errno == EAGAIN || errno == EWOULDBLOCK){
-      udp_silent = 1;
       return 0;
     }
     log_errno("recvfrom");
     return 0;
   }
-  udp_silent = 0;
 
   *src_ip   = ntohl(cli_addr.sin_addr.s_addr);
   *src_port = ntohs(cli_addr.sin_port);
@@ -135,6 +137,10 @@
   return n;
 }
 
+bool tcp_bound(void){
+  return tcp_client_fd != -1;
+}
+
 void tcp_init(tcpev_f func){
   tcp_func = func;
 }
@@ -205,9 +211,6 @@
                            &cli_addr_len);
     if(tcp_client_fd == -1){
       if(errno == EAGAIN || errno == EWOULDBLOCK){
-        if(udp_silent){
-          sleep_nsec(NET_SILENT_SLEEP*NSEC_MSEC);
-        }
         return 0;
       }
       log_errno("accept");
@@ -217,7 +220,8 @@
     if(fcntl(tcp_client_fd,F_SETFL,O_NONBLOCK) != 0){
       log_errno("fcntl");
       close(tcp_client_fd);
-      tcp_client_fd = -1;
+      tcp_client_fd       = -1;
+      poll_fd[IDX_TCP].fd = -1;
       return 0;
     }
 
@@ -238,10 +242,6 @@
   n = recv(tcp_client_fd,data,size,0);
   if(n == -1){
     if(errno == EAGAIN || errno == EWOULDBLOCK){
-      tcp_silent = 1;
-      if(udp_silent){
-        sleep_nsec(NET_SILENT_SLEEP*NSEC_MSEC);
-      }
       return 0;
     }
     log_errno("recv");
@@ -252,7 +252,6 @@
     return 0;
   }
 
-  tcp_silent = 0;
   return n;
 }
 
@@ -281,8 +280,35 @@
 void tcp_cclose(void){
   if(tcp_client_fd == -1) return;
   close(tcp_client_fd);
-  tcp_client_fd = -1;
+  tcp_client_fd       = -1;
+  poll_fd[IDX_TCP].fd = -1;
   log_out("TCP client socket closed");
   if(tcp_func) tcp_func(TCP_DISCONNECT);
 }
 
+bool net_poll(void){
+  switch(poll(poll_fd,POLL_FD_N,POLL_TIMEOUT)){
+  case -1:
+    if(errno == EINTR){
+      return 0;
+    }
+    log_errno("poll");
+    log_err("failed to poll file descriptors");
+    return 0;
+
+  case 0:
+    return 0;
+
+  default:
+    return 1;
+  }
+}
+
+bool udp_ready(void){
+  return poll_fd[IDX_UDP].revents & POLLIN;
+}
+
+bool tcp_ready(void){
+  return poll_fd[IDX_TCP].revents & POLLIN;
+}
+
diff -uNr a/src/net.h b/src/net.h
--- a/src/net.h a9425e8cc9b1480d5728a6354ab87ef756701c1a6ca8d1ff600e74d036e7aadaac65ba1a7e5e2d8f1f1b7454ae89bf695bd0140b76e27a747fe43e9d25407f42
+++ b/src/net.h 4b35e836a16335a5a8f1e500f4dde16a7e330dbe5b4f2db87756a0e837924c7238a5bb1f0e911274f63572c43a8b0f67abb904d12d72abe6230c2ad7c0b30b49
@@ -1,5 +1,5 @@
-#ifndef UDP_H
-#define UDP_H
+#ifndef NET_H
+#define NET_H
 
 #include "type.h"
 #include <stddef.h>
@@ -13,11 +13,16 @@
 size_t              udp_recv        (uint32_t *src_ip,uint16_t *src_port,uint16_t port,uint8_t *data,size_t size);
 size_t              udp_send        (uint32_t ip,uint16_t port,uint8_t const *data,size_t size);
 
+bool                tcp_bound       (void);
 void                tcp_init        (tcpev_f func);
 size_t              tcp_recv        (uint32_t *src_ip,uint16_t *src_port,uint16_t port,uint8_t *data,size_t size);
 size_t              tcp_send        (uint8_t const *data,size_t size);
 void                tcp_lclose      (void);
 void                tcp_cclose      (void);
 
+bool                net_poll        (void);
+bool                udp_ready       (void);
+bool                tcp_ready       (void);
+
 #endif
 
diff -uNr a/src/otherpplgode/serpent.c b/src/otherpplgode/serpent.c
--- a/src/otherpplgode/serpent.c dbff4119259f0a95cff338092e34b772d98f61b7940806c4c3dadf735a97ddf1d333d46eb40bb981f53b80d5e7571b2c9f96f4c76182987edac989a6b49a6830
+++ b/src/otherpplgode/serpent.c d32f40d92f30835c88080b435d3b34178cb7c04ccc9ba4859501ee6ac64d83a489a97482e34987296f719da61dd7b059c4be59363e47f573af6c4ef97710ee7d
@@ -358,19 +358,17 @@
 }
 
 void serpent_block_enc(uint32_t const *k,uint8_t *dst,uint8_t const *src){
-        const uint32_t *s = (const uint32_t *)src;
-        uint32_t        *d = (uint32_t *)dst,
-                r0, r1, r2, r3, r4;
-
-/*
- * Note: The conversions between uint8_t* and uint32_t* might cause trouble
- * on architectures with stricter alignment rules than x86
- */
-
-        r0 = le32_to_cpu(s[0]);
-        r1 = le32_to_cpu(s[1]);
-        r2 = le32_to_cpu(s[2]);
-        r3 = le32_to_cpu(s[3]);
+        uint32_t r0, r1, r2, r3, r4;
+
+        memcpy(&r0,src+ 0,sizeof(r0));
+        memcpy(&r1,src+ 4,sizeof(r1));
+        memcpy(&r2,src+ 8,sizeof(r2));
+        memcpy(&r3,src+12,sizeof(r3));
+
+        r0 = le32_to_cpu(r0);
+        r1 = le32_to_cpu(r1);
+        r2 = le32_to_cpu(r2);
+        r3 = le32_to_cpu(r3);
 
                                  K(r0,r1,r2,r3,0);
         S0(r0,r1,r2,r3,r4);        LK(r2,r1,r3,r0,r4,1);
@@ -406,21 +404,29 @@
         S6(r0,r1,r3,r2,r4);        LK(r3,r4,r1,r2,r0,31);
         S7(r3,r4,r1,r2,r0);         K(r0,r1,r2,r3,32);
 
-        d[0] = cpu_to_le32(r0);
-        d[1] = cpu_to_le32(r1);
-        d[2] = cpu_to_le32(r2);
-        d[3] = cpu_to_le32(r3);
+        r0 = cpu_to_le32(r0);
+        r1 = cpu_to_le32(r1);
+        r2 = cpu_to_le32(r2);
+        r3 = cpu_to_le32(r3);
+
+        memcpy(dst+ 0,&r0,sizeof(r0));
+        memcpy(dst+ 4,&r1,sizeof(r1));
+        memcpy(dst+ 8,&r2,sizeof(r2));
+        memcpy(dst+12,&r3,sizeof(r3));
 }
 
 void serpent_block_dec(uint32_t const *k,uint8_t *dst,uint8_t const *src){
-        const uint32_t *s = (const uint32_t *)src;
-        uint32_t        *d = (uint32_t *)dst,
-                r0, r1, r2, r3, r4;
-
-        r0 = le32_to_cpu(s[0]);
-        r1 = le32_to_cpu(s[1]);
-        r2 = le32_to_cpu(s[2]);
-        r3 = le32_to_cpu(s[3]);
+        uint32_t r0, r1, r2, r3, r4;
+
+        memcpy(&r0,src+ 0,sizeof(r0));
+        memcpy(&r1,src+ 4,sizeof(r1));
+        memcpy(&r2,src+ 8,sizeof(r2));
+        memcpy(&r3,src+12,sizeof(r3));
+
+        r0 = le32_to_cpu(r0);
+        r1 = le32_to_cpu(r1);
+        r2 = le32_to_cpu(r2);
+        r3 = le32_to_cpu(r3);
 
                                 K(r0,r1,r2,r3,32);
         SI7(r0,r1,r2,r3,r4);        KL(r1,r3,r0,r4,r2,31);
@@ -456,9 +462,14 @@
         SI1(r3,r1,r2,r0,r4);        KL(r4,r1,r2,r0,r3,1);
         SI0(r4,r1,r2,r0,r3);        K(r2,r3,r1,r4,0);
 
-        d[0] = cpu_to_le32(r2);
-        d[1] = cpu_to_le32(r3);
-        d[2] = cpu_to_le32(r1);
-        d[3] = cpu_to_le32(r4);
+        r2 = cpu_to_le32(r2);
+        r3 = cpu_to_le32(r3);
+        r1 = cpu_to_le32(r1);
+        r4 = cpu_to_le32(r4);
+
+        memcpy(dst+ 0,&r2,sizeof(r2));
+        memcpy(dst+ 4,&r3,sizeof(r3));
+        memcpy(dst+ 8,&r1,sizeof(r1));
+        memcpy(dst+12,&r4,sizeof(r4));
 }
 
diff -uNr a/src/packetlog.c b/src/packetlog.c
--- a/src/packetlog.c 16f0a79bffc5c27b5fc9ed38e099cb91ec43c416890cff2a58cfb198f0ea0c515d2786684fc077fc78b3c58289400668a4bb8f260f2a091f82f73cc15ab24823
+++ b/src/packetlog.c ef5c13d816535ac3ab2ff9617471363d09652678a089dd3dc6102967fb53834223df298d541489d9048622cc96db9f96c81f0c3be25ad987c0edcf4462d383be
@@ -12,14 +12,14 @@
 #define ARROW_OUT             ANSI_RED   "->" ANSI_NORM
 
 static char const *cmd_abbrev[] = {
-  [ CMD_BROADCAST   ] = "BC",  
-  [ CMD_DIRECT      ] = "DM",  
-  [ CMD_BANNER      ] = "BA",  
-  [ CMD_GETDATA     ] = "GD",  
-  [ CMD_KEYOFFER    ] = "KO",  
-  [ CMD_KEYSLICE    ] = "KS",  
-  [ CMD_ADDRESSCAST ] = "AC",  
-  [ CMD_IGNORE      ] = "IG",  
+  [ CMD_BROADCAST   ] = "BC",
+  [ CMD_DIRECT      ] = "DM",
+  [ CMD_PROD        ] = "PR",
+  [ CMD_GETDATA     ] = "GD",
+  [ CMD_KEYOFFER    ] = "KO",
+  [ CMD_KEYSLICE    ] = "KS",
+  [ CMD_ADDRESSCAST ] = "AC",
+  [ CMD_IGNORE      ] = "IG",
 };
 
 void log_packet(hash_t const  hash,
diff -uNr a/src/pest.c b/src/pest.c
--- a/src/pest.c 5182bfa2a642f8db6e41c730ec6afa50736efcec29fd3037a799796aeadd4c989900afdf3cbecbd4f370b86768df38791edef2c3e743ab3869754f3212b20051
+++ b/src/pest.c a747dc022e486b740d4b76af62088cd0c04f918822ea3d93231f249784c77565734140d3236d232aaf9e370a793762b941d3bbf3f28ff8d9836ded8ce255ff2b
@@ -62,6 +62,7 @@
     p->active = time < p->pak_stamp+irctime;
     if(!active && p->active){
       irc_join(p->handle[0]);
+      prod_send(p,PROD_FLAG_REQANS);
     }
     if(active && !p->active){
       irc_part(p->handle[0]);
@@ -69,7 +70,7 @@
   }
 }
 
-void pest_tick(uint64_t time,uint64_t ntime,bool active){
+void pest_tick(bool ready,uint64_t time,uint64_t ntime,bool active){
   if(!active || !udp_bound()){
     udp_recv(0,0,pest_port,0,0);
     if(!active) return;
@@ -82,14 +83,13 @@
   getdata_retry       (time);
   rekey_clean         (time);
   rekey_broadcast     (time);
-  banner_broadcast    (time);
-  addrcast_broadcast  (time);
+  prod_periodic       (time);
+  addrcast_periodic   (time);
   ignore_broadcast    (ntime);
   peer_check_active   (time);
 
-  for(size_t x = 0;x < PEST_RECV_MAX;x++){
-    if(!pest_recv(time)) break;
-  }
+  (void)ready;
+  pest_recv(time);
 }
 
 static void pestop_wot(pestcmd_t const *c){
@@ -196,6 +196,7 @@
   peer_t *p       = peer_lookup(handle);
   if(!p) return;
   peer_pause(p,0);
+  prod_send(p,PROD_FLAG_REQANS);
 }
 
 static void pestop_key(pestcmd_t const *c){
@@ -218,6 +219,8 @@
 
   peer_key_add(p,key,0);
   key_zero(key);
+  prod_send(p,PROD_FLAG_REQANS);
+  addrcast_broadcast(p);
 }
 
 static void pestop_unkey(pestcmd_t const *c){
@@ -346,6 +349,7 @@
     }
 
     peer_addr_set(p,&addr,1);
+    prod_send(p,PROD_FLAG_REQANS);
   }
 }
 
diff -uNr a/src/pest.h b/src/pest.h
--- a/src/pest.h 7baa0f304a8b2b38e14e5ccb0e8674b9eac1e27ce7243d413a60bcbf393fae047fd243aac743cb4368f3983b57ac9178bd502dc9cee60fa1bdb28f05460ae5e8
+++ b/src/pest.h 0f4382b673af0eb1b11bb5343970ee02405baed9ecec1383f00b3cdd1d9c96c48dd86437b265a5ae041e33f55d8dad78ce14e4737991b3b4aa6acffd1de3c895
@@ -6,7 +6,7 @@
 #include <stdbool.h>
 
 bool                pest_init           (void);
-void                pest_tick           (uint64_t time,uint64_t ntime,bool active);
+void                pest_tick           (bool ready,uint64_t time,uint64_t ntime,bool active);
 bool                pest_broadcast      (char const *msg);
 bool                pest_direct         (char const *handle,char const *msg);
 
@@ -44,8 +44,9 @@
 
 void                hearsay_process     (uint64_t ntime);
 
-void                banner_handle       (peer_t *p,uint8_t const *m);
-void                banner_broadcast    (uint64_t time);
+bool                prod_send           (peer_t *p,uint16_t flag);
+void                prod_handle         (peer_t *p,uint8_t const *t);
+void                prod_periodic       (uint64_t time);
 
 void                rekey_init          (rekey_t *rk);
 bool                rekey_active        (rekey_t *rk);
@@ -53,12 +54,13 @@
 void                rekey_initiate      (peer_t *p,bool log);
 bool                rekey_handle_offer  (peer_t *p,uint8_t const *offer);
 bool                rekey_handle_slice  (peer_t *p,uint8_t const *slice);
-bool                rekey_handle_ignore (peer_t *p,pkey_t *pk,uint64_t time);
+bool                rekey_handle_ignore (peer_t *p,pkey_t *pk);
 bool                rekey_handle_packet (peer_t *p,pkey_t *pk);
 void                rekey_broadcast     (uint64_t time);
 void                rekey_clean         (uint64_t time);
 
-void                addrcast_broadcast  (uint64_t time);
+void                addrcast_broadcast  (peer_t *p);
+void                addrcast_periodic   (uint64_t time);
 void                addrcast_handle     (uint8_t *r,hash_t const hash,uint8_t bounces,char const *speaker);
 
 bool                ignore_send         (peer_t *chan,pkey_t *pk);
diff -uNr a/src/prod.c b/src/prod.c
--- a/src/prod.c false
+++ b/src/prod.c 06a9f4be29f8ce4f14c79ff9e83ba7e406cb264e2c0bd758db43801782fb9b1039f2d0853d3b9078ffa2452f95489bf54d67f76db8f97f525637dbd7a877840b
@@ -0,0 +1,106 @@
+#include "pest.h"
+#include "spec.h"
+#include "packet.h"
+#include "chain.h"
+#include "crypto.h"
+#include "peer.h"
+#include "serial.h"
+#include "string.h"
+#include "utf8.h"
+#include "time.h"
+#include "log.h"
+#include "state.h"
+#include <assert.h>
+
+bool prod_send(peer_t *p,uint16_t flag){
+  uint8_t     t[PROD_SIZE];
+  uint16_t    port = p->addr.port;
+  uint32_t    ip   = byteswap32(p->addr.ip);
+  bool        ret;
+  char const *bann;
+
+  if(!peer_cansend(p,0)) return 1;
+
+  assert(flag == PROD_FLAG_REQANS ||
+         flag == PROD_FLAG_ANSWER);
+
+  write_u16(t+PROD_FLAG_OFF,  &flag);
+  write_u16(t+PROD_PORT_OFF,  &port);
+  write_u32(t+PROD_IP_OFF,    &ip);
+
+  hash_copy(t+PROD_BCSC_OFF,  self);
+  hash_copy(t+PROD_BCNC_OFF,  net);
+  hash_copy(t+PROD_DMSC_OFF,  p->self);
+
+  bann = *banner ? banner : PROG_FULLERNAME;
+  strncpy((char *)t+PROD_BANN_OFF,bann,PROD_BANN_SIZE);
+
+  ret = send_text(CMD_PROD,mono_sec(),t,sizeof(t),p,0);
+  BUF_ZERO(t);
+  return ret;
+}
+
+static void getdata_maybe(peer_t       *p,
+                          peer_t       *chan,
+                          ht_t         *ht,
+                          mess_t       *ms,
+                          hash_t const  hash){
+
+  if(ht_lookup(ht,hash))                        return;
+  if(mess_lookup(ms,hash,0) != LOOKUP_NOTFOUND) return;
+  getdata_push_cond(p,chan,hash);
+}
+
+void prod_handle(peer_t *p,uint8_t const *t){
+  uint16_t  flag;
+  uint16_t  port;
+  uint32_t  ip;
+  char      bann[BANNER_BUF];
+
+  read_u16(t+PROD_FLAG_OFF,   &flag);
+  read_u16(t+PROD_PORT_OFF,   &port);
+  read_u32(t+PROD_IP_OFF,     &ip);
+
+  strzzcpy(bann,
+           (char const *)(t+PROD_BANN_OFF),
+           sizeof(bann),
+           PROD_BANN_SIZE);
+
+  if(flag != PROD_FLAG_REQANS &&
+     flag != PROD_FLAG_ANSWER){
+    log_err("invalid prod flag %u received from peer '%s'",
+            flag,p->handle[0]);
+    return;
+  }
+
+  if(!utf8_valid(bann)){
+    log_err("banner from peer '%s' contains invalid UTF-8 sequence",
+            p->handle[0]);
+    return;
+  }
+
+  acaddr.port = port;
+  acaddr.ip   = byteswap32(ip);
+
+  if(flag == PROD_FLAG_REQANS){
+    prod_send(p,PROD_FLAG_ANSWER);
+  }
+
+  getdata_maybe(p,0,&p->bhead,&mess,t+PROD_BCSC_OFF);
+  getdata_maybe(p,p,&p->dhead,&p->mess,t+PROD_DMSC_OFF);
+
+  if(strcmp(bann,p->banner) != 0){
+    peer_banner_set(p,bann);
+  }
+}
+
+void prod_periodic(uint64_t time){
+  if(time < prod_last+prodint) return;
+  prod_last = time;
+
+  for(size_t x = 0;x < peer_cnt;x++){
+    peer_t *p = peer+x;
+    prod_send(p,PROD_FLAG_REQANS);
+  }
+}
+
diff -uNr a/src/recv.c b/src/recv.c
--- a/src/recv.c 8211afbe36e5b6caa6e02a30f9c3bd2237500e372219fb65ef646f752fdc4f76bdeaae0f722aa0692e88a117111aac68423191a01337b0e95b7470011b4d3011
+++ b/src/recv.c eafc5188b411b3d7b2fd315491bcbfb79a2e1d44c1b926e9735308d70d2f70245e29147e046cf8fb6826ecc7fa6f0e3db2f981ad4ac9de70a34584c39b2e468a
@@ -47,19 +47,6 @@
   return 0;
 }
 
-static void at_update(peer_t *p,addr_t *addr){
-  if(setport){
-    if(!addr_equal(&p->addr,addr)){
-      peer_addr_set(p,addr,0);
-    }
-  }else if(p->addr.ip != addr->ip){
-    addr_t p_addr;
-    p_addr.ip   = addr->ip;
-    p_addr.port = p->addr.port;
-    peer_addr_set(p,&p_addr,0);
-  }
-}
-
 //TODO: this func needs to become smaller or smth
 bool pest_recv(uint64_t time){
   uint8_t       b           [BLACK_SIZE+1]; //+1 for detecting oversize
@@ -187,13 +174,23 @@
     }
   }
 
+  cpy_speaker(speaker,sizeof(speaker),m);
+  if(!handle_valid(speaker)){
+    irclog_err("invalid speaker '%s' received from peer '%s'",
+               speaker,handle);
+    goto clear;
+  }
+
   peer_stamp(p,time);
   peer_key_stamp(p,pk,time);
-  at_update(p,&addr);
+
+  if(!addr_equal(&p->addr,&addr)){
+    peer_addr_set(p,&addr,0);
+    prod_send(p,PROD_FLAG_REQANS);
+  }
 
   log_packet(hash,command,p,&addr,0,time,stamp);
 
-  cpy_speaker(speaker,sizeof(speaker),m);
   immediate = peer_handle_lookup(p,speaker);
   pmaster   = *master && peer_handle_lookup(p,master);
 
@@ -225,8 +222,8 @@
                   r,hash,bounces,speaker);
     break;
 
-  case CMD_BANNER:
-    banner_handle(p,m);
+  case CMD_PROD:
+    prod_handle(p,t);
     break;
 
   case CMD_GETDATA:
@@ -246,7 +243,7 @@
     break;
 
   case CMD_IGNORE:
-    rekey_handle_ignore(p,pk,time);
+    rekey_handle_ignore(p,pk);
     break;
 
   default:
diff -uNr a/src/rekey.c b/src/rekey.c
--- a/src/rekey.c 7eb93bf3f841292b23d794113246b7a3ed2b59a24756114778bdfb41fafa89ddd865ff8a34ae124758e5739c6ed92dd78911474cd2689eca4265ce8f0013cde0
+++ b/src/rekey.c bda7488cd32c86c2bd8f7ef9d7c9c18a893c5da446e477cc915ea877a09bb621fec35988b4236feb589f35cb4465cd6f08585509172b89ed7c20e57592d43a86
@@ -148,7 +148,7 @@
   return ignore_send(p,pk);
 }
 
-static bool rkignore_recv(peer_t *p,pkey_t *pk,uint64_t time){
+static bool rkignore_recv(peer_t *p,pkey_t *pk){
   rekey_t *rk = &p->rekey;
   return key_equal(pk->key.full,rk->key_new);
 }
@@ -296,7 +296,7 @@
   }
 }
 
-bool rekey_handle_ignore(peer_t *p,pkey_t *pk,uint64_t time){
+bool rekey_handle_ignore(peer_t *p,pkey_t *pk){
   rekey_t *rk = &p->rekey;
 
   switch(rk->state){
@@ -305,14 +305,14 @@
 
   case WAIT_IGNORE1:
     if(!peer_cansend(p,rk->log))  return 0;
-    if(!rkignore_recv(p,pk,time)) return 0;
+    if(!rkignore_recv(p,pk))      return 0;
     if(!rkignore_send(p))         return 0;
     rekey_complete(p);
     return 1;
 
   case WAIT_IGNORE2:
     if(!peer_cansend(p,rk->log))  return 0;
-    if(!rkignore_recv(p,pk,time)) return 0;
+    if(!rkignore_recv(p,pk))      return 0;
     rekey_complete(p);
     return 1;
 
diff -uNr a/src/rng.c b/src/rng.c
--- a/src/rng.c 7aac4653483c841c7c70b4ee60058d54f6e6d1ca6e3d6006d1591251cb490aa685c00a67e36c98e31e68d632ed897a6968a1a65435bda779a70e576cb88bb68b
+++ b/src/rng.c 26d04a264703896a15e7e7a699af705b5c96a4ce58ec7d5c23c8a683b4cebb53d5e741f47bb156419caa8a7c1114a1c22f80ce6e49c19cd21bf3c29871a3d2a4
@@ -34,8 +34,9 @@
   return fd;
 }
 
-void rng_close(int fd){
-  close(fd);
+void rng_close(int *fd){
+  close(*fd);
+  *fd = -1;
 }
 
 static ssize_t _rng_read(int fd,void *data,size_t size){
diff -uNr a/src/send.c b/src/send.c
--- a/src/send.c 264b4f626d3c8ff06c0be821bab29beebce5371a1ff31c0429d3698f53c58a83fd80806756db5df7bb7b58c3ac593b0c8aa806bee1eebf6e5a01c75a4fbbb11c
+++ b/src/send.c 1d6e86c46752fd137cdc726059b915392e5aa765125dbb7614f7a52c6b60aeb66d5c6a22dc7afb51b2acca83772d3f56458bd7ff6f07047125421e952342467c
@@ -20,9 +20,7 @@
 
   uint8_t b[BLACK_SIZE];
 
-  if(!peer_cansend(p,0)){
-    return 1;
-  }
+  assert(peer_cansend(p,0));
 
   if(!rng_read(rng_fast_fd,r+NONCE_OFF,NONCE_SIZE)){
     return 0;
@@ -76,6 +74,7 @@
   ret = 1;
   for(size_t x = 0;x < p_cnt;x++){
     peer_t *q = p+peer_idx[x];
+    if(!peer_cansend(q,0)) continue;
     if(!red_send(r,q,pk)) ret = 0;
 #ifndef LOG_COLLAPSE
     log_packet(hash,command,q,&q->addr,1,0,0);
@@ -176,20 +175,19 @@
   }
 
   hash_data(hash,m,MESSAGE_SIZE);
+  dedup_push(hash,stamp);
 
   switch(command){
   case CMD_BROADCAST:
     set_hash(&self,hash,0,FILE_SELF);
     set_hash(&net, hash,0,FILE_NET);
     mess_push(&mess,hash,m);
-    dedup_push(hash,stamp);
     break;
 
   case CMD_DIRECT:
     assert(chan);
     set_hash(&chan->self,hash,chan,FILE_SELF);
     mess_push(&chan->mess,hash,m);
-    dedup_push(hash,stamp);
     break;
   }
 
diff -uNr a/src/sha512.c b/src/sha512.c
--- a/src/sha512.c 532b53f5dfc4a550a6df7edbb32264c9b63fb371c2e286230152de04b4b55e78e3d74f02299af4545820ed8543f2a066cd44c3e6c9fd958916d1a517db52dd1d
+++ b/src/sha512.c debbc05e2674dc30c69a301e464f263501b20de9c5d5f67b522061a488d2d0237560b89094be02c589cd2c2239d761bcc543634f1c16a7e819581fac05043752
@@ -231,10 +231,10 @@
     key_size = SHA384_SIZE;
   }
 
-  memset(key_block+key_size,IPAD_CONST,SHA384_BLOCK_SIZE-key_size);
   for(size_t x = 0;x < key_size;x++){
     key_block[x] ^= IPAD_CONST;
   }
+  memset(key_block+key_size,IPAD_CONST,SHA384_BLOCK_SIZE-key_size);
 
   memcpy(state,h384_init,sizeof(state));
   sha512_block(state,key_block);
diff -uNr a/src/spec.h b/src/spec.h
--- a/src/spec.h 7105fc600df512ef6cd2cbe2a01c3b33cdff4622055aa6d4933d7dcff2d5b6a1dd4a9632ee73e36ab8098cb2dd2fbc9c6b9902afede599efb0ea12831d18498f
+++ b/src/spec.h 5fa17ba7e2f11083cc74c62a2acb0f0af61df82a50368203c12a950313f1806d097b181d6b6df98b1d01873b2a0115f7791b81e7a6f63252dede1e5b44f2e8fb
@@ -14,14 +14,17 @@
 
 #define REKEY_PACKET_CNT                3
 
+#define PROD_FLAG_REQANS                0
+#define PROD_FLAG_ANSWER                1
+
 #define KEY_SIGN_SIZE                  32
 #define KEY_CIPH_SIZE                  32
 #define KEY_SIZE                        (KEY_SIGN_SIZE+KEY_CIPH_SIZE)
-#define BANNER_LEN                      TEXT_SIZE
+#define BANNER_LEN                    220
 
 #define CMD_BROADCAST                0x00
 #define CMD_DIRECT                   0x01
-#define CMD_BANNER                   0x02
+#define CMD_PROD                     0x02
 #define CMD_GETDATA                  0x03
 #define CMD_KEYOFFER                 0x04
 #define CMD_KEYSLICE                 0x05
@@ -31,13 +34,34 @@
 #define CMD_UNDEF_MIN                0x06
 #define CMD_UNDEF_MAX                0xFD
 
+//--- prod ----------------------------------------------------------------
+#define PROD_FLAG_SIZE                  sizeof(uint16_t)
+#define PROD_PORT_SIZE                  sizeof(uint16_t)
+#define PROD_IP_SIZE                    sizeof(uint32_t)
+#define PROD_BCSC_SIZE                  HASH_SIZE
+#define PROD_BCNC_SIZE                  HASH_SIZE
+#define PROD_DMSC_SIZE                  HASH_SIZE
+#define PROD_BANN_SIZE                  BANNER_LEN
+
+#define PROD_FLAG_OFF                   0
+#define PROD_PORT_OFF                   ( PROD_FLAG_OFF  + PROD_FLAG_SIZE )
+#define PROD_IP_OFF                     ( PROD_PORT_OFF  + PROD_PORT_SIZE )
+#define PROD_BCSC_OFF                   ( PROD_IP_OFF    + PROD_IP_SIZE   )
+#define PROD_BCNC_OFF                   ( PROD_BCSC_OFF  + PROD_BCSC_SIZE )
+#define PROD_DMSC_OFF                   ( PROD_BCNC_OFF  + PROD_BCNC_SIZE )
+#define PROD_BANN_OFF                   ( PROD_DMSC_OFF  + PROD_DMSC_SIZE )
+
+#define PROD_SIZE                       ( PROD_BANN_OFF  + PROD_BANN_SIZE )
+
 //--- red address cast ----------------------------------------------------
+#define AC_NONCE_SIZE                  16
 #define AC_CMD_SIZE                     sizeof(uint32_t)
 #define AC_PORT_SIZE                    sizeof(uint16_t)
 #define AC_IP_SIZE                      sizeof(uint32_t)
-#define AC_RPAD_SIZE                  262
+#define AC_RPAD_SIZE                  246
 
-#define AC_CMD_OFF                      ( 0                               )
+#define AC_NONCE_OFF                    ( 0                               )
+#define AC_CMD_OFF                      ( AC_NONCE_OFF   + AC_NONCE_SIZE  )
 #define AC_PORT_OFF                     ( AC_CMD_OFF     + AC_CMD_SIZE    )
 #define AC_IP_OFF                       ( AC_PORT_OFF    + AC_PORT_SIZE   )
 #define AC_RPAD_OFF                     ( AC_IP_OFF      + AC_IP_SIZE     )
diff -uNr a/src/state.c b/src/state.c
--- a/src/state.c fe31e7527ee86a446049dc72b9d9257d705b123feece109d8635d75620f8b04048a01152c68508517df5c31df2224d50b64b2da55b7a86e7bf2a77de1183fefd
+++ b/src/state.c 0da97790cf39be639d221d70f133fc28a919adbae5b771e13e8d84bca3dba874158a37d2a4738adeac5ec13191f4eab61eb436e5176107730ad053d9e5e6dcb3
@@ -21,13 +21,17 @@
 char const         *irc_log_chan                  =  0;
 
 int                 udp_fd                        = -1;
-bool                udp_silent                    =  1;
 tcpev_f             tcp_func                      =  0;
 int                 tcp_listen_fd                 = -1;
 int                 tcp_client_fd                 = -1;
 uint32_t            tcp_client_ip                 =  0;
 uint16_t            tcp_client_port               =  0;
-bool                tcp_silent                    =  0;
+struct pollfd       poll_fd[POLL_FD_N] = {
+  [IDX_UDP].fd      = -1,
+  [IDX_UDP].events  = POLLIN,
+  [IDX_TCP].fd      = -1,
+  [IDX_TCP].events  = POLLIN,
+};
 
 ircev_f             ircd_func                     =  0;
 uint32_t            ircd_src_ip                   =  0;
@@ -36,9 +40,9 @@
 char               *ircd_buf_p                    =  ircd_buf;
 
 uint64_t            con_stamp                     =  0;
+uint64_t            prod_last                     =  0;
 uint64_t            rekey_last                    =  0;
 uint64_t            ignore_next                   =  0;
-uint64_t            banner_last                   =  0;
 uint64_t            addrcast_last                 =  0;
 
 getdata_t           gd            [GETDATA_MAX];
@@ -58,7 +62,6 @@
 uint16_t            pest_port                     =  PEST_PORT_DEF;
 uint8_t             scram_pass    [PASS_SIZE]     = {0};
 
-bool                setport                       =  0;
 int64_t             cutoff                        =  0;
 int64_t             hstime                        =  0;
 int64_t             gdtime                        =  0;
@@ -70,8 +73,8 @@
 int64_t             rkint                         =  0;
 int64_t             igint                         =  0;
 char                banner        [BANNER_BUF]    = {0};
-int64_t             baint                         =  0;
-char                acaddr        [AT_BUF]        = {0};
+int64_t             prodint                       =  0;
+addr_t              acaddr                        = {0};
 int64_t             acint                         =  0;
 int64_t             irctime                       =  0;
 char                master        [HANDLE_BUF]    = {0};
diff -uNr a/src/state.h b/src/state.h
--- a/src/state.h 3c44c27062cae6ab19d1240accfd981fd70ada90ddfd872344e6c68093860348d6968b0c0070ff38d2efc9182b9e96b50694d844df889190eeda631d3fa91a20
+++ b/src/state.h 371804e57c9eea3712d529acec46c3c48c0ec9a16769cd9967fed4b6907fcbab9bf2c1f06df2622c7ca3841f5087d8dc35ce3a687e68cfcbff029eb8b2319013
@@ -6,6 +6,7 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <stdio.h>
+#include <poll.h>
 
 //memory state
 extern char         data_path     [PATH_BUF];
@@ -29,13 +30,12 @@
 extern char const  *irc_log_chan;
 
 extern int          udp_fd;
-extern bool         udp_silent;
 extern tcpev_f      tcp_func;
 extern int          tcp_listen_fd;
 extern int          tcp_client_fd;
 extern uint32_t     tcp_client_ip;
 extern uint16_t     tcp_client_port;
-extern bool         tcp_silent;
+extern struct pollfd poll_fd      [POLL_FD_N];
 
 extern ircev_f      ircd_func;
 extern uint32_t     ircd_src_ip;
@@ -44,9 +44,9 @@
 extern char        *ircd_buf_p;
 
 extern uint64_t     con_stamp;
+extern uint64_t     prod_last;
 extern uint64_t     rekey_last;
 extern uint64_t     ignore_next;
-extern uint64_t     banner_last;
 extern uint64_t     addrcast_last;
 
 extern getdata_t    gd            [GETDATA_MAX];
@@ -66,7 +66,6 @@
 extern uint16_t     pest_port;
 extern uint8_t      scram_pass    [PASS_SIZE];
 
-extern bool         setport;
 extern int64_t      cutoff;
 extern int64_t      hstime;
 extern int64_t      gdtime;
@@ -78,8 +77,8 @@
 extern int64_t      rkint;
 extern int64_t      igint;
 extern char         banner        [BANNER_BUF];
-extern int64_t      baint;
-extern char         acaddr        [AT_BUF];
+extern int64_t      prodint;
+extern addr_t       acaddr;
 extern int64_t      acint;
 extern int64_t      irctime;
 extern char         master        [HANDLE_BUF];
diff -uNr a/src/type.h b/src/type.h
--- a/src/type.h 85d4ab2de693185d9bf5eb7b39dff9bec98af8aa8f02338ca6333e97cc6eac778251f2c22c59be63a58a34711a294bc0472399d24535722199d7bdd4986b0a44
+++ b/src/type.h 44be04a22fa937156283dbacdd277c4668aa9d15c2e80df44e361783f79499778848c267be084b408cf7e0ed6d11f82431ed9856759c47ce46324a7060bcd294
@@ -155,7 +155,7 @@
 
 typedef void      (*strval_f)   (char *,size_t,void const *);
 typedef unsigned  (*setval_f)   (knob_t const *,char const *);
-typedef bool      (*storeval_f) (knob_t const *,char const *);
+typedef unsigned  (*storeval_f) (knob_t const *,char const *);
 typedef unsigned  (*loadval_f)  (knob_t const *,char const *);
 
 #endif
diff -uNr a/src/utf8.c b/src/utf8.c
--- a/src/utf8.c 84e42a8a637696ec293214c3964e9ed09d494683de824c6a3aa59a28e0ec79ea6da57bb0ed66887c21a5c490bfd7d3cf23da174b8fb6f3dfb984f5fb4277a9db
+++ b/src/utf8.c e05a37ca88a2642bfb9b3cc1733ddf67bbbfbc80b552920e44300b5386beba17977a5923e70af27278525eb8ca791244626fe83a310a50b532523bfc1823842e
@@ -6,12 +6,6 @@
   return (c & 0xC0) == 0x80;
 }
 
-static bool unicode_valid(uint32_t u){
-  return u <= 0x0010FFFF &&
-         !(u >= 0x0000D800 &&
-           u <= 0x0000DFFF);
-}
-
 static size_t utf8_readchar(uint8_t const *p,uint32_t *u_out){
   uint32_t  u;
   size_t    s;
diff -uNr a/src/wipe.c b/src/wipe.c
--- a/src/wipe.c f1f8a1e2b568db2bc88e510e970aca58f30cc95ac1f4b36c188b21f30df133c2418d045db7c25fd66212b1bbfdfe9ec97e7912f0e4817d9f98b084ea05713386
+++ b/src/wipe.c f2c18a09c2b235d779b64539180caa1cb708b71b75742e332c5c18f0bfc1afa70be9c6cbace390145df69d72301bffa66b7b840cb12016daebfbbecb464df68e
@@ -30,13 +30,12 @@
   VAR_ZERO(irc_log_chan);
 
   VAR_ZERO(udp_fd);
-  VAR_ZERO(udp_silent);
   VAR_ZERO(tcp_func);
   VAR_ZERO(tcp_listen_fd);
   VAR_ZERO(tcp_client_fd);
   VAR_ZERO(tcp_client_ip);
   VAR_ZERO(tcp_client_port);
-  VAR_ZERO(tcp_silent);
+  BUF_ZERO(poll_fd);
 
   VAR_ZERO(ircd_func);
   VAR_ZERO(ircd_src_ip);
@@ -45,9 +44,9 @@
   VAR_ZERO(ircd_buf_p);
 
   VAR_ZERO(con_stamp);
+  VAR_ZERO(prod_last);
   VAR_ZERO(rekey_last);
   VAR_ZERO(ignore_next);
-  VAR_ZERO(banner_last);
   VAR_ZERO(addrcast_last);
 
   BUF_ZERO(gd);
@@ -66,7 +65,6 @@
   VAR_ZERO(pest_port);
   BUF_ZERO(scram_pass);
 
-  VAR_ZERO(setport);
   VAR_ZERO(cutoff);
   VAR_ZERO(hstime);
   VAR_ZERO(gdtime);
@@ -78,8 +76,8 @@
   VAR_ZERO(rkint);
   VAR_ZERO(igint);
   BUF_ZERO(banner);
-  VAR_ZERO(baint);
-  BUF_ZERO(acaddr);
+  VAR_ZERO(prodint);
+  VAR_ZERO(acaddr);
   VAR_ZERO(acint);
   VAR_ZERO(irctime);
   BUF_ZERO(master);
@@ -125,13 +123,12 @@
   VAR_RAND(irc_log_chan);
 
   VAR_RAND(udp_fd);
-  VAR_RAND(udp_silent);
   VAR_RAND(tcp_func);
   VAR_RAND(tcp_listen_fd);
   VAR_RAND(tcp_client_fd);
   VAR_RAND(tcp_client_ip);
   VAR_RAND(tcp_client_port);
-  VAR_RAND(tcp_silent);
+  BUF_RAND(poll_fd);
 
   VAR_RAND(ircd_func);
   VAR_RAND(ircd_src_ip);
@@ -140,9 +137,9 @@
   VAR_RAND(ircd_buf_p);
 
   VAR_RAND(con_stamp);
+  VAR_ZERO(prod_last);
   VAR_RAND(rekey_last);
   VAR_RAND(ignore_next);
-  VAR_RAND(banner_last);
   VAR_RAND(addrcast_last);
 
   BUF_RAND(gd);
@@ -161,7 +158,6 @@
   VAR_RAND(pest_port);
   BUF_RAND(scram_pass);
 
-  VAR_RAND(setport);
   VAR_RAND(cutoff);
   VAR_RAND(hstime);
   VAR_RAND(gdtime);
@@ -173,8 +169,8 @@
   VAR_RAND(rkint);
   VAR_RAND(igint);
   BUF_RAND(banner);
-  VAR_RAND(baint);
-  BUF_RAND(acaddr);
+  VAR_RAND(prodint);
+  VAR_RAND(acaddr);
   VAR_RAND(acint);
   VAR_RAND(irctime);
   BUF_RAND(master);