00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036 #include <stdio.h>
00037 #include <string.h>
00038
00039 #include "net/psock.h"
00040
00041 #define STATE_NONE 0
00042 #define STATE_ACKED 1
00043 #define STATE_READ 2
00044 #define STATE_BLOCKED_NEWDATA 3
00045 #define STATE_BLOCKED_CLOSE 4
00046 #define STATE_BLOCKED_SEND 5
00047 #define STATE_DATA_SENT 6
00048
00049
00050
00051
00052
00053
00054 #define BUF_NOT_FULL 0
00055 #define BUF_NOT_FOUND 0
00056
00057
00058
00059
00060
00061
00062 #define BUF_FULL 1
00063
00064
00065
00066
00067
00068
00069 #define BUF_FOUND 2
00070
00071
00072 static void
00073 buf_setup(struct psock_buf *buf,
00074 u8_t *bufptr, u16_t bufsize)
00075 {
00076 buf->ptr = bufptr;
00077 buf->left = bufsize;
00078 }
00079
00080 static u8_t
00081 buf_bufdata(struct psock_buf *buf, u16_t len,
00082 u8_t **dataptr, u16_t *datalen)
00083 {
00084 if(*datalen < buf->left) {
00085 memcpy(buf->ptr, *dataptr, *datalen);
00086 buf->ptr += *datalen;
00087 buf->left -= *datalen;
00088 *dataptr += *datalen;
00089 *datalen = 0;
00090 return BUF_NOT_FULL;
00091 } else if(*datalen == buf->left) {
00092 memcpy(buf->ptr, *dataptr, *datalen);
00093 buf->ptr += *datalen;
00094 buf->left = 0;
00095 *dataptr += *datalen;
00096 *datalen = 0;
00097 return BUF_FULL;
00098 } else {
00099 memcpy(buf->ptr, *dataptr, buf->left);
00100 buf->ptr += buf->left;
00101 *datalen -= buf->left;
00102 *dataptr += buf->left;
00103 buf->left = 0;
00104 return BUF_FULL;
00105 }
00106 }
00107
00108 static u8_t
00109 buf_bufto(register struct psock_buf *buf, u8_t endmarker,
00110 register u8_t **dataptr, register u16_t *datalen)
00111 {
00112 u8_t c;
00113 while(buf->left > 0 && *datalen > 0) {
00114 c = *buf->ptr = **dataptr;
00115 ++*dataptr;
00116 ++buf->ptr;
00117 --*datalen;
00118 --buf->left;
00119
00120 if(c == endmarker) {
00121 return BUF_FOUND;
00122 }
00123 }
00124
00125 if(*datalen == 0) {
00126 return BUF_NOT_FOUND;
00127 }
00128
00129 while(*datalen > 0) {
00130 c = **dataptr;
00131 --*datalen;
00132 ++*dataptr;
00133
00134 if(c == endmarker) {
00135 return BUF_FOUND | BUF_FULL;
00136 }
00137 }
00138
00139 return BUF_FULL;
00140 }
00141
00142 static char
00143 send_data(register struct psock *s)
00144 {
00145 if(s->state != STATE_DATA_SENT || uip_rexmit()) {
00146 if(s->sendlen > uip_mss()) {
00147 uip_send(s->sendptr, uip_mss());
00148 } else {
00149 uip_send(s->sendptr, s->sendlen);
00150 }
00151 s->state = STATE_DATA_SENT;
00152 return 1;
00153 }
00154 return 0;
00155 }
00156
00157 static char
00158 data_acked(register struct psock *s)
00159 {
00160 if(s->state == STATE_DATA_SENT && uip_acked()) {
00161 if(s->sendlen > uip_mss()) {
00162 s->sendlen -= uip_mss();
00163 s->sendptr += uip_mss();
00164 } else {
00165 s->sendptr += s->sendlen;
00166 s->sendlen = 0;
00167 }
00168 s->state = STATE_ACKED;
00169 return 1;
00170 }
00171 return 0;
00172 }
00173
00174 PT_THREAD(psock_send(register struct psock *s, const char *buf,
00175 unsigned int len))
00176 {
00177 PT_BEGIN(&s->psockpt);
00178
00179
00180 if(len == 0) {
00181 PT_EXIT(&s->psockpt);
00182 }
00183
00184
00185
00186 s->sendptr = buf;
00187 s->sendlen = len;
00188
00189 s->state = STATE_NONE;
00190
00191
00192
00193 while(s->sendlen > 0) {
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205 PT_WAIT_UNTIL(&s->psockpt, data_acked(s) & send_data(s));
00206 }
00207
00208 s->state = STATE_NONE;
00209
00210 PT_END(&s->psockpt);
00211 }
00212
00213 PT_THREAD(psock_generator_send(register struct psock *s,
00214 unsigned short (*generate)(void *), void *arg))
00215 {
00216 PT_BEGIN(&s->psockpt);
00217
00218
00219 if(generate == NULL) {
00220 PT_EXIT(&s->psockpt);
00221 }
00222
00223
00224
00225 s->sendlen = generate(arg);
00226 s->sendptr = uip_appdata;
00227
00228 s->state = STATE_NONE;
00229 do {
00230
00231
00232 if(uip_rexmit()) {
00233 generate(arg);
00234 }
00235
00236 PT_WAIT_UNTIL(&s->psockpt, data_acked(s) & send_data(s));
00237 } while(s->sendlen > 0);
00238
00239 s->state = STATE_NONE;
00240
00241 PT_END(&s->psockpt);
00242 }
00243
00244 u16_t
00245 psock_datalen(struct psock *psock)
00246 {
00247 return psock->bufsize - psock->buf.left;
00248 }
00249
00250 char
00251 psock_newdata(struct psock *s)
00252 {
00253 if(s->readlen > 0) {
00254
00255
00256 return 1;
00257 } else if(s->state == STATE_READ) {
00258
00259 s->state = STATE_BLOCKED_NEWDATA;
00260 return 0;
00261 } else if(uip_newdata()) {
00262
00263 return 1;
00264 } else {
00265
00266 return 0;
00267 }
00268 }
00269
00270 PT_THREAD(psock_readto(register struct psock *psock, unsigned char c))
00271 {
00272 PT_BEGIN(&psock->psockpt);
00273
00274 buf_setup(&psock->buf, psock->bufptr, psock->bufsize);
00275
00276
00277
00278
00279 do {
00280 if(psock->readlen == 0) {
00281 PT_WAIT_UNTIL(&psock->psockpt, psock_newdata(psock));
00282 psock->state = STATE_READ;
00283 psock->readptr = (u8_t *)uip_appdata;
00284 psock->readlen = uip_datalen();
00285 }
00286 } while((buf_bufto(&psock->buf, c,
00287 &psock->readptr,
00288 &psock->readlen) & BUF_FOUND) == 0);
00289
00290 if(psock_datalen(psock) == 0) {
00291 psock->state = STATE_NONE;
00292 PT_RESTART(&psock->psockpt);
00293 }
00294 PT_END(&psock->psockpt);
00295 }
00296
00297 PT_THREAD(psock_readbuf(register struct psock *psock))
00298 {
00299 PT_BEGIN(&psock->psockpt);
00300
00301 buf_setup(&psock->buf, psock->bufptr, psock->bufsize);
00302
00303
00304
00305
00306 do {
00307 if(psock->readlen == 0) {
00308 PT_WAIT_UNTIL(&psock->psockpt, psock_newdata(psock));
00309 printf("Waited for newdata\n");
00310 psock->state = STATE_READ;
00311 psock->readptr = (u8_t *)uip_appdata;
00312 psock->readlen = uip_datalen();
00313 }
00314 } while(buf_bufdata(&psock->buf, psock->bufsize,
00315 &psock->readptr,
00316 &psock->readlen) != BUF_FULL);
00317
00318 if(psock_datalen(psock) == 0) {
00319 psock->state = STATE_NONE;
00320 PT_RESTART(&psock->psockpt);
00321 }
00322 PT_END(&psock->psockpt);
00323 }
00324
00325 void
00326 psock_init(register struct psock *psock, char *buffer, unsigned int buffersize)
00327 {
00328 psock->state = STATE_NONE;
00329 psock->readlen = 0;
00330 psock->bufptr = buffer;
00331 psock->bufsize = buffersize;
00332 buf_setup(&psock->buf, buffer, buffersize);
00333 PT_INIT(&psock->pt);
00334 PT_INIT(&psock->psockpt);
00335 }
00336