void initializeHeap(Heap *h, uintptr_t *sp, uintptr_t *exnPtr, size_t exnCnt, serverstate ss)
{
int i;
Ro *r0, *r2, *r3, *r4, *r5, *r6;
if ( h->status != HSTAT_UNINITIALIZED )
(*ss->report) (DIE, "initializeHeap: status <> HSTAT_UNINITIALIZED",ss->aux);
r0 = clearStatusBits(*(Ro**)(h->ds)); // r0 is a pointer to a region description on the stack
r2 = r0+1; // r2 is a pointer to the next region description on the stack
r3 = r0+2;
r4 = r0+3;
r5 = r0+4;
r6 = r0+5;
h->sp = sp;
h->exnPtr = exnPtr;
h->exnCnt = exnCnt;
// printf("r0 = %x, r2 = %x, r3=%x, h=%x, ds=%x\n", r0,r2,r3,h,h->ds);
h->r0copy = copyRegion(r0);
h->r2copy = copyRegion(r2);
h->r3copy = copyRegion(r3);
h->r4copy = copyRegion(r4);
h->r5copy = copyRegion(r5);
h->r6copy = copyRegion(r6);
for ( i = 0 ; i < LOWSTACK_COPY_SZ ; i++ )
{
h->lowStack[i] = *(sp - i - 1);
}
h->status = HSTAT_CLEAN;
}
/**
* Resolve the given hostname to an IP address.
* @param aHostname Name to be resolved
* @param aResult IPAddress structure to store the returned IP address
* @return 1 if aIPAddrString was successfully converted to an IP address,
* else error code
*/
int WiFiGenericClass::hostByName(const char* aHostname, IPAddress& aResult)
{
ip_addr_t addr;
aResult = static_cast<uint32_t>(0);
waitStatusBits(WIFI_DNS_IDLE_BIT, 5000);
clearStatusBits(WIFI_DNS_IDLE_BIT);
err_t err = dns_gethostbyname(aHostname, &addr, &wifi_dns_found_callback, &aResult);
if(err == ERR_OK && addr.u_addr.ip4.addr) {
aResult = addr.u_addr.ip4.addr;
} else if(err == ERR_INPROGRESS) {
waitStatusBits(WIFI_DNS_DONE_BIT, 4000);
clearStatusBits(WIFI_DNS_DONE_BIT);
}
setStatusBits(WIFI_DNS_IDLE_BIT);
if((uint32_t)aResult == 0){
log_e("DNS Failed for %s", aHostname);
}
return (uint32_t)aResult != 0;
}
/*-------------------------------------------------------------------------*
*deallocateRegionsUntil: *
* Called with rdAddr=sp, which do not nessesaraly point at a region *
* descriptor. It deallocates all regions that are placed over sp. *
* The function does not return or alter anything. *
*-------------------------------------------------------------------------*/
void dealloc_regions_until(UInt32 rdAddr) {
Regiondesc *rd;
rd = (Regiondesc *) clearStatusBits(rdAddr);
while (rd <= topRegion)
dealloc_region();
return;
}
void
pp_reg(Region r, char *str)
{
r = clearStatusBits(r);
fprintf(stderr,"printRegionInfo called from: %s\n",str);
fprintf(stderr,"Region at address: %p\n", r);
pp_gen(&(r->g0));
#ifdef ENABLE_GEN_GC
pp_gen(&(r->g1));
#endif /* ENABLE_GEN_GC */
return;
}
/*----------------------------------------------------------------------*
*resetRegion: *
* All regionpages except one are inserted into the free list, and *
* the region administration structure is updated. The statusbits are *
* not changed. *
*----------------------------------------------------------------------*/
UInt32 reset_region(UInt32 rdAddr) {
Regiondesc *rd;
rd = (Regiondesc *) clearStatusBits(rdAddr);
/* There is always at least one page in a region. */
if ( (rd->fp)->n != NULL ) { /* There are more than one page in the region. */
(((Regionpage *)rd->b)-1)->n = freelist;
freelist = (rd->fp)->n;
(rd->fp)->n = NULL;
}
rd->a = (UInt32 *)(&(rd->fp)->i); /* beginning of klump in first page */
rd->b = (UInt32 *)((rd->fp)+1); /* end of klump in first page */
return rdAddr; /* We preserve rdAddr and the status bits. */
}
UInt32 *alloc (UInt32 rdAddr, int n) {
UInt32 *t1;
UInt32 *t2;
UInt32 *t3;
Regiondesc *rd;
rd = (Regiondesc *) clearStatusBits(rdAddr);
t1 = rd->a;
t2 = t1 + n;
t3 = rd->b;
if (t2 > t3) {
get_regionpage_from_freelist(rd);
t1 = rd->a;
t2 = t1 + n;
}
rd->a = t2;
return t1;
}
UInt32 *alloc_region(Regiondesc *rdAddr) {
Regionpage *rp;
rdAddr = (Regiondesc *) clearStatusBits((UInt32)rdAddr);
if (freelist==NULL) alloc_regionpages();
rp = freelist;
freelist = freelist->n;
rp->n = NULL;
rdAddr->a = (UInt32 *)(&(rp->i)); /* We allocate from k.i in the page. */
rdAddr->b = (UInt32 *)(rp+1); /* The border is after this page. */
rdAddr->p = topRegion; /* Push this region onto the region stack. */
rdAddr->fp = rp; /* Update pointer to the first page. */
topRegion = rdAddr;
/* We have to set the infinitebit. */
rdAddr = (Regiondesc *) setInfiniteBit((UInt32)rdAddr);
return (UInt32 *)rdAddr;
}
esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event)
{
log_d("Event: %d - %s", event->event_id, system_event_names[event->event_id]);
if(event->event_id == SYSTEM_EVENT_SCAN_DONE) {
WiFiScanClass::_scanDone();
} else if(event->event_id == SYSTEM_EVENT_STA_START) {
WiFiSTAClass::_setStatus(WL_DISCONNECTED);
setStatusBits(STA_STARTED_BIT);
} else if(event->event_id == SYSTEM_EVENT_STA_STOP) {
WiFiSTAClass::_setStatus(WL_NO_SHIELD);
clearStatusBits(STA_STARTED_BIT | STA_CONNECTED_BIT | STA_HAS_IP_BIT | STA_HAS_IP6_BIT);
} else if(event->event_id == SYSTEM_EVENT_STA_CONNECTED) {
WiFiSTAClass::_setStatus(WL_IDLE_STATUS);
setStatusBits(STA_CONNECTED_BIT);
} else if(event->event_id == SYSTEM_EVENT_STA_DISCONNECTED) {
uint8_t reason = event->event_info.disconnected.reason;
log_w("Reason: %u - %s", reason, reason2str(reason));
if(reason == WIFI_REASON_NO_AP_FOUND) {
WiFiSTAClass::_setStatus(WL_NO_SSID_AVAIL);
} else if(reason == WIFI_REASON_AUTH_FAIL || reason == WIFI_REASON_ASSOC_FAIL) {
WiFiSTAClass::_setStatus(WL_CONNECT_FAILED);
} else if(reason == WIFI_REASON_BEACON_TIMEOUT || reason == WIFI_REASON_HANDSHAKE_TIMEOUT) {
WiFiSTAClass::_setStatus(WL_CONNECTION_LOST);
} else if(reason == WIFI_REASON_AUTH_EXPIRE) {
} else {
WiFiSTAClass::_setStatus(WL_DISCONNECTED);
}
clearStatusBits(STA_CONNECTED_BIT | STA_HAS_IP_BIT | STA_HAS_IP6_BIT);
if(((reason == WIFI_REASON_AUTH_EXPIRE) ||
(reason >= WIFI_REASON_BEACON_TIMEOUT && reason != WIFI_REASON_AUTH_FAIL)) &&
WiFi.getAutoReconnect())
{
WiFi.disconnect(true);
WiFi.begin();
}
} else if(event->event_id == SYSTEM_EVENT_STA_GOT_IP) {
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
uint8_t * ip = (uint8_t *)&(event->event_info.got_ip.ip_info.ip.addr);
uint8_t * mask = (uint8_t *)&(event->event_info.got_ip.ip_info.netmask.addr);
uint8_t * gw = (uint8_t *)&(event->event_info.got_ip.ip_info.gw.addr);
log_d("STA IP: %u.%u.%u.%u, MASK: %u.%u.%u.%u, GW: %u.%u.%u.%u",
ip[0], ip[1], ip[2], ip[3],
mask[0], mask[1], mask[2], mask[3],
gw[0], gw[1], gw[2], gw[3]);
#endif
WiFiSTAClass::_setStatus(WL_CONNECTED);
setStatusBits(STA_HAS_IP_BIT | STA_CONNECTED_BIT);
} else if(event->event_id == SYSTEM_EVENT_STA_LOST_IP) {
WiFiSTAClass::_setStatus(WL_IDLE_STATUS);
clearStatusBits(STA_HAS_IP_BIT);
} else if(event->event_id == SYSTEM_EVENT_AP_START) {
setStatusBits(AP_STARTED_BIT);
} else if(event->event_id == SYSTEM_EVENT_AP_STOP) {
clearStatusBits(AP_STARTED_BIT | AP_HAS_CLIENT_BIT);
} else if(event->event_id == SYSTEM_EVENT_AP_STACONNECTED) {
setStatusBits(AP_HAS_CLIENT_BIT);
} else if(event->event_id == SYSTEM_EVENT_AP_STADISCONNECTED) {
wifi_sta_list_t clients;
if(esp_wifi_ap_get_sta_list(&clients) != ESP_OK || !clients.num){
clearStatusBits(AP_HAS_CLIENT_BIT);
}
} else if(event->event_id == SYSTEM_EVENT_ETH_START) {
setStatusBits(ETH_STARTED_BIT);
} else if(event->event_id == SYSTEM_EVENT_ETH_STOP) {
clearStatusBits(ETH_STARTED_BIT | ETH_CONNECTED_BIT | ETH_HAS_IP_BIT | ETH_HAS_IP6_BIT);
} else if(event->event_id == SYSTEM_EVENT_ETH_CONNECTED) {
setStatusBits(ETH_CONNECTED_BIT);
} else if(event->event_id == SYSTEM_EVENT_ETH_DISCONNECTED) {
clearStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP_BIT | ETH_HAS_IP6_BIT);
} else if(event->event_id == SYSTEM_EVENT_ETH_GOT_IP) {
#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
uint8_t * ip = (uint8_t *)&(event->event_info.got_ip.ip_info.ip.addr);
uint8_t * mask = (uint8_t *)&(event->event_info.got_ip.ip_info.netmask.addr);
uint8_t * gw = (uint8_t *)&(event->event_info.got_ip.ip_info.gw.addr);
log_d("ETH IP: %u.%u.%u.%u, MASK: %u.%u.%u.%u, GW: %u.%u.%u.%u",
ip[0], ip[1], ip[2], ip[3],
mask[0], mask[1], mask[2], mask[3],
gw[0], gw[1], gw[2], gw[3]);
#endif
setStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP_BIT);
} else if(event->event_id == SYSTEM_EVENT_GOT_IP6) {
if(event->event_info.got_ip6.if_index == TCPIP_ADAPTER_IF_AP){
setStatusBits(AP_HAS_IP6_BIT);
} else if(event->event_info.got_ip6.if_index == TCPIP_ADAPTER_IF_STA){
setStatusBits(STA_CONNECTED_BIT | STA_HAS_IP6_BIT);
} else if(event->event_info.got_ip6.if_index == TCPIP_ADAPTER_IF_ETH){
setStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP6_BIT);
}
}
for(uint32_t i = 0; i < cbEventList.size(); i++) {
WiFiEventCbList_t entry = cbEventList[i];
if(entry.cb || entry.fcb || entry.scb) {
if(entry.event == (system_event_id_t) event->event_id || entry.event == SYSTEM_EVENT_MAX) {
if(entry.cb) {
entry.cb((system_event_id_t) event->event_id);
} else if(entry.fcb) {
entry.fcb((system_event_id_t) event->event_id, (system_event_info_t) event->event_info);
} else {
entry.scb(event);
}
}
}
}
return ESP_OK;
}
