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