8 files changed, 74 insertions, 74 deletions

diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
index dd47e6da6fb3..72d014442185 100644
--- a/net/ipv4/syncookies.c
+++ b/net/ipv4/syncookies.c
@@ -169,10 +169,10 @@ static inline int cookie_check(struct sk_buff *skb, __u32 cookie)
         return mssind < NUM_MSS ? msstab[mssind] + 1 : 0;
 }
 
-extern struct or_calltable or_ipv4;
+extern struct request_sock_ops tcp_request_sock_ops;
 
 static inline struct sock *get_cookie_sock(struct sock *sk, struct sk_buff *skb,
-                                           struct open_request *req,
+                                           struct request_sock *req,
                                            struct dst_entry *dst)
 {
         struct tcp_sock *tp = tcp_sk(sk);
@@ -182,7 +182,7 @@ static inline struct sock *get_cookie_sock(struct sock *sk, struct sk_buff *skb,
         if (child)
                 tcp_acceptq_queue(sk, req, child);
         else
-                tcp_openreq_free(req);
+                reqsk_free(req);
 
         return child;
 }
@@ -195,7 +195,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
         struct tcp_sock *tp = tcp_sk(sk);
         __u32 cookie = ntohl(skb->h.th->ack_seq) - 1; 
         struct sock *ret = sk;
-        struct open_request *req; 
+        struct request_sock *req; 
         int mss; 
         struct rtable *rt; 
         __u8 rcv_wscale;
@@ -212,7 +212,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
         NET_INC_STATS_BH(LINUX_MIB_SYNCOOKIESRECV);
 
         ret = NULL;
-        req = tcp_openreq_alloc(&or_ipv4); /* for safety */
+        req = reqsk_alloc(&tcp_request_sock_ops); /* for safety */
         if (!req)
                 goto out;
 
@@ -262,7 +262,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
                                                { .sport = skb->h.th->dest,
                                                  .dport = skb->h.th->source } } };
                 if (ip_route_output_key(&rt, &fl)) {
-                        tcp_openreq_free(req);
+                        reqsk_free(req);
                         goto out; 
                 }
         }
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index a3cabfa2022a..1c29feb6b35f 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -516,8 +516,8 @@ static void tcp_listen_stop (struct sock *sk)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct tcp_listen_opt *lopt = tp->listen_opt;
-        struct open_request *acc_req = tp->accept_queue;
-        struct open_request *req;
+        struct request_sock *acc_req = tp->accept_queue;
+        struct request_sock *req;
         int i;
 
         tcp_delete_keepalive_timer(sk);
