diff --git a/src/backend.c b/src/backend.c
index 82a88be..f4b90ce 100644
--- a/src/backend.c
+++ b/src/backend.c
@@ -38,6 +38,7 @@
 #include <proto/lb_fwlc.h>
 #include <proto/lb_fwrr.h>
 #include <proto/lb_map.h>
+#include <proto/obj_type.h>
 #include <proto/protocol.h>
 #include <proto/proto_http.h>
 #include <proto/proto_tcp.h>
@@ -489,7 +490,7 @@
 	if (unlikely(s->pend_pos || s->flags & SN_ASSIGNED))
 		goto out_err;
 
-	prev_srv  = target_srv(&s->target);
+	prev_srv  = objt_server(s->target);
 	conn_slot = s->srv_conn;
 
 	/* We have to release any connection slot before applying any LB algo,
@@ -498,13 +499,13 @@
 	if (conn_slot)
 		sess_change_server(s, NULL);
 
-	/* We will now try to find the good server and store it into <target_srv(&s->target)>.
-	 * Note that <target_srv(&s->target)> may be NULL in case of dispatch or proxy mode,
+	/* We will now try to find the good server and store it into <objt_server(s->target)>.
+	 * Note that <objt_server(s->target)> may be NULL in case of dispatch or proxy mode,
 	 * as well as if no server is available (check error code).
 	 */
 
 	srv = NULL;
-	clear_target(&s->target);
+	s->target = NULL;
 
 	if (s->be->lbprm.algo & BE_LB_KIND) {
 		/* we must check if we have at least one server available */
@@ -631,15 +632,15 @@
 			s->be->be_counters.cum_lbconn++;
 			srv->counters.cum_lbconn++;
 		}
