void main()
{
int a[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
int i;
struct List L;
initList(&L, 5);
for(i = 0; i < 10; i++){
insertLastList(&L, a[i]);
}
insertPosList(&L, 11, 48); insertPosList(&L, 1, 64);
printf("%d ", getElem(&L, 1));
traverseList(&L);
printf("%d ", findList(&L, 10));
updatePosList(&L, 3, 20);
printf("%d ", getElem(&L, 3));
traverseList(&L);
deleteFirstList(&L); deleteFirstList(&L);
deleteLastList(&L); deleteLastList(&L);
deletePosList(&L, 5); ;deletePosList(&L, 7);
printf("%d ", sizeList(&L));
printf("%d ", emptyList(&L));
traverseList(&L);
clearList(&L);
return 0;
}
/*auxiliar para conseguir imprimir um dado numero de elementos por pagina*/
Result printResultPagina(Result r, int indice){
Result aux = r;
int i = 0;
if(aux == NULL) return NULL;
if(indice>=0){
while(aux != NULL && i<ELEMS_POR_PAGINA){
printf("%s\n",getElem(aux));
aux = getNext(aux);
i++;
}
}
else{
while(i<ELEMS_POR_PAGINA*2){
aux = getPrev(aux);
i++;
}
i = 0;
while(aux != NULL && i<ELEMS_POR_PAGINA){
printf("%s\n",getElem(aux));
aux = getNext(aux);
i++;
}
}
return aux;
}
//------------------------------------------------------------------------------
// pivotRow
//------------------------------------------------------------------------------
bool Matrix::pivotRow(const unsigned int r, const unsigned int c)
{
bool l1 = (r < rows-1);
bool l2 = (c < cols);
bool ok = false;
if (l1 && l2) {
unsigned int refrow = r;
double max = std::fabs(getElem(r,c));
for (unsigned int i=r+1; i<rows; i++) {
double val = std::fabs(getElem(i,c));
if (val > max) {
refrow = i;
max = val;
}
}
if (r != refrow) {
swapRow(r, refrow);
}
ok = true;
}
return ok;
}
// add x at position k
// 0 <= k (< getQSize(q))
// !filled(q)
void addElem(Queue q, SQueue x, int k){
int i;
if (k >= getLength(q)) addTail(q, x);
else if (k==0) addHead(q, x);
else {
if (k >= getLength(q)/2) {
for (i=getLength(q)-1; i>=k; i--) {
setElem(q, getElem(q, i), i+1);
}
setElem(q, x, i+1);
setQTail(q, getQTail(q)+1);
}
else {
for (i=0; i<k; i++) {
setElem(q, getElem(q, i), i-1);
}
setElem(q, x, i-1);
setQHead(q, getQHead(q)-1);
if (getQHead(q)<0) {
setQHead(q, getQSize(q)+getQHead(q));
setQTail(q, getQTail(q)+getQSize(q));
}
}
}
}
bool Matrix::sym()
{
if (M != N) {
printf("Symmetrietest durch nichtquadratische Matrix falsch.\n");
return false;
}
for (int i = 0; i < N; i++) {
for (int j = i; j < M; j++) {
/* Elemente mit vertauschten Indizes müssen gleich sein */
if (getElem(i, j) != getElem(j, i))
return false;
}
}
return true;
}
char* simplifyPath(char* path) {
int len = strlen(path);
if (!path || len < 2) return path;
Stack stack;
if (*(path + len - 1) == '/') {
len--;
*(path + len) = '\0';
}
char *str = (char *)malloc(sizeof(char)* (len + 1));
initStack(&stack, len);
int status;
while (status = getElem(&path, str)) {
if (status == 1) {
pushStack(&stack, str);
} else if(status == 2){
popStack(&stack);
}
}
if (stack.top == 0) {
stack.elem[0] = '/';
stack.top = 1;
stack.pos[stack.top] = 1;
}
stack.elem[stack.pos[stack.top]] = '\0';
return stack.elem;
}
int main()
{
int a = 10;
int b = 15;
int c = 20;
vec.push_back(a);
vec.push_back(b);
vec.push_back(c);
vec.push_back(a);
putElemPtr(a);
putElemPtr(b);
putElemPtr(c);
putElemPtr(a);
int d = getElem(3);
d -=5;
std::shared_ptr<int> pd = getElemPtr(3);
*pd = 33;
int e = *pd;
std::cout << "e: " << e << std::endl;
std::cout << "*pd: " << *pd << std::endl;
*pd = 27;
std::cout << "e: " << e << std::endl;
std::cout << "*pd: " << *pd << std::endl;
int x = 12;
int* y = &x;
*y = 21;
int z = *y;
std::cout << "x: " << x << std::endl;
std::cout << "y: " << *y << std::endl;
std::cout << "z: " << z << std::endl;
*y = 32;
std::cout << "x: " << x << std::endl;
std::cout << "y: " << *y << std::endl;
std::cout << "z: " << z << std::endl;
// for (int i = 0; i < vec.size(); i++) {
// std::cout << "Elem[" << i << "]: " << vec[i] << std::endl;
// }
// for (int i = 0; i < vecptr.size(); i++) {
// std::cout << "ElemPtr[" << i << "]: " << *vecptr[i] << std::endl;
// }
}
// write values of q in cq (at same positions in the queue)
void copyValues(Queue q, Queue cq){
int i, j=getLength(q), k=getQSize(cq), l=getLength(cq);
for (i=0; i<j && i<k; i++) {
setElem(cq, getElem(q, i), i);
}
if (i-l > 0) setQTail(cq, getQTail(cq)+(i-l));
}
void ResizableArray<ElemType>::printInt(void) const
{
for( int i=0; i<getNumElem(); i++ ) {
int elem = (int) (getElem(i));
printf("%d\t%d\n",i,elem);
};
}
/*print do resolt (catalogo) */
void printResult(Result r){
Result aux = r;
if(aux == NULL) return;
while(aux != NULL){
printf("%s\n",getElem(aux));
aux = getNext(aux);
}
}
// print an entire queue in stdout
void printQueue(Queue q){
int i, j=getLength(q);
for (i=0; i<j; i++) {
printSQueue(getElem(q, i));
}
printf("\n");
return ;
}
void MatrixPainter::draw(sf::RenderWindow * window)
{
unsigned int e_X = (player_x + mouse_x)/(TILE_SIZE+1);
unsigned int e_Y = (player_y + mouse_y)/(TILE_SIZE+1);
m_vertices->clear();
if((end_x - begin_x + 1 >= m_width) || (end_y - begin_y + 1 >= m_height))
m_vertices->resize(4);
else
m_vertices->resize((end_x - begin_x + 1) * (end_y - begin_y + 1) * 4 + 2 * 4);
//draw area
sf::Color color = sf::Color(180, 180, 180);
m_vertices->append(sf::Vertex ( sf::Vector2f ((float)(TILE_SIZE+1)*begin_x-5*(TILE_SIZE+2) - player_x, (float) (TILE_SIZE+1)*begin_y-5*(TILE_SIZE+2) - player_y), color) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((float)(TILE_SIZE+1)*end_x+TILE_SIZE+5*TILE_SIZE - player_x, (float) (TILE_SIZE+1)*begin_y-5*(TILE_SIZE+2) - player_y), color) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((float)(TILE_SIZE+1)*end_x+TILE_SIZE+5*TILE_SIZE - player_x, (float) (TILE_SIZE+1)*end_y+TILE_SIZE+5*TILE_SIZE - player_y), color) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((float)(TILE_SIZE+1)*begin_x-5*(TILE_SIZE+2) - player_x, (float) (TILE_SIZE+1)*end_y+TILE_SIZE+5*TILE_SIZE - player_y), color) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((float)(TILE_SIZE+1)*begin_x - player_x -1, (float) (TILE_SIZE+1)*begin_y - player_y -1), sf::Color::Black) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((float)(TILE_SIZE+1)*end_x - player_x, (float) (TILE_SIZE+1)*begin_y - player_y -1), sf::Color::Black) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((float)(TILE_SIZE+1)*end_x - player_x, (float) (TILE_SIZE+1)*end_y - player_y), sf::Color::Black) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((float)(TILE_SIZE+1)*begin_x - player_x -1, (float) (TILE_SIZE+1)*end_y - player_y), sf::Color::Black) );
//draw the matrix elements
for(unsigned int i = begin_y; i < end_y; i++)
{
for(unsigned int j = begin_x; j < end_x; j++)
{
sf::Color color;
switch(getElem(j, i))
{
case 0:
color = sf::Color::White;
break;
case 1:
color = sf::Color::Red;
break;
case 2:
color = sf::Color::Green;
break;
default:
color = sf::Color::Blue;
break;
}
if(e_X == j && e_Y == i)
color = sf::Color::Yellow;
m_vertices->append(sf::Vertex ( sf::Vector2f ((TILE_SIZE+1)*j - player_x, (TILE_SIZE+1)*i - player_y), color) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((TILE_SIZE+1)*j+TILE_SIZE - player_x, (TILE_SIZE+1)*i - player_y), color) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((TILE_SIZE+1)*j+TILE_SIZE - player_x, (TILE_SIZE+1)*i+TILE_SIZE - player_y), color) );
m_vertices->append(sf::Vertex ( sf::Vector2f ((TILE_SIZE+1)*j - player_x, (TILE_SIZE+1)*i+TILE_SIZE - player_y), color) );
}
}
window->draw(*m_vertices);
}
float *Matrix::VecMultiply(float *vec, int length) {
float *result = new float [length];
for (int j = 0; j < h; ++j) {
int k = 0;
for (int i = 0; i < length; ++i) {
k += getElem(i, j) * vec[i];
}
result[j] = k % 2;
}
return result;
}
void Matrix::out()
{
int value;
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
value = getElem(i, j);
printf("%4d ", value);
}
printf("\n\n");
}
}
void Matrix::print()const
{
for(size_t i=0; i<M;++i)
{
for(size_t j=0; j<N; ++j)
{
std::cout<<getElem(i,j)<<" ";
}
std::cout<<std::endl;
}
std::cout<<std::endl;
}
// delete the element at position k
// 0 <= k < q.tail
// !empty(q)
void subElem(Queue q, int k){
int i,j;
if (k > getLength(q)-1) ;
else if (k == getLength(q)-1) subTail(q);
else if (k==0) subHead(q);
else {
deleteSQueue(getElem(q, k));
j = getLength(q)-1;
if (k >= getLength(q)/2) {
for (i=k; i<j; i++) {
setElem(q, getElem(q, i+1), i);
}
setQTail(q, getQTail(q)-1);
}
else {
for (i=k; i>0; i--) {
setElem(q, getElem(q, i-1), i);
}
setQHead(q, getQHead(q)+1);
}
}
}
//------------------------------------------------------------------------------
// pivotCol
//------------------------------------------------------------------------------
bool Matrix::pivotCol(const unsigned int r, const unsigned int c)
{
// error check
bool l1 = (r < rows);
bool l2 = (c < cols-1);
bool ok = false;
if (l1 && l2) {
unsigned int refcol = c;
double max = std::fabs(getElem(r,c));
for (unsigned int j=c+1; j<=cols; j++) {
double val = std::fabs(getElem(r,j));
if (val > max) {
refcol = j;
max = val;
}
}
if (c != refcol) {
//swapCol(c, refcol);
int c1 = c;
int c2 = refcol;
for (unsigned int i=0; i<rows; i++) {
unsigned int idx1 = i*cols + c1;
unsigned int idx2 = i*cols + c2;
double xxxx = mda[idx1];
mda[idx1] = mda[idx2];
mda[idx2] = xxxx;
}
}
ok = true;
}
return ok;
}
//------------------------------------------------------------------------------
// Invert
//------------------------------------------------------------------------------
bool Matrix::invert()
{
bool ok = mda != nullptr && rows > 0 && cols > 0 && isSquare();
if (ok) {
Matrix m(rows, cols);
m.makeIdent();
unsigned int origCols = cols; // 'cols' is changed after augment()
augment(m);
for (unsigned int k = 0; k < origCols; k++) {
pivotRow(k,k);
mulRow(k, 1.0/getElem(k,k));
for (unsigned int i=0; i<rows; i++) {
if (i != k) {
addRow(i, k, -getElem(i,k));
}
}
}
remCols(0, origCols-1);
}
return ok;
}
bool StatCollector::getValue(std::string &name, Real64 &val)
{
StatElemDescBase *desc = StatElemDescBase::findDescByName(name.c_str());
if(!desc)
return false;
StatElem *el = getElem(*desc, false);
if(!el)
return false;
val = el->getValue();
return true;
}
BOOLEAN ProbeReq(Signal_t *signal)
{
FrmDesc_t *pfrmDesc;
Frame_t *rdu;
MacAddr_t sta;
Element rSsid;
Element *pWPA = NULL;
U8 vapId = 0;
ZDEBUG("ProbeReq");
pfrmDesc = signal->frmInfo.frmDesc;
rdu = pfrmDesc->mpdu;
if (!getElem(rdu, EID_SSID, &rSsid))
goto release;
if (mHiddenSSID){ //discard broadcast ssid
if (eLen(&rSsid) == 0){
goto release;
}
}
memcpy((U8*)&sta, (U8*)addr2(rdu), 6);
if (eLen(&rSsid) == 0){
//WPA
if (mDynKeyMode == DYN_KEY_TKIP)
pWPA = &mWPAIe;
mkProbeRspFrm(pfrmDesc, &sta, mBeaconPeriod, mCap, &dot11DesiredSsid, &mBrates, &mPhpm, NULL, (Element *)pWPA, vapId);
return sendMgtFrame(signal, pfrmDesc);
}
else{
if (memcmp(&rSsid, &dot11DesiredSsid, eLen(&dot11DesiredSsid)+2) == 0){
//WPA
if (mDynKeyMode == DYN_KEY_TKIP)
pWPA = &mWPAIe;
mkProbeRspFrm(pfrmDesc, &sta, mBeaconPeriod, mCap, &dot11DesiredSsid, &mBrates, &mPhpm, NULL, (Element *)pWPA, vapId);
return sendMgtFrame(signal, pfrmDesc);
}
}
release:
ZDEBUG("goto release");
freeFdesc(pfrmDesc);
return TRUE;
}
/*! Set the contents from a string. The string has to have the format that is
used by StatCollector::putToString.
*/
bool StatCollector::getFromCString(const Char8 *&inVal)
{
const Char8 *c = inVal;
if(*c++ != '{')
return false;
StatElemDescBase *desc;
StatElem *elem;
clearElems();
while(*c && *c != '}')
{
const Char8 *end = c;
while(*end != 0 && *end != '=' && *end != '}' && *end != '|')
end++;
if(*end == 0 || *end == '}' || *end == '|')
return false;
std::string name(c, end - c);
desc = StatElemDescBase::findDescByName(name.c_str());
if(!desc)
return false;
elem = getElem(*desc);
c = end = end + 1;
while(*end != 0 && *end != '}' && *end != '|')
end++;
if(*end == 0)
return false;
std::string val(c, end - c);
const Char8 *valp = val.c_str();
if(!elem->getFromCString(valp))
return false;
c = end + 1;
}
return true;
}
bool WDomElem::removeChild(int pos, int count)
{
// check validity
if (pos+count > domElem.childNodes().size())
{
return false;
}
// remove children
for (int i = 0; i < count; i++)
{
// remove from DOM
//domElem.removeChild(domElem.childNodes().at(pos));
QDomElement delem = getValidElemAt(pos);
getElem().removeChild(delem);
// remove from tree
delete childWDomElems[pos];
childWDomElems.remove(pos);
}
// update row numbers
updateRowNumbers();
return true;
}
Arete getArete(AreteHandle areteH)
{
return (Arete) getElem(areteH->arete);
}
int compare(queue_t * self){
if (getElem(self,getTail(self)-1)<0)
return 1;
}
int main(int argc, char** argv) { // главная часть, обработка параметров входа и выполнение
init();
char* data_file1=argv[1];
char* data_file2=argv[2];
char* strl = argv[3];
FILE* f=fopen(data_file,"r");
FILE* f2=fopen(data_file2,"r");
if(!f)
{
printf("Wrong file\n");
return 1;
}
char tmp[51];
char mnoj_name;
int elem;
int num_mnoj=0;
while(fgets(tmp,51,f)!=NULL)
{
mnoj_name=tmp[0];
elem=getElem(tmp);
int ind=getInd(mnoj_name);
if(ind!=-1)
{
bool is_new=true;
int l;
for(l=0;l<num_elems[ind];l++)
{
if(elems[ind][l]==elem)
{
is_new=false;
}
}
if(is_new)
{
num_elems[ind]++;
elems[ind]=(int *) realloc(elems[ind],num_elems[ind]*sizeof(int));
elems[ind][num_elems[ind]-1]=elem;
}
}
else
{
num_mnoj++;
mnoj=(char*) realloc(mnoj,num_mnoj*sizeof(char));
mnoj[num_mnoj-1]=mnoj_name;
elems=(int**) realloc(elems,num_mnoj*sizeof(int*));
elems[num_mnoj-1]=(int*) calloc(1,sizeof(int));
elems[num_mnoj-1][0]=elem;
num_elems=(int*) realloc(num_elems,num_mnoj*sizeof(int));
num_elems[num_mnoj-1]=1;
}
}
puts("Data file is read");
int j=1; // номер анализируемого элемента
puts(sum_mem);
while(strlen(sum_mem)!=1)
{
printf("%s-%d\n",sum_mem,j);
if(ifChar(sum_mem[j-2]) && ifChar(sum_mem[j]) && isOper(sum_mem[j-1]))
{
char newMn=gnm(); // выбирает неиспользованную букву.
num_mnoj++;
mnoj=(char*) realloc(mnoj,num_mnoj*sizeof(char));
mnoj[num_mnoj-1]=newMn; // мы нашли множество и создаём для него место
elems=(int**) realloc(elems,num_mnoj*sizeof(int*));
elems[num_mnoj-1]=(int*) calloc(0,sizeof(int));
num_elems=(int*) realloc(num_elems,num_mnoj*sizeof(int));
num_elems[num_mnoj-1]=0;
if(sum_mem[j-1]=='*')
{
peresech(sum_mem[j-2],sum_mem[j],newMn);
sum_mem[j-2]=newMn;
movePointer(sum_mem,j+1,2);
}
else if(sum_mem[j-1]=='+')
{
sumg(sum_mem[j-2],sum_mem[j],newMn);
sum_mem[j-2]=newMn;
movePointer(sum_mem,j+1,2);
}
else if(sum_mem[j-1]=='-')
{
minus(sum_mem[j-2],sum_mem[j],newMn);
sum_mem[j-2]=newMn;
movePointer(sum_mem,j+1,2);
}
j=2;
}
}
puts(sum_mem);
int last_ind=getInd(sum_mem[0]);
int l;
for(l=0;l<num_elems[last_ind];l++)
{
printf("%d\n",elems[last_ind][l]);
}
return (EXIT_SUCCESS);
}
/**
* Returns the value of the ith component
*/
int operator[](int i) const {return getElem(i);}
void tva::Doc::slSolveStaticTask()
{
//tva::util::showMsg("slSolveStaticTask");
slMakeMatrises();
//
//if (!model.gM.hasM)
//{
// tva::util::showMsg("matr M not ready");
// return;
//}
if (!model.gM.hasK)
{
tva::util::showMsg("matr K not ready");
return;
}
auto K2=model.gM.getK();
{//correction K
static const double multStuck=100.0;
K2.getElem(0,0) *= multStuck;
//K2.getElem(0,1) *= multStuck;
//K2.getElem(1,0) *= multStuck;
}
//make F_outer
tva::tMatr F_outer;
F_outer.resize(K2.countRows(),1);
{
static const double F_r=-1.0;
F_outer.fill(0.0);
F_outer.getElem(K2.countRows()-1,0) = F_r;
}
//solve
auto b=K2.getSolve(F_outer);
//
tva::postProc::MatrToWidgetTable(b, tableWidget_23);
//extract vector
std::vector<double> stdX,stdB;
for(int i=0; i<b.countRows(); ++i)
{
stdX.push_back(i);
stdB.push_back(b.getElem(i,0));
}
//
//auto p = std::make_pair(stdX, stdB);
{//plot staticTask
typedef tva::chartSetup::chartStyle chStyle;
//
chStyle style;
//
tva::chartSetup::axisStyle asX;
tva::chartSetup::axisStyle asY;
asX.title = "index";
asY.title = "staticDef";
{
tva::chartSetup::opPair limY;
const auto& providerData = stdB;
limY.first =tva::util::getMinElement(stdB);
limY.second = tva::util::getMaxElement(stdB);
if (limY.second.isSettled())
{
//limY.second = limY.second.get()*(1+percentLimitCorrection);
}
tva::chartSetup::opPair limX;
limX.first = 0;//tva::util::getMinElement(model.Omega);
limX.second = stdX.size()+1;
asY.lim = limY;
asX.lim = limX;
}
style.axStyleX = asX;
style.axStyleY = asY;
//
//tva::chartSetup::opChartStyle loc_style;
//
tva::chartSetup::lineStyle lStyle;
lStyle.color = QColor(0,85,0);
//
bool needClear(true);
bool leftAxis(true);
postProc::policyChart policy;
policy.style = style;
policy.lStyle = lStyle;
policy.needClear = needClear;
policy.leftAxis = leftAxis;
//
tva::postProc::vec2Chart( policy, stdX, stdB, plotStaticTask.get() );
}
}
SPoint3D SMatrix4D::transformVertex(const SPoint3D & p)
{
SPoint3D res;
/* multiply vector (x,y,z,1) by this transformation matrix */
res.x = p.x * getElem(0, 0) + p.y * getElem(1, 0) + p.z * getElem(2, 0) + getElem(3, 0);
res.y = p.x * getElem(0, 1) + p.y * getElem(1, 1) + p.z * getElem(2, 1) + getElem(3, 1);
res.z = p.x * getElem(0, 2) + p.y * getElem(1, 2) + p.z * getElem(2, 2) + getElem(3, 2);
return res;
}
BOOLEAN Re_AsocReq(Signal_t *signal)
{
FrmDesc_t *pfrmDesc;
Frame_t *rdu;
MacAddr_t Sta;
U16 aid = 0;
StatusCode asStatus;
U8 lsInterval;
Element WPA;
Element asSsid;
Element asRates;
//Element extRates;
U16 cap;
U8 ZydasMode = 0;
int i;
U8 tmpMaxRate = 0x02;
U8 MaxRate;
U16 notifyStatus = STA_ASOC_REQ;
U16 notifyStatus1 = STA_ASSOCIATED;
TypeSubtype type = ST_ASOC_RSP;
U8 Preamble = 0;
U8 HigestBasicRate = 0;
U8 vapId = 0;
U8 Len;
BOOLEAN bErpSta = FALSE;
ZDEBUG("Re_AsocReq");
pfrmDesc = signal->frmInfo.frmDesc;
rdu = pfrmDesc->mpdu;
lsInterval = listenInt(pfrmDesc->mpdu);
//FPRINT_V("lsInterval", lsInterval);
cap = cap(pfrmDesc->mpdu);
memcpy((U8 *)&Sta, (U8 *)addr2(rdu), 6);
if ((isGroup(addr2(rdu))) || (!getElem(rdu, EID_SSID, &asSsid))
|| (!getElem(rdu, EID_SUPRATES, &asRates))){
freeFdesc(pfrmDesc);
return TRUE;
}
if ((eLen(&asSsid) != eLen(&dot11DesiredSsid) ||
memcmp(&asSsid, &dot11DesiredSsid, eLen(&dot11DesiredSsid)+2) != 0)){
freeFdesc(pfrmDesc);
return TRUE;
}
//chaeck capability
if (cap & CAP_SHORT_PREAMBLE)
Preamble = 1;
else
Preamble = 0;
// Privacy not match
if (cap & CAP_PRIVACY){
if (!mPrivacyInvoked){
freeFdesc(pfrmDesc);
return TRUE;
}
}
else {
if (mPrivacyInvoked){
freeFdesc(pfrmDesc);
return TRUE;
}
}
Len = eLen(&asRates);
for (i=0; i<Len; i++){
if ( (asRates.buf[2+i] & 0x7f) > tmpMaxRate ){
tmpMaxRate = (asRates.buf[2+i] & 0x7f);
if (asRates.buf[2+i] & 0x80)
HigestBasicRate = asRates.buf[2+i];
}
if (((asRates.buf[2+i] & 0x7f) == 0x21) && (!(cap & CAP_PBCC_ENABLE))){ //Zydas 16.5M
void *reg = pdot11Obj->reg;
ZydasMode = 1;
mZyDasModeClient = TRUE;
//FPRINT("ZydasMode");
}
}
MaxRate = RateConvert((tmpMaxRate & 0x7f), cap);
if (signal->id == SIG_REASSOC_REQ)
notifyStatus = STA_REASOC_REQ;
if (!pdot11Obj->StatusNotify(notifyStatus, (U8 *)&Sta)){ //Accept it
if (mDynKeyMode == DYN_KEY_TKIP){
if (getElem(rdu, EID_WPA, &WPA)){
//zd1205_OctetDump("AssocRequest = ", asRdu->body, asRdu->bodyLen);
//zd1205_OctetDump("AssocRequest WPA_IE = ", &WPA.buf[2], WPA.buf[1]);
if (pdot11Obj->AssocRequest((U8 *)&Sta, rdu->body, rdu->bodyLen)){ //reject
asStatus = SC_UNSPEC_FAILURE;
goto check_failed;
//we need reason code here
}
}
else{
asStatus = SC_UNSPEC_FAILURE;
goto wpa_check_failed;
}
}
wpa_check_ok:
if (!UpdateStaStatus(&Sta, STATION_STATE_ASOC, vapId)){
asStatus = SC_AP_FULL;
}
else{
AssocInfoUpdate(&Sta, MaxRate, lsInterval, ZydasMode, Preamble, bErpSta, vapId);
aid = AIdLookup(&Sta);
asStatus = SC_SUCCESSFUL;
if (signal->id == SIG_REASSOC_REQ)
notifyStatus1 = STA_REASSOCIATED;
pdot11Obj->StatusNotify(notifyStatus1, (U8 *)&Sta);
}
}
else{
wpa_check_failed:
asStatus = SC_UNSPEC_FAILURE;
}
aid |= 0xC000;
if (aid != 0xC000){
#ifdef B500_DEBUG
FPRINT_V("Aid", aid);
FPRINT_V("MaxRate", MaxRate);
#endif
}
check_failed:
if (signal->id == SIG_REASSOC_REQ)
type = ST_REASOC_RSP;
mkRe_AsocRspFrm(pfrmDesc, type, &Sta, mCap, asStatus, aid, &mBrates, NULL, vapId);
sendMgtFrame(signal, pfrmDesc);
return FALSE;
}
