2 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
19 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
21 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
24 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
27 * This file is part of the lwIP TCP/IP stack.
29 * Author: Adam Dunkels <adam@sics.se>
33 /* This is the part of the API that is linked with
38 #include "lwip/api_msg.h"
39 #include "lwip/memp.h"
43 netbuf *netbuf_new(void)
47 buf = memp_malloc(MEMP_NETBUF);
58 netbuf_delete(struct netbuf *buf)
63 buf->p = buf->ptr = NULL;
65 memp_free(MEMP_NETBUF, buf);
70 netbuf_alloc(struct netbuf *buf, u16_t size)
72 /* Deallocate any previously allocated memory. */
76 buf->p = pbuf_alloc(PBUF_TRANSPORT, size, PBUF_RAM);
81 return buf->p->payload;
85 netbuf_free(struct netbuf *buf)
90 buf->p = buf->ptr = NULL;
94 netbuf_ref(struct netbuf *buf, void *dataptr, u16_t size)
99 buf->p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF);
100 buf->p->payload = dataptr;
101 buf->p->len = buf->p->tot_len = size;
106 netbuf_chain(struct netbuf *head, struct netbuf *tail)
108 pbuf_chain(head->p, tail->p);
110 memp_free(MEMP_NETBUF, tail);
114 netbuf_len(struct netbuf *buf)
116 return buf->p->tot_len;
120 netbuf_data(struct netbuf *buf, void **dataptr, u16_t *len)
122 if (buf->ptr == NULL) {
125 *dataptr = buf->ptr->payload;
126 *len = buf->ptr->len;
131 netbuf_next(struct netbuf *buf)
133 if (buf->ptr->next == NULL) {
136 buf->ptr = buf->ptr->next;
137 if (buf->ptr->next == NULL) {
144 netbuf_first(struct netbuf *buf)
150 netbuf_copy_partial(struct netbuf *buf, void *dataptr, u16_t len, u16_t offset)
157 if(buf == NULL || dataptr == NULL) {
161 /* This implementation is bad. It should use bcopy
163 for(p = buf->p; left < len && p != NULL; p = p->next) {
164 if (offset != 0 && offset >= p->len) {
167 for(i = offset; i < p->len; ++i) {
168 ((u8_t *)dataptr)[left] = ((u8_t *)p->payload)[i];
179 netbuf_copy(struct netbuf *buf, void *dataptr, u16_t len)
181 netbuf_copy_partial(buf, dataptr, len, 0);
185 netbuf_fromaddr(struct netbuf *buf)
187 return buf->fromaddr;
191 netbuf_fromport(struct netbuf *buf)
193 return buf->fromport;
197 netconn *netconn_new_with_proto_and_callback(enum netconn_type t, u16_t proto,
198 void (*callback)(struct netconn *, enum netconn_evt, u16_t len))
200 struct netconn *conn;
203 conn = memp_malloc(MEMP_NETCONN);
210 conn->pcb.tcp = NULL;
212 if ((conn->mbox = sys_mbox_new()) == SYS_MBOX_NULL) {
213 memp_free(MEMP_NETCONN, conn);
216 conn->recvmbox = SYS_MBOX_NULL;
217 conn->acceptmbox = SYS_MBOX_NULL;
218 conn->sem = SYS_SEM_NULL;
219 conn->state = NETCONN_NONE;
221 conn->callback = callback;
222 conn->recv_avail = 0;
224 if((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
225 memp_free(MEMP_NETCONN, conn);
229 msg->type = API_MSG_NEWCONN;
230 msg->msg.msg.bc.port = proto; /* misusing the port field */
231 msg->msg.conn = conn;
233 sys_mbox_fetch(conn->mbox, NULL);
234 memp_free(MEMP_API_MSG, msg);
236 if ( conn->err != ERR_OK ) {
237 memp_free(MEMP_NETCONN, conn);
246 netconn *netconn_new(enum netconn_type t)
248 return netconn_new_with_proto_and_callback(t,0,NULL);
252 netconn *netconn_new_with_callback(enum netconn_type t,
253 void (*callback)(struct netconn *, enum netconn_evt, u16_t len))
255 return netconn_new_with_proto_and_callback(t,0,callback);
260 netconn_delete(struct netconn *conn)
269 if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
273 msg->type = API_MSG_DELCONN;
274 msg->msg.conn = conn;
276 sys_mbox_fetch(conn->mbox, NULL);
277 memp_free(MEMP_API_MSG, msg);
279 /* Drain the recvmbox. */
280 if (conn->recvmbox != SYS_MBOX_NULL) {
281 while (sys_arch_mbox_fetch(conn->recvmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {
282 if (conn->type == NETCONN_TCP) {
284 pbuf_free((struct pbuf *)mem);
286 netbuf_delete((struct netbuf *)mem);
289 sys_mbox_free(conn->recvmbox);
290 conn->recvmbox = SYS_MBOX_NULL;
294 /* Drain the acceptmbox. */
295 if (conn->acceptmbox != SYS_MBOX_NULL) {
296 while (sys_arch_mbox_fetch(conn->acceptmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {
297 netconn_delete((struct netconn *)mem);
300 sys_mbox_free(conn->acceptmbox);
301 conn->acceptmbox = SYS_MBOX_NULL;
304 sys_mbox_free(conn->mbox);
305 conn->mbox = SYS_MBOX_NULL;
306 if (conn->sem != SYS_SEM_NULL) {
307 sys_sem_free(conn->sem);
309 /* conn->sem = SYS_SEM_NULL;*/
310 memp_free(MEMP_NETCONN, conn);
315 netconn_type(struct netconn *conn)
321 netconn_peer(struct netconn *conn, struct ip_addr *addr,
324 switch (conn->type) {
326 /* return an error as connecting is only a helper for upper layers */
328 case NETCONN_UDPLITE:
329 case NETCONN_UDPNOCHKSUM:
332 if (conn->pcb.udp == NULL ||
333 ((conn->pcb.udp->flags & UDP_FLAGS_CONNECTED) == 0))
335 *addr = (conn->pcb.udp->remote_ip);
336 *port = conn->pcb.udp->remote_port;
342 if (conn->pcb.tcp == NULL)
344 *addr = (conn->pcb.tcp->remote_ip);
345 *port = conn->pcb.tcp->remote_port;
349 return (conn->err = ERR_OK);
353 netconn_addr(struct netconn *conn, struct ip_addr **addr,
356 switch (conn->type) {
359 *addr = &(conn->pcb.raw->local_ip);
360 *port = conn->pcb.raw->protocol;
363 case NETCONN_UDPLITE:
364 case NETCONN_UDPNOCHKSUM:
367 *addr = &(conn->pcb.udp->local_ip);
368 *port = conn->pcb.udp->local_port;
374 *addr = &(conn->pcb.tcp->local_ip);
375 *port = conn->pcb.tcp->local_port;
379 return (conn->err = ERR_OK);
383 netconn_bind(struct netconn *conn, struct ip_addr *addr,
392 if (conn->type != NETCONN_TCP &&
393 conn->recvmbox == SYS_MBOX_NULL) {
394 if ((conn->recvmbox = sys_mbox_new()) == SYS_MBOX_NULL) {
399 if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
400 return (conn->err = ERR_MEM);
402 msg->type = API_MSG_BIND;
403 msg->msg.conn = conn;
404 msg->msg.msg.bc.ipaddr = addr;
405 msg->msg.msg.bc.port = port;
407 sys_mbox_fetch(conn->mbox, NULL);
408 memp_free(MEMP_API_MSG, msg);
414 netconn_connect(struct netconn *conn, struct ip_addr *addr,
424 if (conn->recvmbox == SYS_MBOX_NULL) {
425 if ((conn->recvmbox = sys_mbox_new()) == SYS_MBOX_NULL) {
430 if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
433 msg->type = API_MSG_CONNECT;
434 msg->msg.conn = conn;
435 msg->msg.msg.bc.ipaddr = addr;
436 msg->msg.msg.bc.port = port;
438 sys_mbox_fetch(conn->mbox, NULL);
439 memp_free(MEMP_API_MSG, msg);
444 netconn_disconnect(struct netconn *conn)
452 if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
455 msg->type = API_MSG_DISCONNECT;
456 msg->msg.conn = conn;
458 sys_mbox_fetch(conn->mbox, NULL);
459 memp_free(MEMP_API_MSG, msg);
465 netconn_listen(struct netconn *conn)
473 if (conn->acceptmbox == SYS_MBOX_NULL) {
474 conn->acceptmbox = sys_mbox_new();
475 if (conn->acceptmbox == SYS_MBOX_NULL) {
480 if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
481 return (conn->err = ERR_MEM);
483 msg->type = API_MSG_LISTEN;
484 msg->msg.conn = conn;
486 sys_mbox_fetch(conn->mbox, NULL);
487 memp_free(MEMP_API_MSG, msg);
492 netconn_accept(struct netconn *conn)
494 struct netconn *newconn;
500 sys_mbox_fetch(conn->acceptmbox, (void **)&newconn);
501 /* Register event with callback */
503 (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, 0);
509 netconn_recv(struct netconn *conn)
520 if (conn->recvmbox == SYS_MBOX_NULL) {
521 conn->err = ERR_CONN;
525 if (conn->err != ERR_OK) {
529 if (conn->type == NETCONN_TCP) {
530 if (conn->pcb.tcp->state == LISTEN) {
531 conn->err = ERR_CONN;
536 buf = memp_malloc(MEMP_NETBUF);
543 sys_mbox_fetch(conn->recvmbox, (void **)&p);
548 conn->recv_avail -= len;
553 /* Register event with callback */
555 (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, len);
557 /* If we are closed, we indicate that we no longer wish to receive
558 data by setting conn->recvmbox to SYS_MBOX_NULL. */
560 memp_free(MEMP_NETBUF, buf);
561 sys_mbox_free(conn->recvmbox);
562 conn->recvmbox = SYS_MBOX_NULL;
569 buf->fromaddr = NULL;
571 /* Let the stack know that we have taken the data. */
572 if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
576 msg->type = API_MSG_RECV;
577 msg->msg.conn = conn;
579 msg->msg.msg.len = buf->p->tot_len;
581 msg->msg.msg.len = 1;
585 sys_mbox_fetch(conn->mbox, NULL);
586 memp_free(MEMP_API_MSG, msg);
588 sys_mbox_fetch(conn->recvmbox, (void **)&buf);
589 conn->recv_avail -= buf->p->tot_len;
590 /* Register event with callback */
592 (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, buf->p->tot_len);
598 LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv: received %p (err %d)\n", (void *)buf, conn->err));
605 netconn_send(struct netconn *conn, struct netbuf *buf)
613 if (conn->err != ERR_OK) {
617 if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
618 return (conn->err = ERR_MEM);
621 LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_send: sending %d bytes\n", buf->p->tot_len));
622 msg->type = API_MSG_SEND;
623 msg->msg.conn = conn;
624 msg->msg.msg.p = buf->p;
627 sys_mbox_fetch(conn->mbox, NULL);
628 memp_free(MEMP_API_MSG, msg);
633 netconn_write(struct netconn *conn, void *dataptr, u16_t size, u8_t copy)
642 if (conn->err != ERR_OK) {
646 if (conn->sem == SYS_SEM_NULL) {
647 conn->sem = sys_sem_new(0);
648 if (conn->sem == SYS_SEM_NULL) {
653 if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
654 return (conn->err = ERR_MEM);
656 msg->type = API_MSG_WRITE;
657 msg->msg.conn = conn;
660 conn->state = NETCONN_WRITE;
661 while (conn->err == ERR_OK && size > 0) {
662 msg->msg.msg.w.dataptr = dataptr;
663 msg->msg.msg.w.copy = copy;
665 if (conn->type == NETCONN_TCP) {
666 if (tcp_sndbuf(conn->pcb.tcp) == 0) {
667 sys_sem_wait(conn->sem);
668 if (conn->err != ERR_OK) {
672 if (size > tcp_sndbuf(conn->pcb.tcp)) {
673 /* We cannot send more than one send buffer's worth of data at a
675 len = tcp_sndbuf(conn->pcb.tcp);
683 LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_write: writing %d bytes (%d)\n", len, copy));
684 msg->msg.msg.w.len = len;
686 sys_mbox_fetch(conn->mbox, NULL);
687 if (conn->err == ERR_OK) {
688 dataptr = (void *)((u8_t *)dataptr + len);
690 } else if (conn->err == ERR_MEM) {
692 sys_sem_wait(conn->sem);
698 memp_free(MEMP_API_MSG, msg);
699 conn->state = NETCONN_NONE;
700 if (conn->sem != SYS_SEM_NULL) {
701 sys_sem_free(conn->sem);
702 conn->sem = SYS_SEM_NULL;
709 netconn_close(struct netconn *conn)
716 if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
717 return (conn->err = ERR_MEM);
720 conn->state = NETCONN_CLOSE;
722 msg->type = API_MSG_CLOSE;
723 msg->msg.conn = conn;
725 sys_mbox_fetch(conn->mbox, NULL);
726 if (conn->err == ERR_MEM &&
727 conn->sem != SYS_SEM_NULL) {
728 sys_sem_wait(conn->sem);
731 conn->state = NETCONN_NONE;
732 memp_free(MEMP_API_MSG, msg);
737 netconn_err(struct netconn *conn)