/* u8 setstandby_cmd(unsigned char *adapter) */ u8 setstandby_cmd(_adapter *padapter, uint action) { struct cmd_obj *ph2c; struct usb_suspend_parm *psetusbsuspend; struct cmd_priv *pcmdpriv = &padapter->cmdpriv; u8 ret = _SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) { ret = _FAIL; goto exit; } psetusbsuspend = (struct usb_suspend_parm*)_malloc(sizeof(struct usb_suspend_parm)); if (psetusbsuspend == NULL) { _mfree((u8*)ph2c, sizeof(struct cmd_obj)); ret = _FAIL; goto exit; } psetusbsuspend->action = action; init_h2fwcmd_w_parm_no_rsp(ph2c, psetusbsuspend, GEN_CMD_CODE(_SetUsbSuspend)); enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return ret; }
u8 setMacAddr_cmd(_adapter *padapter, u8 *mac_addr) { struct cmd_priv *pcmdpriv = &padapter->cmdpriv; struct cmd_obj *ph2c; struct SetMacAddr_param *psetMacAddr_para; u8 res = _SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) { res = _FAIL; goto exit; } psetMacAddr_para = (struct SetMacAddr_param*)_malloc(sizeof(struct SetMacAddr_param)); if (psetMacAddr_para == NULL) { _mfree((u8 *) ph2c, sizeof(struct cmd_obj)); res = _FAIL; goto exit; } init_h2fwcmd_w_parm_no_rsp(ph2c, psetMacAddr_para, _SetMacAddress_CMD_); _memcpy(psetMacAddr_para->MacAddr, mac_addr,ETH_ALEN); enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
/* unsigned char setphy_cmd(unsigned char *adapter) 1. be called only after update_registrypriv_dev_network( ~) or mp testing program 2. for AdHoc/Ap mode or mp mode? */ u8 setphy_cmd(_adapter *padapter, u8 modem, u8 ch) { struct cmd_obj* ph2c; struct setphy_parm* psetphypara; struct cmd_priv *pcmdpriv=&padapter->cmdpriv; // struct mlme_priv *pmlmepriv = &padapter->mlmepriv; // struct registry_priv* pregistry_priv = &padapter->registrypriv; // NDIS_WLAN_BSSID_EX *dev_network = &padapter->registrypriv.dev_network; u8 res=_SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if(ph2c==NULL){ res= _FAIL; goto exit; } psetphypara = (struct setphy_parm*)_malloc(sizeof(struct setphy_parm)); if(psetphypara==NULL){ _mfree((u8 *) ph2c, sizeof(struct cmd_obj)); res= _FAIL; goto exit; } init_h2fwcmd_w_parm_no_rsp(ph2c, psetphypara, _SetPhy_CMD_); RT_TRACE(_module_rtl871x_cmd_c_,_drv_info_,("CH=%d, modem=%d", ch, modem)); psetphypara->modem = modem; psetphypara->rfchannel = ch; enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
int main() { void* ptr1 = NULL; void* ptr2 = NULL; void* ptr3 = NULL; void* ptr4 = NULL; void* ptr5 = NULL; void* ptr6 = NULL; void* ptr7 = NULL; printf("\nProgram starts here:\n"); heap_init(getpagesize()); ptr1 = _malloc(1000); ptr2 = _malloc(500); ptr6 = _malloc(100); ptr7 = _malloc(5000); _free(ptr2); _free(ptr1); _free(ptr6); ptr1 = _malloc(1000); memalloc_debug_heap(stderr, HEAP_START); printf("Program finished.\n"); return 0; }
int main(int argc, const char * argv[]) { int *v, *w, *z; int *vet[100]; int i; w = (int*)_malloc(sizeof(int)); v = (int*)_malloc(sizeof(int)); z = NULL; for (i = 0; i < 100; i++){ vet[i] = (int*)_malloc(sizeof(int)); } *v = 10; *w = 20; printf("*v = %d, *w = %d\n", *v, *w); dump(); v = (int*)attrib(v, w); z = (int*)attrib(z, w); printf("*v = %d, *w = %d, *z = %d\n", *v, *w, *z); dump(); for (i = 0; i < 100; i++){ vet[i] = (int*)attrib(vet[i], NULL); } printf("New dump:\n"); dump(); v = (int*)attrib(v, NULL); w = (int*)attrib(w, NULL); z = (int*)attrib(z, NULL); printf("Dump:\n"); dump(); return 0; }
u8 setrttbl_cmd(_adapter *padapter, struct setratable_parm *prate_table) { struct cmd_obj* ph2c; struct setratable_parm * psetrttblparm; struct cmd_priv *pcmdpriv=&padapter->cmdpriv; u8 res=_SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if(ph2c==NULL){ res= _FAIL; goto exit; } psetrttblparm = (struct setratable_parm*)_malloc(sizeof(struct setratable_parm)); if(psetrttblparm==NULL){ _mfree((unsigned char *) ph2c, sizeof(struct cmd_obj)); res= _FAIL; goto exit; } init_h2fwcmd_w_parm_no_rsp(ph2c, psetrttblparm, GEN_CMD_CODE(_SetRaTable)); _memcpy(psetrttblparm,prate_table,sizeof(struct setratable_parm)); enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
u8 setatim_cmd(_adapter* adapter, u8 add, u8 txid) { struct cmd_obj* ph2c; struct setatim_parm* psetatim; struct cmd_priv *pcmdpriv= &( adapter->cmdpriv); u8 res=_SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if(ph2c==NULL){ goto exit; res= _FAIL; } psetatim = (struct setatim_parm*)_malloc(sizeof(struct setatim_parm)); if(psetatim == NULL){ _mfree((unsigned char *) ph2c, sizeof(struct cmd_obj)); res= _FAIL; goto exit; } //NdisZeroMemory(); psetatim->op = add; psetatim->txid = txid; init_h2fwcmd_w_parm_no_rsp(ph2c, psetatim, _SetAtim_CMD_); enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
u8 setopmode_cmd(_adapter *padapter, NDIS_802_11_NETWORK_INFRASTRUCTURE networktype) { struct cmd_obj* ph2c; struct setopmode_parm* psetop; struct cmd_priv *pcmdpriv= &padapter->cmdpriv; u8 res=_SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if(ph2c==NULL){ res= _FALSE; goto exit; } psetop = (struct setopmode_parm*)_malloc(sizeof(struct setopmode_parm)); if(psetop==NULL){ _mfree((u8 *) ph2c, sizeof(struct cmd_obj)); res=_FALSE; goto exit; } init_h2fwcmd_w_parm_no_rsp(ph2c, psetop, _SetOpMode_CMD_); psetop->mode = networktype; enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
u8 setrfintfs_cmd(_adapter *padapter, u8 mode) { struct cmd_obj* ph2c; struct setrfintfs_parm* psetrfintfsparm; struct cmd_priv *pcmdpriv=&padapter->cmdpriv; u8 res=_SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if(ph2c==NULL){ res= _FAIL; goto exit; } psetrfintfsparm = (struct setrfintfs_parm*)_malloc(sizeof(struct setrfintfs_parm)); if(psetrfintfsparm==NULL){ _mfree((unsigned char *) ph2c, sizeof(struct cmd_obj)); res= _FAIL; goto exit; } init_h2fwcmd_w_parm_no_rsp(ph2c, psetrfintfsparm, GEN_CMD_CODE(_SetRFIntFs)); psetrfintfsparm->rfintfs = mode; enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
sint _init_evt_priv(struct evt_priv *pevtpriv) { sint res=_SUCCESS; _func_enter_; #ifdef CONFIG_EVENT_THREAD_MODE _init_sema(&(pevtpriv->evt_notify), 0); _init_sema(&(pevtpriv->terminate_evtthread_sema), 0); #endif #ifdef CONFIG_H2CLBK _init_sema(&(pevtpriv->lbkevt_done), 0); pevtpriv->lbkevt_limit = 0; pevtpriv->lbkevt_num = 0; pevtpriv->cmdevt_parm = NULL; #endif //allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf pevtpriv->event_seq = 0; pevtpriv->evt_allocated_buf = _malloc(MAX_EVTSZ + 4); if (pevtpriv->evt_allocated_buf == NULL){ res= _FAIL; goto exit; } pevtpriv->evt_buf = pevtpriv->evt_allocated_buf + 4 - ((unsigned int)(pevtpriv->evt_allocated_buf) & 3); pevtpriv->evt_done_cnt = 0; #ifdef CONFIG_SDIO_HCI pevtpriv->allocated_c2h_mem = _malloc(C2H_MEM_SZ +4); if (pevtpriv->allocated_c2h_mem == NULL){ res= _FAIL; goto exit; } pevtpriv->c2h_mem = pevtpriv->allocated_c2h_mem + 4\ - ( (u32)(pevtpriv->allocated_c2h_mem) & 3); #ifdef PLATFORM_OS_XP pevtpriv->pc2h_mdl= IoAllocateMdl((u8 *)pevtpriv->c2h_mem, C2H_MEM_SZ , FALSE, FALSE, NULL); if(pevtpriv->pc2h_mdl == NULL){ res= _FAIL; goto exit; } MmBuildMdlForNonPagedPool(pevtpriv->pc2h_mdl); #endif #endif exit: #ifdef CONFIG_RECV_BH _init_queue(&(pevtpriv->evt_queue)); #endif _func_exit_; return res; }
u8 r8712_gettssi_cmd(struct _adapter *padapter, u8 offset, u8 *pval) { struct cmd_priv *pcmdpriv = &padapter->cmdpriv; struct cmd_obj *ph2c; struct readTSSI_parm *prdtssiparm; ph2c = (struct cmd_obj *)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) return _FAIL; prdtssiparm = (struct readTSSI_parm *) _malloc(sizeof(struct readTSSI_parm)); if (prdtssiparm == NULL) { kfree((unsigned char *) ph2c); return _FAIL; } _init_listhead(&ph2c->list); ph2c->cmdcode = GEN_CMD_CODE(_ReadTSSI); ph2c->parmbuf = (unsigned char *)prdtssiparm; ph2c->cmdsz = sizeof(struct readTSSI_parm); ph2c->rsp = pval; ph2c->rspsz = sizeof(struct readTSSI_rsp); prdtssiparm->offset = offset; r8712_enqueue_cmd(pcmdpriv, ph2c); return _SUCCESS; }
u8 r8712_disconnectCtrlEx_cmd(struct _adapter *adapter, u32 enableDrvCtrl, u32 tryPktCnt, u32 tryPktInterval, u32 firstStageTO) { struct cmd_obj *ph2c; struct DisconnectCtrlEx_param *param; struct cmd_priv *pcmdpriv = &adapter->cmdpriv; ph2c = (struct cmd_obj *)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) return _FAIL; param = (struct DisconnectCtrlEx_param *) _malloc(sizeof(struct DisconnectCtrlEx_param)); if (param == NULL) { kfree((unsigned char *) ph2c); return _FAIL; } memset(param, 0, sizeof(struct DisconnectCtrlEx_param)); param->EnableDrvCtrl = (unsigned char)enableDrvCtrl; param->TryPktCnt = (unsigned char)tryPktCnt; param->TryPktInterval = (unsigned char)tryPktInterval; param->FirstStageTO = (unsigned int)firstStageTO; init_h2fwcmd_w_parm_no_rsp(ph2c, param, GEN_CMD_CODE(_DisconnectCtrlEx)); r8712_enqueue_cmd(pcmdpriv, ph2c); return _SUCCESS; }
u8 setbasicrate_cmd(_adapter *padapter, u8 *rateset) { struct cmd_obj* ph2c; struct setbasicrate_parm* pssetbasicratepara; struct cmd_priv* pcmdpriv=&padapter->cmdpriv; u8 res = _SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) { res= _FAIL; goto exit; } pssetbasicratepara = (struct setbasicrate_parm*)_malloc(sizeof(struct setbasicrate_parm)); if (pssetbasicratepara == NULL) { _mfree((u8*) ph2c, sizeof(struct cmd_obj)); res = _FAIL; goto exit; } init_h2fwcmd_w_parm_no_rsp(ph2c, pssetbasicratepara, _SetBasicRate_CMD_); _memcpy(pssetbasicratepara->basicrates, rateset, NumRates); enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
/* Legacy16GetTableAddress */ static void handle_csm_0006(struct bregs *regs) { u16 size = regs->cx; u16 align = regs->dx; u16 region = regs->bx; // (1 for F000 seg, 2 for E000 seg, 0 for either) void *chunk = NULL; if (!region) region = 3; dprintf(3, "Legacy16GetTableAddress size %x align %x region %d\n", size, align, region); if (region & 2) chunk = _malloc(&ZoneLow, size, align); if (!chunk && (region & 1)) chunk = _malloc(&ZoneFSeg, size, align); dprintf(3, "Legacy16GetTableAddress size %x align %x region %d yields %p\n", size, align, region, chunk); if (chunk) { regs->ds = FLATPTR_TO_SEG(chunk); regs->bx = FLATPTR_TO_OFFSET(chunk); regs->ax = 0; } else { regs->ax = 1; } }
u8 r8712_setassocsta_cmd(struct _adapter *padapter, u8 *mac_addr) { struct cmd_priv *pcmdpriv = &padapter->cmdpriv; struct cmd_obj *ph2c; struct set_assocsta_parm *psetassocsta_para; struct set_stakey_rsp *psetassocsta_rsp = NULL; ph2c = (struct cmd_obj *)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) return _FAIL; psetassocsta_para = (struct set_assocsta_parm *) _malloc(sizeof(struct set_assocsta_parm)); if (psetassocsta_para == NULL) { kfree((u8 *) ph2c); return _FAIL; } psetassocsta_rsp = (struct set_stakey_rsp *)_malloc( sizeof(struct set_assocsta_rsp)); if (psetassocsta_rsp == NULL) { kfree((u8 *)ph2c); kfree((u8 *)psetassocsta_para); return _FAIL; } init_h2fwcmd_w_parm_no_rsp(ph2c, psetassocsta_para, _SetAssocSta_CMD_); ph2c->rsp = (u8 *) psetassocsta_rsp; ph2c->rspsz = sizeof(struct set_assocsta_rsp); memcpy(psetassocsta_para->addr, mac_addr, ETH_ALEN); r8712_enqueue_cmd(pcmdpriv, ph2c); return _SUCCESS; }
u8 setrfreg_cmd(_adapter *padapter, u8 offset, u32 val) { struct cmd_obj* ph2c; struct writeRF_parm* pwriterfparm; struct cmd_priv *pcmdpriv=&padapter->cmdpriv; u8 res=_SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if(ph2c==NULL){ res= _FAIL; goto exit; } pwriterfparm = (struct writeRF_parm*)_malloc(sizeof(struct writeRF_parm)); if(pwriterfparm==NULL){ _mfree((u8 *) ph2c, sizeof(struct cmd_obj)); res= _FAIL; goto exit; } init_h2fwcmd_w_parm_no_rsp(ph2c, pwriterfparm, GEN_CMD_CODE(_SetRFReg)); pwriterfparm->offset = offset; pwriterfparm->value = val; enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
/* r8712_sitesurvey_cmd(~) ### NOTE:#### (!!!!) MUST TAKE CARE THAT BEFORE CALLING THIS FUNC, YOU SHOULD HAVE LOCKED pmlmepriv->lock */ u8 r8712_sitesurvey_cmd(struct _adapter *padapter, struct ndis_802_11_ssid *pssid) { struct cmd_obj *ph2c; struct sitesurvey_parm *psurveyPara; struct cmd_priv *pcmdpriv = &padapter->cmdpriv; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; ph2c = (struct cmd_obj *)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) return _FAIL; psurveyPara = (struct sitesurvey_parm *)_malloc( sizeof(struct sitesurvey_parm)); if (psurveyPara == NULL) { kfree((unsigned char *) ph2c); return _FAIL; } init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara, GEN_CMD_CODE(_SiteSurvey)); psurveyPara->bsslimit = cpu_to_le32(48); psurveyPara->passive_mode = cpu_to_le32(1); psurveyPara->ss_ssidlen = 0; memset(psurveyPara->ss_ssid, 0, IW_ESSID_MAX_SIZE + 1); if ((pssid != NULL) && (pssid->SsidLength)) { memcpy(psurveyPara->ss_ssid, pssid->Ssid, pssid->SsidLength); psurveyPara->ss_ssidlen = cpu_to_le32(pssid->SsidLength); } set_fwstate(pmlmepriv, _FW_UNDER_SURVEY); r8712_enqueue_cmd(pcmdpriv, ph2c); _set_timer(&pmlmepriv->scan_to_timer, SCANNING_TIMEOUT); padapter->ledpriv.LedControlHandler(padapter, LED_CTL_SITE_SURVEY); return _SUCCESS; }
static sint _init_cmd_priv(struct cmd_priv *pcmdpriv) { sema_init(&(pcmdpriv->cmd_queue_sema), 0); sema_init(&(pcmdpriv->terminate_cmdthread_sema), 0); _init_queue(&(pcmdpriv->cmd_queue)); /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */ pcmdpriv->cmd_seq = 1; pcmdpriv->cmd_allocated_buf = _malloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ); if (pcmdpriv->cmd_allocated_buf == NULL) return _FAIL; pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf + CMDBUFF_ALIGN_SZ - ((addr_t)(pcmdpriv->cmd_allocated_buf) & (CMDBUFF_ALIGN_SZ-1)); pcmdpriv->rsp_allocated_buf = _malloc(MAX_RSPSZ + 4); if (pcmdpriv->rsp_allocated_buf == NULL) return _FAIL; pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 - ((addr_t)(pcmdpriv->rsp_allocated_buf) & 3); pcmdpriv->cmd_issued_cnt = 0; pcmdpriv->cmd_done_cnt = 0; pcmdpriv->rsp_cnt = 0; return _SUCCESS; }
sint r8712_set_auth(struct _adapter *adapter, struct security_priv *psecuritypriv) { struct cmd_priv *pcmdpriv = &adapter->cmdpriv; struct cmd_obj *pcmd; struct setauth_parm *psetauthparm; sint ret = _SUCCESS; pcmd = (struct cmd_obj *)_malloc(sizeof(struct cmd_obj)); if (pcmd == NULL) return _FAIL; psetauthparm = (struct setauth_parm *)_malloc( sizeof(struct setauth_parm)); if (psetauthparm == NULL) { kfree((unsigned char *)pcmd); return _FAIL; } memset(psetauthparm, 0, sizeof(struct setauth_parm)); psetauthparm->mode = (u8)psecuritypriv->AuthAlgrthm; pcmd->cmdcode = _SetAuth_CMD_; pcmd->parmbuf = (unsigned char *)psetauthparm; pcmd->cmdsz = sizeof(struct setauth_parm); pcmd->rsp = NULL; pcmd->rspsz = 0; _init_listhead(&pcmd->list); r8712_enqueue_cmd(pcmdpriv, pcmd); return ret; }
u8 getrfreg_cmd(_adapter *padapter, u8 offset, u8 *pval) { struct cmd_obj* ph2c; struct readRF_parm* prdrfparm; struct cmd_priv *pcmdpriv=&padapter->cmdpriv; u8 res=_SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if(ph2c==NULL){ res= _FAIL; goto exit; } prdrfparm = (struct readRF_parm*)_malloc(sizeof(struct readRF_parm)); if(prdrfparm ==NULL){ _mfree((u8 *) ph2c, sizeof(struct cmd_obj)); res= _FAIL; goto exit; } _init_listhead(&ph2c->list); ph2c->cmdcode =GEN_CMD_CODE(_GetRFReg); ph2c->parmbuf = (unsigned char *)prdrfparm; ph2c->cmdsz = sizeof(struct readRF_parm); ph2c->rsp = pval; ph2c->rspsz = sizeof(struct readRF_rsp); prdrfparm ->offset = offset; enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
u8 setfwra_cmd(_adapter*padapter, u8 type) { struct cmd_obj* ph2c; struct writePTM_parm* pwriteptmparm; struct cmd_priv *pcmdpriv=&padapter->cmdpriv; u8 res=_SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if(ph2c==NULL){ res= _FAIL; goto exit; } pwriteptmparm = (struct writePTM_parm*)_malloc(sizeof(struct setra_parm)); if(pwriteptmparm==NULL){ _mfree((u8 *) ph2c, sizeof(struct cmd_obj)); res= _FAIL; goto exit; } init_h2fwcmd_w_parm_no_rsp(ph2c, pwriteptmparm, GEN_CMD_CODE(_SetRA)); pwriteptmparm->type= type; enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
u8 setstakey_cmd(_adapter *padapter, u8 *psta, u8 unicast_key) { struct cmd_obj *ph2c; struct set_stakey_parm *psetstakey_para; struct cmd_priv *pcmdpriv = &padapter->cmdpriv; struct set_stakey_rsp *psetstakey_rsp = NULL; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; struct security_priv *psecuritypriv = &padapter->securitypriv; struct sta_info *sta = (struct sta_info*)psta; u8 res = _SUCCESS; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) { res = _FAIL; goto exit; } psetstakey_para = (struct set_stakey_parm*)_malloc(sizeof(struct set_stakey_parm)); if (psetstakey_para == NULL) { _mfree((u8 *) ph2c, sizeof(struct cmd_obj)); res = _FAIL; goto exit; } psetstakey_rsp = (struct set_stakey_rsp*)_malloc(sizeof(struct set_stakey_rsp)); if (psetstakey_rsp == NULL) { _mfree((u8 *) ph2c, sizeof(struct cmd_obj)); _mfree((u8 *) psetstakey_para, sizeof(struct set_stakey_parm)); res = _FAIL; goto exit; } init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_); ph2c->rsp = (u8 *) psetstakey_rsp; ph2c->rspsz = sizeof(struct set_stakey_rsp); _memcpy(psetstakey_para->addr, sta->hwaddr, ETH_ALEN); if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) psetstakey_para->algorithm =(unsigned char) psecuritypriv->dot11PrivacyAlgrthm; else GET_ENCRY_ALGO(psecuritypriv, sta, psetstakey_para->algorithm, _FALSE); if (unicast_key == _TRUE) { _memcpy(&psetstakey_para->key, &sta->dot118021x_UncstKey, 16); } else { _memcpy(&psetstakey_para->key, &psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid-1].skey, 16); } enqueue_cmd(pcmdpriv, ph2c); exit: _func_exit_; return res; }
u32 usb_bulkout_zero(struct intf_hdl *pintfhdl, u32 addr) { int pipe, status, len; u32 ret; unsigned char *pbuf; struct zero_bulkout_context *pcontext; PURB purb = NULL; _adapter *padapter = (_adapter *)pintfhdl->adapter; struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv; struct usb_device *pusbd = pdvobj->pusbdev; //printk("+usb_bulkout_zero\n"); if((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||(padapter->pwrctrlpriv.pnp_bstop_trx)) { return _FAIL; } pcontext = (struct zero_bulkout_context *)_malloc(sizeof(struct zero_bulkout_context)); pbuf = (unsigned char *)_malloc(sizeof(int)); purb = usb_alloc_urb(0, GFP_ATOMIC); len = 0; pcontext->pbuf = pbuf; pcontext->purb = purb; pcontext->pirp = NULL; pcontext->padapter = padapter; //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_bulk_urb(purb, pusbd, pipe, pbuf, len, usb_bulkout_zero_complete, pcontext);//context is pcontext status = usb_submit_urb(purb, GFP_ATOMIC); if (!status) { ret= _SUCCESS; } else { ret= _FAIL; } return _SUCCESS; }
struct tp * tp_create(int max_jobs) { struct tp *pool = _malloc(sizeof(*pool)); pool->jobs = _malloc(sizeof(struct tp_entry)*max_jobs); pool->capacity = max_jobs; pool->size = 0; pthread_mutex_init(&pool->mutex, 0); return pool; }
/* sitesurvey_cmd(~) ### NOTE:#### (!!!!) MUST TAKE CARE THAT BEFORE CALLING THIS FUNC, YOU SHOULD HAVE LOCKED pmlmepriv->lock */ u8 sitesurvey_cmd(_adapter *padapter, NDIS_802_11_SSID *pssid) { struct cmd_obj* ph2c; struct sitesurvey_parm* psurveyPara; struct cmd_priv *pcmdpriv = &padapter->cmdpriv; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) return _FAIL; psurveyPara = (struct sitesurvey_parm*)_malloc(sizeof(struct sitesurvey_parm)); if (psurveyPara == NULL) { _mfree((unsigned char*) ph2c, sizeof(struct cmd_obj)); return _FAIL; } free_network_queue(padapter); RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("\nflush network queue\n\n")); init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara, GEN_CMD_CODE(_SiteSurvey)); psurveyPara->bsslimit = cpu_to_le32(48); psurveyPara->passive_mode = cpu_to_le32(1); psurveyPara->ss_ssidlen= cpu_to_le32(0);// pssid->SsidLength; if (pssid->SsidLength) { _memcpy(psurveyPara->ss_ssid, pssid->Ssid, pssid->SsidLength); psurveyPara->ss_ssidlen = cpu_to_le32(pssid->SsidLength); } else { _memset(psurveyPara->ss_ssid, 0, IW_ESSID_MAX_SIZE + 1); } set_fwstate(pmlmepriv, _FW_UNDER_SURVEY); enqueue_cmd(pcmdpriv, ph2c); _set_timer(&pmlmepriv->scan_to_timer, SCANNING_TIMEOUT); _func_exit_; return _SUCCESS; }
static int serv_read(struct triton_md_handler_t *h) { struct sockaddr_in addr; socklen_t size = sizeof(addr); int sock; struct tcp_client_t *conn; while(1) { sock = accept(h->fd, (struct sockaddr *)&addr, &size); if (sock < 0) { if (errno == EAGAIN) return 0; log_error("cli: tcp: accept failed: %s\n", strerror(errno)); continue; } if (conf_verbose) log_info2("cli: tcp: new connection from %s\n", inet_ntoa(addr.sin_addr)); if (fcntl(sock, F_SETFL, O_NONBLOCK)) { log_error("cli: tcp: failed to set nonblocking mode: %s, closing connection...\n", strerror(errno)); close(sock); continue; } conn = _malloc(sizeof(*conn)); memset(conn, 0, sizeof(*conn)); conn->addr = addr; conn->hnd.fd = sock; conn->hnd.read = cln_read; conn->hnd.write = cln_write; conn->cmdline = _malloc(RECV_BUF_SIZE); INIT_LIST_HEAD(&conn->xmit_queue); conn->cli_client.cmdline = conn->cmdline; conn->cli_client.send = cli_client_send; conn->cli_client.sendv = cli_client_sendv; conn->cli_client.disconnect = cli_client_disconnect; triton_md_register_handler(&serv_ctx, &conn->hnd); triton_md_enable_handler(&conn->hnd,MD_MODE_READ); list_add_tail(&conn->entry, &clients); if (!conf_cli_passwd) conn->auth = 1; } return 0; }
/** * Handle Hello Packet * @param context Matching Context Pointer * @param sendermac Packet Sender MAC * @param length Packet Length */ void _actOnHelloPacket(SceNetAdhocMatchingContext * context, SceNetEtherAddr * sendermac, uint32_t length) { // Interested in Hello Data if((context->mode == ADHOC_MATCHING_MODE_CHILD && _findParent(context) == NULL) || (context->mode == ADHOC_MATCHING_MODE_P2P && _findP2P(context) == NULL)) { // Complete Packet Header available if(length >= 5) { // Extract Optional Data Length int optlen = 0; memcpy(&optlen, context->rxbuf + 1, sizeof(optlen)); // Complete Valid Packet available if(optlen >= 0 && length >= (5 + optlen)) { // Set Default Null Data void * opt = NULL; // Extract Optional Data Pointer if(optlen > 0) opt = context->rxbuf + 5; // Find Peer SceNetAdhocMatchingMemberInternal * peer = _findPeer(context, sendermac); // Peer not found if(peer == NULL) { // Allocate Memory peer = (SceNetAdhocMatchingMemberInternal *)_malloc(sizeof(SceNetAdhocMatchingMemberInternal)); // Allocated Memory if(peer != NULL) { // Clear Memory memset(peer, 0, sizeof(SceNetAdhocMatchingMemberInternal)); // Copy Sender MAC peer->mac = *sendermac; // Set Peer State peer->state = ADHOC_MATCHING_PEER_OFFER; // Initialize Ping Timer peer->lastping = sceKernelGetSystemTimeWide(); // Link Peer into List peer->next = context->peerlist; context->peerlist = peer; } } // Peer available now if(peer != NULL) { // Spawn Hello Event _spawnLocalEvent(context, ADHOC_MATCHING_EVENT_HELLO, sendermac, optlen, opt); } } } } }
/** * Send Join Packet to Player * @param context Matching Context Pointer * @param mac Target Player MAC * @param optlen Optional Data Length * @param opt Optional Data */ void _sendJoinPacket(SceNetAdhocMatchingContext * context, SceNetEtherAddr * mac, int optlen, void * opt) { // Find Peer SceNetAdhocMatchingMemberInternal * peer = _findPeer(context, mac); // Valid Peer if(peer != NULL && peer->state == ADHOC_MATCHING_PEER_OUTGOING_REQUEST) { // Allocate Join Message Buffer uint8_t * join = (uint8_t *)_malloc(5 + optlen); // Allocated Join Message Buffer if(join != NULL) { // Join Opcode join[0] = ADHOC_MATCHING_PACKET_JOIN; // Optional Data Length memcpy(join + 1, &optlen, sizeof(optlen)); // Copy Optional Data if(optlen > 0) memcpy(join + 5, opt, optlen); // Send Data sceNetAdhocPdpSend(context->socket, mac, context->port, join, 5 + optlen, 0, ADHOC_F_NONBLOCK); // Free Memory _free(join); } } }
u32 _r8712_init_sta_priv(struct sta_priv *pstapriv) { struct sta_info *psta; s32 i; pstapriv->pallocated_stainfo_buf = _malloc(sizeof(struct sta_info) * NUM_STA + 4); if (pstapriv->pallocated_stainfo_buf == NULL) return _FAIL; pstapriv->pstainfo_buf = pstapriv->pallocated_stainfo_buf + 4 - ((addr_t)(pstapriv->pallocated_stainfo_buf) & 3); _init_queue(&pstapriv->free_sta_queue); spin_lock_init(&pstapriv->sta_hash_lock); pstapriv->asoc_sta_count = 0; _init_queue(&pstapriv->sleep_q); _init_queue(&pstapriv->wakeup_q); psta = (struct sta_info *)(pstapriv->pstainfo_buf); for (i = 0; i < NUM_STA; i++) { _init_stainfo(psta); _init_listhead(&(pstapriv->sta_hash[i])); list_insert_tail(&psta->list, get_list_head(&pstapriv->free_sta_queue)); psta++; } _init_listhead(&pstapriv->asoc_list); _init_listhead(&pstapriv->auth_list); return _SUCCESS; }
void case3(){ VirtualAddress b = (VirtualAddress) malloc(sizeof(char)); _init(3, 128); if(_malloc(&b, 1024) == -2){ printf("%s", "Not enough memory\n"); } }