-		set_target_server(&s->target, srv);
+		s->target = &srv->obj_type;
 	}
 	else if (s->be->options & (PR_O_DISPATCH | PR_O_TRANSP)) {
-		set_target_proxy(&s->target, s->be);
+		s->target = &s->be->obj_type;
 	}
 	else if ((s->be->options & PR_O_HTTP_PROXY) &&
 		 is_addr(&s->req->cons->conn->addr.to)) {
 		/* in proxy mode, we need a valid destination address */
-		set_target_proxy(&s->target, s->be);
+		s->target = &s->be->obj_type;
 	}
 	else {
 		err = SRV_STATUS_NOSRV;
@@ -691,7 +692,7 @@
 		if (!(s->flags & SN_ASSIGNED))
 			return SRV_STATUS_INTERNAL;
 
-		s->req->cons->conn->addr.to = target_srv(&s->target)->addr;
+		s->req->cons->conn->addr.to = objt_server(s->target)->addr;
 
 		if (!is_addr(&s->req->cons->conn->addr.to)) {
 			/* if the server has no address, we use the same address
@@ -710,7 +711,7 @@
 
 		/* if this server remaps proxied ports, we'll use
 		 * the port the client connected to with an offset. */
-		if (target_srv(&s->target)->state & SRV_MAPPORTS) {
+		if (objt_server(s->target)->state & SRV_MAPPORTS) {
 			int base_port;
 
 			if (!(s->be->options & PR_O_TRANSP))
@@ -764,7 +765,7 @@
  * Returns :
  *
  *   SRV_STATUS_OK       if everything is OK.
- *   SRV_STATUS_NOSRV    if no server is available. target_srv(&s->target) = NULL.
+ *   SRV_STATUS_NOSRV    if no server is available. objt_server(s->target) = NULL.
  *   SRV_STATUS_QUEUED   if the connection has been queued.
  *   SRV_STATUS_FULL     if the server(s) is/are saturated and the
  *                       connection could not be queued at the server's,
@@ -783,7 +784,7 @@
 
 	err = SRV_STATUS_OK;
 	if (!(s->flags & SN_ASSIGNED)) {
-		struct server *prev_srv = target_srv(&s->target);
+		struct server *prev_srv = objt_server(s->target);
 
 		err = assign_server(s);
 		if (prev_srv) {
@@ -796,7 +797,7 @@
 			 *  - if the server remained the same : update retries.
 			 */
 
-			if (prev_srv != target_srv(&s->target)) {
+			if (prev_srv != objt_server(s->target)) {
 				if ((s->txn.flags & TX_CK_MASK) == TX_CK_VALID) {
 					s->txn.flags &= ~TX_CK_MASK;
 					s->txn.flags |= TX_CK_DOWN;
@@ -814,7 +815,7 @@
 	switch (err) {
 	case SRV_STATUS_OK:
 		/* we have SN_ASSIGNED set */
-		srv = target_srv(&s->target);
+		srv = objt_server(s->target);
 		if (!srv)
 			return SRV_STATUS_OK;   /* dispatch or proxy mode */
 
@@ -882,7 +883,7 @@
 static void assign_tproxy_address(struct session *s)
 {
 #if defined(CONFIG_HAP_CTTPROXY) || defined(CONFIG_HAP_LINUX_TPROXY)
-	struct server *srv = target_srv(&s->target);
+	struct server *srv = objt_server(s->target);
 
 	if (srv && srv->state & SRV_BIND_SRC) {
 		switch (srv->state & SRV_TPROXY_MASK) {
@@ -981,13 +982,13 @@
 	}
 
 	/* the target was only on the session, assign it to the SI now */
-	copy_target(&s->req->cons->conn->target, &s->target);
+	s->req->cons->conn->target = s->target;
 
 	/* set the correct protocol on the output stream interface */
-	if (s->target.type == TARG_TYPE_SERVER) {
-		si_prepare_conn(s->req->cons, target_srv(&s->target)->proto, target_srv(&s->target)->xprt);
+	if (objt_server(s->target)) {
+		si_prepare_conn(s->req->cons, objt_server(s->target)->proto, objt_server(s->target)->xprt);
 	}
-	else if (s->target.type == TARG_TYPE_PROXY) {
+	else if (obj_type(s->target) == OBJ_TYPE_PROXY) {
 		/* proxies exclusively run on raw_sock right now */
 		si_prepare_conn(s->req->cons, protocol_by_family(s->req->cons->conn->addr.to.ss_family), &raw_sock);
 		if (!si_ctrl(s->req->cons))
@@ -998,7 +999,7 @@
 
 	/* process the case where the server requires the PROXY protocol to be sent */
 	s->req->cons->send_proxy_ofs = 0;
-	if (s->target.type == TARG_TYPE_SERVER && (s->target.ptr.s->state & SRV_SEND_PROXY)) {
+	if (objt_server(s->target) && (objt_server(s->target)->state & SRV_SEND_PROXY)) {
 		s->req->cons->send_proxy_ofs = 1; /* must compute size */
 		conn_get_to_addr(s->req->prod->conn);
 	}
@@ -1021,7 +1022,7 @@
 	/* set connect timeout */
 	s->req->cons->exp = tick_add_ifset(now_ms, s->be->timeout.connect);
 
-	srv = target_srv(&s->target);
+	srv = objt_server(s->target);
 	if (srv) {
 		s->flags |= SN_CURR_SESS;
 		srv->cur_sess++;
@@ -1053,7 +1054,7 @@
 	 */
  redispatch:
 	conn_err = assign_server_and_queue(t);
-	srv = target_srv(&t->target);
+	srv = objt_server(t->target);
 
 	switch (conn_err) {
 	case SRV_STATUS_OK:
@@ -1173,13 +1174,13 @@
 	if (*p != '.')
 		goto no_cookie;
 
-	clear_target(&s->target);
+	s->target = NULL;
 	while (srv) {
 		if (memcmp(&addr, &(srv->addr), sizeof(addr)) == 0) {
 			if ((srv->state & SRV_RUNNING) || (px->options & PR_O_PERSIST)) {
 				/* we found the server and it is usable */
 				s->flags |= SN_DIRECT | SN_ASSIGNED;
-				set_target_server(&s->target, srv);
+				s->target = &srv->obj_type;
 				break;
 			}
 		}
@@ -1488,11 +1489,11 @@
 acl_fetch_srv_id(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                  const struct arg *args, struct sample *smp)
 {
-	if (!target_srv(&l4->target))
+	if (!objt_server(l4->target))
 		return 0;
 
 	smp->type = SMP_T_UINT;
-	smp->data.uint = target_srv(&l4->target)->puid;
+	smp->data.uint = objt_server(l4->target)->puid;
 
 	return 1;
 }
diff --git a/src/cfgparse.c b/src/cfgparse.c
index 6c58e43..d3b6300 100644
--- a/src/cfgparse.c
+++ b/src/cfgparse.c
@@ -35,6 +35,7 @@
 #include <types/capture.h>
 #include <types/compression.h>
 #include <types/global.h>
+#include <types/obj_type.h>
 #include <types/peers.h>
 
 #include <proto/acl.h>
@@ -265,6 +266,7 @@
 
 		for (; port <= end; port++) {
 			l = (struct listener *)calloc(1, sizeof(struct listener));
+			l->obj_type = OBJ_TYPE_LISTENER;
 			LIST_ADDQ(&curproxy->conf.listeners, &l->by_fe);
 			LIST_ADDQ(&bind_conf->listeners, &l->by_bind);
 			l->frontend = curproxy;
@@ -4034,6 +4036,7 @@
 			newsrv->conf.file = strdup(file);
 			newsrv->conf.line = linenum;
 
+			newsrv->obj_type = OBJ_TYPE_SERVER;
 			LIST_INIT(&newsrv->actconns);
 			LIST_INIT(&newsrv->pendconns);
 			do_check = 0;
diff --git a/src/checks.c b/src/checks.c
index e3c8620..f13273e 100644
--- a/src/checks.c
+++ b/src/checks.c
@@ -349,7 +349,7 @@
 		p = pendconn_from_px(s->proxy);
 		if (!p)
 			break;
-		set_target_server(&p->sess->target, s);
+		p->sess->target = &s->obj_type;
 		sess = p->sess;
 		pendconn_free(p);
 		task_wakeup(sess->task, TASK_WOKEN_RES);
@@ -1299,7 +1299,7 @@
 		}
 
 		/* prepare a new connection */
-		set_target_server(&conn->target, s);
+		conn->target = &s->obj_type;
 		conn_prepare(conn, &check_conn_cb, s->check.proto, s->check.xprt, s);
 
 		/* no client address */
diff --git a/src/dumpstats.c b/src/dumpstats.c
index 306fc61..5f59dde 100644
--- a/src/dumpstats.c
+++ b/src/dumpstats.c
@@ -125,7 +125,7 @@
 {
 	/* we have a dedicated I/O handler for the stats */
 	stream_int_register_handler(&s->si[1], &cli_applet);
-	copy_target(&s->target, &s->si[1].conn->target); // for logging only
+	s->target = s->si[1].conn->target; // for logging only
 	s->si[1].conn->xprt_ctx = s;
 	s->si[1].applet.st1 = 0;
 	s->si[1].applet.st0 = STAT_CLI_INIT;
@@ -3419,8 +3419,8 @@
 		if (sess->be->cap & PR_CAP_BE)
 			chunk_appendf(&trash,
 				     "  server=%s (id=%u)",
-				     target_srv(&sess->target) ? target_srv(&sess->target)->id : "<none>",
-				     target_srv(&sess->target) ? target_srv(&sess->target)->puid : 0);
+				     objt_server(sess->target) ? objt_server(sess->target)->id : "<none>",
+				     objt_server(sess->target) ? objt_server(sess->target)->puid : 0);
 		else
 			chunk_appendf(&trash, "  server=<NONE> (id=-1)");
 
@@ -3638,7 +3638,7 @@
 					     get_host_port(&curr_sess->si[0].conn->addr.from),
 					     curr_sess->fe->id,
 					     (curr_sess->be->cap & PR_CAP_BE) ? curr_sess->be->id : "<NONE>",
-					     target_srv(&curr_sess->target) ? target_srv(&curr_sess->target)->id : "<none>"
+					     objt_server(curr_sess->target) ? objt_server(curr_sess->target)->id : "<none>"
 					     );
 				break;
 			case AF_UNIX:
@@ -3647,7 +3647,7 @@
 					     curr_sess->listener->luid,
 					     curr_sess->fe->id,
 					     (curr_sess->be->cap & PR_CAP_BE) ? curr_sess->be->id : "<NONE>",
-					     target_srv(&curr_sess->target) ? target_srv(&curr_sess->target)->id : "<none>"
+					     objt_server(curr_sess->target) ? objt_server(curr_sess->target)->id : "<none>"
 					     );
 				break;
 			}
@@ -4161,12 +4161,14 @@
 }
 
 struct si_applet http_stats_applet = {
+	.obj_type = OBJ_TYPE_APPLET,
 	.name = "<STATS>", /* used for logging */
 	.fct = http_stats_io_handler,
 	.release = NULL,
 };
 
 static struct si_applet cli_applet = {
+	.obj_type = OBJ_TYPE_APPLET,
 	.name = "<CLI>", /* used for logging */
 	.fct = cli_io_handler,
 	.release = NULL,
diff --git a/src/log.c b/src/log.c
index 79158e0..06a2a57 100644
--- a/src/log.c
+++ b/src/log.c
@@ -800,12 +800,12 @@
 
 	if (!(tolog & LW_SVID))
 		svid = "-";
-	else switch (s->target.type) {
-	case TARG_TYPE_SERVER:
-		svid = s->target.ptr.s->id;
+	else switch (obj_type(s->target)) {
+	case OBJ_TYPE_SERVER:
+		svid = objt_server(s->target)->id;
 		break;
-	case TARG_TYPE_APPLET:
-		svid = s->target.ptr.a->name;
+	case OBJ_TYPE_APPLET:
+		svid = objt_applet(s->target)->name;
 		break;
 	default:
 		svid = "<NOSRV>";
@@ -1175,8 +1175,8 @@
 				break;
 
 			case LOG_FMT_SRVCONN:  // %sc
-				ret = ultoa_o(target_srv(&s->target) ?
-				                 target_srv(&s->target)->cur_sess :
+				ret = ultoa_o(obj_type(s->target) ?
+				                 objt_server(s->target)->cur_sess :
 				                 0, tmplog, dst + maxsize - tmplog);
 				if (ret == NULL)
 					goto out;
diff --git a/src/peers.c b/src/peers.c
index 263cc8a..6870f8f 100644
--- a/src/peers.c
+++ b/src/peers.c
@@ -25,7 +25,8 @@
 #include <common/time.h>
 
 #include <types/global.h>
-#include <proto/listener.h>
+#include <types/listener.h>
+#include <types/obj_type.h>
 #include <types/peers.h>
 
 #include <proto/acl.h>
@@ -1040,6 +1041,7 @@
 }
 
 static struct si_applet peer_applet = {
+	.obj_type = OBJ_TYPE_APPLET,
 	.name = "<PEER>", /* used for logging */
 	.fct = peer_io_handler,
 	.release = peer_session_release,
@@ -1052,8 +1054,7 @@
 {
 	struct stream_interface *oldsi;
 
-	if (session->si[0].conn->target.type == TARG_TYPE_APPLET &&
-	    session->si[0].conn->target.ptr.a == &peer_applet) {
+	if (objt_applet(session->si[0].conn->target) == &peer_applet) {
 		oldsi = &session->si[0];
 	}
 	else {
@@ -1077,7 +1078,7 @@
 {
 	 /* we have a dedicated I/O handler for the stats */
 	stream_int_register_handler(&s->si[1], &peer_applet);
-	copy_target(&s->target, &s->si[1].conn->target); // for logging only
+	s->target = s->si[1].conn->target; // for logging only
 	s->si[1].conn->xprt_ctx = s;
 	s->si[1].applet.st0 = PEER_SESSION_ACCEPT;
 
@@ -1161,7 +1162,7 @@
 	s->si[0].err_loc = NULL;
 	s->si[0].release = NULL;
 	s->si[0].send_proxy_ofs = 0;
-	set_target_client(&s->si[0].conn->target, l);
+	s->si[0].conn->target = &l->obj_type;
 	s->si[0].exp = TICK_ETERNITY;
 	s->si[0].flags = SI_FL_NONE;
 	if (s->fe->options2 & PR_O2_INDEPSTR)
@@ -1180,7 +1181,7 @@
 	s->si[1].err_loc = NULL;
 	s->si[1].release = NULL;
 	s->si[1].send_proxy_ofs = 0;
-	set_target_proxy(&s->si[1].conn->target, s->be);
+	s->si[1].conn->target = &s->be->obj_type;
 	si_prepare_conn(&s->si[1], peer->proto, peer->xprt);
 	s->si[1].exp = TICK_ETERNITY;
 	s->si[1].flags = SI_FL_NONE;
@@ -1188,7 +1189,7 @@
 		s->si[1].flags |= SI_FL_INDEP_STR;
 
 	session_init_srv_conn(s);
-	set_target_proxy(&s->target, s->be);
+	s->target = &s->be->obj_type;
 	s->pend_pos = NULL;
 
 	/* init store persistence */
diff --git a/src/proto_http.c b/src/proto_http.c
index c1fd6a7..f86dcc3 100644
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -767,7 +767,7 @@
 	trash.len = strlen(HTTP_302);
 	memcpy(trash.str, HTTP_302, trash.len);
 
-	srv = target_srv(&s->target);
+	srv = objt_server(s->target);
 
 	/* 2: add the server's prefix */
 	if (trash.len + srv->rdr_len > trash.size)
@@ -3202,7 +3202,7 @@
 		s->logs.tv_request = now;
 		s->task->nice = -32; /* small boost for HTTP statistics */
 		stream_int_register_handler(s->rep->prod, &http_stats_applet);
-		copy_target(&s->target, &s->rep->prod->conn->target); // for logging only
+		s->target = s->rep->prod->conn->target; // for logging only
 		s->rep->prod->conn->xprt_ctx = s;
 		s->rep->prod->applet.st0 = s->rep->prod->applet.st1 = 0;
 		req->analysers = 0;
@@ -4056,16 +4056,16 @@
 	if (s->pend_pos)
 		pendconn_free(s->pend_pos);
 
-	if (target_srv(&s->target)) {
+	if (objt_server(s->target)) {
 		if (s->flags & SN_CURR_SESS) {
 			s->flags &= ~SN_CURR_SESS;
-			target_srv(&s->target)->cur_sess--;
+			objt_server(s->target)->cur_sess--;
 		}
-		if (may_dequeue_tasks(target_srv(&s->target), s->be))
-			process_srv_queue(target_srv(&s->target));
+		if (may_dequeue_tasks(objt_server(s->target), s->be))
+			process_srv_queue(objt_server(s->target));
 	}
 
-	clear_target(&s->target);
+	s->target = NULL;
 
 	s->req->cons->state     = s->req->cons->prev_state = SI_ST_INI;
 	s->req->cons->conn->t.sock.fd = -1; /* just to help with debugging */
@@ -4349,8 +4349,8 @@
 		else if (chn->flags & CF_SHUTW) {
 			txn->rsp.msg_state = HTTP_MSG_ERROR;
 			s->be->be_counters.cli_aborts++;
-			if (target_srv(&s->target))
-				target_srv(&s->target)->counters.cli_aborts++;
+			if (objt_server(s->target))
+				objt_server(s->target)->counters.cli_aborts++;
 			goto wait_other_side;
 		}
 	}
@@ -4628,8 +4628,8 @@
 
 		s->fe->fe_counters.cli_aborts++;
 		s->be->be_counters.cli_aborts++;
-		if (target_srv(&s->target))
-			target_srv(&s->target)->counters.cli_aborts++;
+		if (objt_server(s->target))
+			objt_server(s->target)->counters.cli_aborts++;
 
 		goto return_bad_req_stats_ok;
 	}
@@ -4698,8 +4698,8 @@
 
 	s->fe->fe_counters.srv_aborts++;
 	s->be->be_counters.srv_aborts++;
-	if (target_srv(&s->target))
-		target_srv(&s->target)->counters.srv_aborts++;
+	if (objt_server(s->target))
+		objt_server(s->target)->counters.srv_aborts++;
 
 	if (!(s->flags & SN_ERR_MASK))
 		s->flags |= SN_ERR_SRVCL;
@@ -4823,9 +4823,9 @@
 				http_capture_bad_message(&s->be->invalid_rep, s, msg, msg->msg_state, s->fe);
 
 			s->be->be_counters.failed_resp++;
-			if (target_srv(&s->target)) {
-				target_srv(&s->target)->counters.failed_resp++;
-				health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_HDRRSP);
+			if (objt_server(s->target)) {
+				objt_server(s->target)->counters.failed_resp++;
+				health_adjust(objt_server(s->target), HANA_STATUS_HTTP_HDRRSP);
 			}
 		abort_response:
 			channel_auto_close(rep);
@@ -4856,9 +4856,9 @@
 				http_capture_bad_message(&s->be->invalid_rep, s, msg, msg->msg_state, s->fe);
 
 			s->be->be_counters.failed_resp++;
-			if (target_srv(&s->target)) {
-				target_srv(&s->target)->counters.failed_resp++;
-				health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_READ_ERROR);
+			if (objt_server(s->target)) {
+				objt_server(s->target)->counters.failed_resp++;
+				health_adjust(objt_server(s->target), HANA_STATUS_HTTP_READ_ERROR);
 			}
 
 			channel_auto_close(rep);
@@ -4881,9 +4881,9 @@
 				http_capture_bad_message(&s->be->invalid_rep, s, msg, msg->msg_state, s->fe);
 
 			s->be->be_counters.failed_resp++;
-			if (target_srv(&s->target)) {
-				target_srv(&s->target)->counters.failed_resp++;
-				health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_READ_TIMEOUT);
+			if (objt_server(s->target)) {
+				objt_server(s->target)->counters.failed_resp++;
+				health_adjust(objt_server(s->target), HANA_STATUS_HTTP_READ_TIMEOUT);
 			}
 
 			channel_auto_close(rep);
@@ -4906,9 +4906,9 @@
 				http_capture_bad_message(&s->be->invalid_rep, s, msg, msg->msg_state, s->fe);
 
 			s->be->be_counters.failed_resp++;
-			if (target_srv(&s->target)) {
-				target_srv(&s->target)->counters.failed_resp++;
-				health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_BROKEN_PIPE);
+			if (objt_server(s->target)) {
+				objt_server(s->target)->counters.failed_resp++;
+				health_adjust(objt_server(s->target), HANA_STATUS_HTTP_BROKEN_PIPE);
 			}
 
 			channel_auto_close(rep);
@@ -4969,8 +4969,8 @@
 	if (n == 4)
 		session_inc_http_err_ctr(s);
 
-	if (target_srv(&s->target))
-		target_srv(&s->target)->counters.p.http.rsp[n]++;
+	if (objt_server(s->target))
+		objt_server(s->target)->counters.p.http.rsp[n]++;
 
 	/* check if the response is HTTP/1.1 or above */
 	if ((msg->sl.st.v_l == 8) &&
@@ -4990,11 +4990,11 @@
 	 * and 505 are triggered on demand by client request, so we must not
 	 * count them as server failures.
 	 */
-	if (target_srv(&s->target)) {
+	if (objt_server(s->target)) {
 		if (txn->status >= 100 && (txn->status < 500 || txn->status == 501 || txn->status == 505))
-			health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_OK);
+			health_adjust(objt_server(s->target), HANA_STATUS_HTTP_OK);
 		else
-			health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_STS);
+			health_adjust(objt_server(s->target), HANA_STATUS_HTTP_STS);
 	}
 
 	/*
@@ -5258,9 +5258,9 @@
 			if (rule_set->rsp_exp != NULL) {
 				if (apply_filters_to_response(t, rep, rule_set) < 0) {
 				return_bad_resp:
-					if (target_srv(&t->target)) {
-						target_srv(&t->target)->counters.failed_resp++;
-						health_adjust(target_srv(&t->target), HANA_STATUS_HTTP_RSP);
+					if (objt_server(t->target)) {
+						objt_server(t->target)->counters.failed_resp++;
+						health_adjust(objt_server(t->target), HANA_STATUS_HTTP_RSP);
 					}
 					t->be->be_counters.failed_resp++;
 				return_srv_prx_502:
@@ -5279,8 +5279,8 @@
 
 			/* has the response been denied ? */
 			if (txn->flags & TX_SVDENY) {
-				if (target_srv(&t->target))
-					target_srv(&t->target)->counters.failed_secu++;
+				if (objt_server(t->target))
+					objt_server(t->target)->counters.failed_secu++;
 
 				t->be->be_counters.denied_resp++;
 				t->fe->fe_counters.denied_resp++;
@@ -5348,7 +5348,7 @@
 		/*
 		 * 6: add server cookie in the response if needed
 		 */
-		if (target_srv(&t->target) && (t->be->ck_opts & PR_CK_INS) &&
+		if (objt_server(t->target) && (t->be->ck_opts & PR_CK_INS) &&
 		    !((txn->flags & TX_SCK_FOUND) && (t->be->ck_opts & PR_CK_PSV)) &&
 		    (!(t->flags & SN_DIRECT) ||
 		     ((t->be->cookie_maxidle || txn->cookie_last_date) &&
@@ -5363,13 +5363,13 @@
 			 * requests and this one isn't. Note that servers which don't have cookies
 			 * (eg: some backup servers) will return a full cookie removal request.
 			 */
-			if (!target_srv(&t->target)->cookie) {
+			if (!objt_server(t->target)->cookie) {
 				chunk_printf(&trash,
 					      "Set-Cookie: %s=; Expires=Thu, 01-Jan-1970 00:00:01 GMT; path=/",
 					      t->be->cookie_name);
 			}
 			else {
-				chunk_printf(&trash, "Set-Cookie: %s=%s", t->be->cookie_name, target_srv(&t->target)->cookie);
+				chunk_printf(&trash, "Set-Cookie: %s=%s", t->be->cookie_name, objt_server(t->target)->cookie);
 
 				if (t->be->cookie_maxidle || t->be->cookie_maxlife) {
 					/* emit last_date, which is mandatory */
@@ -5404,7 +5404,7 @@
 				goto return_bad_resp;
 
 			txn->flags &= ~TX_SCK_MASK;
-			if (target_srv(&t->target)->cookie && (t->flags & SN_DIRECT))
+			if (objt_server(t->target)->cookie && (t->flags & SN_DIRECT))
 				/* the server did not change, only the date was updated */
 				txn->flags |= TX_SCK_UPDATED;
 			else
@@ -5438,8 +5438,8 @@
 			 * a set-cookie header. We'll block it as requested by
 			 * the 'checkcache' option, and send an alert.
 			 */
-			if (target_srv(&t->target))
-				target_srv(&t->target)->counters.failed_secu++;
+			if (objt_server(t->target))
+				objt_server(t->target)->counters.failed_secu++;
 
 			t->be->be_counters.denied_resp++;
 			t->fe->fe_counters.denied_resp++;
@@ -5447,10 +5447,10 @@
 				t->listener->counters->denied_resp++;
 
 			Alert("Blocking cacheable cookie in response from instance %s, server %s.\n",
-			      t->be->id, target_srv(&t->target) ? target_srv(&t->target)->id : "<dispatch>");
+			      t->be->id, objt_server(t->target) ? objt_server(t->target)->id : "<dispatch>");
 			send_log(t->be, LOG_ALERT,
 				 "Blocking cacheable cookie in response from instance %s, server %s.\n",
-				 t->be->id, target_srv(&t->target) ? target_srv(&t->target)->id : "<dispatch>");
+				 t->be->id, objt_server(t->target) ? objt_server(t->target)->id : "<dispatch>");
 			goto return_srv_prx_502;
 		}
 
@@ -5712,8 +5712,8 @@
 		if (!(s->flags & SN_ERR_MASK))
 			s->flags |= SN_ERR_SRVCL;
 		s->be->be_counters.srv_aborts++;
-		if (target_srv(&s->target))
-			target_srv(&s->target)->counters.srv_aborts++;
+		if (objt_server(s->target))
+			objt_server(s->target)->counters.srv_aborts++;
 		goto return_bad_res_stats_ok;
 	}
 
@@ -5762,8 +5762,8 @@
 
  return_bad_res: /* let's centralize all bad responses */
 	s->be->be_counters.failed_resp++;
-	if (target_srv(&s->target))
-		target_srv(&s->target)->counters.failed_resp++;
+	if (objt_server(s->target))
+		objt_server(s->target)->counters.failed_resp++;
 
  return_bad_res_stats_ok:
 	txn->rsp.msg_state = HTTP_MSG_ERROR;
@@ -5771,8 +5771,8 @@
 	stream_int_retnclose(res->cons, NULL);
 	res->analysers = 0;
 	s->req->analysers = 0; /* we're in data phase, we want to abort both directions */
-	if (target_srv(&s->target))
-		health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_HDRRSP);
+	if (objt_server(s->target))
+		health_adjust(objt_server(s->target), HANA_STATUS_HTTP_HDRRSP);
 
 	if (!(s->flags & SN_ERR_MASK))
 		s->flags |= SN_ERR_PRXCOND;
@@ -5789,8 +5789,8 @@
 
 	s->fe->fe_counters.cli_aborts++;
 	s->be->be_counters.cli_aborts++;
-	if (target_srv(&s->target))
-		target_srv(&s->target)->counters.cli_aborts++;
+	if (objt_server(s->target))
+		objt_server(s->target)->counters.cli_aborts++;
 
 	if (!(s->flags & SN_ERR_MASK))
 		s->flags |= SN_ERR_CLICL;
@@ -6166,7 +6166,7 @@
 						txn->flags &= ~TX_CK_MASK;
 						txn->flags |= (srv->state & SRV_RUNNING) ? TX_CK_VALID : TX_CK_DOWN;
 						t->flags |= SN_DIRECT | SN_ASSIGNED;
-						set_target_server(&t->target, srv);
+						t->target = &srv->obj_type;
 
 						break;
 					} else {
@@ -6576,7 +6576,7 @@
 							txn->flags &= ~TX_CK_MASK;
 							txn->flags |= (srv->state & SRV_RUNNING) ? TX_CK_VALID : TX_CK_DOWN;
 							t->flags |= SN_DIRECT | SN_ASSIGNED;
-							set_target_server(&t->target, srv);
+							t->target = &srv->obj_type;
 							break;
 						} else {
 							/* we found a server, but it's down,
@@ -7152,7 +7152,7 @@
 				}
 			}
 
-			srv = target_srv(&t->target);
+			srv = objt_server(t->target);
 			/* now check if we need to process it for persistence */
 			if (!(t->flags & SN_IGNORE_PRST) &&
 			    (att_end - att_beg == t->be->cookie_len) && (t->be->cookie_name != NULL) &&
@@ -7289,7 +7289,7 @@
 			memcpy(asession->sessid, txn->sessid, t->be->appsession_len);
 			asession->sessid[t->be->appsession_len] = 0;
 
-			server_id_len = strlen(target_srv(&t->target)->id) + 1;
+			server_id_len = strlen(objt_server(t->target)->id) + 1;
 			if ((asession->serverid = pool_alloc2(apools.serverid)) == NULL) {
 				Alert("Not enough Memory process_srv():asession->serverid:malloc().\n");
 				send_log(t->be, LOG_ALERT, "Not enough Memory process_srv():asession->sessid:malloc().\n");
@@ -7297,7 +7297,7 @@
 				return;
 			}
 			asession->serverid[0] = '\0';
-			memcpy(asession->serverid, target_srv(&t->target)->id, server_id_len);
+			memcpy(asession->serverid, objt_server(t->target)->id, server_id_len);
 
 			asession->request_count = 0;
 			appsession_hash_insert(&(t->be->htbl_proxy), asession);
@@ -7582,7 +7582,7 @@
 
 	es->when = date; // user-visible date
 	es->sid  = s->uniq_id;
-	es->srv  = target_srv(&s->target);
+	es->srv  = objt_server(s->target);
 	es->oe   = other_end;
 	es->src  = s->req->prod->conn->addr.from;
 	es->state = state;
@@ -7775,7 +7775,7 @@
 	s->be = s->fe;
 	s->logs.logwait = s->fe->to_log;
 	session_del_srv_conn(s);
-	clear_target(&s->target);
+	s->target = NULL;
 	/* re-init store persistence */
 	s->store_count = 0;
 
diff --git a/src/proto_tcp.c b/src/proto_tcp.c
index 28df64b..e744c76 100644
--- a/src/proto_tcp.c
+++ b/src/proto_tcp.c
@@ -220,7 +220,7 @@
  * pointed to by conn->addr.from in case of transparent proxying. Normal source
  * bind addresses are still determined locally (due to the possible need of a
  * source port). conn->target may point either to a valid server or to a backend,
- * depending on conn->target.type. Only TARG_TYPE_PROXY and TARG_TYPE_SERVER are
+ * depending on conn->target. Only OBJ_TYPE_PROXY and OBJ_TYPE_SERVER are
  * supported. The <data> parameter is a boolean indicating whether there are data
  * waiting for being sent or not, in order to adjust data write polling and on
  * some platforms, the ability to avoid an empty initial ACK.
@@ -241,13 +241,13 @@
 	struct server *srv;
 	struct proxy *be;
 
-	switch (conn->target.type) {
-	case TARG_TYPE_PROXY:
-		be = conn->target.ptr.p;
+	switch (obj_type(conn->target)) {
+	case OBJ_TYPE_PROXY:
+		be = objt_proxy(conn->target);
 		srv = NULL;
 		break;
-	case TARG_TYPE_SERVER:
-		srv = conn->target.ptr.s;
+	case OBJ_TYPE_SERVER:
+		srv = objt_server(conn->target);
 		be = srv->proxy;
 		break;
 	default:
diff --git a/src/proxy.c b/src/proxy.c
index 2c710bb..914d979 100644
--- a/src/proxy.c
+++ b/src/proxy.c
@@ -26,6 +26,7 @@
 #include <common/time.h>
 
 #include <types/global.h>
+#include <types/obj_type.h>
 #include <types/peers.h>
 
 #include <proto/backend.h>
@@ -425,6 +426,7 @@
 void init_new_proxy(struct proxy *p)
 {
 	memset(p, 0, sizeof(struct proxy));
+	p->obj_type = OBJ_TYPE_PROXY;
 	LIST_INIT(&p->pendconns);
 	LIST_INIT(&p->acl);
 	LIST_INIT(&p->http_req_rules);
diff --git a/src/queue.c b/src/queue.c
index dd6e962..abc0f8c 100644
--- a/src/queue.c
+++ b/src/queue.c
@@ -122,7 +122,7 @@
 
 	/* we want to note that the session has now been assigned a server */
 	sess->flags |= SN_ASSIGNED;
-	set_target_server(&sess->target, srv);
+	sess->target = &srv->obj_type;
 	session_add_srv_conn(sess, srv);
 	srv->served++;
 	if (px->lbprm.server_take_conn)
@@ -148,7 +148,7 @@
 
 	sess->pend_pos = p;
 	p->sess = sess;
-	p->srv = srv = target_srv(&sess->target);
+	p->srv = srv = objt_server(sess->target);
 
 	if (sess->flags & SN_ASSIGNED && srv) {
 		LIST_ADDQ(&srv->pendconns, &p->list);
diff --git a/src/session.c b/src/session.c
index 3d28677..0b0a4ec 100644
--- a/src/session.c
+++ b/src/session.c
@@ -110,7 +110,7 @@
 	s->si[0].conn->ctrl = l->proto;
 	s->si[0].conn->flags = CO_FL_NONE;
 	s->si[0].conn->addr.from = *addr;
-	set_target_client(&s->si[0].conn->target, l);
+	s->si[0].conn->target = &l->obj_type;
 
 	s->logs.accept_date = date; /* user-visible date for logging */
 	s->logs.tv_accept = now;  /* corrected date for internal use */
@@ -415,7 +415,7 @@
 	s->si[1].err_loc   = NULL;
 	s->si[1].release   = NULL;
 	s->si[1].send_proxy_ofs = 0;
-	clear_target(&s->si[1].conn->target);
+	s->si[1].conn->target = NULL;
 	si_prepare_embedded(&s->si[1]);
 	s->si[1].exp       = TICK_ETERNITY;
 	s->si[1].flags     = SI_FL_NONE;
@@ -424,7 +424,7 @@
 		s->si[1].flags |= SI_FL_INDEP_STR;
 
 	session_init_srv_conn(s);
-	clear_target(&s->target);
+	s->target = NULL;
 	s->pend_pos = NULL;
 
 	/* init store persistence */
@@ -548,13 +548,13 @@
 	if (s->pend_pos)
 		pendconn_free(s->pend_pos);
 
-	if (target_srv(&s->target)) { /* there may be requests left pending in queue */
+	if (objt_server(s->target)) { /* there may be requests left pending in queue */
 		if (s->flags & SN_CURR_SESS) {
 			s->flags &= ~SN_CURR_SESS;
-			target_srv(&s->target)->cur_sess--;
+			objt_server(s->target)->cur_sess--;
 		}
-		if (may_dequeue_tasks(target_srv(&s->target), s->be))
-			process_srv_queue(target_srv(&s->target));
+		if (may_dequeue_tasks(objt_server(s->target), s->be))
+			process_srv_queue(objt_server(s->target));
 	}
 
 	if (unlikely(s->srv_conn)) {
@@ -653,8 +653,8 @@
 
 			s->be->be_counters.bytes_in			+= bytes;
 
-			if (target_srv(&s->target))
-				target_srv(&s->target)->counters.bytes_in		+= bytes;
+			if (objt_server(s->target))
+				objt_server(s->target)->counters.bytes_in		+= bytes;
 
 			if (s->listener->counters)
 				s->listener->counters->bytes_in		+= bytes;
@@ -703,8 +703,8 @@
 
 			s->be->be_counters.bytes_out			+= bytes;
 
-			if (target_srv(&s->target))
-				target_srv(&s->target)->counters.bytes_out		+= bytes;
+			if (objt_server(s->target))
+				objt_server(s->target)->counters.bytes_out		+= bytes;
 
 			if (s->listener->counters)
 				s->listener->counters->bytes_out	+= bytes;
@@ -773,7 +773,7 @@
 			si->state    = SI_ST_EST;
 			si->err_type = SI_ET_DATA_ERR;
 			si->ib->flags |= CF_READ_ERROR | CF_WRITE_ERROR;
-			si->err_loc = target_srv(&s->target);
+			si->err_loc = objt_server(s->target);
 			return 1;
 		}
 		si->exp   = TICK_ETERNITY;
@@ -787,7 +787,7 @@
 		if (si->err_type)
 			return 0;
 
-		si->err_loc = target_srv(&s->target);
+		si->err_loc = objt_server(s->target);
 		if (si->flags & SI_FL_ERR)
 			si->err_type = SI_ET_CONN_ERR;
 		else
@@ -803,7 +803,7 @@
 		/* give up */
 		si_shutw(si);
 		si->err_type |= SI_ET_CONN_ABRT;
-		si->err_loc  = target_srv(&s->target);
+		si->err_loc  = objt_server(s->target);
 		if (s->srv_error)
 			s->srv_error(s, si);
 		return 1;
@@ -836,12 +836,12 @@
 static int sess_update_st_cer(struct session *s, struct stream_interface *si)
 {
 	/* we probably have to release last session from the server */
-	if (target_srv(&s->target)) {
-		health_adjust(target_srv(&s->target), HANA_STATUS_L4_ERR);
+	if (objt_server(s->target)) {
+		health_adjust(objt_server(s->target), HANA_STATUS_L4_ERR);
 
 		if (s->flags & SN_CURR_SESS) {
 			s->flags &= ~SN_CURR_SESS;
-			target_srv(&s->target)->cur_sess--;
+			objt_server(s->target)->cur_sess--;
 		}
 	}
 
@@ -850,15 +850,15 @@
 	if (si->conn_retries < 0) {
 		if (!si->err_type) {
 			si->err_type = SI_ET_CONN_ERR;
-			si->err_loc = target_srv(&s->target);
+			si->err_loc = objt_server(s->target);
 		}
 
-		if (target_srv(&s->target))
-			target_srv(&s->target)->counters.failed_conns++;
+		if (objt_server(s->target))
+			objt_server(s->target)->counters.failed_conns++;
 		s->be->be_counters.failed_conns++;
 		sess_change_server(s, NULL);
-		if (may_dequeue_tasks(target_srv(&s->target), s->be))
-			process_srv_queue(target_srv(&s->target));
+		if (may_dequeue_tasks(objt_server(s->target), s->be))
+			process_srv_queue(objt_server(s->target));
 
 		/* shutw is enough so stop a connecting socket */
 		si_shutw(si);
@@ -877,17 +877,17 @@
 	 * bit to ignore any persistence cookie. We won't count a retry nor a
 	 * redispatch yet, because this will depend on what server is selected.
 	 */
-	if (target_srv(&s->target) && si->conn_retries == 0 &&
+	if (objt_server(s->target) && si->conn_retries == 0 &&
 	    s->be->options & PR_O_REDISP && !(s->flags & SN_FORCE_PRST)) {
 		sess_change_server(s, NULL);
-		if (may_dequeue_tasks(target_srv(&s->target), s->be))
-			process_srv_queue(target_srv(&s->target));
+		if (may_dequeue_tasks(objt_server(s->target), s->be))
+			process_srv_queue(objt_server(s->target));
 
 		s->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
 		si->state = SI_ST_REQ;
 	} else {
-		if (target_srv(&s->target))
-			target_srv(&s->target)->counters.retries++;
+		if (objt_server(s->target))
+			objt_server(s->target)->counters.retries++;
 		s->be->be_counters.retries++;
 		si->state = SI_ST_ASS;
 	}
@@ -919,8 +919,8 @@
 	struct channel *req = si->ob;
 	struct channel *rep = si->ib;
 
-	if (target_srv(&s->target))
-		health_adjust(target_srv(&s->target), HANA_STATUS_L4_OK);
+	if (objt_server(s->target))
+		health_adjust(objt_server(s->target), HANA_STATUS_L4_OK);
 
 	if (s->be->mode == PR_MODE_TCP) { /* let's allow immediate data connection in this case */
 		/* if the user wants to log as soon as possible, without counting
@@ -955,7 +955,7 @@
  */
 static void sess_update_stream_int(struct session *s, struct stream_interface *si)
 {
-	struct server *srv = target_srv(&s->target);
+	struct server *srv = objt_server(s->target);
 
 	DPRINTF(stderr,"[%u] %s: sess=%p rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rqh=%d rqt=%d rph=%d rpt=%d cs=%d ss=%d\n",
 		now_ms, __FUNCTION__,
@@ -970,7 +970,7 @@
 		int conn_err;
 
 		conn_err = connect_server(s);
-		srv = target_srv(&s->target);
+		srv = objt_server(s->target);
 
 		if (conn_err == SN_ERR_NONE) {
 			/* state = SI_ST_CON now */
@@ -1314,7 +1314,7 @@
 				    (px->options & PR_O_PERSIST) ||
 				    (s->flags & SN_FORCE_PRST)) {
 					s->flags |= SN_DIRECT | SN_ASSIGNED;
-					set_target_server(&s->target, srv);
+					s->target = &srv->obj_type;
 					break;
 				}
 				/* if the server is not UP, let's go on with next rules
@@ -1392,7 +1392,7 @@
 							    (px->options & PR_O_PERSIST) ||
 							    (s->flags & SN_FORCE_PRST)) {
 								s->flags |= SN_DIRECT | SN_ASSIGNED;
-								set_target_server(&s->target, srv);
+								s->target = &srv->obj_type;
 							}
 						}
 					}
@@ -1488,7 +1488,7 @@
 		struct stksess *ts;
 		void *ptr;
 
-		if (target_srv(&s->target) && target_srv(&s->target)->state & SRV_NON_STICK) {
+		if (objt_server(s->target) && objt_server(s->target)->state & SRV_NON_STICK) {
 			stksess_free(s->store[i].table, s->store[i].ts);
 			s->store[i].ts = NULL;
 			continue;
@@ -1505,7 +1505,7 @@
 
 		s->store[i].ts = NULL;
 		ptr = stktable_data_ptr(s->store[i].table, ts, STKTABLE_DT_SERVER_ID);
-		stktable_data_cast(ptr, server_id) = target_srv(&s->target)->puid;
+		stktable_data_cast(ptr, server_id) = objt_server(s->target)->puid;
 	}
 	s->store_count = 0; /* everything is stored */
 
@@ -1621,7 +1621,7 @@
 	 * the client cannot have connect (hence retryable) errors. Also, the
 	 * connection setup code must be able to deal with any type of abort.
 	 */
-	srv = target_srv(&s->target);
+	srv = objt_server(s->target);
 	if (unlikely(s->si[0].flags & SI_FL_ERR)) {
 		if (s->si[0].state == SI_ST_EST || s->si[0].state == SI_ST_DIS) {
 			si_shutr(&s->si[0]);
@@ -1706,7 +1706,7 @@
 	 */
 	if (unlikely(s->req->cons->state == SI_ST_DIS)) {
 		s->req->cons->state = SI_ST_CLO;
-		srv = target_srv(&s->target);
+		srv = objt_server(s->target);
 		if (srv) {
 			if (s->flags & SN_CURR_SESS) {
 				s->flags &= ~SN_CURR_SESS;
@@ -1988,7 +1988,7 @@
 	 * we're just in a data phase here since it means we have not
 	 * seen any analyser who could set an error status.
 	 */
-	srv = target_srv(&s->target);
+	srv = objt_server(s->target);
 	if (unlikely(!(s->flags & SN_ERR_MASK))) {
 		if (s->req->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
 			/* Report it if the client got an error or a read timeout expired */
@@ -2148,7 +2148,7 @@
 				 */
 				s->req->cons->state = SI_ST_REQ; /* new connection requested */
 				s->req->cons->conn_retries = s->be->conn_retries;
-				if (unlikely(s->req->cons->conn->target.type == TARG_TYPE_APPLET &&
+				if (unlikely(obj_type(s->req->cons->conn->target) == OBJ_TYPE_APPLET &&
 					     !(si_ctrl(s->req->cons) && si_ctrl(s->req->cons)->connect))) {
 					s->req->cons->state = SI_ST_EST; /* connection established */
 					s->rep->flags |= CF_READ_ATTACHED; /* producer is now attached */
@@ -2177,7 +2177,7 @@
 			if (s->si[1].state == SI_ST_REQ)
 				sess_prepare_conn_req(s, &s->si[1]);
 
-			srv = target_srv(&s->target);
+			srv = objt_server(s->target);
 			if (s->si[1].state == SI_ST_ASS && srv && srv->rdr_len && (s->flags & SN_REDIRECTABLE))
 				perform_http_redirect(s, &s->si[1]);
 		} while (s->si[1].state == SI_ST_ASS);
@@ -2187,7 +2187,7 @@
 		if ((s->flags & SN_BE_ASSIGNED) &&
 		    (s->be->mode == PR_MODE_HTTP) &&
 		    (s->be->server_id_hdr_name != NULL)) {
-			http_send_name_header(&s->txn, s->be, target_srv(&s->target)->id);
+			http_send_name_header(&s->txn, s->be, objt_server(s->target)->id);
 		}
 	}
 
@@ -2327,10 +2327,10 @@
 		if ((s->fe->options & PR_O_CONTSTATS) && (s->flags & SN_BE_ASSIGNED))
 			session_process_counters(s);
 
-		if (s->rep->cons->state == SI_ST_EST && s->rep->cons->conn->target.type != TARG_TYPE_APPLET)
+		if (s->rep->cons->state == SI_ST_EST && obj_type(s->rep->cons->conn->target) != OBJ_TYPE_APPLET)
 			si_update(s->rep->cons);
 
-		if (s->req->cons->state == SI_ST_EST && s->req->cons->conn->target.type != TARG_TYPE_APPLET)
+		if (s->req->cons->state == SI_ST_EST && obj_type(s->req->cons->conn->target) != OBJ_TYPE_APPLET)
 			si_update(s->req->cons);
 
 		s->req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
@@ -2357,12 +2357,12 @@
 		/* Call the stream interfaces' I/O handlers when embedded.
 		 * Note that this one may wake the task up again.
 		 */
-		if (s->req->cons->conn->target.type == TARG_TYPE_APPLET ||
-		    s->rep->cons->conn->target.type == TARG_TYPE_APPLET) {
-			if (s->req->cons->conn->target.type == TARG_TYPE_APPLET)
-				s->req->cons->conn->target.ptr.a->fct(s->req->cons);
-			if (s->rep->cons->conn->target.type == TARG_TYPE_APPLET)
-				s->rep->cons->conn->target.ptr.a->fct(s->rep->cons);
+		if (obj_type(s->req->cons->conn->target) == OBJ_TYPE_APPLET ||
+		    obj_type(s->rep->cons->conn->target) == OBJ_TYPE_APPLET) {
+			if (objt_applet(s->req->cons->conn->target))
+				objt_applet(s->req->cons->conn->target)->fct(s->req->cons);
+			if (objt_applet(s->rep->cons->conn->target))
+				objt_applet(s->rep->cons->conn->target)->fct(s->rep->cons);
 			if (task_in_rq(t)) {
 				/* If we woke up, we don't want to requeue the
 				 * task to the wait queue, but rather requeue
diff --git a/src/ssl_sock.c b/src/ssl_sock.c
index bc4afc6..f19e0a7 100644
--- a/src/ssl_sock.c
+++ b/src/ssl_sock.c
@@ -125,7 +125,7 @@
 			conn->xprt_st |= SSL_SOCK_CAEDEPTH_TO_ST(depth);
 		}
 
-		if (target_client(&conn->target)->bind_conf->ca_ignerr & (1ULL << err))
+		if (objt_listener(conn->target)->bind_conf->ca_ignerr & (1ULL << err))
 			return 1;
 
 		return 0;
@@ -135,7 +135,7 @@
 		conn->xprt_st |= SSL_SOCK_CRTERROR_TO_ST(err);
 
 	/* check if certificate error needs to be ignored */
-	if (target_client(&conn->target)->bind_conf->crt_ignerr & (1ULL << err))
+	if (objt_listener(conn->target)->bind_conf->crt_ignerr & (1ULL << err))
 		return 1;
 
 	return 0;
@@ -798,15 +798,15 @@
 
 	/* If it is in client mode initiate SSL session
 	   in connect state otherwise accept state */
-	if (target_srv(&conn->target)) {
+	if (objt_server(conn->target)) {
 		/* Alloc a new SSL session ctx */
-		conn->xprt_ctx = SSL_new(target_srv(&conn->target)->ssl_ctx.ctx);
+		conn->xprt_ctx = SSL_new(objt_server(conn->target)->ssl_ctx.ctx);
 		if (!conn->xprt_ctx)
 			return -1;
 
 		SSL_set_connect_state(conn->xprt_ctx);
-		if (target_srv(&conn->target)->ssl_ctx.reused_sess)
-			SSL_set_session(conn->xprt_ctx, target_srv(&conn->target)->ssl_ctx.reused_sess);
+		if (objt_server(conn->target)->ssl_ctx.reused_sess)
+			SSL_set_session(conn->xprt_ctx, objt_server(conn->target)->ssl_ctx.reused_sess);
 
 		/* set fd on SSL session context */
 		SSL_set_fd(conn->xprt_ctx, conn->t.sock.fd);
@@ -817,9 +817,9 @@
 		sslconns++;
 		return 0;
 	}
-	else if (target_client(&conn->target)) {
+	else if (objt_listener(conn->target)) {
 		/* Alloc a new SSL session ctx */
-		conn->xprt_ctx = SSL_new(target_client(&conn->target)->bind_conf->default_ctx);
+		conn->xprt_ctx = SSL_new(objt_listener(conn->target)->bind_conf->default_ctx);
 		if (!conn->xprt_ctx)
 			return -1;
 
@@ -893,13 +893,13 @@
 	}
 
 	/* Handshake succeeded */
-	if (target_srv(&conn->target)) {
+	if (objt_server(conn->target)) {
 		if (!SSL_session_reused(conn->xprt_ctx)) {
 			/* check if session was reused, if not store current session on server for reuse */
-			if (target_srv(&conn->target)->ssl_ctx.reused_sess)
-				SSL_SESSION_free(target_srv(&conn->target)->ssl_ctx.reused_sess);
+			if (objt_server(conn->target)->ssl_ctx.reused_sess)
+				SSL_SESSION_free(objt_server(conn->target)->ssl_ctx.reused_sess);
 
-			target_srv(&conn->target)->ssl_ctx.reused_sess = SSL_get1_session(conn->xprt_ctx);
+			objt_server(conn->target)->ssl_ctx.reused_sess = SSL_get1_session(conn->xprt_ctx);
 		}
 	}
 
@@ -909,9 +909,9 @@
 
  out_error:
 	/* free resumed session if exists */
-	if (target_srv(&conn->target) && target_srv(&conn->target)->ssl_ctx.reused_sess) {
-		SSL_SESSION_free(target_srv(&conn->target)->ssl_ctx.reused_sess);
-		target_srv(&conn->target)->ssl_ctx.reused_sess = NULL;
+	if (objt_server(conn->target) && objt_server(conn->target)->ssl_ctx.reused_sess) {
+		SSL_SESSION_free(objt_server(conn->target)->ssl_ctx.reused_sess);
+		objt_server(conn->target)->ssl_ctx.reused_sess = NULL;
 	}
 
 	/* Fail on all other handshake errors */
diff --git a/src/stream_interface.c b/src/stream_interface.c
index bcedcb0..c847632 100644
--- a/src/stream_interface.c
+++ b/src/stream_interface.c
@@ -406,7 +406,7 @@
 	DPRINTF(stderr, "registering handler %p for si %p (was %p)\n", app, si, si->owner);
 
 	si_prepare_embedded(si);
-	set_target_applet(&si->conn->target, app);
+	si->conn->target = &app->obj_type;
 	si->release = app->release;
 	si->flags |= SI_FL_WAIT_DATA;
 	return si->owner;
@@ -419,7 +419,7 @@
 {
 	si->release = NULL;
 	si->owner = NULL;
-	clear_target(&si->conn->target);
+	si->conn->target = NULL;
 }
 
 /* This callback is used to send a valid PROXY protocol line to a socket being