static int fixup_unix_address(struct socket *sock, struct cpt_sock_image *si,
struct cpt_context *ctx)
{
struct sock *sk = sock->sk;
cpt_object_t *obj;
struct sock *parent;
if (sk->sk_family != AF_UNIX || sk->sk_state == TCP_LISTEN)
return 0;
if (si->cpt_parent == -1)
return bind_unix_socket(sock, si, ctx);
obj = lookup_cpt_obj_byindex(CPT_OBJ_SOCKET, si->cpt_parent, ctx);
if (!obj)
return 0;
parent = obj->o_obj;
if (unix_sk(parent)->addr) {
if (unix_sk(sk)->addr &&
atomic_dec_and_test(&unix_sk(sk)->addr->refcnt))
kfree(unix_sk(sk)->addr);
atomic_inc(&unix_sk(parent)->addr->refcnt);
unix_sk(sk)->addr = unix_sk(parent)->addr;
}
return 0;
}
static int restore_unix_rqueue(struct sock *sk, struct cpt_sock_image *si,
loff_t pos, struct cpt_context *ctx)
{
loff_t endpos;
pos = pos + si->cpt_hdrlen;
endpos = pos + si->cpt_next;
while (pos < endpos) {
struct sk_buff *skb;
struct sock *owner_sk;
__u32 owner;
skb = rst_skb(sk, &pos, &owner, NULL, ctx);
if (IS_ERR(skb)) {
if (PTR_ERR(skb) == -EINVAL) {
int err;
err = rst_sock_attr(&pos, sk, ctx);
if (err)
return err;
}
return PTR_ERR(skb);
}
owner_sk = unix_peer(sk);
if (owner != -1) {
cpt_object_t *pobj;
pobj = lookup_cpt_obj_byindex(CPT_OBJ_SOCKET, owner, ctx);
if (pobj == NULL) {
eprintk_ctx("orphan af_unix skb?\n");
kfree_skb(skb);
continue;
}
owner_sk = pobj->o_obj;
}
if (owner_sk == NULL) {
dprintk_ctx("orphan af_unix skb 2?\n");
kfree_skb(skb);
continue;
}
skb_set_owner_w(skb, owner_sk);
if (UNIXCB(skb).fp)
skb->destructor = unix_destruct_fds;
skb_queue_tail(&sk->sk_receive_queue, skb);
if (sk->sk_state == TCP_LISTEN) {
struct socket *sock = skb->sk->sk_socket;
if (sock == NULL) BUG();
if (sock->file) BUG();
skb->sk->sk_socket = NULL;
skb->sk->sk_sleep = NULL;
sock->sk = NULL;
sock_release(sock);
}
}
return 0;
}
int rst_sockets_complete(struct cpt_context *ctx)
{
int err;
cpt_object_t *obj;
for_each_object(obj, CPT_OBJ_SOCKET) {
struct cpt_sock_image *sbuf;
struct sock *sk = obj->o_obj;
struct sock *peer;
if (!sk) BUG();
if (sk->sk_family != AF_UNIX)
continue;
sbuf = cpt_get_buf(ctx);
err = rst_get_object(CPT_OBJ_SOCKET, obj->o_pos, sbuf, ctx);
if (err) {
cpt_release_buf(ctx);
return err;
}
if (sbuf->cpt_next > sbuf->cpt_hdrlen)
restore_unix_rqueue(sk, sbuf, obj->o_pos, ctx);
cpt_release_buf(ctx);
if (sk->sk_type == SOCK_DGRAM && unix_peer(sk) == NULL) {
cpt_object_t *pobj;
sbuf = cpt_get_buf(ctx);
err = rst_get_object(CPT_OBJ_SOCKET, obj->o_pos, sbuf, ctx);
if (err) {
cpt_release_buf(ctx);
return err;
}
if (sbuf->cpt_peer != -1) {
pobj = lookup_cpt_obj_byindex(CPT_OBJ_SOCKET, sbuf->cpt_peer, ctx);
if (pobj) {
peer = pobj->o_obj;
sock_hold(peer);
unix_peer(sk) = peer;
}
}
cpt_release_buf(ctx);
}
}
rst_orphans(ctx);
return 0;
}
static int rst_socket_tcp(struct cpt_sock_image *si, loff_t pos, struct sock *sk,
struct cpt_context *ctx)
{
struct tcp_sock *tp = tcp_sk(sk);
struct sk_buff *skb;
tp->pred_flags = si->cpt_pred_flags;
tp->rcv_nxt = si->cpt_rcv_nxt;
tp->snd_nxt = si->cpt_snd_nxt;
tp->snd_una = si->cpt_snd_una;
tp->snd_sml = si->cpt_snd_sml;
tp->rcv_tstamp = tcp_jiffies_import(si->cpt_rcv_tstamp);
tp->lsndtime = tcp_jiffies_import(si->cpt_lsndtime);
tp->tcp_header_len = si->cpt_tcp_header_len;
inet_csk(sk)->icsk_ack.pending = si->cpt_ack_pending;
inet_csk(sk)->icsk_ack.quick = si->cpt_quick;
inet_csk(sk)->icsk_ack.pingpong = si->cpt_pingpong;
inet_csk(sk)->icsk_ack.blocked = si->cpt_blocked;
inet_csk(sk)->icsk_ack.ato = si->cpt_ato;
inet_csk(sk)->icsk_ack.timeout = jiffies_import(si->cpt_ack_timeout);
inet_csk(sk)->icsk_ack.lrcvtime = tcp_jiffies_import(si->cpt_lrcvtime);
inet_csk(sk)->icsk_ack.last_seg_size = si->cpt_last_seg_size;
inet_csk(sk)->icsk_ack.rcv_mss = si->cpt_rcv_mss;
tp->snd_wl1 = si->cpt_snd_wl1;
tp->snd_wnd = si->cpt_snd_wnd;
tp->max_window = si->cpt_max_window;
inet_csk(sk)->icsk_pmtu_cookie = si->cpt_pmtu_cookie;
tp->mss_cache = si->cpt_mss_cache;
tp->rx_opt.mss_clamp = si->cpt_mss_clamp;
inet_csk(sk)->icsk_ext_hdr_len = si->cpt_ext_header_len;
inet_csk(sk)->icsk_ca_state = si->cpt_ca_state;
inet_csk(sk)->icsk_retransmits = si->cpt_retransmits;
tp->reordering = si->cpt_reordering;
tp->frto_counter = si->cpt_frto_counter;
tp->frto_highmark = si->cpt_frto_highmark;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
// // tp->adv_cong = si->cpt_adv_cong;
#endif
inet_csk(sk)->icsk_accept_queue.rskq_defer_accept = si->cpt_defer_accept;
inet_csk(sk)->icsk_backoff = si->cpt_backoff;
tp->srtt = si->cpt_srtt;
tp->mdev = si->cpt_mdev;
tp->mdev_max = si->cpt_mdev_max;
tp->rttvar = si->cpt_rttvar;
tp->rtt_seq = si->cpt_rtt_seq;
inet_csk(sk)->icsk_rto = si->cpt_rto;
tp->packets_out = si->cpt_packets_out;
tp->retrans_out = si->cpt_retrans_out;
tp->lost_out = si->cpt_lost_out;
tp->sacked_out = si->cpt_sacked_out;
tp->fackets_out = si->cpt_fackets_out;
tp->snd_ssthresh = si->cpt_snd_ssthresh;
tp->snd_cwnd = si->cpt_snd_cwnd;
tp->snd_cwnd_cnt = si->cpt_snd_cwnd_cnt;
tp->snd_cwnd_clamp = si->cpt_snd_cwnd_clamp;
tp->snd_cwnd_used = si->cpt_snd_cwnd_used;
tp->snd_cwnd_stamp = tcp_jiffies_import(si->cpt_snd_cwnd_stamp);
inet_csk(sk)->icsk_timeout = tcp_jiffies_import(si->cpt_timeout);
tp->rcv_wnd = si->cpt_rcv_wnd;
tp->rcv_wup = si->cpt_rcv_wup;
tp->write_seq = si->cpt_write_seq;
tp->pushed_seq = si->cpt_pushed_seq;
tp->copied_seq = si->cpt_copied_seq;
tp->rx_opt.tstamp_ok = si->cpt_tstamp_ok;
tp->rx_opt.wscale_ok = si->cpt_wscale_ok;
tp->rx_opt.sack_ok = si->cpt_sack_ok;
tp->rx_opt.saw_tstamp = si->cpt_saw_tstamp;
tp->rx_opt.snd_wscale = si->cpt_snd_wscale;
tp->rx_opt.rcv_wscale = si->cpt_rcv_wscale;
tp->nonagle = si->cpt_nonagle;
tp->keepalive_probes = si->cpt_keepalive_probes;
tp->rx_opt.rcv_tsval = si->cpt_rcv_tsval;
tp->rx_opt.rcv_tsecr = si->cpt_rcv_tsecr;
tp->rx_opt.ts_recent = si->cpt_ts_recent;
tp->rx_opt.ts_recent_stamp = si->cpt_ts_recent_stamp;
tp->rx_opt.user_mss = si->cpt_user_mss;
tp->rx_opt.dsack = si->cpt_dsack;
tp->duplicate_sack[0].start_seq = si->cpt_sack_array[0];
tp->duplicate_sack[0].end_seq = si->cpt_sack_array[1];
tp->selective_acks[0].start_seq = si->cpt_sack_array[2];
tp->selective_acks[0].end_seq = si->cpt_sack_array[3];
tp->selective_acks[1].start_seq = si->cpt_sack_array[4];
tp->selective_acks[1].end_seq = si->cpt_sack_array[5];
tp->selective_acks[2].start_seq = si->cpt_sack_array[6];
tp->selective_acks[2].end_seq = si->cpt_sack_array[7];
tp->selective_acks[3].start_seq = si->cpt_sack_array[8];
tp->selective_acks[3].end_seq = si->cpt_sack_array[9];
tp->window_clamp = si->cpt_window_clamp;
tp->rcv_ssthresh = si->cpt_rcv_ssthresh;
inet_csk(sk)->icsk_probes_out = si->cpt_probes_out;
tp->rx_opt.num_sacks = si->cpt_num_sacks;
tp->advmss = si->cpt_advmss;
inet_csk(sk)->icsk_syn_retries = si->cpt_syn_retries;
tp->ecn_flags = si->cpt_ecn_flags;
tp->prior_ssthresh = si->cpt_prior_ssthresh;
tp->high_seq = si->cpt_high_seq;
tp->retrans_stamp = si->cpt_retrans_stamp;
tp->undo_marker = si->cpt_undo_marker;
tp->undo_retrans = si->cpt_undo_retrans;
tp->urg_seq = si->cpt_urg_seq;
tp->urg_data = si->cpt_urg_data;
inet_csk(sk)->icsk_pending = si->cpt_pending;
tp->snd_up = si->cpt_snd_up;
tp->keepalive_time = si->cpt_keepalive_time;
tp->keepalive_intvl = si->cpt_keepalive_intvl;
tp->linger2 = si->cpt_linger2;
sk->sk_send_head = NULL;
for (skb = skb_peek(&sk->sk_write_queue);
skb && skb != (struct sk_buff*)&sk->sk_write_queue;
skb = skb->next) {
if (!after(tp->snd_nxt, TCP_SKB_CB(skb)->seq)) {
sk->sk_send_head = skb;
break;
}
}
if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN) {
struct inet_sock *inet = inet_sk(sk);
if (inet->num == 0) {
cpt_object_t *lobj = NULL;
if ((int)si->cpt_parent != -1)
lobj = lookup_cpt_obj_byindex(CPT_OBJ_SOCKET, si->cpt_parent, ctx);
if (lobj && lobj->o_obj) {
inet->num = ntohs(inet->sport);
local_bh_disable();
__inet_inherit_port(lobj->o_obj, sk);
local_bh_enable();
dprintk_ctx("port inherited from parent\n");
} else {
struct sock *lsk = find_parent(inet->sport, ctx);
if (lsk) {
inet->num = ntohs(inet->sport);
local_bh_disable();
__inet_inherit_port(lsk, sk);
local_bh_enable();
dprintk_ctx("port inherited\n");
} else {
eprintk_ctx("we are kinda lost...\n");
}
}
}
sk->sk_prot->hash(sk);
if (inet_csk(sk)->icsk_ack.pending&ICSK_ACK_TIMER)
sk_reset_timer(sk, &inet_csk(sk)->icsk_delack_timer, inet_csk(sk)->icsk_ack.timeout);
if (inet_csk(sk)->icsk_pending)
sk_reset_timer(sk, &inet_csk(sk)->icsk_retransmit_timer,
inet_csk(sk)->icsk_timeout);
if (sock_flag(sk, SOCK_KEEPOPEN)) {
unsigned long expires = jiffies_import(si->cpt_ka_timeout);
if (time_after(jiffies, expires))
expires = jiffies + HZ;
sk_reset_timer(sk, &sk->sk_timer, expires);
}
}
if (sk->sk_family == AF_INET6)
sk->sk_gso_type = SKB_GSO_TCPV6;
else
sk->sk_gso_type = SKB_GSO_TCPV4;
return 0;
}
static int open_socket(cpt_object_t *obj, struct cpt_sock_image *si,
struct cpt_context *ctx)
{
int err;
struct socket *sock;
struct socket *sock2 = NULL;
struct file *file;
cpt_object_t *fobj;
cpt_object_t *pobj = NULL;
err = sock_create(si->cpt_family, si->cpt_type, si->cpt_protocol,
&sock);
if (err)
return err;
if (si->cpt_socketpair) {
err = sock_create(si->cpt_family, si->cpt_type,
si->cpt_protocol, &sock2);
if (err)
goto err_out;
err = sock->ops->socketpair(sock, sock2);
if (err < 0)
goto err_out;
/* Socketpair with a peer outside our environment.
* So, we create real half-open pipe and do not worry
* about dead end anymore. */
if (si->cpt_peer == -1) {
sock_release(sock2);
sock2 = NULL;
}
}
cpt_obj_setobj(obj, sock->sk, ctx);
if (si->cpt_file != CPT_NULL) {
file = sock_mapfile(sock);
err = PTR_ERR(file);
if (IS_ERR(file))
goto err_out;
err = -ENOMEM;
obj->o_parent = file;
if ((fobj = cpt_object_add(CPT_OBJ_FILE, file, ctx)) == NULL)
goto err_out;
cpt_obj_setpos(fobj, si->cpt_file, ctx);
cpt_obj_setindex(fobj, si->cpt_index, ctx);
}
if (sock2) {
struct file *file2;
pobj = lookup_cpt_obj_byindex(CPT_OBJ_SOCKET, si->cpt_peer, ctx);
if (!pobj) BUG();
if (pobj->o_obj) BUG();
cpt_obj_setobj(pobj, sock2->sk, ctx);
if (pobj->o_ppos != CPT_NULL) {
file2 = sock_mapfile(sock2);
err = PTR_ERR(file2);
if (IS_ERR(file2))
goto err_out;
err = -ENOMEM;
if ((fobj = cpt_object_add(CPT_OBJ_FILE, file2, ctx)) == NULL)
goto err_out;
cpt_obj_setpos(fobj, pobj->o_ppos, ctx);
cpt_obj_setindex(fobj, si->cpt_peer, ctx);
pobj->o_parent = file2;
}
}
setup_sock_common(sock->sk, si, obj->o_pos, ctx);
if (sock->sk->sk_family == AF_INET || sock->sk->sk_family == AF_INET6) {
int saved_reuse = sock->sk->sk_reuse;
inet_sk(sock->sk)->freebind = 1;
sock->sk->sk_reuse = 2;
if (si->cpt_laddrlen) {
err = sock->ops->bind(sock, (struct sockaddr *)&si->cpt_laddr, si->cpt_laddrlen);
if (err) {
dprintk_ctx("binding failed: %d, do not worry\n", err);
}
}
sock->sk->sk_reuse = saved_reuse;
rst_socket_in(si, obj->o_pos, sock->sk, ctx);
} else if (sock->sk->sk_family == AF_NETLINK) {
struct sockaddr_nl *nl = (struct sockaddr_nl *)&si->cpt_laddr;
if (nl->nl_pid) {
err = sock->ops->bind(sock, (struct sockaddr *)&si->cpt_laddr, si->cpt_laddrlen);
if (err) {
eprintk_ctx("AF_NETLINK binding failed: %d\n", err);
}
}
if (si->cpt_raddrlen && nl->nl_pid) {
err = sock->ops->connect(sock, (struct sockaddr *)&si->cpt_raddr, si->cpt_raddrlen, O_NONBLOCK);
if (err) {
eprintk_ctx("oops, AF_NETLINK connect failed: %d\n", err);
}
}
generic_restore_queues(sock->sk, si, obj->o_pos, ctx);
} else if (sock->sk->sk_family == PF_PACKET) {
struct sockaddr_ll *ll = (struct sockaddr_ll *)&si->cpt_laddr;
if (ll->sll_protocol || ll->sll_ifindex) {
int alen = si->cpt_laddrlen;
if (alen < sizeof(struct sockaddr_ll))
alen = sizeof(struct sockaddr_ll);
err = sock->ops->bind(sock, (struct sockaddr *)&si->cpt_laddr, alen);
if (err) {
eprintk_ctx("AF_PACKET binding failed: %d\n", err);
}
}
generic_restore_queues(sock->sk, si, obj->o_pos, ctx);
}
fixup_unix_address(sock, si, ctx);
if (sock2) {
err = rst_get_object(CPT_OBJ_SOCKET, pobj->o_pos, si, ctx);
if (err)
return err;
setup_sock_common(sock2->sk, si, pobj->o_pos, ctx);
fixup_unix_address(sock2, si, ctx);
}
if ((sock->sk->sk_family == AF_INET || sock->sk->sk_family == AF_INET6)
&& (int)si->cpt_parent != -1) {
cpt_object_t *lobj = lookup_cpt_obj_byindex(CPT_OBJ_SOCKET, si->cpt_parent, ctx);
if (lobj && cpt_attach_accept(lobj->o_obj, sock->sk, ctx) == 0)
sock->sk = NULL;
}
if (si->cpt_file == CPT_NULL && sock->sk &&
sock->sk->sk_family == AF_INET) {
struct sock *sk = sock->sk;
if (sk) {
sock->sk = NULL;
local_bh_disable();
bh_lock_sock(sk);
if (sock_owned_by_user(sk))
eprintk_ctx("oops, sock is locked by user\n");
sock_hold(sk);
sock_orphan(sk);
ub_inc_orphan_count(sk);
bh_unlock_sock(sk);
local_bh_enable();
sock_put(sk);
dprintk_ctx("orphaning socket %p\n", sk);
}
}
if (si->cpt_file == CPT_NULL && sock->sk == NULL)
sock_release(sock);
return 0;
err_out:
if (sock2)
sock_release(sock2);
sock_release(sock);
return err;
}
