• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 1995 Danny Gasparovski.
3  *
4  * Please read the file COPYRIGHT for the
5  * terms and conditions of the copyright.
6  */
7 
8 #include <slirp.h>
9 
10 static void sbappendsb(struct sbuf *sb, struct mbuf *m);
11 
12 /* Done as a macro in socket.h */
13 /* int
14  * sbspace(struct sockbuff *sb)
15  * {
16  *	return SB_DATALEN - sb->sb_cc;
17  * }
18  */
19 
20 void
sbfree(struct sbuf * sb)21 sbfree(struct sbuf *sb)
22 {
23 	free(sb->sb_data);
24 }
25 
26 void
sbdrop(struct sbuf * sb,int num)27 sbdrop(struct sbuf *sb, int num)
28 {
29 	/*
30 	 * We can only drop how much we have
31 	 * This should never succeed
32 	 */
33 	if(num > sb->sb_cc)
34 		num = sb->sb_cc;
35 	sb->sb_cc -= num;
36 	sb->sb_rptr += num;
37 	if(sb->sb_rptr >= sb->sb_data + sb->sb_datalen)
38 		sb->sb_rptr -= sb->sb_datalen;
39 
40 }
41 
42 void
sbreserve(struct sbuf * sb,int size)43 sbreserve(struct sbuf *sb, int size)
44 {
45 	if (sb->sb_data) {
46 		/* Already alloced, realloc if necessary */
47 		if (sb->sb_datalen != size) {
48 			sb->sb_wptr = sb->sb_rptr = sb->sb_data = (char *)realloc(sb->sb_data, size);
49 			sb->sb_cc = 0;
50 			if (sb->sb_wptr)
51 			   sb->sb_datalen = size;
52 			else
53 			   sb->sb_datalen = 0;
54 		}
55 	} else {
56 		sb->sb_wptr = sb->sb_rptr = sb->sb_data = (char *)malloc(size);
57 		sb->sb_cc = 0;
58 		if (sb->sb_wptr)
59 		   sb->sb_datalen = size;
60 		else
61 		   sb->sb_datalen = 0;
62 	}
63 }
64 
65 /*
66  * Try and write() to the socket, whatever doesn't get written
67  * append to the buffer... for a host with a fast net connection,
68  * this prevents an unnecessary copy of the data
69  * (the socket is non-blocking, so we won't hang)
70  */
71 void
sbappend(struct socket * so,struct mbuf * m)72 sbappend(struct socket *so, struct mbuf *m)
73 {
74 	int ret = 0;
75 
76 	DEBUG_CALL("sbappend");
77 	DEBUG_ARG("so = %lx", (long)so);
78 	DEBUG_ARG("m = %lx", (long)m);
79 	DEBUG_ARG("m->m_len = %d", m->m_len);
80 
81 	/* Shouldn't happen, but...  e.g. foreign host closes connection */
82 	if (m->m_len <= 0) {
83 		m_free(m);
84 		return;
85 	}
86 
87 	/*
88 	 * If there is urgent data, call sosendoob
89 	 * if not all was sent, sowrite will take care of the rest
90 	 * (The rest of this function is just an optimisation)
91 	 */
92 	if (so->so_urgc) {
93 		sbappendsb(&so->so_rcv, m);
94 		m_free(m);
95 		sosendoob(so);
96 		return;
97 	}
98 
99 	/*
100 	 * We only write if there's nothing in the buffer,
101 	 * ottherwise it'll arrive out of order, and hence corrupt
102 	 */
103 	if (!so->so_rcv.sb_cc)
104 	   ret = slirp_send(so, m->m_data, m->m_len, 0);
105 
106 	if (ret <= 0) {
107 		/*
108 		 * Nothing was written
109 		 * It's possible that the socket has closed, but
110 		 * we don't need to check because if it has closed,
111 		 * it will be detected in the normal way by soread()
112 		 */
113 		sbappendsb(&so->so_rcv, m);
114 	} else if (ret != m->m_len) {
115 		/*
116 		 * Something was written, but not everything..
117 		 * sbappendsb the rest
118 		 */
119 		m->m_len -= ret;
120 		m->m_data += ret;
121 		sbappendsb(&so->so_rcv, m);
122 	} /* else */
123 	/* Whatever happened, we free the mbuf */
124 	m_free(m);
125 }
126 
127 /*
128  * Copy the data from m into sb
129  * The caller is responsible to make sure there's enough room
130  */
131 static void
sbappendsb(struct sbuf * sb,struct mbuf * m)132 sbappendsb(struct sbuf *sb, struct mbuf *m)
133 {
134 	int len, n,  nn;
135 
136 	len = m->m_len;
137 
138 	if (sb->sb_wptr < sb->sb_rptr) {
139 		n = sb->sb_rptr - sb->sb_wptr;
140 		if (n > len) n = len;
141 		memcpy(sb->sb_wptr, m->m_data, n);
142 	} else {
143 		/* Do the right edge first */
144 		n = sb->sb_data + sb->sb_datalen - sb->sb_wptr;
145 		if (n > len) n = len;
146 		memcpy(sb->sb_wptr, m->m_data, n);
147 		len -= n;
148 		if (len) {
149 			/* Now the left edge */
150 			nn = sb->sb_rptr - sb->sb_data;
151 			if (nn > len) nn = len;
152 			memcpy(sb->sb_data,m->m_data+n,nn);
153 			n += nn;
154 		}
155 	}
156 
157 	sb->sb_cc += n;
158 	sb->sb_wptr += n;
159 	if (sb->sb_wptr >= sb->sb_data + sb->sb_datalen)
160 		sb->sb_wptr -= sb->sb_datalen;
161 }
162 
163 /*
164  * Copy data from sbuf to a normal, straight buffer
165  * Don't update the sbuf rptr, this will be
166  * done in sbdrop when the data is acked
167  */
168 void
sbcopy(struct sbuf * sb,int off,int len,char * to)169 sbcopy(struct sbuf *sb, int off, int len, char *to)
170 {
171 	char *from;
172 
173 	from = sb->sb_rptr + off;
174 	if (from >= sb->sb_data + sb->sb_datalen)
175 		from -= sb->sb_datalen;
176 
177 	if (from < sb->sb_wptr) {
178 		if (len > sb->sb_cc) len = sb->sb_cc;
179 		memcpy(to,from,len);
180 	} else {
181 		/* re-use off */
182 		off = (sb->sb_data + sb->sb_datalen) - from;
183 		if (off > len) off = len;
184 		memcpy(to,from,off);
185 		len -= off;
186 		if (len)
187 		   memcpy(to+off,sb->sb_data,len);
188 	}
189 }
190