自学教程：C++ sys_sem_signal函数代码示例

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 voidInitDone(void* pvArg){	sys_sem_t*	pSem=(sys_sem_t*)pvArg;	dbgprintf("InitDone: TCPIP initialized/n");	sys_sem_signal(*pSem);}

/** * Delete the pcb inside a netconn. * Called from netconn_delete. * * @param msg the api_msg_msg pointing to the connection */voiddo_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() */	voidmem_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_tsys_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 voidthreadsync_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 voidthreadsync_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 voidsswt_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 voidtcpip_init_done(void *arg){	sys_sem_t *sem;	sem = (sys_sem_t *)arg;	init_netifs();	sys_sem_signal(sem);}

static voidget_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);}

/*-----------------------------------------------------------------------------------*/intlwip_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;}

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 voidxemacif_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 voidxllfifo_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 */voiddo_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 */voidlwip_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 */voiddo_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);    }}

voidmem_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_tpoll_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 voidsockex_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 intalloc_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;}