static void mbed_lwip_netif_status_irq(struct netif *lwip_netif) { if (netif_is_up(lwip_netif)) { bool dns_addr_has_to_be_added = false; if (!(lwip_has_addr_state & HAS_ANY_ADDR) && mbed_lwip_get_ip_addr(true, lwip_netif)) { if (lwip_blocking) { sys_sem_signal(&lwip_netif_has_any_addr); } lwip_has_addr_state |= HAS_ANY_ADDR; dns_addr_has_to_be_added = true; } #if PREF_ADDR_TIMEOUT if (!(lwip_has_addr_state & HAS_PREF_ADDR) && mbed_lwip_get_ip_addr(false, lwip_netif)) { if (lwip_blocking) { sys_sem_signal(&lwip_netif_has_pref_addr); } lwip_has_addr_state |= HAS_PREF_ADDR; dns_addr_has_to_be_added = true; } #endif #if BOTH_ADDR_TIMEOUT if (!(lwip_has_addr_state & HAS_BOTH_ADDR) && mbed_lwip_get_ipv4_addr(lwip_netif) && mbed_lwip_get_ipv6_addr(lwip_netif)) { if (lwip_blocking) { sys_sem_signal(&lwip_netif_has_both_addr); } lwip_has_addr_state |= HAS_BOTH_ADDR; dns_addr_has_to_be_added = true; } #endif if (dns_addr_has_to_be_added && !lwip_blocking) { add_dns_addr(lwip_netif); } if (lwip_has_addr_state & HAS_ANY_ADDR) { lwip_connected = NSAPI_STATUS_GLOBAL_UP; } } else { lwip_connected = NSAPI_STATUS_DISCONNECTED; } if (lwip_client_callback) { lwip_client_callback(lwip_status_cb_handle, NSAPI_EVENT_CONNECTION_STATUS_CHANGE, lwip_connected); } }
/** * Callback function called in the lwIP thread to process incoming data from the serial port */ static void gprs_input_callback(void *arg) { gprs_t * gprs = (gprs_t *)arg; /* LWIP_DEBUGF(GPRS_DEBUG,("gprs_input_callback: %u\n",p->len));*/ gprs_input_internal(gprs,(u8_t *)gprs->recvBuffer,gprs->recvLen); sys_sem_signal(&gprs->recvSem); }
static void InitDone(void* pvArg) { sys_sem_t* pSem=(sys_sem_t*)pvArg; dbgprintf("InitDone: TCPIP initialized\n"); sys_sem_signal(*pSem); }
/*-----------------------------------------------------------------------------------*/ static void timeout(void *arg) { struct netif *netif; struct pcapif *pcapif; struct pbuf *p, *q; u8_t *bufptr; struct eth_hdr *ethhdr; netif = (struct netif *)arg; pcapif = netif->state; ethhdr = (struct eth_hdr *)pcapif->pkt; if(htons(ethhdr->type) != ETHTYPE_IP || ip_lookup(pcapif->pkt + 14, netif)) { /* We allocate a pbuf chain of pbufs from the pool. */ p = pbuf_alloc(PBUF_LINK, pcapif->len, PBUF_POOL); if(p != NULL) { /* We iterate over the pbuf chain until we have read the entire packet into the pbuf. */ bufptr = (u_char *)pcapif->pkt; for(q = p; q != NULL; q = q->next) { /* Read enough bytes to fill this pbuf in the chain. The avaliable data in the pbuf is given by the q->len variable. */ /* read data into(q->payload, q->len); */ bcopy(bufptr, q->payload, q->len); bufptr += q->len; } ethhdr = p->payload; switch(htons(ethhdr->type)) { case ETHTYPE_IP: arp_ip_input(netif, p); pbuf_header(p, -14); netif->input(p, netif); break; case ETHTYPE_ARP: p = arp_arp_input(netif, pcapif->ethaddr, p); if(p != NULL) { printf("ARP outout\n"); pbuf_free(p); } break; default: pbuf_free(p); break; } } } else { printf("ip_lookup dropped\n"); } sys_sem_signal(pcapif->sem); }
/** * Delete the pcb inside a netconn. * Called from netconn_delete. * * @param msg the api_msg_msg pointing to the connection */ void do_delconn(struct api_msg_msg *msg) { /* @todo TCP: abort running write/connect? */ if ((msg->conn->state != NETCONN_NONE) && (msg->conn->state != NETCONN_LISTEN) && (msg->conn->state != NETCONN_CONNECT)) { /* this only happens for TCP netconns */ LWIP_ASSERT("msg->conn->type == NETCONN_TCP", msg->conn->type == NETCONN_TCP); msg->err = ERR_INPROGRESS; } else { LWIP_ASSERT("blocking connect in progress", (msg->conn->state != NETCONN_CONNECT) || IN_NONBLOCKING_CONNECT(msg->conn)); /* Drain and delete mboxes */ netconn_drain(msg->conn); if (msg->conn->pcb.tcp != NULL) { switch (NETCONNTYPE_GROUP(msg->conn->type)) { #if LWIP_RAW case NETCONN_RAW: raw_remove(msg->conn->pcb.raw); break; #endif /* LWIP_RAW */ #if LWIP_UDP case NETCONN_UDP: msg->conn->pcb.udp->recv_arg = NULL; udp_remove(msg->conn->pcb.udp); break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL && msg->conn->write_offset == 0); msg->conn->state = NETCONN_CLOSE; msg->msg.sd.shut = NETCONN_SHUT_RDWR; msg->conn->current_msg = msg; do_close_internal(msg->conn); /* API_EVENT is called inside do_close_internal, before releasing the application thread, so we can return at this point! */ return; #endif /* LWIP_TCP */ default: break; } msg->conn->pcb.tcp = NULL; } /* tcp netconns don't come here! */ /* @todo: this lets select make the socket readable and writable, which is wrong! errfd instead? */ API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0); API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0); } if (sys_sem_valid(&msg->conn->op_completed)) { sys_sem_signal(&msg->conn->op_completed); } }
/** * Put a struct mem back on the heap * * @param rmem is the data portion of a struct mem as returned by a previous * call to mem_malloc() */ void mem_free(void *rmem) { struct mem *mem; if (rmem == NULL) { LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_TRACE | 2, ("mem_free(p == NULL) was called.\n")); return; } LWIP_ASSERT("mem_free: sanity check alignment", (((mem_ptr_t)rmem) & (MEM_ALIGNMENT-1)) == 0); /* protect the heap from concurrent access */ sys_arch_sem_wait(mem_sem, 0); LWIP_ASSERT("mem_free: legal memory", (u8_t *)rmem >= (u8_t *)ram && (u8_t *)rmem < (u8_t *)ram_end); if ((u8_t *)rmem < (u8_t *)ram || (u8_t *)rmem >= (u8_t *)ram_end) { LWIP_DEBUGF(MEM_DEBUG | 3, ("mem_free: illegal memory\n")); #if MEM_STATS ++lwip_stats.mem.err; #endif /* MEM_STATS */ sys_sem_signal(mem_sem); return; } /* Get the corresponding struct mem ... */ mem = (struct mem *)((u8_t *)rmem - SIZEOF_STRUCT_MEM); /* ... which has to be in a used state ... */ LWIP_ASSERT("mem_free: mem->used", mem->used); /* ... and is now unused. */ mem->used = 0; if (mem < lfree) { /* the newly freed struct is now the lowest */ lfree = mem; } #if MEM_STATS lwip_stats.mem.used -= mem->next - ((u8_t *)mem - ram); #endif /* MEM_STATS */ /* finally, see if prev or next are free also */ plug_holes(mem); sys_sem_signal(mem_sem); }
/*-----------------------------------------------------------------------------------*/ u32_t sys_arch_mbox_fetch(struct sys_mbox *mbox, void **msg, u32_t timeout) { u32_t time = 0; /* The mutex lock is quick so we don't bother with the timeout stuff here. */ sys_arch_sem_wait(mbox->mutex, 0); while (mbox->first == mbox->last) { sys_sem_signal(mbox->mutex); /* We block while waiting for a mail to arrive in the mailbox. We must be prepared to timeout. */ if (timeout != 0) { time = sys_arch_sem_wait(mbox->mail, timeout); if (time == SYS_ARCH_TIMEOUT) { return SYS_ARCH_TIMEOUT; } } else { sys_arch_sem_wait(mbox->mail, 0); } sys_arch_sem_wait(mbox->mutex, 0); } if (msg != NULL) { LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_fetch: mbox %p msg %p\n", (void *)mbox, *msg)); *msg = mbox->msgs[mbox->first % SYS_MBOX_SIZE]; } else{ LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_fetch: mbox %p, null msg\n", (void *)mbox)); } mbox->first++; if (mbox->wait_send) { sys_sem_signal(mbox->mail); } sys_sem_signal(mbox->mutex); return time; }
static void mbed_lwip_netif_link_irq(struct netif *lwip_netif) { if (netif_is_link_up(lwip_netif)) { nsapi_error_t dhcp_status = mbed_set_dhcp(lwip_netif); if (lwip_blocking && dhcp_status == NSAPI_ERROR_OK) { sys_sem_signal(&lwip_netif_linked); } else if (dhcp_status != NSAPI_ERROR_OK) { netif_set_down(lwip_netif); } } else { sys_sem_signal(&lwip_netif_unlinked); netif_set_down(lwip_netif); } }
/*-----------------------------------------------------------------------------------*/ void * memp_mallocp(memp_t type) { void *mem; sys_sem_wait(mutex); mem = memp_malloc(type); sys_sem_signal(mutex); return mem; }
static void threadsync_set_value_synced(void *ctx) { struct threadsync_data *call_data = (struct threadsync_data*)ctx; call_data->retval.err = call_data->proxy_instance.set_value(&call_data->proxy_instance, call_data->arg2.len, call_data->arg1.value); sys_sem_signal(&call_data->threadsync_node->instance->sem); }
static void threadsync_release_instance_synced(void* ctx) { struct threadsync_data *call_data = (struct threadsync_data*)ctx; call_data->proxy_instance.release_instance(&call_data->proxy_instance); sys_sem_signal(&call_data->threadsync_node->instance->sem); }
static void sswt_handler(void *arg) { struct sswt_cb *sswt_cb = (struct sswt_cb *) arg; /* Timeout. Set flag to TRUE and signal semaphore */ sswt_cb->timeflag = 1; sys_sem_signal(*(sswt_cb->psem)); }
static void tcpip_init_done(void *arg) { sys_sem_t *sem; sem = (sys_sem_t *)arg; init_netifs(); sys_sem_signal(sem); }
static void get_next_instance_synced(void* ctx) { struct threadsync_data *call_data = (struct threadsync_data*)ctx; const struct snmp_leaf_node *leaf = (const struct snmp_leaf_node*)(const void*)call_data->proxy_instance.node; call_data->retval.err = leaf->get_next_instance(call_data->arg1.root_oid, call_data->arg2.root_oid_len, &call_data->proxy_instance); sys_sem_signal(&call_data->threadsync_node->instance->sem); }
/*-----------------------------------------------------------------------------------*/ int lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen) { struct lwip_socket *sock; struct netconn *newconn; struct ip_addr naddr; u16_t port; int newsock; struct sockaddr_in sin; DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s)); sock = get_socket(s); if (!sock) { return -1; } newconn = netconn_accept(sock->conn); /* get the IP address and port of the remote host */ netconn_peer(newconn, &naddr, &port); memset(&sin, 0, sizeof(sin)); sin.sin_len = sizeof(sin); sin.sin_family = AF_INET; sin.sin_port = htons(port); sin.sin_addr.s_addr = naddr.addr; if (*addrlen > sizeof(sin)) *addrlen = sizeof(sin); memcpy(addr, &sin, *addrlen); newsock = alloc_socket(newconn); if (newsock == -1) { netconn_delete(newconn); sock_set_errno(sock, ENOBUFS); return -1; } newconn->callback = event_callback; sock = get_socket(newsock); sys_sem_wait(socksem); sock->rcvevent += -1 - newconn->socket; newconn->socket = newsock; sys_sem_signal(socksem); #if SOCKETS_DEBUG DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d addr=", s, newsock)); ip_addr_debug_print(&naddr); DEBUGF(SOCKETS_DEBUG, (" port=%u\n", port)); #endif sock_set_errno(sock, 0); return newsock; }
/*-----------------------------------------------------------------------------------*/ u16_t sys_arch_mbox_fetch(struct sys_mbox *mbox, void **msg, u16_t timeout) { u16_t time = 1; /* The mutex lock is quick so we don't bother with the timeout stuff here. */ sys_arch_sem_wait(mbox->mutex, 0); while(mbox->first == mbox->last) { sys_sem_signal(mbox->mutex); /* We block while waiting for a mail to arrive in the mailbox. We must be prepared to timeout. */ if(timeout != 0) { time = sys_arch_sem_wait(mbox->mail, timeout); /* If time == 0, the sem_wait timed out, and we return 0. */ if(time == 0) { return 0; } } else { sys_arch_sem_wait(mbox->mail, 0); } sys_arch_sem_wait(mbox->mutex, 0); } if(msg != NULL) { DEBUGF(SYS_DEBUG, ("sys_mbox_fetch: mbox %p msg %p\n", mbox, *msg)); *msg = mbox->msgs[mbox->first]; } mbox->first++; if(mbox->first == SYS_MBOX_SIZE) { mbox->first = 0; } sys_sem_signal(mbox->mutex); return time; }
void fifoPut(fifo_t * fifo, int fd) { /* FIXME: mutex around struct data.. */ int cnt=0; sys_sem_wait(&fifo->sem ); /* enter critical */ LWIP_DEBUGF( SIO_FIFO_DEBUG,("fifoput: len%d dat%d empt%d --> ", fifo->len, fifo->dataslot, fifo->emptyslot ) ); if ( fifo->emptyslot < fifo->dataslot ) { cnt = read( fd, &fifo->data[fifo->emptyslot], fifo->dataslot - fifo->emptyslot ); } else { cnt = read( fd, &fifo->data[fifo->emptyslot], FIFOSIZE-fifo->emptyslot ); } fifo->emptyslot += cnt; fifo->len += cnt; LWIP_DEBUGF( SIO_FIFO_DEBUG,("len%d dat%d empt%d\n", fifo->len, fifo->dataslot, fifo->emptyslot ) ); if ( fifo->len > FIFOSIZE ) { printf( "ERROR: fifo overrun detected len=%d, flushing\n", fifo->len ); fifo->dataslot = 0; fifo->emptyslot = 0; fifo->len = 0; } if ( fifo->emptyslot == FIFOSIZE ) { fifo->emptyslot = 0; LWIP_DEBUGF( SIO_FIFO_DEBUG, ("(WRAP) ") ); sys_sem_signal(&fifo->sem ); /* leave critical */ fifoPut( fifo, fd ); return; } if ( fifo->getWaiting ) { fifo->getWaiting = FALSE; sys_sem_signal(&fifo->getSem ); } sys_sem_signal(&fifo->sem ); /* leave critical */ return; }
static void xemacif_recv_handler(void *arg) { struct xemac_s *xemac = (struct xemac_s *)(arg); xemacliteif_s *xemacliteif = (xemacliteif_s *)(xemac->state); XEmacLite *instance = xemacliteif->instance; struct pbuf *p; int len = 0; struct xtopology_t *xtopologyp = &xtopology[xemac->topology_index]; #if XLWIP_CONFIG_INCLUDE_EMACLITE_ON_ZYNQ == 1 #else XIntc_AckIntr(xtopologyp->intc_baseaddr, 1 << xtopologyp->intc_emac_intr); #endif p = pbuf_alloc(PBUF_RAW, XEL_MAX_FRAME_SIZE, PBUF_POOL); if (!p) { #if LINK_STATS lwip_stats.link.memerr++; lwip_stats.link.drop++; #endif /* receive and just ignore the frame. * we need to receive the frame because otherwise emaclite will * not generate any other interrupts since it cannot receive, * and we do not actively poll the emaclite */ XEmacLite_Recv(instance, xemac_tx_frame); return; } /* receive the packet */ len = XEmacLite_Recv(instance, p->payload); if (len == 0) { #if LINK_STATS lwip_stats.link.drop++; #endif pbuf_free(p); return; } /* store it in the receive queue, where it'll be processed by xemacif input thread */ if (pq_enqueue(xemacliteif->recv_q, (void*)p) < 0) { #if LINK_STATS lwip_stats.link.memerr++; lwip_stats.link.drop++; #endif pbuf_free(p); return; } #if !NO_SYS sys_sem_signal(&xemac->sem_rx_data_available); #endif }
static void mbed_lwip_netif_status_irq(struct netif *lwip_netif) { if (netif_is_up(lwip_netif)) { if (!(lwip_has_addr_state & HAS_ANY_ADDR) && mbed_lwip_get_ip_addr(true, lwip_netif)) { sys_sem_signal(&lwip_netif_has_any_addr); lwip_has_addr_state |= HAS_ANY_ADDR; } #if PREF_ADDR_TIMEOUT if (!(lwip_has_addr_state & HAS_PREF_ADDR) && mbed_lwip_get_ip_addr(false, lwip_netif)) { sys_sem_signal(&lwip_netif_has_pref_addr); lwip_has_addr_state |= HAS_PREF_ADDR; } #endif #if BOTH_ADDR_TIMEOUT if (!(lwip_has_addr_state & HAS_BOTH_ADDR) && mbed_lwip_get_ipv4_addr(lwip_netif) && mbed_lwip_get_ipv6_addr(lwip_netif)) { sys_sem_signal(&lwip_netif_has_both_addr); lwip_has_addr_state |= HAS_BOTH_ADDR; } #endif } }
static void xllfifo_recv_handler(struct xemac_s *xemac) { u32_t frame_length; struct pbuf *p; xaxiemacif_s *xaxiemacif = (xaxiemacif_s *)(xemac->state); XLlFifo *llfifo = &xaxiemacif->axififo; /* While there is data in the fifo ... */ while (XLlFifo_RxOccupancy(llfifo)) { /* find packet length */ frame_length = XLlFifo_RxGetLen(llfifo); /* allocate a pbuf */ p = pbuf_alloc(PBUF_RAW, frame_length, PBUF_POOL); if (!p) { char tmp_frame[XAE_MAX_FRAME_SIZE]; #if LINK_STATS lwip_stats.link.memerr++; lwip_stats.link.drop++; #endif /* receive and drop packet to keep data & len registers in sync */ XLlFifo_Read(llfifo, tmp_frame, frame_length); continue; } /* receive packet */ XLlFifo_Read(llfifo, p->payload, frame_length); #if ETH_PAD_SIZE len += ETH_PAD_SIZE; /* allow room for Ethernet padding */ #endif /* store it in the receive queue, where it'll be processed by xemacif input thread */ if (pq_enqueue(xaxiemacif->recv_q, (void*)p) < 0) { #if LINK_STATS lwip_stats.link.memerr++; lwip_stats.link.drop++; #endif pbuf_free(p); continue; } #if !NO_SYS sys_sem_signal(&xemac->sem_rx_data_available); #endif #if LINK_STATS lwip_stats.link.recv++; #endif } }
/** * Connect a pcb contained inside a netconn * Called from netconn_connect. * * @param msg the api_msg_msg pointing to the connection and containing * the IP address and port to connect to */ void do_connect(struct api_msg_msg *msg) { if (msg->conn->pcb.tcp == NULL) { /* This may happen when calling netconn_connect() a second time */ msg->err = ERR_CLSD; } else { switch (NETCONNTYPE_GROUP(msg->conn->type)) { #if LWIP_RAW case NETCONN_RAW: msg->err = raw_connect(msg->conn->pcb.raw, msg->msg.bc.ipaddr); break; #endif /* LWIP_RAW */ #if LWIP_UDP case NETCONN_UDP: msg->err = udp_connect(msg->conn->pcb.udp, msg->msg.bc.ipaddr, msg->msg.bc.port); break; #endif /* LWIP_UDP */ #if LWIP_TCP case NETCONN_TCP: /* Prevent connect while doing any other action. */ if (msg->conn->state != NETCONN_NONE) { msg->err = ERR_ISCONN; } else { setup_tcp(msg->conn); msg->err = tcp_connect(msg->conn->pcb.tcp, msg->msg.bc.ipaddr, msg->msg.bc.port, do_connected); if (msg->err == ERR_OK) { u8_t non_blocking = netconn_is_nonblocking(msg->conn); msg->conn->state = NETCONN_CONNECT; SET_NONBLOCKING_CONNECT(msg->conn, non_blocking); if (non_blocking) { msg->err = ERR_INPROGRESS; } else { msg->conn->current_msg = msg; /* sys_sem_signal() is called from do_connected (or err_tcp()), * when the connection is established! */ return; } } } break; #endif /* LWIP_TCP */ default: LWIP_ERROR("Invalid netconn type", 0, do { msg->err = ERR_VAL; } while(0)); break; } } sys_sem_signal(&msg->conn->op_completed); }
/** * Execute a DNS query * Called from netconn_gethostbyname * * @param arg the dns_api_msg pointing to the query */ void lwip_netconn_do_gethostbyname(void *arg) { struct dns_api_msg *msg = (struct dns_api_msg*)arg; API_EXPR_DEREF(msg->err) = dns_gethostbyname(msg->name, API_EXPR_REF(msg->addr), lwip_netconn_do_dns_found, msg); if (API_EXPR_DEREF(msg->err) != ERR_INPROGRESS) { /* on error or immediate success, wake up the application * task waiting in netconn_gethostbyname */ sys_sem_signal(API_EXPR_REF(msg->sem)); } }
/** * Execute a DNS query * Called from netconn_gethostbyname * * @param arg the dns_api_msg pointing to the query */ void do_gethostbyname(void *arg) { struct dns_api_msg *msg = (struct dns_api_msg*)arg; *msg->err = dns_gethostbyname(msg->name, msg->addr, do_dns_found, msg); if (*msg->err != ERR_INPROGRESS) { /* on error or immediate success, wake up the application * task waiting in netconn_gethostbyname */ sys_sem_signal(msg->sem); } }
void mem_free(void *rmem) { struct mem *mem; if (rmem == NULL) { LWIP_DEBUGF(MEM_DEBUG | DBG_TRACE | 2, ("mem_free(p == NULL) was called.\n")); return; } sys_sem_wait(mem_sem); LWIP_ASSERT("mem_free: legal memory", (u8_t *)rmem >= (u8_t *)ram && (u8_t *)rmem < (u8_t *)ram_end); if ((u8_t *)rmem < (u8_t *)ram || (u8_t *)rmem >= (u8_t *)ram_end) { LWIP_DEBUGF(MEM_DEBUG | 3, ("mem_free: illegal memory\n")); #if MEM_STATS ++lwip_stats.mem.err; #endif /* MEM_STATS */ sys_sem_signal(mem_sem); return; } mem = (struct mem *)((u8_t *)rmem - SIZEOF_STRUCT_MEM); LWIP_ASSERT("mem_free: mem->used", mem->used); mem->used = 0; if (mem < lfree) { lfree = mem; } #if MEM_STATS lwip_stats.mem.used -= mem->next - ((u8_t *)mem - ram); #endif /* MEM_STATS */ plug_holes(mem); sys_sem_signal(mem_sem); }
void hndl_pkt(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct ip_addr *host, u16_t port) { TftpClient *tc = (TftpClient *)arg; if(memcmp(host, &(tc->rem_host), sizeof(struct ip_addr)) != 0) return; char *data = (char *)p->payload; u16_t datalen = p->len; u16_t opcode = ntohs(*(u16_t *)data); if(opcode == 3){ u16_t pktblk = ntohs(*(u16_t *)(data+2)); // Send ack to pktblk struct ack *a = (struct ack *) safe_malloc(sizeof(struct ack)); a->opcode = htons(4); a->blkno = htons(pktblk); struct pbuf *sndbuf = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct ack), PBUF_ROM); sndbuf->payload = a; udp_sendto(pcb, sndbuf, host, port); //pbuf_free(sndbuf); // If the pkt isn't a duplicate write the data into f if(pktblk < tc->blkno) return; if(tc->mode == MODE_OCTET){ write(tc->fd, data+4,datalen-4); }else{ netascii_write(tc->fd, data+4, datalen-4); } tc->blkno++; if(datalen-4 < 512){ //sleep(2); sys_sem_signal(&(tc->get_wait)); } return; } if(opcode == 5){ tc->error(data+4, true); } tc->error("Recieved irrelavent data from target..... Ignoring", false); }
static err_t poll_tcp(void *arg, struct tcp_pcb *pcb) { struct netconn *conn; conn = arg; if (conn != NULL && (conn->state == NETCONN_WRITE || conn->state == NETCONN_CLOSE) && conn->sem != SYS_SEM_NULL) { sys_sem_signal(conn->sem); } return ERR_OK; }
u8_t fifoGet(fifo_t * fifo) { u8_t c; sys_sem_wait(&fifo->sem); /* enter critical section */ if (fifo->dataslot == fifo->emptyslot) { fifo->getWaiting = TRUE; /* tell putFifo to signal us when data is available */ sys_sem_signal(&fifo->sem); /* leave critical section (allow input from serial port..) */ sys_sem_wait(&fifo->getSem); /* wait 4 data */ sys_sem_wait(&fifo->sem); /* reenter critical section */ } c = fifo->data[fifo->dataslot++]; fifo->len--; if (fifo->dataslot == FIFOSIZE) { fifo->dataslot = 0; } sys_sem_signal(&fifo->sem); /* leave critical section */ return c; }
void * mem_realloc(void *rmem, mem_size_t newsize) { mem_size_t size; mem_size_t ptr, ptr2; struct mem *mem, *mem2; /* Expand the size of the allocated memory region so that we can adjust for alignment. */ if ((newsize % MEM_ALIGNMENT) != 0) { newsize += MEM_ALIGNMENT - ((newsize + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT); } if (newsize > MEM_SIZE) { return NULL; } sys_sem_wait(mem_sem); LWIP_ASSERT("mem_realloc: legal memory", (u8_t *)rmem >= (u8_t *)ram && (u8_t *)rmem < (u8_t *)ram_end); if ((u8_t *)rmem < (u8_t *)ram || (u8_t *)rmem >= (u8_t *)ram_end) { LWIP_DEBUGF(MEM_DEBUG | 3, ("mem_realloc: illegal memory\n")); return rmem; } mem = (struct mem *)((u8_t *)rmem - SIZEOF_STRUCT_MEM); ptr = (u8_t *)mem - ram; size = mem->next - ptr - SIZEOF_STRUCT_MEM; #if MEM_STATS lwip_stats.mem.used -= (size - newsize); #endif /* MEM_STATS */ if (newsize + SIZEOF_STRUCT_MEM + MIN_SIZE < size) { ptr2 = ptr + SIZEOF_STRUCT_MEM + newsize; mem2 = (struct mem *)&ram[ptr2]; mem2->used = 0; mem2->next = mem->next; mem2->prev = ptr; mem->next = ptr2; if (mem2->next != MEM_SIZE) { ((struct mem *)&ram[mem2->next])->prev = ptr2; } plug_holes(mem2); } sys_sem_signal(mem_sem); return rmem; }
/** helper thread to wait for socket events using select */ static void sockex_select_waiter(void *arg) { struct sockex_select_helper *helper = (struct sockex_select_helper *)arg; int ret; fd_set readset; fd_set writeset; fd_set errset; struct timeval tv; LWIP_ASSERT("helper != NULL", helper != NULL); FD_ZERO(&readset); FD_ZERO(&writeset); FD_ZERO(&errset); if (helper->wait_read) { FD_SET(helper->socket, &readset); } if (helper->wait_write) { FD_SET(helper->socket, &writeset); } if (helper->wait_err) { FD_SET(helper->socket, &errset); } tv.tv_sec = helper->wait_ms / 1000; tv.tv_usec = (helper->wait_ms % 1000) * 1000; ret = lwip_select(helper->socket, &readset, &writeset, &errset, &tv); if (helper->expect_read || helper->expect_write || helper->expect_err) { LWIP_ASSERT("ret > 0", ret > 0); } else { LWIP_ASSERT("ret == 0", ret == 0); } if (helper->expect_read) { LWIP_ASSERT("FD_ISSET(helper->socket, &readset)", FD_ISSET(helper->socket, &readset)); } else { LWIP_ASSERT("!FD_ISSET(helper->socket, &readset)", !FD_ISSET(helper->socket, &readset)); } if (helper->expect_write) { LWIP_ASSERT("FD_ISSET(helper->socket, &writeset)", FD_ISSET(helper->socket, &writeset)); } else { LWIP_ASSERT("!FD_ISSET(helper->socket, &writeset)", !FD_ISSET(helper->socket, &writeset)); } if (helper->expect_err) { LWIP_ASSERT("FD_ISSET(helper->socket, &errset)", FD_ISSET(helper->socket, &errset)); } else { LWIP_ASSERT("!FD_ISSET(helper->socket, &errset)", !FD_ISSET(helper->socket, &errset)); } sys_sem_signal(&helper->sem); }
static int alloc_socket(struct netconn *newconn) { int i,fd; if (!socksem) socksem = sys_sem_new(1); /* Protect socket array */ sys_sem_wait(socksem); /* allocate a new socket identifier */ for(i = 0; i < NUM_SOCKETS; ++i) { if (!sockets[i].conn) { sockets[i].conn = newconn; sockets[i].lastdata = NULL; sockets[i].lastoffset = 0; sockets[i].rcvevent = 0; sockets[i].sendevent = 1; /* TCP send buf is empty */ sockets[i].flags = 0; sockets[i].err = 0; fd=socket(PF_INET, SOCK_DGRAM, 0); if (fd < 0) { sys_sem_signal(socksem); return -1; } sys_sem_signal(socksem); sockets[i].fdfake=fd; lwip_sockmap[fd]=i+1; return fd; } } printf("LU\n"); sys_sem_signal(socksem); return -1; }