![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sbuf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / slirp|
Return to sbuf.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / slirp |
1.1 root 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: