root / slirp / sbuf.c @ a76bab49
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 |
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
|
21 |
sbfree(sb) |
22 |
struct sbuf *sb;
|
23 |
{ |
24 |
free(sb->sb_data); |
25 |
} |
26 |
|
27 |
void
|
28 |
sbdrop(sb, num) |
29 |
struct sbuf *sb;
|
30 |
int num;
|
31 |
{ |
32 |
/*
|
33 |
* We can only drop how much we have
|
34 |
* This should never succeed
|
35 |
*/
|
36 |
if(num > sb->sb_cc)
|
37 |
num = sb->sb_cc; |
38 |
sb->sb_cc -= num; |
39 |
sb->sb_rptr += num; |
40 |
if(sb->sb_rptr >= sb->sb_data + sb->sb_datalen)
|
41 |
sb->sb_rptr -= sb->sb_datalen; |
42 |
|
43 |
} |
44 |
|
45 |
void
|
46 |
sbreserve(sb, size) |
47 |
struct sbuf *sb;
|
48 |
int size;
|
49 |
{ |
50 |
if (sb->sb_data) {
|
51 |
/* Already alloced, realloc if necessary */
|
52 |
if (sb->sb_datalen != size) {
|
53 |
sb->sb_wptr = sb->sb_rptr = sb->sb_data = (char *)realloc(sb->sb_data, size);
|
54 |
sb->sb_cc = 0;
|
55 |
if (sb->sb_wptr)
|
56 |
sb->sb_datalen = size; |
57 |
else
|
58 |
sb->sb_datalen = 0;
|
59 |
} |
60 |
} else {
|
61 |
sb->sb_wptr = sb->sb_rptr = sb->sb_data = (char *)malloc(size);
|
62 |
sb->sb_cc = 0;
|
63 |
if (sb->sb_wptr)
|
64 |
sb->sb_datalen = size; |
65 |
else
|
66 |
sb->sb_datalen = 0;
|
67 |
} |
68 |
} |
69 |
|
70 |
/*
|
71 |
* Try and write() to the socket, whatever doesn't get written
|
72 |
* append to the buffer... for a host with a fast net connection,
|
73 |
* this prevents an unnecessary copy of the data
|
74 |
* (the socket is non-blocking, so we won't hang)
|
75 |
*/
|
76 |
void
|
77 |
sbappend(so, m) |
78 |
struct socket *so;
|
79 |
struct mbuf *m;
|
80 |
{ |
81 |
int ret = 0; |
82 |
|
83 |
DEBUG_CALL("sbappend");
|
84 |
DEBUG_ARG("so = %lx", (long)so); |
85 |
DEBUG_ARG("m = %lx", (long)m); |
86 |
DEBUG_ARG("m->m_len = %d", m->m_len);
|
87 |
|
88 |
/* Shouldn't happen, but... e.g. foreign host closes connection */
|
89 |
if (m->m_len <= 0) { |
90 |
m_free(m); |
91 |
return;
|
92 |
} |
93 |
|
94 |
/*
|
95 |
* If there is urgent data, call sosendoob
|
96 |
* if not all was sent, sowrite will take care of the rest
|
97 |
* (The rest of this function is just an optimisation)
|
98 |
*/
|
99 |
if (so->so_urgc) {
|
100 |
sbappendsb(&so->so_rcv, m); |
101 |
m_free(m); |
102 |
sosendoob(so); |
103 |
return;
|
104 |
} |
105 |
|
106 |
/*
|
107 |
* We only write if there's nothing in the buffer,
|
108 |
* ottherwise it'll arrive out of order, and hence corrupt
|
109 |
*/
|
110 |
if (!so->so_rcv.sb_cc)
|
111 |
ret = send(so->s, m->m_data, m->m_len, 0);
|
112 |
|
113 |
if (ret <= 0) { |
114 |
/*
|
115 |
* Nothing was written
|
116 |
* It's possible that the socket has closed, but
|
117 |
* we don't need to check because if it has closed,
|
118 |
* it will be detected in the normal way by soread()
|
119 |
*/
|
120 |
sbappendsb(&so->so_rcv, m); |
121 |
} else if (ret != m->m_len) { |
122 |
/*
|
123 |
* Something was written, but not everything..
|
124 |
* sbappendsb the rest
|
125 |
*/
|
126 |
m->m_len -= ret; |
127 |
m->m_data += ret; |
128 |
sbappendsb(&so->so_rcv, m); |
129 |
} /* else */
|
130 |
/* Whatever happened, we free the mbuf */
|
131 |
m_free(m); |
132 |
} |
133 |
|
134 |
/*
|
135 |
* Copy the data from m into sb
|
136 |
* The caller is responsible to make sure there's enough room
|
137 |
*/
|
138 |
static void |
139 |
sbappendsb(struct sbuf *sb, 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 |
|