@@ -533,7 +533,7 @@ static void tcp_listen_stop (struct sock *sk)
                         while ((req = lopt->syn_table[i]) != NULL) {
                                 lopt->syn_table[i] = req->dl_next;
                                 lopt->qlen--;
-                                tcp_openreq_free(req);
+                                reqsk_free(req);
 
                 /* Following specs, it would be better either to send FIN
                  * (and enter FIN-WAIT-1, it is normal close)
@@ -573,7 +573,7 @@ static void tcp_listen_stop (struct sock *sk)
                 sock_put(child);
 
                 sk_acceptq_removed(sk);
-                tcp_openreq_fastfree(req);
+                __reqsk_free(req);
         }
         BUG_TRAP(!sk->sk_ack_backlog);
 }
@@ -1894,7 +1894,7 @@ static int wait_for_connect(struct sock *sk, long timeo)
 struct sock *tcp_accept(struct sock *sk, int flags, int *err)
 {
         struct tcp_sock *tp = tcp_sk(sk);
-        struct open_request *req;
+        struct request_sock *req;
         struct sock *newsk;
         int error;
 
@@ -1927,7 +1927,7 @@ struct sock *tcp_accept(struct sock *sk, int flags, int *err)
 
         newsk = req->sk;
         sk_acceptq_removed(sk);
-        tcp_openreq_fastfree(req);
+        __reqsk_free(req);
         BUG_TRAP(newsk->sk_state != TCP_SYN_RECV);
         release_sock(sk);
         return newsk;
diff --git a/net/ipv4/tcp_diag.c b/net/ipv4/tcp_diag.c
index 700ff2413588..67277800d0c1 100644
--- a/net/ipv4/tcp_diag.c
+++ b/net/ipv4/tcp_diag.c
@@ -455,7 +455,7 @@ static int tcpdiag_dump_sock(struct sk_buff *skb, struct sock *sk,
 }
 
 static int tcpdiag_fill_req(struct sk_buff *skb, struct sock *sk,
-                            struct open_request *req,
+                            struct request_sock *req,
                             u32 pid, u32 seq)
 {
         const struct inet_request_sock *ireq = inet_rsk(req);
@@ -542,7 +542,7 @@ static int tcpdiag_dump_reqs(struct sk_buff *skb, struct sock *sk,
         }
 
         for (j = s_j; j < TCP_SYNQ_HSIZE; j++) {
-                struct open_request *req, *head = lopt->syn_table[j];
+                struct request_sock *req, *head = lopt->syn_table[j];
 
                 reqnum = 0;
                 for (req = head; req; reqnum++, req = req->dl_next) {
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index e156be90df14..95528a75a63d 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -36,7 +36,7 @@
  *                                      ACK bit.
  *              Andi Kleen :            Implemented fast path mtu discovery.
  *                                      Fixed many serious bugs in the
- *                                      open_request handling and moved
+ *                                      request_sock handling and moved
  *                                      most of it into the af independent code.
  *                                      Added tail drop and some other bugfixes.
  *                                      Added new listen sematics.
@@ -869,13 +869,13 @@ static __inline__ u32 tcp_v4_synq_hash(u32 raddr, u16 rport, u32 rnd)
         return (jhash_2words(raddr, (u32) rport, rnd) & (TCP_SYNQ_HSIZE - 1));
 }
 
-static struct open_request *tcp_v4_search_req(struct tcp_sock *tp,
-                                              struct open_request ***prevp,
+static struct request_sock *tcp_v4_search_req(struct tcp_sock *tp,
+                                              struct request_sock ***prevp,
                                               __u16 rport,
                                               __u32 raddr, __u32 laddr)
 {
         struct tcp_listen_opt *lopt = tp->listen_opt;
-        struct open_request *req, **prev;
+        struct request_sock *req, **prev;
 
         for (prev = &lopt->syn_table[tcp_v4_synq_hash(raddr, rport, lopt->hash_rnd)];
              (req = *prev) != NULL;
@@ -885,7 +885,7 @@ static struct open_request *tcp_v4_search_req(struct tcp_sock *tp,
                 if (ireq->rmt_port == rport &&
                     ireq->rmt_addr == raddr &&
                     ireq->loc_addr == laddr &&
-                    TCP_INET_FAMILY(req->class->family)) {
+                    TCP_INET_FAMILY(req->rsk_ops->family)) {
                         BUG_TRAP(!req->sk);
                         *prevp = prev;
                         break;
@@ -895,7 +895,7 @@ static struct open_request *tcp_v4_search_req(struct tcp_sock *tp,
         return req;
 }
 
-static void tcp_v4_synq_add(struct sock *sk, struct open_request *req)
+static void tcp_v4_synq_add(struct sock *sk, struct request_sock *req)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct tcp_listen_opt *lopt = tp->listen_opt;
@@ -1052,7 +1052,7 @@ void tcp_v4_err(struct sk_buff *skb, u32 info)
         }
 
         switch (sk->sk_state) {
-                struct open_request *req, **prev;
+                struct request_sock *req, **prev;
         case TCP_LISTEN:
                 if (sock_owned_by_user(sk))
                         goto out;
@@ -1256,14 +1256,14 @@ static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
         tcp_tw_put(tw);
 }
 
-static void tcp_v4_or_send_ack(struct sk_buff *skb, struct open_request *req)
+static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
 {
         tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
                         req->ts_recent);
 }
 
 static struct dst_entry* tcp_v4_route_req(struct sock *sk,
-                                          struct open_request *req)
+                                          struct request_sock *req)
 {
         struct rtable *rt;
         const struct inet_request_sock *ireq = inet_rsk(req);
@@ -1294,10 +1294,10 @@ static struct dst_entry* tcp_v4_route_req(struct sock *sk,
 
 /*
  *      Send a SYN-ACK after having received an ACK.
- *      This still operates on a open_request only, not on a big
+ *      This still operates on a request_sock only, not on a big
  *      socket.
  */
-static int tcp_v4_send_synack(struct sock *sk, struct open_request *req,
+static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
                               struct dst_entry *dst)
 {
         const struct inet_request_sock *ireq = inet_rsk(req);
@@ -1332,9 +1332,9 @@ out:
 }
 
 /*
- *      IPv4 open_request destructor.
+ *      IPv4 request_sock destructor.
  */
-static void tcp_v4_or_free(struct open_request *req)
+static void tcp_v4_reqsk_destructor(struct request_sock *req)
 {
         if (inet_rsk(req)->opt)
                 kfree(inet_rsk(req)->opt);
@@ -1353,7 +1353,7 @@ static inline void syn_flood_warning(struct sk_buff *skb)
 }
 
 /*
- * Save and compile IPv4 options into the open_request if needed.
+ * Save and compile IPv4 options into the request_sock if needed.
  */
 static inline struct ip_options *tcp_v4_save_options(struct sock *sk,
                                                      struct sk_buff *skb)
@@ -1389,12 +1389,12 @@ static inline struct ip_options *tcp_v4_save_options(struct sock *sk,
  */
 int sysctl_max_syn_backlog = 256;
 
-struct or_calltable or_ipv4 = {
+struct request_sock_ops tcp_request_sock_ops = {
         .family         =       PF_INET,
         .obj_size       =       sizeof(struct tcp_request_sock),
         .rtx_syn_ack    =       tcp_v4_send_synack,
-        .send_ack       =       tcp_v4_or_send_ack,
-        .destructor     =       tcp_v4_or_free,
+        .send_ack       =       tcp_v4_reqsk_send_ack,
+        .destructor     =       tcp_v4_reqsk_destructor,
         .send_reset     =       tcp_v4_send_reset,
 };
 
@@ -1402,7 +1402,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
 {
         struct inet_request_sock *ireq;
         struct tcp_options_received tmp_opt;
-        struct open_request *req;
+        struct request_sock *req;
         __u32 saddr = skb->nh.iph->saddr;
         __u32 daddr = skb->nh.iph->daddr;
         __u32 isn = TCP_SKB_CB(skb)->when;
@@ -1439,7 +1439,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
         if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
                 goto drop;
 
-        req = tcp_openreq_alloc(&or_ipv4);
+        req = reqsk_alloc(&tcp_request_sock_ops);
         if (!req)
                 goto drop;
 
@@ -1535,14 +1535,14 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
                 goto drop_and_free;
 
         if (want_cookie) {
-                tcp_openreq_free(req);
+                reqsk_free(req);
         } else {
                 tcp_v4_synq_add(sk, req);
         }
         return 0;
 
 drop_and_free:
-        tcp_openreq_free(req);
+        reqsk_free(req);
 drop:
         TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
         return 0;
@@ -1554,7 +1554,7 @@ drop:
  * now create the new socket.
  */
 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
-                                  struct open_request *req,
+                                  struct request_sock *req,
                                   struct dst_entry *dst)
 {
         struct inet_request_sock *ireq;
@@ -1613,9 +1613,9 @@ static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
         struct iphdr *iph = skb->nh.iph;
         struct tcp_sock *tp = tcp_sk(sk);
         struct sock *nsk;
-        struct open_request **prev;
+        struct request_sock **prev;
         /* Find possible connection requests. */
-        struct open_request *req = tcp_v4_search_req(tp, &prev, th->source,
+        struct request_sock *req = tcp_v4_search_req(tp, &prev, th->source,
                                                      iph->saddr, iph->daddr);
         if (req)
                 return tcp_check_req(sk, skb, req, prev);
@@ -2152,13 +2152,13 @@ static void *listening_get_next(struct seq_file *seq, void *cur)
         ++st->num;
 
         if (st->state == TCP_SEQ_STATE_OPENREQ) {
-                struct open_request *req = cur;
+                struct request_sock *req = cur;
 
                 tp = tcp_sk(st->syn_wait_sk);
                 req = req->dl_next;
                 while (1) {
                         while (req) {
-                                if (req->class->family == st->family) {
+                                if (req->rsk_ops->family == st->family) {
                                         cur = req;
                                         goto out;
                                 }
@@ -2459,7 +2459,7 @@ void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
         memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops)); 
 }
 
-static void get_openreq4(struct sock *sk, struct open_request *req,
+static void get_openreq4(struct sock *sk, struct request_sock *req,
                          char *tmpbuf, int i, int uid)
 {
         const struct inet_request_sock *ireq = inet_rsk(req);
@@ -2627,7 +2627,7 @@ struct proto tcp_prot = {
         .sysctl_rmem            = sysctl_tcp_rmem,
         .max_header             = MAX_TCP_HEADER,
         .obj_size               = sizeof(struct tcp_sock),
-        .rsk_prot               = &or_ipv4,
+        .rsk_prot               = &tcp_request_sock_ops,
 };
 
 
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 1037401c7cc8..0e6d525a8341 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -684,7 +684,7 @@ out:
  * Actually, we could lots of memory writes here. tp of listening
  * socket contains all necessary default parameters.
  */
-struct sock *tcp_create_openreq_child(struct sock *sk, struct open_request *req, struct sk_buff *skb)
+struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req, struct sk_buff *skb)
 {
         /* allocate the newsk from the same slab of the master sock,
          * if not, at sk_free time we'll try to free it from the wrong
@@ -853,12 +853,12 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct open_request *req,
 
 /* 
  *      Process an incoming packet for SYN_RECV sockets represented
- *      as an open_request.
+ *      as a request_sock.
  */
 
 struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
-                           struct open_request *req,
-                           struct open_request **prev)
+                           struct request_sock *req,
+                           struct request_sock **prev)
 {
         struct tcphdr *th = skb->h.th;
         struct tcp_sock *tp = tcp_sk(sk);
@@ -903,7 +903,7 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
                  * Enforce "SYN-ACK" according to figure 8, figure 6
                  * of RFC793, fixed by RFC1122.
                  */
-                req->class->rtx_syn_ack(sk, req, NULL);
+                req->rsk_ops->rtx_syn_ack(sk, req, NULL);
                 return NULL;
         }
 
@@ -975,7 +975,7 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
                                           tcp_rsk(req)->rcv_isn + 1, tcp_rsk(req)->rcv_isn + 1 + req->rcv_wnd)) {
                 /* Out of window: send ACK and drop. */
                 if (!(flg & TCP_FLAG_RST))
-                        req->class->send_ack(skb, req);
+                        req->rsk_ops->send_ack(skb, req);
                 if (paws_reject)
                         NET_INC_STATS_BH(LINUX_MIB_PAWSESTABREJECTED);
                 return NULL;
@@ -1035,7 +1035,7 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
         embryonic_reset:
                 NET_INC_STATS_BH(LINUX_MIB_EMBRYONICRSTS);
                 if (!(flg & TCP_FLAG_RST))
-                        req->class->send_reset(skb);
+                        req->rsk_ops->send_reset(skb);
 
                 tcp_synq_drop(sk, req, prev);
                 return NULL;
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index f3c8747caf91..f17c6577e337 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1356,7 +1356,7 @@ int tcp_send_synack(struct sock *sk)
  * Prepare a SYN-ACK.
  */
 struct sk_buff * tcp_make_synack(struct sock *sk, struct dst_entry *dst,
-                                 struct open_request *req)
+                                 struct request_sock *req)
 {
         struct inet_request_sock *ireq = inet_rsk(req);
         struct tcp_sock *tp = tcp_sk(sk);
diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index ba30ca0aa6a3..f03efe5fb76a 100644
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -468,7 +468,7 @@ static void tcp_synack_timer(struct sock *sk)
         int max_retries = tp->syn_retries ? : sysctl_tcp_synack_retries;
         int thresh = max_retries;
         unsigned long now = jiffies;
-        struct open_request **reqp, *req;
+        struct request_sock **reqp, *req;
         int i, budget;
 
         if (lopt == NULL || lopt->qlen == 0)
@@ -514,7 +514,7 @@ static void tcp_synack_timer(struct sock *sk)
                         if (time_after_eq(now, req->expires)) {
                                 if ((req->retrans < thresh ||
                                      (inet_rsk(req)->acked && req->retrans < max_retries))
-                                    && !req->class->rtx_syn_ack(sk, req, NULL)) {
+                                    && !req->rsk_ops->rtx_syn_ack(sk, req, NULL)) {
                                         unsigned long timeo;
 
                                         if (req->retrans++ == 0)
@@ -533,7 +533,7 @@ static void tcp_synack_timer(struct sock *sk)
                                 lopt->qlen--;
                                 if (req->retrans == 0)
                                         lopt->qlen_young--;
-                                tcp_openreq_free(req);
+                                reqsk_free(req);
                                 continue;
                         }
                         reqp = &req->dl_next;
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 9199ad2fde0d..068cd4a8c292 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -65,7 +65,7 @@
 #include <linux/seq_file.h>
 
 static void     tcp_v6_send_reset(struct sk_buff *skb);
-static void     tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req);
+static void     tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req);
 static void     tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len, 
                                   struct sk_buff *skb);
 
@@ -394,15 +394,15 @@ static u32 tcp_v6_synq_hash(struct in6_addr *raddr, u16 rport, u32 rnd)
         return c & (TCP_SYNQ_HSIZE - 1);
 }
 
-static struct open_request *tcp_v6_search_req(struct tcp_sock *tp,
-                                              struct open_request ***prevp,
+static struct request_sock *tcp_v6_search_req(struct tcp_sock *tp,
+                                              struct request_sock ***prevp,
                                               __u16 rport,
                                               struct in6_addr *raddr,
                                               struct in6_addr *laddr,
                                               int iif)
 {
         struct tcp_listen_opt *lopt = tp->listen_opt;
-        struct open_request *req, **prev;  
+        struct request_sock *req, **prev;  
 
         for (prev = &lopt->syn_table[tcp_v6_synq_hash(raddr, rport, lopt->hash_rnd)];
              (req = *prev) != NULL;
@@ -410,7 +410,7 @@ static struct open_request *tcp_v6_search_req(struct tcp_sock *tp,
                 const struct tcp6_request_sock *treq = tcp6_rsk(req);
 
                 if (inet_rsk(req)->rmt_port == rport &&
-                    req->class->family == AF_INET6 &&
+                    req->rsk_ops->family == AF_INET6 &&
                     ipv6_addr_equal(&treq->rmt_addr, raddr) &&
                     ipv6_addr_equal(&treq->loc_addr, laddr) &&
                     (!treq->iif || treq->iif == iif)) {
@@ -908,9 +908,9 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
 
         icmpv6_err_convert(type, code, &err);
 
-        /* Might be for an open_request */
+        /* Might be for an request_sock */
         switch (sk->sk_state) {
-                struct open_request *req, **prev;
+                struct request_sock *req, **prev;
         case TCP_LISTEN:
                 if (sock_owned_by_user(sk))
                         goto out;
@@ -959,7 +959,7 @@ out:
 }
 
 
-static int tcp_v6_send_synack(struct sock *sk, struct open_request *req,
+static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
                               struct dst_entry *dst)
 {
         struct tcp6_request_sock *treq = tcp6_rsk(req);
@@ -1027,18 +1027,18 @@ done:
         return err;
 }
 
-static void tcp_v6_or_free(struct open_request *req)
+static void tcp_v6_reqsk_destructor(struct request_sock *req)
 {
         if (tcp6_rsk(req)->pktopts)
                 kfree_skb(tcp6_rsk(req)->pktopts);
 }
 
-static struct or_calltable or_ipv6 = {
+static struct request_sock_ops tcp6_request_sock_ops = {
         .family         =       AF_INET6,
         .obj_size       =       sizeof(struct tcp6_request_sock),
         .rtx_syn_ack    =       tcp_v6_send_synack,
-        .send_ack       =       tcp_v6_or_send_ack,
-        .destructor     =       tcp_v6_or_free,
+        .send_ack       =       tcp_v6_reqsk_send_ack,
+        .destructor     =       tcp_v6_reqsk_destructor,
         .send_reset     =       tcp_v6_send_reset
 };
 
@@ -1223,7 +1223,7 @@ static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
         tcp_tw_put(tw);
 }
 
-static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req)
+static void tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
 {
         tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent);
 }
@@ -1231,7 +1231,7 @@ static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req)
 
 static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
 {
-        struct open_request *req, **prev;
+        struct request_sock *req, **prev;
         struct tcphdr *th = skb->h.th;
         struct tcp_sock *tp = tcp_sk(sk);
         struct sock *nsk;
@@ -1264,7 +1264,7 @@ static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
         return sk;
 }
 
-static void tcp_v6_synq_add(struct sock *sk, struct open_request *req)
+static void tcp_v6_synq_add(struct sock *sk, struct request_sock *req)
 {
         struct tcp_sock *tp = tcp_sk(sk);
         struct tcp_listen_opt *lopt = tp->listen_opt;
@@ -1292,7 +1292,7 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
         struct ipv6_pinfo *np = inet6_sk(sk);
         struct tcp_options_received tmp_opt;
         struct tcp_sock *tp = tcp_sk(sk);
-        struct open_request *req = NULL;
+        struct request_sock *req = NULL;
         __u32 isn = TCP_SKB_CB(skb)->when;
 
         if (skb->protocol == htons(ETH_P_IP))
@@ -1313,7 +1313,7 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
         if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
                 goto drop;
 
-        req = tcp_openreq_alloc(&or_ipv6);
+        req = reqsk_alloc(&tcp6_request_sock_ops);
         if (req == NULL)
                 goto drop;
 
@@ -1358,14 +1358,14 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
 
 drop:
         if (req)
-                tcp_openreq_free(req);
+                reqsk_free(req);
 
         TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
         return 0; /* don't send reset */
 }
 
 static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
-                                          struct open_request *req,
+                                          struct request_sock *req,
                                           struct dst_entry *dst)
 {
         struct tcp6_request_sock *treq = tcp6_rsk(req);
@@ -2055,7 +2055,7 @@ static int tcp_v6_destroy_sock(struct sock *sk)
 
 /* Proc filesystem TCPv6 sock list dumping. */
 static void get_openreq6(struct seq_file *seq, 
-                         struct sock *sk, struct open_request *req, int i, int uid)
+                         struct sock *sk, struct request_sock *req, int i, int uid)
 {
         struct in6_addr *dest, *src;
         int ttd = req->expires - jiffies;
@@ -2244,7 +2244,7 @@ struct proto tcpv6_prot = {
         .sysctl_rmem            = sysctl_tcp_rmem,
         .max_header             = MAX_TCP_HEADER,
         .obj_size               = sizeof(struct tcp6_sock),
-        .rsk_prot               = &or_ipv6,
+        .rsk_prot               = &tcp6_request_sock_ops,
 };
 
 static struct inet6_protocol tcpv6_protocol = {