Type: improvement
Signed-off-by: Florin Coras <fcoras@cisco.com>
Change-Id: I8e466e789c860caaa55f67095a57fc6ab670f32b
s = vcl_session_get (wrk, vls->session_index);
if (PREDICT_FALSE (!s))
return;
s = vcl_session_get (wrk, vls->session_index);
if (PREDICT_FALSE (!s))
return;
- is_nonblk = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
+ is_nonblk = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
VCL_SESS_ATTR_MAX
} vppcom_session_attr_t;
VCL_SESS_ATTR_MAX
} vppcom_session_attr_t;
-#define VCL_SESS_ATTR_SET(ATTR, VAL) \
-do { \
- (ATTR) |= 1 << (VAL); \
- } while (0)
-
-#define VCL_SESS_ATTR_CLR(ATTR, VAL) \
-do { \
- (ATTR) &= ~(1 << (VAL)); \
- } while (0)
-
-#define VCL_SESS_ATTR_TEST(ATTR, VAL) \
- ((ATTR) & (1 << (VAL)) ? 1 : 0)
-
typedef enum vcl_session_flags_
{
VCL_SESSION_F_CONNECTED = 1 << 0,
VCL_SESSION_F_IS_VEP = 1 << 1,
VCL_SESSION_F_IS_VEP_SESSION = 1 << 2,
typedef enum vcl_session_flags_
{
VCL_SESSION_F_CONNECTED = 1 << 0,
VCL_SESSION_F_IS_VEP = 1 << 1,
VCL_SESSION_F_IS_VEP_SESSION = 1 << 2,
+ VCL_SESSION_F_HAS_RX_EVT = 1 << 3,
} __clib_packed vcl_session_flags_t;
} __clib_packed vcl_session_flags_t;
+typedef struct vcl_session_
{
CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
{
CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
#define _(type, name) type name;
foreach_app_session_field
#undef _
#define _(type, name) type name;
foreach_app_session_field
#undef _
- u32 sndbuf_size; // VPP-TBD: Hack until support setsockopt(SO_SNDBUF)
- u32 rcvbuf_size; // VPP-TBD: Hack until support setsockopt(SO_RCVBUF)
- u32 user_mss; // VPP-TBD: Hack until support setsockopt(TCP_MAXSEG)
- u64 vpp_handle;
- u32 vpp_thread_index;
+ vcl_session_flags_t flags; /**< see @ref vcl_session_flags_t */
+ u32 rx_bytes_pending; /**< bytes rx-ed as segs but not yet freed */
svm_fifo_t *ct_rx_fifo;
svm_fifo_t *ct_tx_fifo;
svm_fifo_t *ct_rx_fifo;
svm_fifo_t *ct_tx_fifo;
+ vcl_session_msg_t *accept_evts_fifo;
- /* Socket configuration state */
- vcl_session_flags_t flags;
- /* VCL session index of the listening session (if any) */
- u32 listener_index;
- /* Accepted sessions on this listener */
- int n_accepted_sessions;
- u8 has_rx_evt;
- u32 attr;
+ u64 vpp_handle;
+ u32 vpp_thread_index;
+ u32 listener_index; /**< index of parent listener (if any) */
+ int n_accepted_sessions; /**< sessions accepted by this listener */
+ u32 attributes; /**< see @ref vppcom_session_attr_t */
- svm_msg_q_t *our_evt_q;
- vcl_session_msg_t *accept_evts_fifo;
- /** bytes delivered as segment but not yet freed */
- u32 rx_bytes_pending;
+ vppcom_epoll_t vep;
+
+ u32 sndbuf_size; // VPP-TBD: Hack until support setsockopt(SO_SNDBUF)
+ u32 rcvbuf_size; // VPP-TBD: Hack until support setsockopt(SO_RCVBUF)
+ u32 user_mss; // VPP-TBD: Hack until support setsockopt(TCP_MAXSEG)
+
#if VCL_ELOG
elog_track_t elog_track;
#endif
#if VCL_ELOG
elog_track_t elog_track;
#endif
return proto == VPPCOM_PROTO_UDP;
}
return proto == VPPCOM_PROTO_UDP;
}
+static inline u8
+vcl_session_has_attr (vcl_session_t * s, u8 attr)
+{
+ return (s->attributes & (1 << attr)) ? 1 : 0;
+}
+
+static inline void
+vcl_session_set_attr (vcl_session_t * s, u8 attr)
+{
+ s->attributes |= 1 << attr;
+}
+
+static inline void
+vcl_session_clear_attr (vcl_session_t * s, u8 attr)
+{
+ s->attributes &= ~(1 << attr);
+}
+
session->transport.lcl_port = mp->lcl.port;
/* Application closed session before connect reply */
session->transport.lcl_port = mp->lcl.port;
/* Application closed session before connect reply */
- if (VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK)
+ if (vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK)
&& session->session_state == VCL_STATE_CLOSED)
vcl_send_session_disconnect (wrk, session);
else
&& session->session_state == VCL_STATE_CLOSED)
vcl_send_session_disconnect (wrk, session);
else
session->is_dgram = vcl_proto_is_dgram (proto);
if (is_nonblocking)
session->is_dgram = vcl_proto_is_dgram (proto);
if (is_nonblocking)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_NONBLOCK);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_NONBLOCK);
vcl_evt (VCL_EVT_CREATE, session, session_type, session->session_state,
is_nonblocking, session_index);
vcl_evt (VCL_EVT_CREATE, session, session_type, session->session_state,
is_nonblocking, session_index);
- is_nonblocking = VCL_SESS_ATTR_TEST (listen_session->attr,
- VCL_SESS_ATTR_NONBLOCK);
+ is_nonblocking = vcl_session_has_attr (listen_session,
+ VCL_SESS_ATTR_NONBLOCK);
while (1)
{
if (svm_msg_q_is_empty (wrk->app_event_queue) && is_nonblocking)
while (1)
{
if (svm_msg_q_is_empty (wrk->app_event_queue) && is_nonblocking)
client_session = vcl_session_get (wrk, client_session_index);
if (flags & O_NONBLOCK)
client_session = vcl_session_get (wrk, client_session_index);
if (flags & O_NONBLOCK)
- VCL_SESS_ATTR_SET (client_session->attr, VCL_SESS_ATTR_NONBLOCK);
+ vcl_session_set_attr (client_session, VCL_SESS_ATTR_NONBLOCK);
VDBG (1, "listener %u [0x%llx]: Got a connect request! session %u [0x%llx],"
" flags %d, is_nonblocking %u", listen_session->session_index,
listen_session->vpp_handle, client_session_index,
client_session->vpp_handle, flags,
VDBG (1, "listener %u [0x%llx]: Got a connect request! session %u [0x%llx],"
" flags %d, is_nonblocking %u", listen_session->session_index,
listen_session->vpp_handle, client_session_index,
client_session->vpp_handle, flags,
- VCL_SESS_ATTR_TEST (client_session->attr, VCL_SESS_ATTR_NONBLOCK));
+ vcl_session_has_attr (client_session, VCL_SESS_ATTR_NONBLOCK));
vcl_send_session_connect (wrk, session);
vcl_send_session_connect (wrk, session);
- if (VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK))
+ if (vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK))
{
/* State set to STATE_UPDATED to ensure the session is not assumed
* to be ready and to also allow the app to close it prior to vpp's
{
/* State set to STATE_UPDATED to ensure the session is not assumed
* to be ready and to also allow the app to close it prior to vpp's
return vcl_session_closed_error (s);
}
return vcl_session_closed_error (s);
}
- is_nonblocking = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
+ is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
is_ct = vcl_session_is_ct (s);
mq = wrk->app_event_queue;
rx_fifo = is_ct ? s->ct_rx_fifo : s->rx_fifo;
is_ct = vcl_session_is_ct (s);
mq = wrk->app_event_queue;
rx_fifo = is_ct ? s->ct_rx_fifo : s->rx_fifo;
+ s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
if (svm_fifo_is_empty_cons (rx_fifo))
{
if (svm_fifo_is_empty_cons (rx_fifo))
{
if (PREDICT_FALSE (!vcl_session_is_open (s)))
return vcl_session_closed_error (s);
if (PREDICT_FALSE (!vcl_session_is_open (s)))
return vcl_session_closed_error (s);
- is_nonblocking = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
+ is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
is_ct = vcl_session_is_ct (s);
is_ct = vcl_session_is_ct (s);
- mq = is_ct ? s->our_evt_q : wrk->app_event_queue;
+ mq = wrk->app_event_queue;
+ s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
if (is_ct)
svm_fifo_unset_event (s->rx_fifo);
if (is_ct)
svm_fifo_unset_event (s->rx_fifo);
svm_fifo_unset_event (s->rx_fifo);
if (svm_fifo_max_dequeue_cons (rx_fifo) != n_read
&& svm_fifo_set_event (s->rx_fifo)
svm_fifo_unset_event (s->rx_fifo);
if (svm_fifo_max_dequeue_cons (rx_fifo) != n_read
&& svm_fifo_set_event (s->rx_fifo)
- && VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK))
+ && vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK))
{
session_event_t *e;
vec_add2 (wrk->unhandled_evts_vector, e, 1);
{
session_event_t *e;
vec_add2 (wrk->unhandled_evts_vector, e, 1);
is_ct = vcl_session_is_ct (s);
tx_fifo = is_ct ? s->ct_tx_fifo : s->tx_fifo;
is_ct = vcl_session_is_ct (s);
tx_fifo = is_ct ? s->ct_tx_fifo : s->tx_fifo;
- is_nonblocking = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
+ is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
mq = wrk->app_event_queue;
if (!vcl_fifo_is_writeable (tx_fifo, n, is_dgram))
mq = wrk->app_event_queue;
if (!vcl_fifo_is_writeable (tx_fifo, n, is_dgram))
break;
vcl_fifo_rx_evt_valid_or_break (session);
session_events = session->vep.ev.events;
break;
vcl_fifo_rx_evt_valid_or_break (session);
session_events = session->vep.ev.events;
- if (!(EPOLLIN & session->vep.ev.events) || session->has_rx_evt)
+ if (!(EPOLLIN & session->vep.ev.events)
+ || (session->flags & VCL_SESSION_F_HAS_RX_EVT))
break;
add_event = 1;
events[*num_ev].events |= EPOLLIN;
session_evt_data = session->vep.ev.data.u64;
break;
add_event = 1;
events[*num_ev].events |= EPOLLIN;
session_evt_data = session->vep.ev.data.u64;
- session->has_rx_evt = 1;
+ session->flags |= VCL_SESSION_F_HAS_RX_EVT;
break;
case SESSION_IO_EVT_TX:
sid = e->session_index;
break;
case SESSION_IO_EVT_TX:
sid = e->session_index;
- (VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK) ?
+ (vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK) ?
O_NONBLOCK : 0);
*buflen = sizeof (*flags);
VDBG (2, "VPPCOM_ATTR_GET_FLAGS: sh %u, flags = 0x%08x, "
"is_nonblocking = %u", session_handle, *flags,
O_NONBLOCK : 0);
*buflen = sizeof (*flags);
VDBG (2, "VPPCOM_ATTR_GET_FLAGS: sh %u, flags = 0x%08x, "
"is_nonblocking = %u", session_handle, *flags,
- VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
+ vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK));
}
else
rv = VPPCOM_EINVAL;
}
else
rv = VPPCOM_EINVAL;
if (PREDICT_TRUE (buffer && buflen && (*buflen == sizeof (*flags))))
{
if (*flags & O_NONBLOCK)
if (PREDICT_TRUE (buffer && buflen && (*buflen == sizeof (*flags))))
{
if (*flags & O_NONBLOCK)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_NONBLOCK);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_NONBLOCK);
- VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_NONBLOCK);
+ vcl_session_clear_attr (session, VCL_SESS_ATTR_NONBLOCK);
VDBG (2, "VPPCOM_ATTR_SET_FLAGS: sh %u, flags = 0x%08x,"
" is_nonblocking = %u", session_handle, *flags,
VDBG (2, "VPPCOM_ATTR_SET_FLAGS: sh %u, flags = 0x%08x,"
" is_nonblocking = %u", session_handle, *flags,
- VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
+ vcl_session_has_attr (session, VCL_SESS_ATTR_NONBLOCK));
}
else
rv = VPPCOM_EINVAL;
}
else
rv = VPPCOM_EINVAL;
case VPPCOM_ATTR_GET_LISTEN:
if (buffer && buflen && (*buflen >= sizeof (int)))
{
case VPPCOM_ATTR_GET_LISTEN:
if (buffer && buflen && (*buflen >= sizeof (int)))
{
- *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_LISTEN);
+ *(int *) buffer = vcl_session_has_attr (session,
+ VCL_SESS_ATTR_LISTEN);
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_LISTEN: %d, buflen %d", *(int *) buffer,
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_LISTEN: %d, buflen %d", *(int *) buffer,
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
- *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_REUSEADDR);
+ *(int *) buffer = vcl_session_has_attr (session,
+ VCL_SESS_ATTR_REUSEADDR);
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_REUSEADDR: %d, buflen %d, #VPP-TBD#",
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_REUSEADDR: %d, buflen %d, #VPP-TBD#",
case VPPCOM_ATTR_SET_REUSEADDR:
if (buffer && buflen && (*buflen == sizeof (int)) &&
case VPPCOM_ATTR_SET_REUSEADDR:
if (buffer && buflen && (*buflen == sizeof (int)) &&
- !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
+ !vcl_session_has_attr (session, VCL_SESS_ATTR_LISTEN))
{
/* VPP-TBD */
if (*(int *) buffer)
{
/* VPP-TBD */
if (*(int *) buffer)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEADDR);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_REUSEADDR);
- VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEADDR);
+ vcl_session_clear_attr (session, VCL_SESS_ATTR_REUSEADDR);
VDBG (2, "VPPCOM_ATTR_SET_REUSEADDR: %d, buflen %d, #VPP-TBD#",
VDBG (2, "VPPCOM_ATTR_SET_REUSEADDR: %d, buflen %d, #VPP-TBD#",
- VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_REUSEADDR),
+ vcl_session_has_attr (session, VCL_SESS_ATTR_REUSEADDR),
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
- *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_REUSEPORT);
+ *(int *) buffer = vcl_session_has_attr (session,
+ VCL_SESS_ATTR_REUSEPORT);
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_REUSEPORT: %d, buflen %d, #VPP-TBD#",
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_REUSEPORT: %d, buflen %d, #VPP-TBD#",
case VPPCOM_ATTR_SET_REUSEPORT:
if (buffer && buflen && (*buflen == sizeof (int)) &&
case VPPCOM_ATTR_SET_REUSEPORT:
if (buffer && buflen && (*buflen == sizeof (int)) &&
- !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
+ !vcl_session_has_attr (session, VCL_SESS_ATTR_LISTEN))
{
/* VPP-TBD */
if (*(int *) buffer)
{
/* VPP-TBD */
if (*(int *) buffer)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEPORT);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_REUSEPORT);
- VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEPORT);
+ vcl_session_clear_attr (session, VCL_SESS_ATTR_REUSEPORT);
VDBG (2, "VPPCOM_ATTR_SET_REUSEPORT: %d, buflen %d, #VPP-TBD#",
VDBG (2, "VPPCOM_ATTR_SET_REUSEPORT: %d, buflen %d, #VPP-TBD#",
- VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_REUSEPORT),
+ vcl_session_has_attr (session, VCL_SESS_ATTR_REUSEPORT),
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
- *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_BROADCAST);
+ *(int *) buffer = vcl_session_has_attr (session,
+ VCL_SESS_ATTR_BROADCAST);
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_BROADCAST: %d, buflen %d, #VPP-TBD#",
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_BROADCAST: %d, buflen %d, #VPP-TBD#",
{
/* VPP-TBD */
if (*(int *) buffer)
{
/* VPP-TBD */
if (*(int *) buffer)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_BROADCAST);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_BROADCAST);
- VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_BROADCAST);
+ vcl_session_clear_attr (session, VCL_SESS_ATTR_BROADCAST);
VDBG (2, "VPPCOM_ATTR_SET_BROADCAST: %d, buflen %d, #VPP-TBD#",
VDBG (2, "VPPCOM_ATTR_SET_BROADCAST: %d, buflen %d, #VPP-TBD#",
- VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_BROADCAST),
+ vcl_session_has_attr (session, VCL_SESS_ATTR_BROADCAST),
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
- *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_V6ONLY);
+ *(int *) buffer = vcl_session_has_attr (session,
+ VCL_SESS_ATTR_V6ONLY);
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_V6ONLY: %d, buflen %d, #VPP-TBD#",
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_V6ONLY: %d, buflen %d, #VPP-TBD#",
{
/* VPP-TBD */
if (*(int *) buffer)
{
/* VPP-TBD */
if (*(int *) buffer)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_V6ONLY);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_V6ONLY);
- VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_V6ONLY);
+ vcl_session_clear_attr (session, VCL_SESS_ATTR_V6ONLY);
VDBG (2, "VPPCOM_ATTR_SET_V6ONLY: %d, buflen %d, #VPP-TBD#",
VDBG (2, "VPPCOM_ATTR_SET_V6ONLY: %d, buflen %d, #VPP-TBD#",
- VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_V6ONLY),
+ vcl_session_has_attr (session, VCL_SESS_ATTR_V6ONLY),
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
- *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_KEEPALIVE);
+ *(int *) buffer = vcl_session_has_attr (session,
+ VCL_SESS_ATTR_KEEPALIVE);
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_KEEPALIVE: %d, buflen %d, #VPP-TBD#",
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_KEEPALIVE: %d, buflen %d, #VPP-TBD#",
{
/* VPP-TBD */
if (*(int *) buffer)
{
/* VPP-TBD */
if (*(int *) buffer)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_KEEPALIVE);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_KEEPALIVE);
- VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_KEEPALIVE);
+ vcl_session_clear_attr (session, VCL_SESS_ATTR_KEEPALIVE);
VDBG (2, "VPPCOM_ATTR_SET_KEEPALIVE: %d, buflen %d, #VPP-TBD#",
VDBG (2, "VPPCOM_ATTR_SET_KEEPALIVE: %d, buflen %d, #VPP-TBD#",
- VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_KEEPALIVE),
+ vcl_session_has_attr (session, VCL_SESS_ATTR_KEEPALIVE),
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
- *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_TCP_NODELAY);
+ *(int *) buffer = vcl_session_has_attr (session,
+ VCL_SESS_ATTR_TCP_NODELAY);
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_TCP_NODELAY: %d, buflen %d, #VPP-TBD#",
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_TCP_NODELAY: %d, buflen %d, #VPP-TBD#",
{
/* VPP-TBD */
if (*(int *) buffer)
{
/* VPP-TBD */
if (*(int *) buffer)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_TCP_NODELAY);
- VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
+ vcl_session_clear_attr (session, VCL_SESS_ATTR_TCP_NODELAY);
VDBG (2, "VPPCOM_ATTR_SET_TCP_NODELAY: %d, buflen %d, #VPP-TBD#",
VDBG (2, "VPPCOM_ATTR_SET_TCP_NODELAY: %d, buflen %d, #VPP-TBD#",
- VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_TCP_NODELAY),
+ vcl_session_has_attr (session, VCL_SESS_ATTR_TCP_NODELAY),
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
- *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_TCP_KEEPIDLE);
+ *(int *) buffer = vcl_session_has_attr (session,
+ VCL_SESS_ATTR_TCP_KEEPIDLE);
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, buflen %d, #VPP-TBD#",
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, buflen %d, #VPP-TBD#",
{
/* VPP-TBD */
if (*(int *) buffer)
{
/* VPP-TBD */
if (*(int *) buffer)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_TCP_KEEPIDLE);
- VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
+ vcl_session_clear_attr (session, VCL_SESS_ATTR_TCP_KEEPIDLE);
VDBG (2, "VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, buflen %d, #VPP-TBD#",
VDBG (2, "VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, buflen %d, #VPP-TBD#",
- VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_TCP_KEEPIDLE), *buflen);
+ vcl_session_has_attr (session,
+ VCL_SESS_ATTR_TCP_KEEPIDLE), *buflen);
}
else
rv = VPPCOM_EINVAL;
}
else
rv = VPPCOM_EINVAL;
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
if (buffer && buflen && (*buflen >= sizeof (int)))
{
/* VPP-TBD */
- *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_TCP_KEEPINTVL);
+ *(int *) buffer = vcl_session_has_attr (session,
+ VCL_SESS_ATTR_TCP_KEEPINTVL);
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, buflen %d, #VPP-TBD#",
*buflen = sizeof (int);
VDBG (2, "VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, buflen %d, #VPP-TBD#",
{
/* VPP-TBD */
if (*(int *) buffer)
{
/* VPP-TBD */
if (*(int *) buffer)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_TCP_KEEPINTVL);
- VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
+ vcl_session_clear_attr (session, VCL_SESS_ATTR_TCP_KEEPINTVL);
VDBG (2, "VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, buflen %d, #VPP-TBD#",
VDBG (2, "VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, buflen %d, #VPP-TBD#",
- VCL_SESS_ATTR_TEST (session->attr,
- VCL_SESS_ATTR_TCP_KEEPINTVL), *buflen);
+ vcl_session_has_attr (session,
+ VCL_SESS_ATTR_TCP_KEEPINTVL), *buflen);
}
else
rv = VPPCOM_EINVAL;
}
else
rv = VPPCOM_EINVAL;
case VPPCOM_ATTR_SET_SHUT:
if (*flags == SHUT_RD || *flags == SHUT_RDWR)
case VPPCOM_ATTR_SET_SHUT:
if (*flags == SHUT_RD || *flags == SHUT_RDWR)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_SHUT_RD);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_SHUT_RD);
if (*flags == SHUT_WR || *flags == SHUT_RDWR)
if (*flags == SHUT_WR || *flags == SHUT_RDWR)
- VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_SHUT_WR);
+ vcl_session_set_attr (session, VCL_SESS_ATTR_SHUT_WR);
break;
case VPPCOM_ATTR_GET_SHUT:
break;
case VPPCOM_ATTR_GET_SHUT:
- if (VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_SHUT_RD))
+ if (vcl_session_has_attr (session, VCL_SESS_ATTR_SHUT_RD))
- if (VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_SHUT_WR))
+ if (vcl_session_has_attr (session, VCL_SESS_ATTR_SHUT_WR))
tmp_flags |= 2;
if (tmp_flags == 1)
*(int *) buffer = SHUT_RD;
tmp_flags |= 2;
if (tmp_flags == 1)
*(int *) buffer = SHUT_RD;