DatagramPeerIO: allow setting and unsetting handlers

client/DatagramPeerIO.c

@@ -146,9 +146,6 @@ int DatagramPeerIO_Init (
     int num_frames,
     PacketPassInterface *recv_userif,
     int otp_warning_count,
-    DatagramPeerIO_handler_otp_warning handler_otp_warning,
-    DatagramPeerIO_handler_otp_ready handler_otp_ready,
-    void *user,
     BThreadWorkDispatcher *twd
 )
 {
@@ -160,7 +157,6 @@ int DatagramPeerIO_Init (
     if (SPPROTO_HAVE_OTP(sp_params)) {
         ASSERT(otp_warning_count > 0)
         ASSERT(otp_warning_count <= sp_params.otp_num)
-        ASSERT(handler_otp_warning)
     }
     
     // set parameters
@@ -201,7 +197,7 @@ int DatagramPeerIO_Init (
     PacketPassNotifier_Init(&o->recv_notifier, FragmentProtoAssembler_GetInput(&o->recv_assembler), BReactor_PendingGroup(o->reactor));
     
     // init decoder
-    if (!SPProtoDecoder_Init(&o->recv_decoder, PacketPassNotifier_GetInput(&o->recv_notifier), o->sp_params, 2, BReactor_PendingGroup(o->reactor), twd, handler_otp_ready, user)) {
+    if (!SPProtoDecoder_Init(&o->recv_decoder, PacketPassNotifier_GetInput(&o->recv_notifier), o->sp_params, 2, BReactor_PendingGroup(o->reactor), twd)) {
         BLog(BLOG_ERROR, "SPProtoDecoder_Init failed");
         goto fail1;
     }
@@ -221,7 +217,7 @@ int DatagramPeerIO_Init (
     FragmentProtoDisassembler_Init(&o->send_disassembler, o->reactor, o->payload_mtu, o->spproto_payload_mtu, -1, latency);
     
     // init encoder
-    if (!SPProtoEncoder_Init(&o->send_encoder, FragmentProtoDisassembler_GetOutput(&o->send_disassembler), o->sp_params, otp_warning_count, handler_otp_warning, user, BReactor_PendingGroup(o->reactor), twd)) {
+    if (!SPProtoEncoder_Init(&o->send_encoder, FragmentProtoDisassembler_GetOutput(&o->send_disassembler), o->sp_params, otp_warning_count, BReactor_PendingGroup(o->reactor), twd)) {
         BLog(BLOG_ERROR, "SPProtoEncoder_Init failed");
         goto fail3;
     }
@@ -428,3 +424,11 @@ void DatagramPeerIO_RemoveOTPRecvSeeds (DatagramPeerIO *o)
     // remove receiving seeds
     SPProtoDecoder_RemoveOTPSeeds(&o->recv_decoder);
 }
+
+void DatagramPeerIO_SetHandlers (DatagramPeerIO *o, DatagramPeerIO_handler_otp_warning handler_otp_warning, DatagramPeerIO_handler_otp_ready handler_otp_ready, void *user)
+{
+    DebugObject_Access(&o->d_obj);
+    
+    SPProtoDecoder_SetHandlers(&o->recv_decoder, handler_otp_ready, user);
+    SPProtoEncoder_SetHandlers(&o->send_encoder, handler_otp_warning, user);
+}

client/DatagramPeerIO.h

@@ -142,9 +142,6 @@ typedef struct {
  * @param recv_userif interface to pass received packets to the user. Its MTU must be >=payload_mtu.
  * @param otp_warning_count If using OTPs, after how many encoded packets to call the handler.
  *                          In this case, must be >0 and <=sp_params.otp_num.
- * @param handler_otp_warning OTP warning handler
- * @param handler_otp_ready handler called when OTP generation for a new receive seed is finished
- * @param user value to pass to handler
  * @param twd thread work dispatcher
  * @return 1 on success, 0 on failure
  */
@@ -158,9 +155,6 @@ int DatagramPeerIO_Init (
     int num_frames,
     PacketPassInterface *recv_userif,
     int otp_warning_count,
-    DatagramPeerIO_handler_otp_warning handler_otp_warning,
-    DatagramPeerIO_handler_otp_ready handler_otp_ready,
-    void *user,
     BThreadWorkDispatcher *twd
 ) WARN_UNUSED;
 
@@ -258,4 +252,14 @@ void DatagramPeerIO_AddOTPRecvSeed (DatagramPeerIO *o, uint16_t seed_id, uint8_t
  */
 void DatagramPeerIO_RemoveOTPRecvSeeds (DatagramPeerIO *o);
 
+/**
+ * Sets handlers.
+ * 
+ * @param o the object
+ * @param handler_otp_warning OTP warning handler
+ * @param handler_otp_ready handler called when OTP generation for a new receive seed is finished
+ * @param user value to pass to handler
+ */
+void DatagramPeerIO_SetHandlers (DatagramPeerIO *o, DatagramPeerIO_handler_otp_warning handler_otp_warning, DatagramPeerIO_handler_otp_ready handler_otp_ready, void *user);
+
 #endif

client/client.c

@@ -1561,15 +1561,20 @@ int peer_init_link (struct peer_data *peer)
         if (!DatagramPeerIO_Init(
             &peer->pio.udp.pio, &ss, data_mtu, CLIENT_UDP_MTU, sp_params,
             options.fragmentation_latency, PEER_UDP_ASSEMBLER_NUM_FRAMES, &peer->recv_ppi,
-            options.otp_num_warn,
-            (DatagramPeerIO_handler_otp_warning)peer_udp_pio_handler_seed_warning,
-            (DatagramPeerIO_handler_otp_ready)peer_udp_pio_handler_seed_ready,
-            peer, &twd
+            options.otp_num_warn, &twd
         )) {
             peer_log(peer, BLOG_ERROR, "DatagramPeerIO_Init failed");
             goto fail1;
         }
         
+        // set handlers
+        DatagramPeerIO_SetHandlers(
+            &peer->pio.udp.pio,
+            (DatagramPeerIO_handler_otp_warning)peer_udp_pio_handler_seed_warning,
+            (DatagramPeerIO_handler_otp_ready)peer_udp_pio_handler_seed_ready,
+            peer
+        );
+        
         // init send seed state
         if (SPPROTO_HAVE_OTP(sp_params)) {
             peer->pio.udp.sendseed_nextid = 0;

flow/SPProtoDecoder.c

@@ -214,7 +214,7 @@ static void maybe_stop_work_and_ignore (SPProtoDecoder *o)
     }
 }
 
-int SPProtoDecoder_Init (SPProtoDecoder *o, PacketPassInterface *output, struct spproto_security_params sp_params, int num_otp_seeds, BPendingGroup *pg, BThreadWorkDispatcher *twd, SPProtoDecoder_otp_handler otp_handler, void *user)
+int SPProtoDecoder_Init (SPProtoDecoder *o, PacketPassInterface *output, struct spproto_security_params sp_params, int num_otp_seeds, BPendingGroup *pg, BThreadWorkDispatcher *twd)
 {
     spproto_assert_security_params(sp_params);
     ASSERT(spproto_carrier_mtu_for_payload_mtu(sp_params, PacketPassInterface_GetMTU(output)) >= 0)
@@ -258,7 +258,7 @@ int SPProtoDecoder_Init (SPProtoDecoder *o, PacketPassInterface *output, struct
     
     // init OTP checker
     if (SPPROTO_HAVE_OTP(o->sp_params)) {
-        if (!OTPChecker_Init(&o->otpchecker, o->sp_params.otp_num, o->sp_params.otp_mode, num_otp_seeds, o->twd, otp_handler, user)) {
+        if (!OTPChecker_Init(&o->otpchecker, o->sp_params.otp_num, o->sp_params.otp_mode, num_otp_seeds, o->twd)) {
             goto fail1;
         }
     }
@@ -374,3 +374,12 @@ void SPProtoDecoder_RemoveOTPSeeds (SPProtoDecoder *o)
     
     OTPChecker_RemoveSeeds(&o->otpchecker);
 }
+
+void SPProtoDecoder_SetHandlers (SPProtoDecoder *o, SPProtoDecoder_otp_handler otp_handler, void *user)
+{
+    DebugObject_Access(&o->d_obj);
+    
+    if (SPPROTO_HAVE_OTP(o->sp_params)) {
+        OTPChecker_SetHandlers(&o->otpchecker, otp_handler, user);
+    }
+}

flow/SPProtoDecoder.h

@@ -87,11 +87,9 @@ typedef struct {
  *                      receiving packets. Must be >=2 if using OTPs.
  * @param pg pending group
  * @param twd thread work dispatcher
- * @param otp_handler handler called when OTP generation is finished
- * @param user argument to handler
  * @return 1 on success, 0 on failure
  */
-int SPProtoDecoder_Init (SPProtoDecoder *o, PacketPassInterface *output, struct spproto_security_params sp_params, int num_otp_seeds, BPendingGroup *pg, BThreadWorkDispatcher *twd, SPProtoDecoder_otp_handler otp_handler, void *user) WARN_UNUSED;
+int SPProtoDecoder_Init (SPProtoDecoder *o, PacketPassInterface *output, struct spproto_security_params sp_params, int num_otp_seeds, BPendingGroup *pg, BThreadWorkDispatcher *twd) WARN_UNUSED;
 
 /**
  * Frees the object.
@@ -149,4 +147,13 @@ void SPProtoDecoder_AddOTPSeed (SPProtoDecoder *o, uint16_t seed_id, uint8_t *ke
  */
 void SPProtoDecoder_RemoveOTPSeeds (SPProtoDecoder *o);
 
+/**
+ * Sets handlers.
+ *
+ * @param o the object
+ * @param otp_handler handler called when OTP generation is finished
+ * @param user argument to handler
+ */
+void SPProtoDecoder_SetHandlers (SPProtoDecoder *o, SPProtoDecoder_otp_handler otp_handler, void *user);
+
 #endif

flow/SPProtoEncoder.c

@@ -208,8 +208,10 @@ static void handler_job_hander (SPProtoEncoder *o)
     ASSERT(SPPROTO_HAVE_OTP(o->sp_params))
     DebugObject_Access(&o->d_obj);
     
-    o->handler(o->user);
-    return;
+    if (o->handler) {
+        o->handler(o->user);
+        return;
+    }
 }
 
 static void otpgenerator_handler (SPProtoEncoder *o)
@@ -233,24 +235,24 @@ static void maybe_stop_work (SPProtoEncoder *o)
     }
 }
 
-int SPProtoEncoder_Init (SPProtoEncoder *o, PacketRecvInterface *input, struct spproto_security_params sp_params, int otp_warning_count, SPProtoEncoder_handler handler, void *user, BPendingGroup *pg, BThreadWorkDispatcher *twd)
+int SPProtoEncoder_Init (SPProtoEncoder *o, PacketRecvInterface *input, struct spproto_security_params sp_params, int otp_warning_count, BPendingGroup *pg, BThreadWorkDispatcher *twd)
 {
     spproto_assert_security_params(sp_params);
     ASSERT(spproto_carrier_mtu_for_payload_mtu(sp_params, PacketRecvInterface_GetMTU(input)) >= 0)
     if (SPPROTO_HAVE_OTP(sp_params)) {
         ASSERT(otp_warning_count > 0)
         ASSERT(otp_warning_count <= sp_params.otp_num)
-        ASSERT(handler)
     }
     
     // init arguments
     o->input = input;
     o->sp_params = sp_params;
     o->otp_warning_count = otp_warning_count;
-    o->handler = handler;
-    o->user = user;
     o->twd = twd;
     
+    // set no handlers
+    o->handler = NULL;
+    
     // calculate hash size
     if (SPPROTO_HAVE_HASH(o->sp_params)) {
         o->hash_size = BHash_size(o->sp_params.hash_mode);
@@ -417,3 +419,11 @@ void SPProtoEncoder_RemoveOTPSeed (SPProtoEncoder *o)
     // reset OTP generator
     OTPGenerator_Reset(&o->otpgen);
 }
+
+void SPProtoEncoder_SetHandlers (SPProtoEncoder *o, SPProtoEncoder_handler handler, void *user)
+{
+    DebugObject_Access(&o->d_obj);
+    
+    o->handler = handler;
+    o->user = user;
+}

flow/SPProtoEncoder.h

@@ -94,13 +94,11 @@ typedef struct {
  * @param sp_params SPProto security parameters
  * @param otp_warning_count If using OTPs, after how many encoded packets to call the handler.
  *                          In this case, must be >0 and <=sp_params.otp_num.
- * @param handler OTP warning handler
- * @param user value to pass to handler
  * @param pg pending group
  * @param twd thread work dispatcher
  * @return 1 on success, 0 on failure
  */
-int SPProtoEncoder_Init (SPProtoEncoder *o, PacketRecvInterface *input, struct spproto_security_params sp_params, int otp_warning_count, SPProtoEncoder_handler handler, void *user, BPendingGroup *pg, BThreadWorkDispatcher *twd) WARN_UNUSED;
+int SPProtoEncoder_Init (SPProtoEncoder *o, PacketRecvInterface *input, struct spproto_security_params sp_params, int otp_warning_count, BPendingGroup *pg, BThreadWorkDispatcher *twd) WARN_UNUSED;
 
 /**
  * Frees the object.
@@ -155,4 +153,13 @@ void SPProtoEncoder_SetOTPSeed (SPProtoEncoder *o, uint16_t seed_id, uint8_t *ke
  */
 void SPProtoEncoder_RemoveOTPSeed (SPProtoEncoder *o);
 
+/**
+ * Sets handlers.
+ *
+ * @param o the object
+ * @param handler OTP warning handler
+ * @param user value to pass to handler
+ */
+void SPProtoEncoder_SetHandlers (SPProtoEncoder *o, SPProtoEncoder_handler handler, void *user);
+
 #endif

security/OTPChecker.c

@@ -133,11 +133,13 @@ static void work_done_handler (OTPChecker *mc)
     }
     
     // call handler
-    mc->handler(mc->user);
-    return;
+    if (mc->handler) {
+        mc->handler(mc->user);
+        return;
+    }
 }
 
-int OTPChecker_Init (OTPChecker *mc, int num_otps, int cipher, int num_tables, BThreadWorkDispatcher *twd, OTPChecker_handler handler, void *user)
+int OTPChecker_Init (OTPChecker *mc, int num_otps, int cipher, int num_tables, BThreadWorkDispatcher *twd)
 {
     ASSERT(num_otps > 0)
     ASSERT(BEncryption_cipher_valid(cipher))
@@ -148,8 +150,9 @@ int OTPChecker_Init (OTPChecker *mc, int num_otps, int cipher, int num_tables, B
     mc->cipher = cipher;
     mc->num_tables = num_tables;
     mc->twd = twd;
-    mc->handler = handler;
-    mc->user = user;
+    
+    // set no handlers
+    mc->handler = NULL;
     
     // set number of entries
     mc->num_entries = 2 * mc->num_otps;
@@ -262,3 +265,11 @@ int OTPChecker_CheckOTP (OTPChecker *mc, uint16_t seed_id, otp_t otp)
     
     return 0;
 }
+
+void OTPChecker_SetHandlers (OTPChecker *mc, OTPChecker_handler handler, void *user)
+{
+    DebugObject_Access(&mc->d_obj);
+    
+    mc->handler = handler;
+    mc->user = user;
+}

security/OTPChecker.h

@@ -85,12 +85,9 @@ typedef struct {
  *               according to {@link BEncryption_cipher_valid}.
  * @param num_tables number of tables to keep, each for one seed. Must be >0.
  * @param twd thread work dispatcher
- * @param handler handler to call when generation of new OTPs is complete,
- *                after {@link OTPChecker_AddSeed} was called.
- * @param user argument to handler
  * @return 1 on success, 0 on failure
  */
-int OTPChecker_Init (OTPChecker *mc, int num_otps, int cipher, int num_tables, BThreadWorkDispatcher *twd, OTPChecker_handler handler, void *user) WARN_UNUSED;
+int OTPChecker_Init (OTPChecker *mc, int num_otps, int cipher, int num_tables, BThreadWorkDispatcher *twd) WARN_UNUSED;
 
 /**
  * Frees the checker.
@@ -128,4 +125,14 @@ void OTPChecker_RemoveSeeds (OTPChecker *mc);
  */
 int OTPChecker_CheckOTP (OTPChecker *mc, uint16_t seed_id, otp_t otp);
 
+/**
+ * Sets handlers.
+ *
+ * @param mc the object
+ * @param handler handler to call when generation of new OTPs is complete,
+ *                after {@link OTPChecker_AddSeed} was called.
+ * @param user argument to handler
+ */
+void OTPChecker_SetHandlers (OTPChecker *mc, OTPChecker_handler handler, void *user);
+
 #endif