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