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