fedora中nano，显示command not found.是因为有些fedora中没有nano吗？
没安装就自己装咯....
默认的编辑器应该是vi
nano需要自己装, 可以直接 yum -y install nano&
rpm -ivh&http://www.nano-editor.org/dist/v2.2/RPMS/nano-2.2.6-1.i386.rpm
--- 共有 1 条评论 ---
谢谢，已经解决了，确实是有些fedora中没有自带，所以需要自己安装
你说的是苹果的音乐播放器吗？怎样修改DCCP协议中的RTO？
我有DCCP协议的代码，可是在ION中该代码不能运行长延时，因此要改代码，但我不知道怎么改，求高手。
以下是timer.c文件
net/dccp/timer.c
An implementation of the DCCP protocol
Arnaldo Carvalho de Melo &.br&
* This prog you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software F either version
* 2 of the License, or (at your option) any later version.
#include &linux/dccp.h&
#include &linux/skbuff.h&
#include &linux/export.h&
#include &dccp.h&
/* sysctl variables governing numbers of retransmission attempts */
sysctl_dccp_request_retries __read_mostly = TCP_SYN_RETRIES;
sysctl_dccp_retries1
__read_mostly = TCP_RETR1;
sysctl_dccp_retries2
__read_mostly = TCP_RETR2;
static void dccp_write_err(struct sock *sk)
sk-&sk_err = sk-&sk_err_soft ? : ETIMEDOUT;
sk-&sk_error_report(sk);
dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
dccp_done(sk);
DCCP_INC_STATS_BH(DCCP_MIB_ABORTONTIMEOUT);
/* A write timeout has occurred. Process the after effects. */
static int dccp_write_timeout(struct sock *sk)
const struct inet_connection_sock *icsk = inet_csk(sk);
int retry_
if (sk-&sk_state == DCCP_REQUESTING || sk-&sk_state == DCCP_PARTOPEN) {
if (icsk-&icsk_retransmits != 0)
dst_negative_advice(sk);
retry_until = icsk-&icsk_syn_retries ?
: sysctl_dccp_request_
if (icsk-&icsk_retransmits &= sysctl_dccp_retries1) {
/* NOTE. draft-ietf-tcpimpl-pmtud-01.txt requires pmtu
black hole detection. :-(
It is place to make it. It is not made. I do not want
to make it. It is disguisting. It does not work in any
case. Let me to cite the same draft, which requires for
us to implement this:
&The one security concern raised by this memo is that ICMP black holes
are often caused by over-zealous security administrators who block
all ICMP messages.
It is vitally important that those who design and
deploy security systems understand the impact of strict filtering on
upper-layer protocols.
The safest web site in the world is worthless
if most TCP implementations cannot transfer data from it.
be far nicer to have all of the black holes fixed rather than fixing
all of the TCP implementations.&
Golden words :-).
dst_negative_advice(sk);
retry_until = sysctl_dccp_retries2;
* FIXME: see tcp_write_timout and tcp_out_of_resources
if (icsk-&icsk_retransmits &= retry_until) {
/* Has it gone just too far? */
dccp_write_err(sk);
* The DCCP retransmit timer.
static void dccp_retransmit_timer(struct sock *sk)
struct inet_connection_sock *icsk = inet_csk(sk);
* More than than 4MSL (8 minutes) has passed, a RESET(aborted) was
* sent, no need to retransmit, this sock is dead.
if (dccp_write_timeout(sk))
* We want to know the number of packets retransmitted, not the
* total number of retransmissions of clones of original packets.
if (icsk-&icsk_retransmits == 0)
DCCP_INC_STATS_BH(DCCP_MIB_TIMEOUTS);
if (dccp_retransmit_skb(sk) != 0) {
* Retransmission failed because of local congestion,
* do not backoff.
if (--icsk-&icsk_retransmits == 0)
icsk-&icsk_retransmits = 1;
inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
min(icsk-&icsk_rto,
TCP_RESOURCE_PROBE_INTERVAL),
DCCP_RTO_MAX);
icsk-&icsk_backoff++;
icsk-&icsk_rto = min(icsk-&icsk_rto && 1, DCCP_RTO_MAX);
inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk-&icsk_rto,
DCCP_RTO_MAX);
if (icsk-&icsk_retransmits & sysctl_dccp_retries1)
__sk_dst_reset(sk);
static void dccp_write_timer(unsigned long data)
struct sock *sk = (struct sock *)
struct inet_connection_sock *icsk = inet_csk(sk);
int event = 0;
bh_lock_sock(sk);
if (sock_owned_by_user(sk)) {
/* Try again later */
sk_reset_timer(sk, &icsk-&icsk_retransmit_timer,
jiffies + (HZ / 20));
if (sk-&sk_state == DCCP_CLOSED || !icsk-&icsk_pending)
if (time_after(icsk-&icsk_timeout, jiffies)) {
sk_reset_timer(sk, &icsk-&icsk_retransmit_timer,
icsk-&icsk_timeout);
event = icsk-&icsk_
icsk-&icsk_pending = 0;
switch (event) {
case ICSK_TIME_RETRANS:
dccp_retransmit_timer(sk);
bh_unlock_sock(sk);
sock_put(sk);
* Timer for listening sockets
static void dccp_response_timer(struct sock *sk)
inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL, DCCP_TIMEOUT_INIT,
DCCP_RTO_MAX);
static void dccp_keepalive_timer(unsigned long data)
struct sock *sk = (struct sock *)
/* Only process if socket is not in use. */
bh_lock_sock(sk);
if (sock_owned_by_user(sk)) {
/* Try again later. */
inet_csk_reset_keepalive_timer(sk, HZ / 20);
if (sk-&sk_state == DCCP_LISTEN) {
dccp_response_timer(sk);
bh_unlock_sock(sk);
sock_put(sk);
/* This is the same as tcp_delack_timer, sans prequeue & mem_reclaim stuff */
static void dccp_delack_timer(unsigned long data)
struct sock *sk = (struct sock *)
struct inet_connection_sock *icsk = inet_csk(sk);
bh_lock_sock(sk);
if (sock_owned_by_user(sk)) {
/* Try again later. */
icsk-&icsk_ack.blocked = 1;
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOCKED);
sk_reset_timer(sk, &icsk-&icsk_delack_timer,
jiffies + TCP_DELACK_MIN);
if (sk-&sk_state == DCCP_CLOSED ||
!(icsk-&icsk_ack.pending & ICSK_ACK_TIMER))
if (time_after(icsk-&icsk_ack.timeout, jiffies)) {
sk_reset_timer(sk, &icsk-&icsk_delack_timer,
icsk-&icsk_ack.timeout);
icsk-&icsk_ack.pending &= ~ICSK_ACK_TIMER;
if (inet_csk_ack_scheduled(sk)) {
if (!icsk-&icsk_ack.pingpong) {
/* Delayed ACK missed: inflate ATO. */
icsk-&icsk_ack.ato = min(icsk-&icsk_ack.ato && 1,
icsk-&icsk_rto);
/* Delayed ACK missed: leave pingpong mode and
* deflate ATO.
icsk-&icsk_ack.pingpong = 0;
icsk-&icsk_ack.ato = TCP_ATO_MIN;
dccp_send_ack(sk);
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKS);
bh_unlock_sock(sk);
sock_put(sk);
* dccp_write_xmitlet
Workhorse for CCID packet dequeueing interface
* See the comments above %ccid_dequeueing_decision for supported modes.
static void dccp_write_xmitlet(unsigned long data)
struct sock *sk = (struct sock *)
bh_lock_sock(sk);
if (sock_owned_by_user(sk))
sk_reset_timer(sk, &dccp_sk(sk)-&dccps_xmit_timer, jiffies + 1);
dccp_write_xmit(sk);
bh_unlock_sock(sk);
static void dccp_write_xmit_timer(unsigned long data)
dccp_write_xmitlet(data);
sock_put((struct sock *)data);
void dccp_init_xmit_timers(struct sock *sk)
struct dccp_sock *dp = dccp_sk(sk);
tasklet_init(&dp-&dccps_xmitlet, dccp_write_xmitlet, (unsigned long)sk);
setup_timer(&dp-&dccps_xmit_timer, dccp_write_xmit_timer,
(unsigned long)sk);
inet_csk_init_xmit_timers(sk, &dccp_write_timer, &dccp_delack_timer,
&dccp_keepalive_timer);
static ktime_t dccp_timestamp_
* dccp_timestamp
10s of microseconds time source
* Returns the number of 10s of microseconds since loading DCCP. This is native
* DCCP time difference format (RFC 4340, sec. 13).
* Please note: This will wrap around about circa every 11.9 hours.
u32 dccp_timestamp(void)
s64 delta = ktime_us_delta(ktime_get_real(), dccp_timestamp_seed);
do_div(delta, 10);
EXPORT_SYMBOL_GPL(dccp_timestamp);
void __init dccp_timestamping_init(void)
dccp_timestamp_seed = ktime_get_real();
以下是dccp.h文件
#ifndef _DCCP_H
#define _DCCP_H
net/dccp/dccp.h
An implementation of the DCCP protocol
Copyright (c) 2005 Arnaldo Carvalho de Melo &.br&
Copyright (c) 2005-6 Ian McDonald &ian.mcdonald@jandi.co.nz&
* This prog you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
#include &linux/dccp.h&
#include &linux/ktime.h&
#include &net/snmp.h&
#include &net/sock.h&
#include &net/tcp.h&
#include &ackvec.h&
DCCP - specific warning and debugging macros.
#define DCCP_WARN(fmt, a...) LIMIT_NETDEBUG(KERN_WARNING &%s: & fmt,
__func__, ##a)
#define DCCP_CRIT(fmt, a...) printk(KERN_CRIT fmt & at %s:%d/%s()\n&, ##a, \
__FILE__, __LINE__, __func__)
#define DCCP_BUG(a...)
do { DCCP_CRIT(&BUG: & a); dump_stack(); } while(0)
#define DCCP_BUG_ON(cond)
do { if (unlikely((cond) != 0))
DCCP_BUG(&\&%s\& holds (exception!)&, \
__stringify(cond));
} while (0)
#define DCCP_PRINTK(enable, fmt, args...) do { if (enable)
printk(fmt, ##args); \
} while(0)
#define DCCP_PR_DEBUG(enable, fmt, a...) DCCP_PRINTK(enable, KERN_DEBUG \
&%s: & fmt, __func__, ##a)
#ifdef CONFIG_IP_DCCP_DEBUG
extern int dccp_
#define dccp_pr_debug(format, a...)
DCCP_PR_DEBUG(dccp_debug, format, ##a)
#define dccp_pr_debug_cat(format, a...)
DCCP_PRINTK(dccp_debug, format, ##a)
#define dccp_debug(fmt, a...)
dccp_pr_debug_cat(KERN_DEBUG fmt, ##a)
#define dccp_pr_debug(format, a...)
#define dccp_pr_debug_cat(format, a...)
#define dccp_debug(format, a...)
extern struct inet_hashinfo dccp_
extern struct percpu_counter dccp_orphan_
extern void dccp_time_wait(struct sock *sk, int state, int timeo);
Set safe upper bounds for header and option length. Since Data Offset is 8
bits (RFC 4340, sec. 5.1), the total header length can never be more than
4 * 255 = 1020 bytes. The largest possible header length is 28 bytes (X=1):
- DCCP-Response with ACK Subheader and 4 bytes of Service code
- DCCP-Reset
with ACK Subheader and 4 bytes of Reset Code fields
Hence a safe upper bound for the maximum option length is 1020-28 = 992
#define MAX_DCCP_SPECIFIC_HEADER (255 * sizeof(uint32_t))
#define DCCP_MAX_PACKET_HDR 28
#define DCCP_MAX_OPT_LEN (MAX_DCCP_SPECIFIC_HEADER - DCCP_MAX_PACKET_HDR)
#define MAX_DCCP_HEADER (MAX_DCCP_SPECIFIC_HEADER + MAX_HEADER)
/* Upper bound for initial feature-negotiation overhead (padded to 32 bits) */
#define DCCP_FEATNEG_OVERHEAD
(32 * sizeof(uint32_t))
#define DCCP_TIMEWAIT_LEN (60 * HZ) /* how long to wait to destroy TIME-WAIT
* state, about 60 seconds */
/* RFC .3.1 initial RTO value */
#define DCCP_TIMEOUT_INIT ((unsigned)(15 * HZ))
* The maximum back-off value for retransmissions. This is needed for
- retransmitting client-Requests (sec. 8.1.1),
- retransmitting Close/CloseReq when closing (sec. 8.3),
- feature-negotiation retransmission (sec. 6.6.3),
- Acks in client-PARTOPEN state (sec. 8.1.5).
#define DCCP_RTO_MAX ((unsigned)(64 * HZ))
* RTT sampling: sanity bounds and fallback RTT value from RFC 4340, section 3.4
#define DCCP_SANE_RTT_MIN 100
#define DCCP_FALLBACK_RTT (USEC_PER_SEC / 5)
#define DCCP_SANE_RTT_MAX (3 * USEC_PER_SEC)
/* sysctl variables for DCCP */
extern int
sysctl_dccp_request_
extern int
sysctl_dccp_retries1;
extern int
sysctl_dccp_retries2;
extern int
sysctl_dccp_tx_
extern int
sysctl_dccp_sync_
* 48-bit sequence number arithmetic (signed and unsigned)
#define INT48_MIN
#define UINT48_MAX
0xFFFFFFFFFFFFLL
/* 2^48 - 1 */
#define COMPLEMENT48(x)
(0x0LL - (x)) /* 2^48 - x */
#define TO_SIGNED48(x)
(((x) & INT48_MIN)? (x) : -COMPLEMENT48( (x)))
#define TO_UNSIGNED48(x) (((x) &= 0)?
COMPLEMENT48(-(x)))
#define ADD48(a, b)
(((a) + (b)) & UINT48_MAX)
#define SUB48(a, b)
ADD48((a), COMPLEMENT48(b))
static inline void dccp_set_seqno(u64 *seqno, u64 value)
*seqno = value & UINT48_MAX;
static inline void dccp_inc_seqno(u64 *seqno)
*seqno = ADD48(*seqno, 1);
/* signed mod-2^48 distance: pos. if seqno1 & seqno2, neg. if seqno1 & seqno2 */
static inline s64 dccp_delta_seqno(const u64 seqno1, const u64 seqno2)
u64 delta = SUB48(seqno2, seqno1);
return TO_SIGNED48(delta);
/* is seq1 & seq2 ? */
static inline int before48(const u64 seq1, const u64 seq2)
return (s64)((seq2 && 16) - (seq1 && 16)) & 0;
/* is seq1 & seq2 ? */
#define after48(seq1, seq2) before48(seq2, seq1)
/* is seq2 &= seq1 &= seq3 ? */
static inline int between48(const u64 seq1, const u64 seq2, const u64 seq3)
return (seq3 && 16) - (seq2 && 16) &= (seq1 && 16) - (seq2 && 16);
static inline u64 max48(const u64 seq1, const u64 seq2)
return after48(seq1, seq2) ? seq1 : seq2;
* dccp_loss_count - Approximate the number of lost data packets in a burst loss
last known sequence number before the loss ('hole')
first sequence number seen after the 'hole'
* @ndp: NDP count on packet with sequence number @s2
static inline u64 dccp_loss_count(const u64 s1, const u64 s2, const u64 ndp)
s64 delta = dccp_delta_seqno(s1, s2);
WARN_ON(delta & 0);
delta -= ndp + 1;
return delta & 0 ? delta : 0;
* dccp_loss_free - Evaluate condition for data loss from RFC .1
static inline bool dccp_loss_free(const u64 s1, const u64 s2, const u64 ndp)
return dccp_loss_count(s1, s2, ndp) == 0;
DCCP_MIB_NUM = 0,
DCCP_MIB_ACTIVEOPENS,
/* ActiveOpens */
DCCP_MIB_ESTABRESETS,
/* EstabResets */
DCCP_MIB_CURRESTAB,
/* CurrEstab */
DCCP_MIB_OUTSEGS,
/* OutSegs */
DCCP_MIB_OUTRSTS,
DCCP_MIB_ABORTONTIMEOUT,
DCCP_MIB_TIMEOUTS,
DCCP_MIB_ABORTFAILED,
DCCP_MIB_PASSIVEOPENS,
DCCP_MIB_ATTEMPTFAILS,
DCCP_MIB_OUTDATAGRAMS,
DCCP_MIB_INERRS,
DCCP_MIB_OPTMANDATORYERROR,
DCCP_MIB_INVALIDOPT,
__DCCP_MIB_MAX
#define DCCP_MIB_MAX __DCCP_MIB_MAX
struct dccp_mib {
unsigned long mibs[DCCP_MIB_MAX];
DECLARE_SNMP_STAT(struct dccp_mib, dccp_statistics);
#define DCCP_INC_STATS(field)
SNMP_INC_STATS(dccp_statistics, field)
#define DCCP_INC_STATS_BH(field)
SNMP_INC_STATS_BH(dccp_statistics, field)
#define DCCP_DEC_STATS(field)
SNMP_DEC_STATS(dccp_statistics, field)
Checksumming routines
static inline unsigned int dccp_csum_coverage(const struct sk_buff *skb)
const struct dccp_hdr* dh = dccp_hdr(skb);
if (dh-&dccph_cscov == 0)
return skb-&
return (dh-&dccph_doff + dh-&dccph_cscov - 1) * sizeof(u32);
static inline void dccp_csum_outgoing(struct sk_buff *skb)
unsigned int cov = dccp_csum_coverage(skb);
if (cov &= skb-&len)
dccp_hdr(skb)-&dccph_cscov = 0;
skb-&csum = skb_checksum(skb, 0, (cov & skb-&len)? skb-&len : cov, 0);
extern void dccp_v4_send_check(struct sock *sk, struct sk_buff *skb);
extern int
dccp_retransmit_skb(struct sock *sk);
extern void dccp_send_ack(struct sock *sk);
extern void dccp_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
struct request_sock *rsk);
extern void dccp_send_sync(struct sock *sk, const u64 seq,
const enum dccp_pkt_type pkt_type);
* TX Packet Dequeueing Interface
extern void
dccp_qpolicy_push(struct sock *sk, struct sk_buff *skb);
extern bool
dccp_qpolicy_full(struct sock *sk);
extern void
dccp_qpolicy_drop(struct sock *sk, struct sk_buff *skb);
extern struct sk_buff *dccp_qpolicy_top(struct sock *sk);
extern struct sk_buff *dccp_qpolicy_pop(struct sock *sk);
extern bool
dccp_qpolicy_param_ok(struct sock *sk, __be32 param);
* TX Packet Output and TX Timers
extern void
dccp_write_xmit(struct sock *sk);
extern void
dccp_write_space(struct sock *sk);
extern void
dccp_flush_write_queue(struct sock *sk, long *time_budget);
extern void dccp_init_xmit_timers(struct sock *sk);
static inline void dccp_clear_xmit_timers(struct sock *sk)
inet_csk_clear_xmit_timers(sk);
extern unsigned int dccp_sync_mss(struct sock *sk, u32 pmtu);
extern const char *dccp_packet_name(const int type);
extern void dccp_set_state(struct sock *sk, const int state);
extern void dccp_done(struct sock *sk);
extern int
dccp_reqsk_init(struct request_sock *rq, struct dccp_sock const *dp,
struct sk_buff const *skb);
extern int dccp_v4_conn_request(struct sock *sk, struct sk_buff *skb);
extern struct sock *dccp_create_openreq_child(struct sock *sk,
const struct request_sock *req,
const struct sk_buff *skb);
extern int dccp_v4_do_rcv(struct sock *sk, struct sk_buff *skb);
extern struct sock *dccp_v4_request_recv_sock(struct sock *sk,
struct sk_buff *skb,
struct request_sock *req,
struct dst_entry *dst);
extern struct sock *dccp_check_req(struct sock *sk, struct sk_buff *skb,
struct request_sock *req,
struct request_sock **prev);
extern int dccp_child_process(struct sock *parent, struct sock *child,
struct sk_buff *skb);
extern int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
struct dccp_hdr *dh, unsigned len);
extern int dccp_rcv_established(struct sock *sk, struct sk_buff *skb,
const struct dccp_hdr *dh, const unsigned len);
extern int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized);
extern void dccp_destroy_sock(struct sock *sk);
extern void
dccp_close(struct sock *sk, long timeout);
extern struct sk_buff *dccp_make_response(struct sock *sk,
struct dst_entry *dst,
struct request_sock *req);
extern int
dccp_connect(struct sock *sk);
extern int
dccp_disconnect(struct sock *sk, int flags);
extern int
dccp_getsockopt(struct sock *sk, int level, int optname,
char __user *optval, int __user *optlen);
extern int
dccp_setsockopt(struct sock *sk, int level, int optname,
char __user *optval, unsigned int optlen);
#ifdef CONFIG_COMPAT
extern int
compat_dccp_getsockopt(struct sock *sk,
int level, int optname,
char __user *optval, int __user *optlen);
extern int
compat_dccp_setsockopt(struct sock *sk,
int level, int optname,
char __user *optval, unsigned int optlen);
extern int
dccp_ioctl(struct sock *sk, int cmd, unsigned long arg);
extern int
dccp_sendmsg(struct kiocb *iocb, struct sock *sk,
struct msghdr *msg, size_t size);
extern int
dccp_recvmsg(struct kiocb *iocb, struct sock *sk,
struct msghdr *msg, size_t len, int nonblock,
int flags, int *addr_len);
extern void
dccp_shutdown(struct sock *sk, int how);
extern int
inet_dccp_listen(struct socket *sock, int backlog);
extern unsigned int dccp_poll(struct file *file, struct socket *sock,
poll_table *wait);
extern int
dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr,
int addr_len);
extern struct sk_buff *dccp_ctl_make_reset(struct sock *sk,
struct sk_buff *skb);
extern int
dccp_send_reset(struct sock *sk, enum dccp_reset_codes code);
extern void
dccp_send_close(struct sock *sk, const int active);
extern int
dccp_invalid_packet(struct sk_buff *skb);
extern u32
dccp_sample_rtt(struct sock *sk, long delta);
static inline int dccp_bad_service_code(const struct sock *sk,
const __be32 service)
const struct dccp_sock *dp = dccp_sk(sk);
if (dp-&dccps_service == service)
return !dccp_list_has_service(dp-&dccps_service_list, service);
* dccp_skb_cb
DCCP per-packet control information
* @dccpd_type: one of %dccp_pkt_type (or unknown)
* @dccpd_ccval: CCVal field (5.1), see e.g. RFC
* @dccpd_reset_code: one of %dccp_reset_codes
* @dccpd_reset_data: Data1..3 fields (depend on @dccpd_reset_code)
* @dccpd_opt_len: total length of all options (5.8) in the packet
* @dccpd_seq: sequence number
* @dccpd_ack_seq: acknowledgment number subheader field value
* This is used for transmission as well as for reception.
struct dccp_skb_cb {
struct inet_skb_parm h4;
#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
struct inet6_skb_parm h6;
dccpd_type:4;
dccpd_ccval:4;
dccpd_reset_code,
dccpd_reset_data[3];
__u16 dccpd_opt_
__u64 dccpd_
__u64 dccpd_ack_
#define DCCP_SKB_CB(__skb) ((struct dccp_skb_cb *)&((__skb)-&cb[0]))
/* RFC 4340, sec. 7.7 */
static inline int dccp_non_data_packet(const struct sk_buff *skb)
const __u8 type = DCCP_SKB_CB(skb)-&dccpd_
return type == DCCP_PKT_ACK
type == DCCP_PKT_CLOSE
type == DCCP_PKT_CLOSEREQ ||
type == DCCP_PKT_RESET
type == DCCP_PKT_SYNC
type == DCCP_PKT_SYNCACK;
/* RFC 4340, sec. 7.7 */
static inline int dccp_data_packet(const struct sk_buff *skb)
const __u8 type = DCCP_SKB_CB(skb)-&dccpd_
return type == DCCP_PKT_DATA
type == DCCP_PKT_DATAACK
type == DCCP_PKT_REQUEST
type == DCCP_PKT_RESPONSE;
static inline int dccp_packet_without_ack(const struct sk_buff *skb)
const __u8 type = DCCP_SKB_CB(skb)-&dccpd_
return type == DCCP_PKT_DATA || type == DCCP_PKT_REQUEST;
#define DCCP_PKT_WITHOUT_ACK_SEQ (UINT48_MAX && 2)
static inline void dccp_hdr_set_seq(struct dccp_hdr *dh, const u64 gss)
struct dccp_hdr_ext *dhx = (struct dccp_hdr_ext *)((void *)dh +
sizeof(*dh));
dh-&dccph_seq2 = 0;
dh-&dccph_seq = htons((gss && 32) & 0xfffff);
dhx-&dccph_seq_low = htonl(gss & 0xffffffff);
static inline void dccp_hdr_set_ack(struct dccp_hdr_ack_bits *dhack,
const u64 gsr)
dhack-&dccph_reserved1 = 0;
dhack-&dccph_ack_nr_high = htons(gsr && 32);
dhack-&dccph_ack_nr_low
= htonl(gsr & 0xffffffff);
static inline void dccp_update_gsr(struct sock *sk, u64 seq)
struct dccp_sock *dp = dccp_sk(sk);
if (after48(seq, dp-&dccps_gsr))
dp-&dccps_gsr =
/* Sequence validity window depends on remote Sequence Window (7.5.1) */
dp-&dccps_swl = SUB48(ADD48(dp-&dccps_gsr, 1), dp-&dccps_r_seq_win / 4);
* Adjust SWL so that it is not below ISR. In contrast to RFC 4340,
* 7.5.1 we perform this check beyond the initial handshake: W/W' are
* always & 32, so for the first W/W' packets in the lifetime of a
* connection we always have to adjust SWL.
* A second reason why we are doing this is that the window depends on
* the feature-remote value of Sequence Window: nothing stops the peer
* from updating this value while we are busy adjusting SWL for the
* first W packets (we would have to count from scratch again then).
* Therefore it is safer to always make sure that the Sequence Window
* is not artificially extended by a peer who grows SWL downwards by
* continually updating the feature-remote Sequence-Window.
* If sequence numbers wrap it is bad luck. But that will take a while
* (48 bit), and this measure prevents Sequence-number attacks.
if (before48(dp-&dccps_swl, dp-&dccps_isr))
dp-&dccps_swl = dp-&dccps_
dp-&dccps_swh = ADD48(dp-&dccps_gsr, (3 * dp-&dccps_r_seq_win) / 4);
static inline void dccp_update_gss(struct sock *sk, u64 seq)
struct dccp_sock *dp = dccp_sk(sk);
dp-&dccps_gss =
/* Ack validity window depends on local Sequence Window value (7.5.1) */
dp-&dccps_awl = SUB48(ADD48(dp-&dccps_gss, 1), dp-&dccps_l_seq_win);
/* Adjust AWL so that it is not below ISS - see comment above for SWL */
if (before48(dp-&dccps_awl, dp-&dccps_iss))
dp-&dccps_awl = dp-&dccps_
dp-&dccps_awh = dp-&dccps_
static inline int dccp_ackvec_pending(const struct sock *sk)
return dccp_sk(sk)-&dccps_hc_rx_ackvec != NULL &&
!dccp_ackvec_is_empty(dccp_sk(sk)-&dccps_hc_rx_ackvec);
static inline int dccp_ack_pending(const struct sock *sk)
return dccp_ackvec_pending(sk) || inet_csk_ack_scheduled(sk);
extern int
dccp_feat_signal_nn_change(struct sock *sk, u8 feat, u64 nn_val);
extern int
dccp_feat_finalise_settings(struct dccp_sock *dp);
extern int
dccp_feat_server_ccid_dependencies(struct dccp_request_sock *dreq);
extern int
dccp_feat_insert_opts(struct dccp_sock*, struct dccp_request_sock*,
struct sk_buff *skb);
extern int
dccp_feat_activate_values(struct sock *sk, struct list_head *fn);
extern void dccp_feat_list_purge(struct list_head *fn_list);
extern int dccp_insert_options(struct sock *sk, struct sk_buff *skb);
extern int dccp_insert_options_rsk(struct dccp_request_sock*, struct sk_buff*);
extern int dccp_insert_option_elapsed_time(struct sk_buff *skb, u32 elapsed);
extern u32 dccp_timestamp(void);
extern void dccp_timestamping_init(void);
extern int dccp_insert_option(struct sk_buff *skb, unsigned char option,
const void *value, unsigned char len);
#ifdef CONFIG_SYSCTL
extern int dccp_sysctl_init(void);
extern void dccp_sysctl_exit(void);
static inline int dccp_sysctl_init(void)
static inline void dccp_sysctl_exit(void)
#endif /* _DCCP_H */