static void write_in_dat_file(void* data, void *param)
{
FILE *file = (FILE*)param;
road_t *road = (road_t*)data;
uint16_t datalen;
uint32_t linkid = ENDIAN_SWAP32(road->link_id);
uint16_t len;
uint32_t last_bytes = 0;
datalen = (road->name ? road->length + 2: 0) + 12;
len = (road->name ? ENDIAN_SWAP16(datalen - 12) : 0);
datalen = ENDIAN_SWAP16(datalen);
fwrite(&datalen, sizeof(datalen), 1, file);
fwrite(&linkid, sizeof(linkid), 1, file);
fwrite(&len, sizeof(len), 1, file);
if (ENDIAN_SWAP16(datalen) > 12)
{
last_bytes = 1;
last_bytes = last_bytes << 3;
}
last_bytes |= road->crossings;
last_bytes = last_bytes << 4;
last_bytes |= road->if_class;
last_bytes = ENDIAN_SWAP32(last_bytes);
fwrite(&last_bytes, sizeof(last_bytes), 1, file);
if (road->name && road->length)
fwrite(road->name, road->length + 2, 1, file);
}
void flip_endian_ino(qnx4fs_dir_entry_t *deptr)
{
/* d_inode.name is char */
ENDIAN_SWAP32(&deptr->d_inode.i_size);
flip_endian_xtnt(&deptr->d_inode.i_first_xtnt);
ENDIAN_SWAP32(&deptr->d_inode.i_xblk);
ENDIAN_SWAP32(&deptr->d_inode.i_ftime);
ENDIAN_SWAP32(&deptr->d_inode.i_mtime);
ENDIAN_SWAP32(&deptr->d_inode.i_atime);
ENDIAN_SWAP32(&deptr->d_inode.i_ctime);
ENDIAN_SWAP16(&deptr->d_inode.i_num_xtnts);
ENDIAN_SWAP16(&deptr->d_inode.i_mode);
ENDIAN_SWAP16(&deptr->d_inode.i_uid);
ENDIAN_SWAP16(&deptr->d_inode.i_gid);
ENDIAN_SWAP16(&deptr->d_inode.i_nlink);
/* d_inode.i_zero is char */
/* d_inode.i_type is ftype_t which is char */
/* d_inode.i_status is char */
}
void endian_adjust_ehdr(Elf32_Ehdr *ehdr,int flip)
{
if (flip==0) return;
/* unsigned char e_ident[EI_NIDENT] */
/* ELF32_E_TYPE e_type */
/* (elf32-half) ELF32_E_MACHINE e_machine */
ENDIAN_SWAP16(&ehdr->e_machine);
/* ELF32_E_VERSION e_version */
ENDIAN_SWAP32(&ehdr->e_version);
/* Elf32_Addr e_entry; */
ENDIAN_SWAP32(&ehdr->e_entry);
/* Elf32_Off e_phoff; */
ENDIAN_SWAP32(&ehdr->e_phoff);
/* Elf32_Off e_shoff; */
ENDIAN_SWAP32(&ehdr->e_shoff);
/* Elf32_Word e_flags; */
ENDIAN_SWAP32(&ehdr->e_flags);
/* Elf32_Half e_ehsize; */
ENDIAN_SWAP16(&ehdr->e_ehsize);
/* Elf32_Half e_phentsize; */
ENDIAN_SWAP16(&ehdr->e_phentsize);
/* Elf32_Half e_phnum; */
ENDIAN_SWAP16(&ehdr->e_phnum);
/* Elf32_Half e_shentsize */
ENDIAN_SWAP16(&ehdr->e_shentsize);
/* Elf32_Half e_shnum; */
ENDIAN_SWAP16(&ehdr->e_shnum);
/* Elf32_Half e_shstrndx; */
ENDIAN_SWAP16(&ehdr->e_shstrndx);
return;
}
void wlRecv(struct net_device *netdev)
{
struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, netdev);
int work_done = 0;
wlrxdesc_t *pCurrent = ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pNextRxDesc;
static Bool_e isFunctionBusy = WL_FALSE;
int receivedHandled = 0;
u_int32_t rxRdPtr;
u_int32_t rxWrPtr;
struct sk_buff *pRxSkBuff=NULL;
WL_BUFF *wlb = NULL;
void *pCurrentData;
u_int8_t rxRate;
int rxCount;
int rssi;
vmacApInfo_t *vmacSta_p = wlpptr->vmacSta_p;
u_int32_t status;
u_int32_t rssi_paths;
WLDBG_ENTER(DBG_LEVEL_14);
/* In a corner case the descriptors may be uninitialized and not usable, accessing these may cause a crash */
if (isFunctionBusy || (pCurrent == NULL))
{
return;
}
isFunctionBusy = WL_TRUE;
rxRdPtr = readl(wlpptr->ioBase0 + ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxDescRead);
rxWrPtr = readl(wlpptr->ioBase0 + ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxDescWrite);
while ((pCurrent->RxControl ==EAGLE_RXD_CTRL_DMA_OWN)
&& (work_done < vmacSta_p->work_to_do)
)
{
/* AUTOCHANNEL */
{
if(vmacSta_p->StopTraffic)
goto out;
} /* AUTOCHANNEL */
rxCount = ENDIAN_SWAP16(pCurrent->PktLen);
pRxSkBuff = pCurrent->pSkBuff;
if (pRxSkBuff == NULL)
{
goto out;
}
pci_unmap_single(wlpptr->pPciDev,
ENDIAN_SWAP32(pCurrent->pPhysBuffData),
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize,
PCI_DMA_FROMDEVICE);
pCurrentData = pCurrent->pBuffData;
rxRate = pCurrent->Rate;
status = (u_int32_t)pCurrent->Status;
pRxSkBuff->protocol = 0;
if(pCurrent->QosCtrl & IEEE_QOS_CTL_AMSDU)
{
pRxSkBuff->protocol |= WL_WLAN_TYPE_AMSDU;
}
rssi = (int)pCurrent->RSSI + W836X_RSSI_OFFSET;
rssi_paths = *((u_int32_t *)&pCurrent->HwRssiInfo);
if (skb_tailroom(pRxSkBuff) >= rxCount)
{
skb_put(pRxSkBuff, rxCount );
skb_pull(pRxSkBuff, 2);
}
else
{
WLDBG_INFO(DBG_LEVEL_14,"Not enough tail room =%x recvlen=%x, pCurrent=%x, pCurrentData=%x", WL_BUFF_TAILROOM(pRxSkBuff), rxCount,pCurrent, pCurrentData);
WL_SKB_FREE(pRxSkBuff);
goto out;
}
wlpptr->netDevStats->rx_packets++;
wlb = WL_BUFF_PTR(pRxSkBuff);
WL_PREPARE_BUF_INFO(pRxSkBuff);
if(pCurrent->HtSig2 & 0x8 )
{
u_int8_t ampdu_qos;
/** use bit 3 for ampdu flag, and 0,1,2,3 for qos so as to save a register **/
ampdu_qos = 8|(pCurrent->QosCtrl&0x7);
work_done+=ieee80211_input(wlpptr, wlb,rssi,rssi_paths,ampdu_qos,status);
}
else
{
u_int8_t ampdu_qos;
/** use bit 3 for ampdu flag, and 0,1,2,3 for qos so as to save a register **/
ampdu_qos = 0|(pCurrent->QosCtrl&0x7);
work_done+=ieee80211_input(wlpptr, wlb,rssi,rssi_paths,ampdu_qos,status);
}
wlpptr->netDevStats->rx_bytes += pRxSkBuff->len;
{
pCurrent->pSkBuff = dev_alloc_skb(((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize);
if (pCurrent->pSkBuff != NULL)
{
if(skb_linearize(pCurrent->pSkBuff))
{
WL_SKB_FREE(pCurrent->pSkBuff);
printk(KERN_ERR "%s: Need linearize memory\n", netdev->name);
goto out;
}
skb_reserve(pCurrent->pSkBuff , MIN_BYTES_HEADROOM);
pCurrent->Status = EAGLE_RXD_STATUS_OK;
pCurrent->QosCtrl = 0x0000;
pCurrent->Channel = 0x00;
pCurrent->RSSI = 0x00;
pCurrent->SQ2 = 0x00;
pCurrent->PktLen = 6*netdev->mtu + NUM_EXTRA_RX_BYTES;
pCurrent->pBuffData = pCurrent->pSkBuff->data;
pCurrent->pPhysBuffData =
ENDIAN_SWAP32(pci_map_single(wlpptr->pPciDev,
pCurrent->pSkBuff->data,
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize/*+sizeof(struct skb_shared_info)*/,
PCI_DMA_BIDIRECTIONAL));
}
}
out:
receivedHandled++;
pCurrent->RxControl = EAGLE_RXD_CTRL_DRIVER_OWN;
pCurrent->QosCtrl =0;
rxRdPtr = ENDIAN_SWAP32(pCurrent->pPhysNext);
pCurrent = pCurrent->pNext;
}
writel(rxRdPtr, wlpptr->ioBase0 + ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxDescRead);
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pNextRxDesc = pCurrent;
isFunctionBusy = WL_FALSE;
WLDBG_EXIT(DBG_LEVEL_14);
}
int procmgr_msg_daemon(resmgr_context_t *ctp, proc_daemon_t *msg) {
PROCESS *prp;
int fd;
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
ENDIAN_SWAP16(&msg->i.subtype);
ENDIAN_SWAP32(&msg->i.status);
ENDIAN_SWAP32(&msg->i.flags);
}
if(!(prp = proc_lock_pid(ctp->info.pid))) {
return ESRCH;
}
// First detach from parent returning a status if nessessary
procmgr_nozombie(prp, msg->i.status);
// Now detach from session and join proc's session
// Remember an fd that may need to be closed while not proc_lock()ed
fd = -1;
if(prp->flags & _NTO_PF_SLEADER) {
prp->pgrp = 1; // So we don't drop a SIGHUP on ourselves
fd = procmgr_sleader_detach(prp);
}
if(atomic_sub_value(&prp->session->links, 1) == 1) {
// This should only happen if the session leader died...
_ksfree(prp->session, sizeof *prp->session);
}
prp->session = sysmgr_prp->session;
atomic_add(&prp->session->links, 1);
prp->pgrp = prp->pid;
// Change directory to root
if(!(msg->i.flags & PROCMGR_DAEMON_NOCHDIR)) {
if(prp->cwd != prp->root) {
NODE *old = prp->cwd;
prp->cwd = pathmgr_node_clone(prp->root);
pathmgr_node_detach(old);
}
}
// Clear the umask
if(!(msg->i.flags & PROCMGR_DAEMON_KEEPUMASK)) {
prp->umask = 0;
}
// Return the highest used fd so the lib can close them
ctp->status = prp->fdcons.nentries;
// unlock the process;
proc_unlock(prp);
// Free up any fd's if nessessary
if(fd != -1) {
if(proc_thread_pool_reserve() != 0) {
return EAGAIN;
}
close(fd);
proc_thread_pool_reserve_done();
}
return EOK;
}
int procmgr_wait(resmgr_context_t *ctp, proc_wait_t *msg) {
PROCESS *prp, *child;
struct wait_entry *wap, **pwap, waitl;
int alive;
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
ENDIAN_SWAP16(&msg->i.idtype);
ENDIAN_SWAP32(&msg->i.options);
ENDIAN_SWAP32(&msg->i.id);
}
if(msg->i.options & ~WOPTMASK) {
return EINVAL;
}
waitl.rcvid = ctp->rcvid;
waitl.idtype = msg->i.idtype;
waitl.options = msg->i.options;
waitl.id = msg->i.id;
alive = 0;
if(ND_NODE_CMP(ctp->info.nd, ND_LOCAL_NODE) != 0) {
struct _client_info info;
struct _cred_info *src, *dst;
pid_t nm_pid;
if(ConnectClientInfo(ctp->info.scoid, &info, 0) == -1) {
return errno;
}
nm_pid = pathmgr_netmgr_pid();
if(nm_pid == 0) {
/* netmgr is gone */
return EL2HLT;
}
if(!(prp = proc_lock_pid(nm_pid))) {
return EL2HLT;
}
src = &info.cred;
for(child = prp->child; child; child = child->sibling) {
if(child->pid != waitl.id) {
continue;
}
/* security check */
dst = &child->cred->info;
if(!(src->euid == 0 ||
src->ruid == dst->ruid ||
src->ruid == dst->suid ||
src->euid == dst->ruid ||
src->euid == dst->suid)) {
return proc_error(EPERM, prp);
}
switch(procmgr_wait_check(child, prp, &waitl, 0)) {
case 0:
alive++;
break;
case -1:
break;
default:
return proc_error(_RESMGR_NOREPLY, prp);
}
if(alive) {
break;
}
}
if(alive == 0) {
return proc_error(ECHILD, prp);
}
} else {
if(!(prp = proc_lock_pid(ctp->info.pid))) {
return EL2HLT;
}
for(child = prp->child; child; child = child->sibling) {
switch(procmgr_wait_check(child, prp, &waitl, 0)) {
case 0:
alive++;
break;
case -1:
break;
default:
return proc_error(_RESMGR_NOREPLY, prp);
}
}
//
// If we're the guardian process for our parent, we'll pick up his
// children when he dies so we need to see if there are any children
// of our parent which might satisfy the wait condition in the
// future and, if so, pretend like they're our children for the
// purposes of the wait request.
//
if(prp->parent && prp->parent->guardian == prp) {
if(procmgr_wait_check(prp->parent, prp, &waitl, 0) == 0) {
alive++;
}
}
if(alive == 0) {
if(!prp->parent || prp->parent->guardian != prp || procmgr_wait_check(prp->parent, prp, &waitl, 0) != 0) {
return proc_error(ECHILD, prp);
}
}
}
if(waitl.options & WNOHANG) {
memset(&msg->o, 0x00, sizeof msg->o);
return proc_error(_RESMGR_PTR(ctp, &msg->o, sizeof msg->o), prp);
}
// nothing waiting, so add to queue sorted so pid match has higher priority
if(!(wap = proc_object_alloc(&wait_souls))) {
return proc_error(ENOMEM, prp);
}
for(pwap = &prp->wap; (waitl.next = *pwap); pwap = &waitl.next->next) {
if(waitl.next->idtype < waitl.idtype) {
break;
}
}
*wap = waitl;
*pwap = wap;
ctp->id = root_id;
(void)resmgr_open_bind(ctp, wap, &proc_wait_funcs);
return proc_error(_RESMGR_NOREPLY, prp);
}
static int procmgr_handler(message_context_t *mctp, int code, unsigned flags, void *handle) {
int n = ENOSYS;
resmgr_context_t *ctp = (resmgr_context_t *) mctp;
union proc_msg_union_local {
uint16_t type;
proc_getsetid_t getsetid;
proc_setpgid_t setpgid;
proc_wait_t wait;
proc_fork_t fork;
proc_umask_t umask;
proc_guardian_t guardian;
proc_session_t session;
proc_daemon_t daemon;
proc_event_t event;
sys_conf_t conf;
sys_cmd_t syscmd;
} *msg = (union proc_msg_union_local *)(void *) ctp->msg;
ctp->status = 0;
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
ENDIAN_SWAP16(&msg->type);
}
switch(msg->type) {
case _PROC_GETSETID:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_getsetid(ctp, &msg->getsetid);
}
break;
case _PROC_SETPGID:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_setpgid(ctp, &msg->setpgid);
}
break;
case _PROC_WAIT:
n = procmgr_wait(ctp, &msg->wait);
break;
case _PROC_FORK:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_fork(ctp, &msg->fork);
}
break;
case _PROC_SPAWN:
n = procmgr_spawn(ctp, msg, NULL);
break;
case _PROC_POSIX_SPAWN:
n = procmgr_pspawn(ctp, msg);
break;
case _PROC_UMASK:
n = procmgr_umask(ctp, &msg->umask);
break;
case _PROC_GUARDIAN:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_msg_guardian(ctp, &msg->guardian);
}
break;
case _PROC_SESSION:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_msg_session(ctp, &msg->session);
}
break;
case _PROC_DAEMON:
n = procmgr_msg_daemon(ctp, &msg->daemon);
break;
case _PROC_EVENT:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_event(ctp, &msg->event);
}
break;
case _PROC_RESOURCE:
if(ctp->info.flags & _NTO_MI_ENDIAN_DIFF) {
n = EENDIAN;
} else {
n = procmgr_msg_resource(ctp, msg);
}
break;
case _SYS_CONF:
n = sysmgr_conf(ctp, &msg->conf);
break;
case _SYS_CMD:
n = sysmgr_cmd(ctp, &msg->syscmd);
break;
case _SYS_VENDOR:
if ( sys_vendor_handler_hook ) {
n = sys_vendor_handler_hook(ctp);
}
break;
default:
break;
}
return proc_status(ctp, n);
}
