Split multi_get_create_instance_udp into data and control parts

This currently leads to a bit of code duplication but this refactoring
will make the follow up patches cleaner and better to understand when
the control channel lookup will be changed to use session ids instead of
IP addresses.

Change-Id: I8e9923b51b77f184c7d49d697004cb02d2b5cfc3
Signed-off-by: Arne Schwabe <arne@rfc2549.org>

Author: schwabe

src/openvpn/mudp.c

@@ -188,15 +188,14 @@ do_pre_decrypt_check(struct multi_context *m, struct tls_pre_decrypt_state *stat
 struct multi_instance *
 handle_connection_attempt(struct multi_context *m,
                           struct link_socket *sock,
-                          struct mroute_addr *real,
-                          const uint64_t hv,
-                          struct hash_bucket *bucket)
+                          struct mroute_addr *real)
 {
     struct hash *hash = m->hash;
     struct tls_pre_decrypt_state state = { 0 };
     struct multi_instance *mi = NULL;
     struct gc_arena gc = gc_new();
 
+
     if (m->deferred_shutdown_signal.signal_received)
     {
         msg(D_MULTI_ERRORS,
@@ -220,7 +219,10 @@ handle_connection_attempt(struct multi_context *m,
             mi = multi_create_instance(m, real, sock);
             if (mi)
             {
+                const uint64_t hv = hash_value(hash, real);
+                struct hash_bucket *bucket = hash_bucket(hash, hv);
                 hash_add_fast(hash, bucket, &mi->real, hv, mi);
+
                 mi->did_real_hash = true;
                 multi_assign_peer_id(m, mi);
 
@@ -249,88 +251,139 @@ handle_connection_attempt(struct multi_context *m,
     return mi;
 }
 
-/**
- * Get a client instance based on real address.  If
- * the instance doesn't exist, create it while
- * maintaining real address hash table atomicity.
- */
 struct multi_instance *
-multi_get_create_instance_udp(struct multi_context *m, bool *floated, struct link_socket *sock)
+multi_get_instance_udp_control(struct multi_context *m, struct link_socket *sock)
 {
-    struct gc_arena gc = gc_new();
     struct mroute_addr real = { 0 };
-    struct multi_instance *mi = NULL;
     struct hash *hash = m->hash;
     real.proto = sock->info.proto;
-    m->hmac_reply_ls = sock;
 
     if (mroute_extract_openvpn_sockaddr(&real, &m->top.c2.from.dest, true) && m->top.c2.buf.len > 0)
     {
         struct hash_element *he;
         const uint64_t hv = hash_value(hash, &real);
         struct hash_bucket *bucket = hash_bucket(hash, hv);
-        uint8_t *ptr = BPTR(&m->top.c2.buf);
-        uint8_t op = ptr[0] >> P_OPCODE_SHIFT;
-        bool v2 = (op == P_DATA_V2) && (m->top.c2.buf.len >= (1 + 3));
-        bool peer_id_disabled = false;
 
-        /* make sure buffer has enough length to read opcode (1 byte) and peer-id (3 bytes) */
-        if (v2)
+        he = hash_lookup_fast(hash, bucket, &real, hv);
+        if (he)
         {
-            uint32_t peer_id = ((uint32_t)ptr[1] << 16) | ((uint32_t)ptr[2] << 8) | ((uint32_t)ptr[3]);
-            peer_id_disabled = (peer_id == MAX_PEER_ID);
+            return he->value;
+        }
+    }
+
+    return NULL;
+}
+
+/**
+ * Get a client instance based on real address.  If
+ * the instance doesn't exist, create it while
+ * maintaining real address hash table atomicity.
+ */
+struct multi_instance *
+multi_get_instance_udp_data(struct multi_context *m, bool *floated, struct mroute_addr *real, struct link_socket *sock)
+{
+    struct multi_instance *mi = NULL;
+    struct hash *hash = m->hash;
 
-            if (!peer_id_disabled && (peer_id < m->max_clients) && (m->instances[peer_id]))
+    struct hash_element *he;
+    const uint64_t hv = hash_value(hash, real);
+    struct hash_bucket *bucket = hash_bucket(hash, hv);
+    uint8_t *ptr = BPTR(&m->top.c2.buf);
+    uint8_t op = ptr[0] >> P_OPCODE_SHIFT;
+    bool v2 = (op == P_DATA_V2) && (m->top.c2.buf.len >= (1 + 3));
+    bool peer_id_disabled = false;
+
+    /* make sure buffer has enough length to read opcode (1 byte) and peer-id (3 bytes) */
+    if (v2)
+    {
+        uint32_t peer_id = ((uint32_t)ptr[1] << 16) | ((uint32_t)ptr[2] << 8) | ((uint32_t)ptr[3]);
+        peer_id_disabled = (peer_id == MAX_PEER_ID);
+
+        if (!peer_id_disabled && (peer_id < m->max_clients) && (m->instances[peer_id]))
+        {
+            /* Floating on TCP will never be possible, so ensure we only process
+             * UDP clients */
+            if (m->instances[peer_id]->context.c2.link_sockets[0]->info.proto
+                == sock->info.proto)
             {
-                /* Floating on TCP will never be possible, so ensure we only process
-                 * UDP clients */
-                if (m->instances[peer_id]->context.c2.link_sockets[0]->info.proto
-                    == sock->info.proto)
+                mi = m->instances[peer_id];
+                *floated = !link_socket_actual_match(&mi->context.c2.from, &m->top.c2.from);
+
+                if (*floated)
                 {
-                    mi = m->instances[peer_id];
-                    *floated = !link_socket_actual_match(&mi->context.c2.from, &m->top.c2.from);
-
-                    if (*floated)
-                    {
-                        /* reset prefix, since here we are not sure peer is the one it claims to be
-                         */
-                        ungenerate_prefix(mi);
-                        msg(D_MULTI_MEDIUM, "Float requested for peer %" PRIu32 " to %s", peer_id,
-                            mroute_addr_print(&real, &gc));
-                    }
+                    /* reset prefix, since here we are not sure peer is the one it claims to be
+                     */
+                    ungenerate_prefix(mi);
+                    struct gc_arena gc = gc_new();
+                    msg(D_MULTI_MEDIUM, "Float requested for peer %" PRIu32 " to %s", peer_id,
+                        mroute_addr_print(real, &gc));
+                    gc_free(&gc);
                 }
+                return mi;
             }
         }
-        if (!v2 || peer_id_disabled)
+    }
+    if (!v2 || peer_id_disabled)
+    {
+        he = hash_lookup_fast(hash, bucket, real, hv);
+        if (he)
         {
-            he = hash_lookup_fast(hash, bucket, &real, hv);
-            if (he)
-            {
-                mi = (struct multi_instance *)he->value;
-            }
+            return he->value;
         }
+    }
+
+    return NULL;
+}
+
+
+struct multi_instance *
+multi_get_create_instance_udp(struct multi_context *m, bool *floated, struct link_socket *sock)
+{
+    uint8_t *ptr = BPTR(&m->top.c2.buf);
+    uint8_t op = ptr[0] >> P_OPCODE_SHIFT;
+
+    struct mroute_addr real = { 0 };
+    real.proto = sock->info.proto;
 
-        /* we have no existing multi instance for this connection */
+    if (!mroute_extract_openvpn_sockaddr(&real, &m->top.c2.from.dest, true) || m->top.c2.buf.len == 0)
+    {
+        return NULL;
+    }
+
+    struct multi_instance *mi = NULL;
+    if (op == P_DATA_V1 || op == P_DATA_V2)
+    {
+        mi = multi_get_instance_udp_data(m, floated, &real, sock);
+    }
+    else
+    {
+        mi = multi_get_instance_udp_control(m, sock);
+
+        /* we have no existing multi instance for this connection, control
+         * packets can create a session. Data packets cannot */
         if (!mi)
         {
-            mi = handle_connection_attempt(m, sock, &real, hv, bucket);
+            m->hmac_reply_ls = sock;
+            mi = handle_connection_attempt(m, sock, &real);
         }
+    }
 
 #ifdef ENABLE_DEBUG
-        if (check_debug_level(D_MULTI_DEBUG))
-        {
-            const char *status = mi ? "[ok]" : "[failed]";
+    if (check_debug_level(D_MULTI_DEBUG))
+    {
+        struct gc_arena gc = gc_new();
+        const char *status = mi ? "[ok]" : "[failed]";
 
-            dmsg(D_MULTI_DEBUG, "GET INST BY REAL: %s %s", mroute_addr_print(&real, &gc), status);
-        }
-#endif
+        dmsg(D_MULTI_DEBUG, "GET INST BY REAL: %s %s", mroute_addr_print(&real, &gc), status);
+        gc_free(&gc);
     }
+#endif
 
-    gc_free(&gc);
     ASSERT(!(mi && mi->halt));
     return mi;
 }
 
+
 /*
  * Send a packet to UDP socket.
  */